mirror of https://github.com/akelge/zsh
Added conque, terminal emulator
This commit is contained in:
parent
d7f498b61d
commit
f5eab1d188
|
|
@ -1 +1,2 @@
|
|||
textformat.vba: call delete('/Users/andre/.vim/autoload/textformat.vim')|call delete('/Users/andre/.vim/doc/textformat.txt')|call delete('/Users/andre/.vim/plugin/textformat.vim')
|
||||
conque_2.0.vba: call delete('/Users/andre/.vim/doc/conque_term.txt')|call delete('/Users/andre/.vim/syntax/conque_term.vim')|call delete('/Users/andre/.vim/autoload/conque_term/conque_screen.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_win32_util.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_sole_shared_memory.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_sole_wrapper.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_sole_communicator.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_sole.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_globals.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_subprocess.py')|call delete('/Users/andre/.vim/autoload/conque_term/conque_sole_subprocess.py')|call delete('/Users/andre/.vim/autoload/conque_term.vim')|call delete('/Users/andre/.vim/plugin/conque_term.vim')
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,975 @@
|
|||
# FILE: autoload/conque_term/conque.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""
|
||||
Vim terminal emulator.
|
||||
|
||||
The Conque does two things. First, it handles communication between Vim and
|
||||
the terminal/console subprocess. For example, Vim uses the Conque.write()
|
||||
method to send input, and Conque.read() to update the terminal buffer.
|
||||
|
||||
Second, the Conque class handles Unix terminal escape sequence parsing.
|
||||
"""
|
||||
|
||||
import vim
|
||||
import re
|
||||
import math
|
||||
|
||||
|
||||
|
||||
|
||||
class Conque:
|
||||
|
||||
# CLASS PROPERTIES {{{
|
||||
|
||||
# screen object
|
||||
screen = None
|
||||
|
||||
# subprocess object
|
||||
proc = None
|
||||
|
||||
# terminal dimensions and scrolling region
|
||||
columns = 80 # same as $COLUMNS
|
||||
lines = 24 # same as $LINES
|
||||
working_columns = 80 # can be changed by CSI ? 3 l/h
|
||||
working_lines = 24 # can be changed by CSI r
|
||||
|
||||
# top/bottom of the scroll region
|
||||
top = 1 # relative to top of screen
|
||||
bottom = 24 # relative to top of screen
|
||||
|
||||
# cursor position
|
||||
l = 1 # current cursor line
|
||||
c = 1 # current cursor column
|
||||
|
||||
# autowrap mode
|
||||
autowrap = True
|
||||
|
||||
# absolute coordinate mode
|
||||
absolute_coords = True
|
||||
|
||||
# tabstop positions
|
||||
tabstops = []
|
||||
|
||||
# enable colors
|
||||
enable_colors = True
|
||||
|
||||
# color changes
|
||||
color_changes = {}
|
||||
|
||||
# color history
|
||||
color_history = {}
|
||||
|
||||
# don't wrap table output
|
||||
unwrap_tables = True
|
||||
|
||||
# wrap CUF/CUB around line breaks
|
||||
wrap_cursor = False
|
||||
|
||||
# do we need to move the cursor?
|
||||
cursor_set = False
|
||||
|
||||
# current character set, ascii or graphics
|
||||
character_set = 'ascii'
|
||||
|
||||
# used for auto_read actions
|
||||
read_count = 0
|
||||
|
||||
# }}}
|
||||
|
||||
# constructor
|
||||
def __init__(self): # {{{
|
||||
self.screen = ConqueScreen()
|
||||
# }}}
|
||||
|
||||
# start program and initialize this instance
|
||||
def open(self, command, options): # {{{
|
||||
|
||||
# int vars
|
||||
self.columns = vim.current.window.width
|
||||
self.lines = vim.current.window.height
|
||||
self.working_columns = vim.current.window.width
|
||||
self.working_lines = vim.current.window.height
|
||||
self.bottom = vim.current.window.height
|
||||
|
||||
# init color
|
||||
self.enable_colors = options['color']
|
||||
|
||||
# init tabstops
|
||||
self.init_tabstops()
|
||||
|
||||
# open command
|
||||
self.proc = ConqueSubprocess()
|
||||
self.proc.open(command, {'TERM': options['TERM'], 'CONQUE': '1', 'LINES': str(self.lines), 'COLUMNS': str(self.columns)})
|
||||
|
||||
# send window size signal, in case LINES/COLUMNS is ignored
|
||||
self.update_window_size(True)
|
||||
# }}}
|
||||
|
||||
# write to pty
|
||||
def write(self, input, set_cursor=True, read=True): # {{{
|
||||
|
||||
# check if window size has changed
|
||||
if read:
|
||||
self.update_window_size()
|
||||
|
||||
# write and read
|
||||
self.proc.write(input)
|
||||
|
||||
# read output immediately
|
||||
if read:
|
||||
self.read(1, set_cursor)
|
||||
|
||||
# }}}
|
||||
|
||||
# convert latin-1 input into utf-8
|
||||
# XXX - this is a hack, to be removed soon
|
||||
def write_latin1(self, input, set_cursor=True, read=True): # {{{
|
||||
|
||||
if CONQUE_PYTHON_VERSION == 2:
|
||||
try:
|
||||
input_unicode = input.decode('latin-1', 'ignore')
|
||||
self.write(input_unicode.encode('utf-8', 'ignore'), set_cursor, read)
|
||||
except:
|
||||
return
|
||||
else:
|
||||
self.write(input, set_cursor, read)
|
||||
|
||||
# }}}
|
||||
|
||||
# read from pty, and update buffer
|
||||
def read(self, timeout=1, set_cursor=True, return_output=False, update_buffer=True): # {{{
|
||||
output = ''
|
||||
|
||||
# this may not actually work
|
||||
try:
|
||||
|
||||
# read from subprocess
|
||||
output = self.proc.read(timeout)
|
||||
# and strip null chars
|
||||
output = output.replace(chr(0), '')
|
||||
|
||||
if output == '':
|
||||
return
|
||||
|
||||
# for bufferless terminals
|
||||
if not update_buffer:
|
||||
return output
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
chunks = CONQUE_SEQ_REGEX.split(output)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# don't go through all the csi regex if length is one (no matches)
|
||||
if len(chunks) == 1:
|
||||
|
||||
self.plain_text(chunks[0])
|
||||
|
||||
else:
|
||||
for s in chunks:
|
||||
if s == '':
|
||||
continue
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# Check for control character match {{{
|
||||
if CONQUE_SEQ_REGEX_CTL.match(s[0]):
|
||||
|
||||
nr = ord(s[0])
|
||||
if nr in CONQUE_CTL:
|
||||
getattr(self, 'ctl_' + CONQUE_CTL[nr])()
|
||||
else:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# check for escape sequence match {{{
|
||||
elif CONQUE_SEQ_REGEX_CSI.match(s):
|
||||
|
||||
if s[-1] in CONQUE_ESCAPE:
|
||||
csi = self.parse_csi(s[2:])
|
||||
|
||||
getattr(self, 'csi_' + CONQUE_ESCAPE[s[-1]])(csi)
|
||||
else:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# check for title match {{{
|
||||
elif CONQUE_SEQ_REGEX_TITLE.match(s):
|
||||
|
||||
self.change_title(s[2], s[4:-1])
|
||||
# }}}
|
||||
|
||||
# check for hash match {{{
|
||||
elif CONQUE_SEQ_REGEX_HASH.match(s):
|
||||
|
||||
if s[-1] in CONQUE_ESCAPE_HASH:
|
||||
getattr(self, 'hash_' + CONQUE_ESCAPE_HASH[s[-1]])()
|
||||
else:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# check for charset match {{{
|
||||
elif CONQUE_SEQ_REGEX_CHAR.match(s):
|
||||
|
||||
if s[-1] in CONQUE_ESCAPE_CHARSET:
|
||||
getattr(self, 'charset_' + CONQUE_ESCAPE_CHARSET[s[-1]])()
|
||||
else:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# check for other escape match {{{
|
||||
elif CONQUE_SEQ_REGEX_ESC.match(s):
|
||||
|
||||
if s[-1] in CONQUE_ESCAPE_PLAIN:
|
||||
getattr(self, 'esc_' + CONQUE_ESCAPE_PLAIN[s[-1]])()
|
||||
else:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# else process plain text {{{
|
||||
else:
|
||||
self.plain_text(s)
|
||||
# }}}
|
||||
|
||||
# check window size
|
||||
if set_cursor:
|
||||
self.screen.set_cursor(self.l, self.c)
|
||||
|
||||
# we need to set the cursor position
|
||||
self.cursor_set = False
|
||||
|
||||
vim.command('redraw')
|
||||
|
||||
|
||||
|
||||
except:
|
||||
|
||||
|
||||
pass
|
||||
|
||||
if return_output:
|
||||
if CONQUE_PYTHON_VERSION == 3:
|
||||
return output
|
||||
else:
|
||||
return output.encode(vim.eval('&encoding'), 'replace')
|
||||
# }}}
|
||||
|
||||
# for polling
|
||||
def auto_read(self): # {{{
|
||||
|
||||
# check subprocess status, but not every time since it's CPU expensive
|
||||
if self.read_count == 10:
|
||||
if not self.proc.is_alive():
|
||||
vim.command('call conque_term#get_instance().close()')
|
||||
return
|
||||
else:
|
||||
self.read_count = 0
|
||||
self.read_count += 1
|
||||
|
||||
# read output
|
||||
self.read(1)
|
||||
|
||||
# reset timer
|
||||
if self.c == 1:
|
||||
vim.command('call feedkeys("\<right>\<left>", "n")')
|
||||
else:
|
||||
vim.command('call feedkeys("\<left>\<right>", "n")')
|
||||
|
||||
# stop here if cursor doesn't need to be moved
|
||||
if self.cursor_set:
|
||||
return
|
||||
|
||||
# otherwise set cursor position
|
||||
try:
|
||||
self.set_cursor(self.l, self.c)
|
||||
except:
|
||||
|
||||
|
||||
pass
|
||||
self.cursor_set = True
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# Plain text # {{{
|
||||
|
||||
def plain_text(self, input):
|
||||
|
||||
# translate input into correct character set
|
||||
if self.character_set == 'graphics':
|
||||
old_input = input
|
||||
input = ''
|
||||
for i in range(0, len(old_input)):
|
||||
chrd = ord(old_input[i])
|
||||
|
||||
|
||||
try:
|
||||
if chrd > 255:
|
||||
|
||||
input = input + old_input[i]
|
||||
else:
|
||||
input = input + unichr(CONQUE_GRAPHICS_SET[chrd])
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
|
||||
current_line = self.screen[self.l]
|
||||
|
||||
if len(current_line) < self.working_columns:
|
||||
current_line = current_line + ' ' * (self.c - len(current_line))
|
||||
|
||||
# if line is wider than screen
|
||||
if self.c + len(input) - 1 > self.working_columns:
|
||||
# Table formatting hack
|
||||
if self.unwrap_tables and CONQUE_TABLE_OUTPUT.match(input):
|
||||
self.screen[self.l] = current_line[:self.c - 1] + input + current_line[self.c + len(input) - 1:]
|
||||
self.apply_color(self.c, self.c + len(input))
|
||||
self.c += len(input)
|
||||
return
|
||||
|
||||
diff = self.c + len(input) - self.working_columns - 1
|
||||
# if autowrap is enabled
|
||||
if self.autowrap:
|
||||
self.screen[self.l] = current_line[:self.c - 1] + input[:-1 * diff]
|
||||
self.apply_color(self.c, self.working_columns)
|
||||
self.ctl_nl()
|
||||
self.ctl_cr()
|
||||
remaining = input[-1 * diff:]
|
||||
|
||||
self.plain_text(remaining)
|
||||
else:
|
||||
self.screen[self.l] = current_line[:self.c - 1] + input[:-1 * diff - 1] + input[-1]
|
||||
self.apply_color(self.c, self.working_columns)
|
||||
self.c = self.working_columns
|
||||
|
||||
# no autowrap
|
||||
else:
|
||||
self.screen[self.l] = current_line[:self.c - 1] + input + current_line[self.c + len(input) - 1:]
|
||||
self.apply_color(self.c, self.c + len(input))
|
||||
self.c += len(input)
|
||||
|
||||
def apply_color(self, start, end, line=0):
|
||||
|
||||
|
||||
# stop here if coloration is disabled
|
||||
if not self.enable_colors:
|
||||
return
|
||||
|
||||
# allow custom line nr to be passed
|
||||
if line:
|
||||
real_line = line
|
||||
else:
|
||||
real_line = self.screen.get_real_line(self.l)
|
||||
|
||||
# check for previous overlapping coloration
|
||||
|
||||
to_del = []
|
||||
if real_line in self.color_history:
|
||||
for i in range(len(self.color_history[real_line])):
|
||||
syn = self.color_history[real_line][i]
|
||||
|
||||
if syn['start'] >= start and syn['start'] < end:
|
||||
|
||||
vim.command('syn clear ' + syn['name'])
|
||||
to_del.append(i)
|
||||
# outside
|
||||
if syn['end'] > end:
|
||||
|
||||
self.exec_highlight(real_line, end, syn['end'], syn['highlight'])
|
||||
elif syn['end'] > start and syn['end'] <= end:
|
||||
|
||||
vim.command('syn clear ' + syn['name'])
|
||||
to_del.append(i)
|
||||
# outside
|
||||
if syn['start'] < start:
|
||||
|
||||
self.exec_highlight(real_line, syn['start'], start, syn['highlight'])
|
||||
|
||||
if len(to_del) > 0:
|
||||
to_del.reverse()
|
||||
for di in to_del:
|
||||
del self.color_history[real_line][di]
|
||||
|
||||
# if there are no new colors
|
||||
if len(self.color_changes) == 0:
|
||||
return
|
||||
|
||||
highlight = ''
|
||||
for attr in self.color_changes.keys():
|
||||
highlight = highlight + ' ' + attr + '=' + self.color_changes[attr]
|
||||
|
||||
# execute the highlight
|
||||
self.exec_highlight(real_line, start, end, highlight)
|
||||
|
||||
def exec_highlight(self, real_line, start, end, highlight):
|
||||
unique_key = str(self.proc.pid)
|
||||
|
||||
syntax_name = 'EscapeSequenceAt_' + unique_key + '_' + str(self.l) + '_' + str(start) + '_' + str(len(self.color_history) + 1)
|
||||
syntax_options = ' contains=ALLBUT,ConqueString,MySQLString,MySQLKeyword oneline'
|
||||
syntax_region = 'syntax match ' + syntax_name + ' /\%' + str(real_line) + 'l\%>' + str(start - 1) + 'c.*\%<' + str(end + 1) + 'c/' + syntax_options
|
||||
syntax_highlight = 'highlight ' + syntax_name + highlight
|
||||
|
||||
vim.command(syntax_region)
|
||||
vim.command(syntax_highlight)
|
||||
|
||||
# add syntax name to history
|
||||
if not real_line in self.color_history:
|
||||
self.color_history[real_line] = []
|
||||
|
||||
self.color_history[real_line].append({'name': syntax_name, 'start': start, 'end': end, 'highlight': highlight})
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# Control functions {{{
|
||||
|
||||
def ctl_nl(self):
|
||||
# if we're in a scrolling region, scroll instead of moving cursor down
|
||||
if self.lines != self.working_lines and self.l == self.bottom:
|
||||
del self.screen[self.top]
|
||||
self.screen.insert(self.bottom, '')
|
||||
elif self.l == self.bottom:
|
||||
self.screen.append('')
|
||||
else:
|
||||
self.l += 1
|
||||
|
||||
self.color_changes = {}
|
||||
|
||||
def ctl_cr(self):
|
||||
self.c = 1
|
||||
|
||||
self.color_changes = {}
|
||||
|
||||
def ctl_bs(self):
|
||||
if self.c > 1:
|
||||
self.c += -1
|
||||
|
||||
def ctl_soh(self):
|
||||
pass
|
||||
|
||||
def ctl_stx(self):
|
||||
pass
|
||||
|
||||
def ctl_bel(self):
|
||||
vim.command('call conque_term#bell()')
|
||||
|
||||
def ctl_tab(self):
|
||||
# default tabstop location
|
||||
ts = self.working_columns
|
||||
|
||||
# check set tabstops
|
||||
for i in range(self.c, len(self.tabstops)):
|
||||
if self.tabstops[i]:
|
||||
ts = i + 1
|
||||
break
|
||||
|
||||
|
||||
|
||||
self.c = ts
|
||||
|
||||
def ctl_so(self):
|
||||
self.character_set = 'graphics'
|
||||
|
||||
def ctl_si(self):
|
||||
self.character_set = 'ascii'
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# CSI functions {{{
|
||||
|
||||
def csi_font(self, csi): # {{{
|
||||
if not self.enable_colors:
|
||||
return
|
||||
|
||||
# defaults to 0
|
||||
if len(csi['vals']) == 0:
|
||||
csi['vals'] = [0]
|
||||
|
||||
# 256 xterm color foreground
|
||||
if len(csi['vals']) == 3 and csi['vals'][0] == 38 and csi['vals'][1] == 5:
|
||||
self.color_changes['ctermfg'] = str(csi['vals'][2])
|
||||
self.color_changes['guifg'] = '#' + self.xterm_to_rgb(csi['vals'][2])
|
||||
|
||||
# 256 xterm color background
|
||||
elif len(csi['vals']) == 3 and csi['vals'][0] == 48 and csi['vals'][1] == 5:
|
||||
self.color_changes['ctermbg'] = str(csi['vals'][2])
|
||||
self.color_changes['guibg'] = '#' + self.xterm_to_rgb(csi['vals'][2])
|
||||
|
||||
# 16 colors
|
||||
else:
|
||||
for val in csi['vals']:
|
||||
if val in CONQUE_FONT:
|
||||
|
||||
# ignore starting normal colors
|
||||
if CONQUE_FONT[val]['normal'] and len(self.color_changes) == 0:
|
||||
|
||||
continue
|
||||
# clear color changes
|
||||
elif CONQUE_FONT[val]['normal']:
|
||||
|
||||
self.color_changes = {}
|
||||
# save these color attributes for next plain_text() call
|
||||
else:
|
||||
|
||||
for attr in CONQUE_FONT[val]['attributes'].keys():
|
||||
if attr in self.color_changes and (attr == 'cterm' or attr == 'gui'):
|
||||
self.color_changes[attr] += ',' + CONQUE_FONT[val]['attributes'][attr]
|
||||
else:
|
||||
self.color_changes[attr] = CONQUE_FONT[val]['attributes'][attr]
|
||||
# }}}
|
||||
|
||||
def csi_clear_line(self, csi): # {{{
|
||||
|
||||
|
||||
# this escape defaults to 0
|
||||
if len(csi['vals']) == 0:
|
||||
csi['val'] = 0
|
||||
|
||||
|
||||
|
||||
|
||||
# 0 means cursor right
|
||||
if csi['val'] == 0:
|
||||
self.screen[self.l] = self.screen[self.l][0:self.c - 1]
|
||||
|
||||
# 1 means cursor left
|
||||
elif csi['val'] == 1:
|
||||
self.screen[self.l] = ' ' * (self.c) + self.screen[self.l][self.c:]
|
||||
|
||||
# clear entire line
|
||||
elif csi['val'] == 2:
|
||||
self.screen[self.l] = ''
|
||||
|
||||
# clear colors
|
||||
if csi['val'] == 2 or (csi['val'] == 0 and self.c == 1):
|
||||
real_line = self.screen.get_real_line(self.l)
|
||||
if real_line in self.color_history:
|
||||
for syn in self.color_history[real_line]:
|
||||
vim.command('syn clear ' + syn['name'])
|
||||
|
||||
|
||||
|
||||
# }}}
|
||||
|
||||
def csi_cursor_right(self, csi): # {{{
|
||||
# we use 1 even if escape explicitly specifies 0
|
||||
if csi['val'] == 0:
|
||||
csi['val'] = 1
|
||||
|
||||
|
||||
|
||||
|
||||
if self.wrap_cursor and self.c + csi['val'] > self.working_columns:
|
||||
self.l += int(math.floor((self.c + csi['val']) / self.working_columns))
|
||||
self.c = (self.c + csi['val']) % self.working_columns
|
||||
return
|
||||
|
||||
self.c = self.bound(self.c + csi['val'], 1, self.working_columns)
|
||||
# }}}
|
||||
|
||||
def csi_cursor_left(self, csi): # {{{
|
||||
# we use 1 even if escape explicitly specifies 0
|
||||
if csi['val'] == 0:
|
||||
csi['val'] = 1
|
||||
|
||||
if self.wrap_cursor and csi['val'] >= self.c:
|
||||
self.l += int(math.floor((self.c - csi['val']) / self.working_columns))
|
||||
self.c = self.working_columns - (csi['val'] - self.c) % self.working_columns
|
||||
return
|
||||
|
||||
self.c = self.bound(self.c - csi['val'], 1, self.working_columns)
|
||||
# }}}
|
||||
|
||||
def csi_cursor_to_column(self, csi): # {{{
|
||||
self.c = self.bound(csi['val'], 1, self.working_columns)
|
||||
# }}}
|
||||
|
||||
def csi_cursor_up(self, csi): # {{{
|
||||
self.l = self.bound(self.l - csi['val'], self.top, self.bottom)
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def csi_cursor_down(self, csi): # {{{
|
||||
self.l = self.bound(self.l + csi['val'], self.top, self.bottom)
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def csi_clear_screen(self, csi): # {{{
|
||||
# default to 0
|
||||
if len(csi['vals']) == 0:
|
||||
csi['val'] = 0
|
||||
|
||||
# 2 == clear entire screen
|
||||
if csi['val'] == 2:
|
||||
self.l = 1
|
||||
self.c = 1
|
||||
self.screen.clear()
|
||||
|
||||
# 0 == clear down
|
||||
elif csi['val'] == 0:
|
||||
for l in range(self.bound(self.l + 1, 1, self.lines), self.lines + 1):
|
||||
self.screen[l] = ''
|
||||
|
||||
# clear end of current line
|
||||
self.csi_clear_line(self.parse_csi('K'))
|
||||
|
||||
# 1 == clear up
|
||||
elif csi['val'] == 1:
|
||||
for l in range(1, self.bound(self.l, 1, self.lines + 1)):
|
||||
self.screen[l] = ''
|
||||
|
||||
# clear beginning of current line
|
||||
self.csi_clear_line(self.parse_csi('1K'))
|
||||
|
||||
# clear coloration
|
||||
if csi['val'] == 2 or csi['val'] == 0:
|
||||
real_line = self.screen.get_real_line(self.l)
|
||||
for line in self.color_history.keys():
|
||||
if line >= real_line:
|
||||
for syn in self.color_history[line]:
|
||||
vim.command('syn clear ' + syn['name'])
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def csi_delete_chars(self, csi): # {{{
|
||||
self.screen[self.l] = self.screen[self.l][:self.c] + self.screen[self.l][self.c + csi['val']:]
|
||||
# }}}
|
||||
|
||||
def csi_add_spaces(self, csi): # {{{
|
||||
self.screen[self.l] = self.screen[self.l][: self.c - 1] + ' ' * csi['val'] + self.screen[self.l][self.c:]
|
||||
# }}}
|
||||
|
||||
def csi_cursor(self, csi): # {{{
|
||||
if len(csi['vals']) == 2:
|
||||
new_line = csi['vals'][0]
|
||||
new_col = csi['vals'][1]
|
||||
else:
|
||||
new_line = 1
|
||||
new_col = 1
|
||||
|
||||
if self.absolute_coords:
|
||||
self.l = self.bound(new_line, 1, self.lines)
|
||||
else:
|
||||
self.l = self.bound(self.top + new_line - 1, self.top, self.bottom)
|
||||
|
||||
self.c = self.bound(new_col, 1, self.working_columns)
|
||||
if self.c > len(self.screen[self.l]):
|
||||
self.screen[self.l] = self.screen[self.l] + ' ' * (self.c - len(self.screen[self.l]))
|
||||
|
||||
# }}}
|
||||
|
||||
def csi_set_coords(self, csi): # {{{
|
||||
if len(csi['vals']) == 2:
|
||||
new_start = csi['vals'][0]
|
||||
new_end = csi['vals'][1]
|
||||
else:
|
||||
new_start = 1
|
||||
new_end = vim.current.window.height
|
||||
|
||||
self.top = new_start
|
||||
self.bottom = new_end
|
||||
self.working_lines = new_end - new_start + 1
|
||||
|
||||
# if cursor is outside scrolling region, reset it
|
||||
if self.l < self.top:
|
||||
self.l = self.top
|
||||
elif self.l > self.bottom:
|
||||
self.l = self.bottom
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def csi_tab_clear(self, csi): # {{{
|
||||
# this escape defaults to 0
|
||||
if len(csi['vals']) == 0:
|
||||
csi['val'] = 0
|
||||
|
||||
|
||||
|
||||
if csi['val'] == 0:
|
||||
self.tabstops[self.c - 1] = False
|
||||
elif csi['val'] == 3:
|
||||
for i in range(0, self.columns + 1):
|
||||
self.tabstops[i] = False
|
||||
# }}}
|
||||
|
||||
def csi_set(self, csi): # {{{
|
||||
# 132 cols
|
||||
if csi['val'] == 3:
|
||||
self.csi_clear_screen(self.parse_csi('2J'))
|
||||
self.working_columns = 132
|
||||
|
||||
# relative_origin
|
||||
elif csi['val'] == 6:
|
||||
self.absolute_coords = False
|
||||
|
||||
# set auto wrap
|
||||
elif csi['val'] == 7:
|
||||
self.autowrap = True
|
||||
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def csi_reset(self, csi): # {{{
|
||||
# 80 cols
|
||||
if csi['val'] == 3:
|
||||
self.csi_clear_screen(self.parse_csi('2J'))
|
||||
self.working_columns = 80
|
||||
|
||||
# absolute origin
|
||||
elif csi['val'] == 6:
|
||||
self.absolute_coords = True
|
||||
|
||||
# reset auto wrap
|
||||
elif csi['val'] == 7:
|
||||
self.autowrap = False
|
||||
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# ESC functions {{{
|
||||
|
||||
def esc_scroll_up(self): # {{{
|
||||
self.ctl_nl()
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
def esc_next_line(self): # {{{
|
||||
self.ctl_nl()
|
||||
self.c = 1
|
||||
# }}}
|
||||
|
||||
def esc_set_tab(self): # {{{
|
||||
|
||||
if self.c <= len(self.tabstops):
|
||||
self.tabstops[self.c - 1] = True
|
||||
# }}}
|
||||
|
||||
def esc_scroll_down(self): # {{{
|
||||
if self.l == self.top:
|
||||
del self.screen[self.bottom]
|
||||
self.screen.insert(self.top, '')
|
||||
else:
|
||||
self.l += -1
|
||||
|
||||
self.color_changes = {}
|
||||
# }}}
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# HASH functions {{{
|
||||
|
||||
def hash_screen_alignment_test(self): # {{{
|
||||
self.csi_clear_screen(self.parse_csi('2J'))
|
||||
self.working_lines = self.lines
|
||||
for l in range(1, self.lines + 1):
|
||||
self.screen[l] = 'E' * self.working_columns
|
||||
# }}}
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# CHARSET functions {{{
|
||||
|
||||
def charset_us(self):
|
||||
self.character_set = 'ascii'
|
||||
|
||||
def charset_uk(self):
|
||||
self.character_set = 'ascii'
|
||||
|
||||
def charset_graphics(self):
|
||||
self.character_set = 'graphics'
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# Random stuff {{{
|
||||
|
||||
def set_cursor(self, line, col):
|
||||
self.screen.set_cursor(line, col)
|
||||
|
||||
def change_title(self, key, val):
|
||||
|
||||
|
||||
if key == '0' or key == '2':
|
||||
|
||||
vim.command('setlocal statusline=' + re.escape(val))
|
||||
try:
|
||||
vim.command('set titlestring=' + re.escape(val))
|
||||
except:
|
||||
pass
|
||||
|
||||
def paste(self):
|
||||
input = vim.eval('@@')
|
||||
input = input.replace("\n", "\r")
|
||||
self.read(50)
|
||||
|
||||
def paste_selection(self):
|
||||
input = vim.eval('@@')
|
||||
input = input.replace("\n", "\r")
|
||||
self.write(input)
|
||||
|
||||
def update_window_size(self, force=False):
|
||||
# resize if needed
|
||||
if force or vim.current.window.width != self.columns or vim.current.window.height != self.lines:
|
||||
|
||||
# reset all window size attributes to default
|
||||
self.columns = vim.current.window.width
|
||||
self.lines = vim.current.window.height
|
||||
self.working_columns = vim.current.window.width
|
||||
self.working_lines = vim.current.window.height
|
||||
self.bottom = vim.current.window.height
|
||||
|
||||
# reset screen object attributes
|
||||
self.l = self.screen.reset_size(self.l)
|
||||
|
||||
# reset tabstops
|
||||
self.init_tabstops()
|
||||
|
||||
|
||||
|
||||
# signal process that screen size has changed
|
||||
self.proc.window_resize(self.lines, self.columns)
|
||||
|
||||
def insert_enter(self):
|
||||
|
||||
# check window size
|
||||
self.update_window_size()
|
||||
|
||||
# we need to set the cursor position
|
||||
self.cursor_set = False
|
||||
|
||||
def init_tabstops(self):
|
||||
for i in range(0, self.columns + 1):
|
||||
if i % 8 == 0:
|
||||
self.tabstops.append(True)
|
||||
else:
|
||||
self.tabstops.append(False)
|
||||
|
||||
def idle(self):
|
||||
pass
|
||||
|
||||
def resume(self):
|
||||
pass
|
||||
|
||||
def close(self):
|
||||
self.proc.close()
|
||||
|
||||
def abort(self):
|
||||
self.proc.signal(1)
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# Utility {{{
|
||||
|
||||
def parse_csi(self, s): # {{{
|
||||
attr = {'key': s[-1], 'flag': '', 'val': 1, 'vals': []}
|
||||
|
||||
if len(s) == 1:
|
||||
return attr
|
||||
|
||||
full = s[0:-1]
|
||||
|
||||
if full[0] == '?':
|
||||
full = full[1:]
|
||||
attr['flag'] = '?'
|
||||
|
||||
if full != '':
|
||||
vals = full.split(';')
|
||||
for val in vals:
|
||||
|
||||
val = re.sub("\D", "", val)
|
||||
|
||||
if val != '':
|
||||
attr['vals'].append(int(val))
|
||||
|
||||
if len(attr['vals']) == 1:
|
||||
attr['val'] = int(attr['vals'][0])
|
||||
|
||||
return attr
|
||||
# }}}
|
||||
|
||||
def bound(self, val, min, max): # {{{
|
||||
if val > max:
|
||||
return max
|
||||
|
||||
if val < min:
|
||||
return min
|
||||
|
||||
return val
|
||||
# }}}
|
||||
|
||||
def xterm_to_rgb(self, color_code): # {{{
|
||||
if color_code < 16:
|
||||
ascii_colors = ['000000', 'CD0000', '00CD00', 'CDCD00', '0000EE', 'CD00CD', '00CDCD', 'E5E5E5',
|
||||
'7F7F7F', 'FF0000', '00FF00', 'FFFF00', '5C5CFF', 'FF00FF', '00FFFF', 'FFFFFF']
|
||||
return ascii_colors[color_code]
|
||||
|
||||
elif color_code < 232:
|
||||
cc = int(color_code) - 16
|
||||
|
||||
p1 = "%02x" % (math.floor(cc / 36) * (255 / 5))
|
||||
p2 = "%02x" % (math.floor((cc % 36) / 6) * (255 / 5))
|
||||
p3 = "%02x" % (math.floor(cc % 6) * (255 / 5))
|
||||
|
||||
return p1 + p2 + p3
|
||||
else:
|
||||
grey_tone = "%02x" % math.floor((255 / 24) * (color_code - 232))
|
||||
return grey_tone + grey_tone + grey_tone
|
||||
# }}}
|
||||
|
||||
# }}}
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,287 @@
|
|||
# FILE: autoload/conque_term/conque_globals.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""Common global constants and functions for Conque."""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import re
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# shared memory size
|
||||
CONQUE_SOLE_BUFFER_LENGTH = 1000
|
||||
CONQUE_SOLE_INPUT_SIZE = 1000
|
||||
CONQUE_SOLE_STATS_SIZE = 1000
|
||||
CONQUE_SOLE_COMMANDS_SIZE = 255
|
||||
CONQUE_SOLE_RESCROLL_SIZE = 255
|
||||
CONQUE_SOLE_RESIZE_SIZE = 255
|
||||
|
||||
# interval of screen redraw
|
||||
# larger number means less frequent
|
||||
CONQUE_SOLE_SCREEN_REDRAW = 100
|
||||
|
||||
# interval of full buffer redraw
|
||||
# larger number means less frequent
|
||||
CONQUE_SOLE_BUFFER_REDRAW = 500
|
||||
|
||||
# interval of full output bucket replacement
|
||||
# larger number means less frequent, 1 = every time
|
||||
CONQUE_SOLE_MEM_REDRAW = 1000
|
||||
|
||||
# PYTHON VERSION
|
||||
CONQUE_PYTHON_VERSION = sys.version_info[0]
|
||||
|
||||
|
||||
def u(str_val, str_encoding='latin-1', errors='strict'):
|
||||
"""foolhardy attempt to make unicode string syntax compatible with both python 2 and 3"""
|
||||
|
||||
if not str_val:
|
||||
str_val = ''
|
||||
|
||||
if CONQUE_PYTHON_VERSION == 3:
|
||||
return str_val
|
||||
|
||||
else:
|
||||
return unicode(str_val, str_encoding, errors)
|
||||
|
||||
# Escape sequence settings {{{
|
||||
|
||||
CONQUE_CTL = {
|
||||
1: 'soh', # start of heading
|
||||
2: 'stx', # start of text
|
||||
7: 'bel', # bell
|
||||
8: 'bs', # backspace
|
||||
9: 'tab', # tab
|
||||
10: 'nl', # new line
|
||||
13: 'cr', # carriage return
|
||||
14: 'so', # shift out
|
||||
15: 'si' # shift in
|
||||
}
|
||||
# 11 : 'vt', # vertical tab
|
||||
# 12 : 'ff', # form feed
|
||||
|
||||
# Escape sequences
|
||||
CONQUE_ESCAPE = {
|
||||
'm': 'font',
|
||||
'J': 'clear_screen',
|
||||
'K': 'clear_line',
|
||||
'@': 'add_spaces',
|
||||
'A': 'cursor_up',
|
||||
'B': 'cursor_down',
|
||||
'C': 'cursor_right',
|
||||
'D': 'cursor_left',
|
||||
'G': 'cursor_to_column',
|
||||
'H': 'cursor',
|
||||
'P': 'delete_chars',
|
||||
'f': 'cursor',
|
||||
'g': 'tab_clear',
|
||||
'r': 'set_coords',
|
||||
'h': 'set',
|
||||
'l': 'reset'
|
||||
}
|
||||
# 'L': 'insert_lines',
|
||||
# 'M': 'delete_lines',
|
||||
# 'd': 'cusor_vpos',
|
||||
|
||||
# Alternate escape sequences, no [
|
||||
CONQUE_ESCAPE_PLAIN = {
|
||||
'D': 'scroll_up',
|
||||
'E': 'next_line',
|
||||
'H': 'set_tab',
|
||||
'M': 'scroll_down'
|
||||
}
|
||||
# 'N': 'single_shift_2',
|
||||
# 'O': 'single_shift_3',
|
||||
# '=': 'alternate_keypad',
|
||||
# '>': 'numeric_keypad',
|
||||
# '7': 'save_cursor',
|
||||
# '8': 'restore_cursor',
|
||||
|
||||
# Character set escape sequences, with "("
|
||||
CONQUE_ESCAPE_CHARSET = {
|
||||
'A': 'uk',
|
||||
'B': 'us',
|
||||
'0': 'graphics'
|
||||
}
|
||||
|
||||
# Uber alternate escape sequences, with # or ?
|
||||
CONQUE_ESCAPE_QUESTION = {
|
||||
'1h': 'new_line_mode',
|
||||
'3h': '132_cols',
|
||||
'4h': 'smooth_scrolling',
|
||||
'5h': 'reverse_video',
|
||||
'6h': 'relative_origin',
|
||||
'7h': 'set_auto_wrap',
|
||||
'8h': 'set_auto_repeat',
|
||||
'9h': 'set_interlacing_mode',
|
||||
'1l': 'set_cursor_key',
|
||||
'2l': 'set_vt52',
|
||||
'3l': '80_cols',
|
||||
'4l': 'set_jump_scrolling',
|
||||
'5l': 'normal_video',
|
||||
'6l': 'absolute_origin',
|
||||
'7l': 'reset_auto_wrap',
|
||||
'8l': 'reset_auto_repeat',
|
||||
'9l': 'reset_interlacing_mode'
|
||||
}
|
||||
|
||||
CONQUE_ESCAPE_HASH = {
|
||||
'8': 'screen_alignment_test'
|
||||
}
|
||||
# '3': 'double_height_top',
|
||||
# '4': 'double_height_bottom',
|
||||
# '5': 'single_height_single_width',
|
||||
# '6': 'single_height_double_width',
|
||||
|
||||
CONQUE_GRAPHICS_SET = [
|
||||
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
|
||||
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
|
||||
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
|
||||
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
|
||||
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
|
||||
0x0028, 0x0029, 0x002A, 0x2192, 0x2190, 0x2191, 0x2193, 0x002F,
|
||||
0x2588, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
|
||||
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
|
||||
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
|
||||
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
|
||||
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
|
||||
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x00A0,
|
||||
0x25C6, 0x2592, 0x2409, 0x240C, 0x240D, 0x240A, 0x00B0, 0x00B1,
|
||||
0x2591, 0x240B, 0x2518, 0x2510, 0x250C, 0x2514, 0x253C, 0xF800,
|
||||
0xF801, 0x2500, 0xF803, 0xF804, 0x251C, 0x2524, 0x2534, 0x252C,
|
||||
0x2502, 0x2264, 0x2265, 0x03C0, 0x2260, 0x00A3, 0x00B7, 0x007F,
|
||||
0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
||||
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
||||
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
||||
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
|
||||
]
|
||||
|
||||
# Font codes {{{
|
||||
CONQUE_FONT = {
|
||||
0: {'description': 'Normal (default)', 'attributes': {'cterm': 'NONE', 'ctermfg': 'NONE', 'ctermbg': 'NONE', 'gui': 'NONE', 'guifg': 'NONE', 'guibg': 'NONE'}, 'normal': True},
|
||||
1: {'description': 'Bold', 'attributes': {'cterm': 'BOLD', 'gui': 'BOLD'}, 'normal': False},
|
||||
4: {'description': 'Underlined', 'attributes': {'cterm': 'UNDERLINE', 'gui': 'UNDERLINE'}, 'normal': False},
|
||||
5: {'description': 'Blink (appears as Bold)', 'attributes': {'cterm': 'BOLD', 'gui': 'BOLD'}, 'normal': False},
|
||||
7: {'description': 'Inverse', 'attributes': {'cterm': 'REVERSE', 'gui': 'REVERSE'}, 'normal': False},
|
||||
8: {'description': 'Invisible (hidden)', 'attributes': {'ctermfg': '0', 'ctermbg': '0', 'guifg': '#000000', 'guibg': '#000000'}, 'normal': False},
|
||||
22: {'description': 'Normal (neither bold nor faint)', 'attributes': {'cterm': 'NONE', 'gui': 'NONE'}, 'normal': True},
|
||||
24: {'description': 'Not underlined', 'attributes': {'cterm': 'NONE', 'gui': 'NONE'}, 'normal': True},
|
||||
25: {'description': 'Steady (not blinking)', 'attributes': {'cterm': 'NONE', 'gui': 'NONE'}, 'normal': True},
|
||||
27: {'description': 'Positive (not inverse)', 'attributes': {'cterm': 'NONE', 'gui': 'NONE'}, 'normal': True},
|
||||
28: {'description': 'Visible (not hidden)', 'attributes': {'ctermfg': 'NONE', 'ctermbg': 'NONE', 'guifg': 'NONE', 'guibg': 'NONE'}, 'normal': True},
|
||||
30: {'description': 'Set foreground color to Black', 'attributes': {'ctermfg': '16', 'guifg': '#000000'}, 'normal': False},
|
||||
31: {'description': 'Set foreground color to Red', 'attributes': {'ctermfg': '1', 'guifg': '#ff0000'}, 'normal': False},
|
||||
32: {'description': 'Set foreground color to Green', 'attributes': {'ctermfg': '2', 'guifg': '#00ff00'}, 'normal': False},
|
||||
33: {'description': 'Set foreground color to Yellow', 'attributes': {'ctermfg': '3', 'guifg': '#ffff00'}, 'normal': False},
|
||||
34: {'description': 'Set foreground color to Blue', 'attributes': {'ctermfg': '4', 'guifg': '#0000ff'}, 'normal': False},
|
||||
35: {'description': 'Set foreground color to Magenta', 'attributes': {'ctermfg': '5', 'guifg': '#990099'}, 'normal': False},
|
||||
36: {'description': 'Set foreground color to Cyan', 'attributes': {'ctermfg': '6', 'guifg': '#009999'}, 'normal': False},
|
||||
37: {'description': 'Set foreground color to White', 'attributes': {'ctermfg': '7', 'guifg': '#ffffff'}, 'normal': False},
|
||||
39: {'description': 'Set foreground color to default (original)', 'attributes': {'ctermfg': 'NONE', 'guifg': 'NONE'}, 'normal': True},
|
||||
40: {'description': 'Set background color to Black', 'attributes': {'ctermbg': '16', 'guibg': '#000000'}, 'normal': False},
|
||||
41: {'description': 'Set background color to Red', 'attributes': {'ctermbg': '1', 'guibg': '#ff0000'}, 'normal': False},
|
||||
42: {'description': 'Set background color to Green', 'attributes': {'ctermbg': '2', 'guibg': '#00ff00'}, 'normal': False},
|
||||
43: {'description': 'Set background color to Yellow', 'attributes': {'ctermbg': '3', 'guibg': '#ffff00'}, 'normal': False},
|
||||
44: {'description': 'Set background color to Blue', 'attributes': {'ctermbg': '4', 'guibg': '#0000ff'}, 'normal': False},
|
||||
45: {'description': 'Set background color to Magenta', 'attributes': {'ctermbg': '5', 'guibg': '#990099'}, 'normal': False},
|
||||
46: {'description': 'Set background color to Cyan', 'attributes': {'ctermbg': '6', 'guibg': '#009999'}, 'normal': False},
|
||||
47: {'description': 'Set background color to White', 'attributes': {'ctermbg': '7', 'guibg': '#ffffff'}, 'normal': False},
|
||||
49: {'description': 'Set background color to default (original).', 'attributes': {'ctermbg': 'NONE', 'guibg': 'NONE'}, 'normal': True},
|
||||
90: {'description': 'Set foreground color to Black', 'attributes': {'ctermfg': '8', 'guifg': '#000000'}, 'normal': False},
|
||||
91: {'description': 'Set foreground color to Red', 'attributes': {'ctermfg': '9', 'guifg': '#ff0000'}, 'normal': False},
|
||||
92: {'description': 'Set foreground color to Green', 'attributes': {'ctermfg': '10', 'guifg': '#00ff00'}, 'normal': False},
|
||||
93: {'description': 'Set foreground color to Yellow', 'attributes': {'ctermfg': '11', 'guifg': '#ffff00'}, 'normal': False},
|
||||
94: {'description': 'Set foreground color to Blue', 'attributes': {'ctermfg': '12', 'guifg': '#0000ff'}, 'normal': False},
|
||||
95: {'description': 'Set foreground color to Magenta', 'attributes': {'ctermfg': '13', 'guifg': '#990099'}, 'normal': False},
|
||||
96: {'description': 'Set foreground color to Cyan', 'attributes': {'ctermfg': '14', 'guifg': '#009999'}, 'normal': False},
|
||||
97: {'description': 'Set foreground color to White', 'attributes': {'ctermfg': '15', 'guifg': '#ffffff'}, 'normal': False},
|
||||
100: {'description': 'Set background color to Black', 'attributes': {'ctermbg': '8', 'guibg': '#000000'}, 'normal': False},
|
||||
101: {'description': 'Set background color to Red', 'attributes': {'ctermbg': '9', 'guibg': '#ff0000'}, 'normal': False},
|
||||
102: {'description': 'Set background color to Green', 'attributes': {'ctermbg': '10', 'guibg': '#00ff00'}, 'normal': False},
|
||||
103: {'description': 'Set background color to Yellow', 'attributes': {'ctermbg': '11', 'guibg': '#ffff00'}, 'normal': False},
|
||||
104: {'description': 'Set background color to Blue', 'attributes': {'ctermbg': '12', 'guibg': '#0000ff'}, 'normal': False},
|
||||
105: {'description': 'Set background color to Magenta', 'attributes': {'ctermbg': '13', 'guibg': '#990099'}, 'normal': False},
|
||||
106: {'description': 'Set background color to Cyan', 'attributes': {'ctermbg': '14', 'guibg': '#009999'}, 'normal': False},
|
||||
107: {'description': 'Set background color to White', 'attributes': {'ctermbg': '15', 'guibg': '#ffffff'}, 'normal': False}
|
||||
}
|
||||
# }}}
|
||||
|
||||
# regular expression matching (almost) all control sequences
|
||||
CONQUE_SEQ_REGEX = re.compile(u("(\x1b\[?\??#?[0-9;]*[a-zA-Z0-9@=>]|\x1b\][0-9];.*?\x07|[\x01-\x0f]|\x1b\([AB0])"), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_CTL = re.compile(u("^[\x01-\x0f]$"), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_CSI = re.compile(u("^\x1b\["), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_TITLE = re.compile(u("^\x1b\]"), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_HASH = re.compile(u("^\x1b#"), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_ESC = re.compile(u("^\x1b.$"), re.UNICODE)
|
||||
CONQUE_SEQ_REGEX_CHAR = re.compile(u("^\x1b\("), re.UNICODE)
|
||||
|
||||
# match table output
|
||||
CONQUE_TABLE_OUTPUT = re.compile("^\s*\|\s.*\s\|\s*$|^\s*\+[=+-]+\+\s*$")
|
||||
|
||||
# }}}
|
||||
|
||||
# Windows subprocess config {{{
|
||||
|
||||
CONQUE_SEQ_REGEX_VK = re.compile(u("(\x1b\[\d{1,3}VK)"), re.UNICODE)
|
||||
|
||||
# }}}
|
||||
|
||||
CONQUE_COLOR_SEQUENCE = (
|
||||
'000', '009', '090', '099', '900', '909', '990', '999',
|
||||
'000', '00f', '0f0', '0ff', 'f00', 'f0f', 'ff0', 'fff'
|
||||
)
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,209 @@
|
|||
# FILE: autoload/conque_term/conque_screen.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""
|
||||
ConqueScreen is an extention of the vim.current.buffer object
|
||||
|
||||
It restricts the working indices of the buffer object to the scroll region
|
||||
which pty is expecting. It also uses 1-based indexes, to match escape
|
||||
sequence commands.
|
||||
|
||||
E.g.:
|
||||
s = ConqueScreen()
|
||||
...
|
||||
s[5] = 'Set 5th line in terminal to this line'
|
||||
s.append('Add new line to terminal')
|
||||
s[5] = 'Since previous append() command scrolled the terminal down, this is a different line than first cb[5] call'
|
||||
"""
|
||||
|
||||
import vim
|
||||
|
||||
|
||||
class ConqueScreen(object):
|
||||
|
||||
# CLASS PROPERTIES {{{
|
||||
|
||||
# the buffer
|
||||
buffer = None
|
||||
|
||||
# screen and scrolling regions
|
||||
screen_top = 1
|
||||
|
||||
# screen width
|
||||
screen_width = 80
|
||||
screen_height = 80
|
||||
|
||||
# }}}
|
||||
|
||||
def __init__(self): # {{{
|
||||
self.buffer = vim.current.buffer
|
||||
|
||||
self.screen_top = 1
|
||||
self.screen_width = vim.current.window.width
|
||||
self.screen_height = vim.current.window.height
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# List overload {{{
|
||||
|
||||
def __len__(self): # {{{
|
||||
return len(self.buffer)
|
||||
# }}}
|
||||
|
||||
def __getitem__(self, key): # {{{
|
||||
real_line = self.get_real_idx(key)
|
||||
|
||||
# if line is past buffer end, add lines to buffer
|
||||
if real_line >= len(self.buffer):
|
||||
for i in range(len(self.buffer), real_line + 1):
|
||||
self.append(' ' * self.screen_width)
|
||||
|
||||
return u(self.buffer[real_line], 'utf-8')
|
||||
# }}}
|
||||
|
||||
def __setitem__(self, key, value): # {{{
|
||||
real_line = self.get_real_idx(key)
|
||||
|
||||
if CONQUE_PYTHON_VERSION == 2:
|
||||
val = value.encode('utf-8')
|
||||
else:
|
||||
# XXX / Vim's python3 interface doesn't accept bytes object
|
||||
val = str(value)
|
||||
|
||||
# if line is past end of screen, append
|
||||
if real_line == len(self.buffer):
|
||||
self.buffer.append(val)
|
||||
else:
|
||||
self.buffer[real_line] = val
|
||||
# }}}
|
||||
|
||||
def __delitem__(self, key): # {{{
|
||||
del self.buffer[self.screen_top + key - 2]
|
||||
# }}}
|
||||
|
||||
def append(self, value): # {{{
|
||||
if len(self.buffer) > self.screen_top + self.screen_height - 1:
|
||||
self.buffer[len(self.buffer) - 1] = value
|
||||
else:
|
||||
self.buffer.append(value)
|
||||
|
||||
if len(self.buffer) > self.screen_top + self.screen_height - 1:
|
||||
self.screen_top += 1
|
||||
if vim.current.buffer.number == self.buffer.number:
|
||||
vim.command('normal G')
|
||||
# }}}
|
||||
|
||||
def insert(self, line, value): # {{{
|
||||
|
||||
l = self.screen_top + line - 2
|
||||
self.buffer.append(value, l)
|
||||
|
||||
# }}}
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
# Util {{{
|
||||
|
||||
def get_top(self): # {{{
|
||||
return self.screen_top
|
||||
# }}}
|
||||
|
||||
def get_real_idx(self, line): # {{{
|
||||
return (self.screen_top + line - 2)
|
||||
# }}}
|
||||
|
||||
def get_real_line(self, line): # {{{
|
||||
return (self.screen_top + line - 1)
|
||||
# }}}
|
||||
|
||||
def set_screen_width(self, width): # {{{
|
||||
self.screen_width = width
|
||||
# }}}
|
||||
|
||||
# }}}
|
||||
|
||||
###############################################################################################
|
||||
def clear(self): # {{{
|
||||
self.buffer.append(' ')
|
||||
vim.command('normal Gzt')
|
||||
self.screen_top = len(self.buffer)
|
||||
# }}}
|
||||
|
||||
def set_cursor(self, line, column): # {{{
|
||||
# figure out line
|
||||
real_line = self.screen_top + line - 1
|
||||
if real_line > len(self.buffer):
|
||||
for l in range(len(self.buffer) - 1, real_line):
|
||||
self.buffer.append('')
|
||||
|
||||
# figure out column
|
||||
real_column = column
|
||||
if len(self.buffer[real_line - 1]) < real_column:
|
||||
self.buffer[real_line - 1] = self.buffer[real_line - 1] + ' ' * (real_column - len(self.buffer[real_line - 1]))
|
||||
|
||||
# python version is occasionally grumpy
|
||||
try:
|
||||
vim.current.window.cursor = (real_line, real_column - 1)
|
||||
except:
|
||||
vim.command('call cursor(' + str(real_line) + ', ' + str(real_column) + ')')
|
||||
# }}}
|
||||
|
||||
def reset_size(self, line): # {{{
|
||||
|
||||
|
||||
|
||||
|
||||
# save cursor line number
|
||||
real_line = self.screen_top + line
|
||||
|
||||
# reset screen size
|
||||
self.screen_width = vim.current.window.width
|
||||
self.screen_height = vim.current.window.height
|
||||
self.screen_top = len(self.buffer) - vim.current.window.height + 1
|
||||
if self.screen_top < 1:
|
||||
self.screen_top = 1
|
||||
|
||||
|
||||
# align bottom of buffer to bottom of screen
|
||||
vim.command('normal ' + str(self.screen_height) + 'kG')
|
||||
|
||||
# return new relative line number
|
||||
return (real_line - self.screen_top)
|
||||
# }}}
|
||||
|
||||
def scroll_to_bottom(self): # {{{
|
||||
vim.current.window.cursor = (len(self.buffer) - 1, 1)
|
||||
# }}}
|
||||
|
||||
def align(self): # {{{
|
||||
# align bottom of buffer to bottom of screen
|
||||
vim.command('normal ' + str(self.screen_height) + 'kG')
|
||||
# }}}
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,459 @@
|
|||
# FILE: autoload/conque_term/conque_sole.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
import vim
|
||||
|
||||
|
||||
class ConqueSole(Conque):
|
||||
|
||||
window_top = None
|
||||
window_bottom = None
|
||||
|
||||
color_cache = {}
|
||||
color_mode = None
|
||||
color_conceals = {}
|
||||
|
||||
buffer = None
|
||||
|
||||
# counters for periodic rendering
|
||||
buffer_redraw_ct = 0
|
||||
screen_redraw_ct = 0
|
||||
|
||||
# *********************************************************************************************
|
||||
# start program and initialize this instance
|
||||
|
||||
def open(self, command, options={}, python_exe='', communicator_py=''): # {{{
|
||||
|
||||
# init size
|
||||
self.columns = vim.current.window.width
|
||||
self.lines = vim.current.window.height
|
||||
self.window_top = 0
|
||||
self.window_bottom = vim.current.window.height - 1
|
||||
|
||||
# init color
|
||||
self.enable_colors = options['color']
|
||||
|
||||
# open command
|
||||
self.proc = ConqueSoleWrapper()
|
||||
self.proc.open(command, {'TERM': options['TERM'], 'CONQUE': '1', 'LINES': self.lines, 'COLUMNS': self.columns}, python_exe, communicator_py)
|
||||
|
||||
self.buffer = vim.current.buffer
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# *********************************************************************************************
|
||||
# read and update screen
|
||||
|
||||
def read(self, timeout=1, set_cursor=True, return_output=False, update_buffer=True): # {{{
|
||||
|
||||
try:
|
||||
stats = self.proc.get_stats()
|
||||
|
||||
if not stats:
|
||||
return
|
||||
|
||||
self.buffer_redraw_ct += 1
|
||||
self.screen_redraw_ct += 1
|
||||
|
||||
update_top = 0
|
||||
update_bottom = 0
|
||||
lines = []
|
||||
|
||||
# full buffer redraw, our favorite!
|
||||
if self.buffer_redraw_ct == CONQUE_SOLE_BUFFER_REDRAW:
|
||||
self.buffer_redraw_ct = 0
|
||||
update_top = 0
|
||||
update_bottom = stats['top_offset'] + self.lines
|
||||
(lines, attributes) = self.proc.read(update_top, update_bottom)
|
||||
if return_output:
|
||||
output = self.get_new_output(lines, update_top, stats)
|
||||
if update_buffer:
|
||||
for i in range(update_top, update_bottom + 1):
|
||||
self.plain_text(i, lines[i], attributes[i], stats)
|
||||
|
||||
# full screen redraw
|
||||
elif stats['cursor_y'] + 1 != self.l or stats['top_offset'] != self.window_top or self.screen_redraw_ct == CONQUE_SOLE_SCREEN_REDRAW:
|
||||
self.screen_redraw_ct = 0
|
||||
update_top = self.window_top
|
||||
update_bottom = stats['top_offset'] + self.lines + 1
|
||||
(lines, attributes) = self.proc.read(update_top, update_bottom - update_top + 1)
|
||||
if return_output:
|
||||
output = self.get_new_output(lines, update_top, stats)
|
||||
if update_buffer:
|
||||
for i in range(update_top, update_bottom + 1):
|
||||
self.plain_text(i, lines[i - update_top], attributes[i - update_top], stats)
|
||||
|
||||
|
||||
# single line redraw
|
||||
else:
|
||||
update_top = stats['cursor_y']
|
||||
update_bottom = stats['cursor_y']
|
||||
(lines, attributes) = self.proc.read(update_top, 1)
|
||||
if return_output:
|
||||
output = self.get_new_output(lines, update_top, stats)
|
||||
if update_buffer:
|
||||
if lines[0].rstrip() != self.buffer[update_top].rstrip():
|
||||
self.plain_text(update_top, lines[0], attributes[0], stats)
|
||||
|
||||
|
||||
# reset current position
|
||||
self.window_top = stats['top_offset']
|
||||
self.l = stats['cursor_y'] + 1
|
||||
self.c = stats['cursor_x'] + 1
|
||||
|
||||
# reposition cursor if this seems plausible
|
||||
if set_cursor:
|
||||
self.set_cursor(self.l, self.c)
|
||||
|
||||
if return_output:
|
||||
return output
|
||||
|
||||
except:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# Calculate the "new" output from this read. Fake but useful
|
||||
|
||||
def get_new_output(self, lines, update_top, stats): # {{{
|
||||
|
||||
if not (stats['cursor_y'] + 1 > self.l or (stats['cursor_y'] + 1 == self.l and stats['cursor_x'] + 1 > self.c)):
|
||||
return ""
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
try:
|
||||
num_to_return = stats['cursor_y'] - self.l + 2
|
||||
|
||||
lines = lines[self.l - update_top - 1:]
|
||||
|
||||
|
||||
new_output = []
|
||||
|
||||
# first line
|
||||
new_output.append(lines[0][self.c - 1:].rstrip())
|
||||
|
||||
# the rest
|
||||
for i in range(1, num_to_return):
|
||||
new_output.append(lines[i].rstrip())
|
||||
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
|
||||
|
||||
return "\n".join(new_output)
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# update the buffer
|
||||
|
||||
def plain_text(self, line_nr, text, attributes, stats): # {{{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
self.l = line_nr + 1
|
||||
|
||||
# remove trailing whitespace
|
||||
text = text.rstrip()
|
||||
|
||||
# if we're using concealed text for color, then s- is weird
|
||||
if self.color_mode == 'conceal':
|
||||
|
||||
text = self.add_conceal_color(text, attributes, stats, line_nr)
|
||||
|
||||
|
||||
# update vim buffer
|
||||
if len(self.buffer) <= line_nr:
|
||||
self.buffer.append(text)
|
||||
else:
|
||||
self.buffer[line_nr] = text
|
||||
|
||||
if not self.color_mode == 'conceal':
|
||||
self.do_color(attributes=attributes, stats=stats)
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# add conceal color
|
||||
|
||||
def add_conceal_color(self, text, attributes, stats, line_nr): # {{{
|
||||
|
||||
# stop here if coloration is disabled
|
||||
if not self.enable_colors:
|
||||
return text
|
||||
|
||||
# if no colors for this line, clear everything out
|
||||
if len(attributes) == 0 or attributes == u(chr(stats['default_attribute'])) * len(attributes):
|
||||
return text
|
||||
|
||||
new_text = ''
|
||||
|
||||
# if text attribute is different, call add_color()
|
||||
attr = None
|
||||
start = 0
|
||||
self.color_conceals[line_nr] = []
|
||||
ends = []
|
||||
for i in range(0, len(attributes)):
|
||||
c = ord(attributes[i])
|
||||
|
||||
if c != attr:
|
||||
if attr and attr != stats['default_attribute']:
|
||||
|
||||
color = self.translate_color(attr)
|
||||
|
||||
new_text += chr(27) + 'sf' + color['fg_code'] + ';'
|
||||
ends.append(chr(27) + 'ef' + color['fg_code'] + ';')
|
||||
self.color_conceals[line_nr].append(start)
|
||||
|
||||
if c > 15:
|
||||
new_text += chr(27) + 'sf' + color['bg_code'] + ';'
|
||||
ends.append(chr(27) + 'ef' + color['bg_code'] + ';')
|
||||
self.color_conceals[line_nr].append(start)
|
||||
|
||||
new_text += text[start:i]
|
||||
|
||||
# close color regions
|
||||
ends.reverse()
|
||||
for j in range(0, len(ends)):
|
||||
new_text += ends[j]
|
||||
self.color_conceals[line_nr].append(i)
|
||||
ends = []
|
||||
|
||||
start = i
|
||||
attr = c
|
||||
|
||||
|
||||
if attr and attr != stats['default_attribute']:
|
||||
|
||||
color = self.translate_color(attr)
|
||||
|
||||
new_text += chr(27) + 'sf' + color['fg_code'] + ';'
|
||||
ends.append(chr(27) + 'ef' + color['fg_code'] + ';')
|
||||
|
||||
if c > 15:
|
||||
new_text += chr(27) + 'sf' + color['bg_code'] + ';'
|
||||
ends.append(chr(27) + 'ef' + color['bg_code'] + ';')
|
||||
|
||||
new_text += text[start:]
|
||||
|
||||
# close color regions
|
||||
ends.reverse()
|
||||
for i in range(0, len(ends)):
|
||||
new_text += ends[i]
|
||||
|
||||
return new_text
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
|
||||
def do_color(self, start=0, end=0, attributes='', stats=None): # {{{
|
||||
|
||||
# stop here if coloration is disabled
|
||||
if not self.enable_colors:
|
||||
return
|
||||
|
||||
# if no colors for this line, clear everything out
|
||||
if len(attributes) == 0 or attributes == u(chr(stats['default_attribute'])) * len(attributes):
|
||||
self.color_changes = {}
|
||||
self.apply_color(1, len(attributes), self.l)
|
||||
return
|
||||
|
||||
# if text attribute is different, call add_color()
|
||||
attr = None
|
||||
start = 0
|
||||
for i in range(0, len(attributes)):
|
||||
c = ord(attributes[i])
|
||||
|
||||
if c != attr:
|
||||
if attr and attr != stats['default_attribute']:
|
||||
self.color_changes = self.translate_color(attr)
|
||||
self.apply_color(start + 1, i + 1, self.l)
|
||||
start = i
|
||||
attr = c
|
||||
|
||||
if attr and attr != stats['default_attribute']:
|
||||
self.color_changes = self.translate_color(attr)
|
||||
self.apply_color(start + 1, len(attributes), self.l)
|
||||
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
|
||||
def translate_color(self, attr): # {{{
|
||||
|
||||
# check for cached color
|
||||
if attr in self.color_cache:
|
||||
return self.color_cache[attr]
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# convert attribute integer to bit string
|
||||
bit_str = bin(attr)
|
||||
bit_str = bit_str.replace('0b', '')
|
||||
|
||||
# slice foreground and background portions of bit string
|
||||
fg = bit_str[-4:].rjust(4, '0')
|
||||
bg = bit_str[-8:-4].rjust(4, '0')
|
||||
|
||||
# ok, first create foreground #rbg
|
||||
red = int(fg[1]) * 204 + int(fg[0]) * int(fg[1]) * 51
|
||||
green = int(fg[2]) * 204 + int(fg[0]) * int(fg[2]) * 51
|
||||
blue = int(fg[3]) * 204 + int(fg[0]) * int(fg[3]) * 51
|
||||
fg_str = "#%02x%02x%02x" % (red, green, blue)
|
||||
fg_code = "%02x%02x%02x" % (red, green, blue)
|
||||
fg_code = fg_code[0] + fg_code[2] + fg_code[4]
|
||||
|
||||
# ok, first create foreground #rbg
|
||||
red = int(bg[1]) * 204 + int(bg[0]) * int(bg[1]) * 51
|
||||
green = int(bg[2]) * 204 + int(bg[0]) * int(bg[2]) * 51
|
||||
blue = int(bg[3]) * 204 + int(bg[0]) * int(bg[3]) * 51
|
||||
bg_str = "#%02x%02x%02x" % (red, green, blue)
|
||||
bg_code = "%02x%02x%02x" % (red, green, blue)
|
||||
bg_code = bg_code[0] + bg_code[2] + bg_code[4]
|
||||
|
||||
# build value for color_changes
|
||||
|
||||
color = {'guifg': fg_str, 'guibg': bg_str}
|
||||
|
||||
if self.color_mode == 'conceal':
|
||||
color['fg_code'] = fg_code
|
||||
color['bg_code'] = bg_code
|
||||
|
||||
self.color_cache[attr] = color
|
||||
|
||||
return color
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# write virtual key code to shared memory using proprietary escape seq
|
||||
|
||||
def write_vk(self, vk_code): # {{{
|
||||
|
||||
self.proc.write_vk(vk_code)
|
||||
|
||||
# }}}
|
||||
|
||||
# *********************************************************************************************
|
||||
# resize if needed
|
||||
|
||||
def update_window_size(self): # {{{
|
||||
|
||||
if vim.current.window.width != self.columns or vim.current.window.height != self.lines:
|
||||
|
||||
# reset all window size attributes to default
|
||||
self.columns = vim.current.window.width
|
||||
self.lines = vim.current.window.height
|
||||
self.working_columns = vim.current.window.width
|
||||
self.working_lines = vim.current.window.height
|
||||
self.bottom = vim.current.window.height
|
||||
|
||||
self.proc.window_resize(vim.current.window.height, vim.current.window.width)
|
||||
|
||||
# }}}
|
||||
|
||||
# *********************************************************************************************
|
||||
# resize if needed
|
||||
|
||||
def set_cursor(self, line, column): # {{{
|
||||
|
||||
# shift cursor position to handle concealed text
|
||||
if self.enable_colors and self.color_mode == 'conceal':
|
||||
if line - 1 in self.color_conceals:
|
||||
for c in self.color_conceals[line - 1]:
|
||||
if c < column:
|
||||
column += 7
|
||||
else:
|
||||
break
|
||||
|
||||
# figure out line
|
||||
real_line = line
|
||||
if real_line > len(self.buffer):
|
||||
for l in range(len(self.buffer) - 1, real_line):
|
||||
self.buffer.append('')
|
||||
|
||||
# figure out column
|
||||
real_column = column
|
||||
if len(self.buffer[real_line - 1]) < real_column:
|
||||
self.buffer[real_line - 1] = self.buffer[real_line - 1] + ' ' * (real_column - len(self.buffer[real_line - 1]))
|
||||
|
||||
# python version is occasionally grumpy
|
||||
try:
|
||||
vim.current.window.cursor = (real_line, real_column - 1)
|
||||
except:
|
||||
vim.command('call cursor(' + str(real_line) + ', ' + str(real_column) + ')')
|
||||
# }}}
|
||||
|
||||
|
||||
# *********************************************************************************************
|
||||
# go into idle mode
|
||||
|
||||
def idle(self): # {{{
|
||||
|
||||
self.proc.idle()
|
||||
|
||||
# }}}
|
||||
|
||||
# *********************************************************************************************
|
||||
# resume from idle mode
|
||||
|
||||
def resume(self): # {{{
|
||||
|
||||
self.proc.resume()
|
||||
|
||||
# }}}
|
||||
|
||||
# *********************************************************************************************
|
||||
# end subprocess
|
||||
|
||||
def close(self):
|
||||
self.proc.close()
|
||||
|
||||
# *********************************************************************************************
|
||||
# end subprocess forcefully
|
||||
|
||||
def abort(self):
|
||||
self.proc.close()
|
||||
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,183 @@
|
|||
# FILE: autoload/conque_term/conque_sole_communicator.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""
|
||||
ConqueSoleCommunicator
|
||||
|
||||
Script to transfer communications between python being run in Vim and a
|
||||
subprocess run inside a Windows console. This is required since interactive
|
||||
programs in Windows appear to require a console, and python run in Vim is
|
||||
not attached to any console. So a console version of python must be initiated
|
||||
for the subprocess. Communication is then done with the use of shared memory
|
||||
objects. Good times!
|
||||
"""
|
||||
|
||||
import time
|
||||
import sys
|
||||
|
||||
from conque_globals import *
|
||||
from conque_win32_util import *
|
||||
from conque_sole_subprocess import *
|
||||
from conque_sole_shared_memory import *
|
||||
|
||||
##############################################################
|
||||
# only run if this file was run directly
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
# attempt to catch ALL exceptions to fend of zombies
|
||||
try:
|
||||
|
||||
# startup and config {{{
|
||||
|
||||
# simple arg validation
|
||||
|
||||
if len(sys.argv) < 5:
|
||||
|
||||
exit()
|
||||
|
||||
# shared memory size
|
||||
CONQUE_SOLE_COMMANDS_SIZE = 255
|
||||
|
||||
# maximum time this thing reads. 0 means no limit. Only for testing.
|
||||
max_loops = 0
|
||||
|
||||
# read interval, in seconds
|
||||
sleep_time = 0.01
|
||||
|
||||
# idle read interval, in seconds
|
||||
idle_sleep_time = 0.10
|
||||
|
||||
# are we idled?
|
||||
is_idle = False
|
||||
|
||||
# mem key
|
||||
mem_key = sys.argv[1]
|
||||
|
||||
# console width
|
||||
console_width = int(sys.argv[2])
|
||||
|
||||
# console height
|
||||
console_height = int(sys.argv[3])
|
||||
|
||||
# the actual subprocess to run
|
||||
cmd_line = " ".join(sys.argv[4:])
|
||||
|
||||
|
||||
# width and height
|
||||
options = {'LINES': console_height, 'COLUMNS': console_width}
|
||||
|
||||
|
||||
|
||||
# set initial idle status
|
||||
shm_command = ConqueSoleSharedMemory(CONQUE_SOLE_COMMANDS_SIZE, 'command', mem_key, serialize=True)
|
||||
shm_command.create('write')
|
||||
|
||||
cmd = shm_command.read()
|
||||
if cmd:
|
||||
|
||||
if cmd['cmd'] == 'idle':
|
||||
is_idle = True
|
||||
shm_command.clear()
|
||||
|
||||
# }}}
|
||||
|
||||
##############################################################
|
||||
# Create the subprocess
|
||||
|
||||
# {{{
|
||||
proc = ConqueSoleSubprocess()
|
||||
res = proc.open(cmd_line, mem_key, options)
|
||||
|
||||
if not res:
|
||||
|
||||
exit()
|
||||
|
||||
# }}}
|
||||
|
||||
##############################################################
|
||||
# main loop!
|
||||
|
||||
loops = 0
|
||||
|
||||
while True:
|
||||
|
||||
# check for idle/resume
|
||||
if is_idle or loops % 25 == 0:
|
||||
|
||||
# check process health
|
||||
if not proc.is_alive():
|
||||
|
||||
proc.close()
|
||||
exit()
|
||||
|
||||
# check for change in buffer focus
|
||||
cmd = shm_command.read()
|
||||
if cmd:
|
||||
|
||||
if cmd['cmd'] == 'idle':
|
||||
is_idle = True
|
||||
shm_command.clear()
|
||||
|
||||
elif cmd['cmd'] == 'resume':
|
||||
is_idle = False
|
||||
shm_command.clear()
|
||||
|
||||
|
||||
# sleep between loops if moderation is requested
|
||||
if sleep_time > 0:
|
||||
if is_idle:
|
||||
time.sleep(idle_sleep_time)
|
||||
else:
|
||||
time.sleep(sleep_time)
|
||||
|
||||
# write, read, etc
|
||||
proc.write()
|
||||
proc.read()
|
||||
|
||||
# increment loops, and exit if max has been reached
|
||||
loops += 1
|
||||
if max_loops and loops >= max_loops:
|
||||
|
||||
break
|
||||
|
||||
##############################################################
|
||||
# all done!
|
||||
|
||||
|
||||
|
||||
proc.close()
|
||||
|
||||
# if an exception was thrown, croak
|
||||
except:
|
||||
|
||||
proc.close()
|
||||
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,202 @@
|
|||
# FILE: autoload/conque_term/conque_sole_shared_memory.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""Wrapper class for shared memory between Windows python processes"""
|
||||
|
||||
import mmap
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] == 2:
|
||||
CONQUE_PYTHON_VERSION = 2
|
||||
else:
|
||||
CONQUE_PYTHON_VERSION = 3
|
||||
|
||||
if CONQUE_PYTHON_VERSION == 2:
|
||||
import cPickle as pickle
|
||||
else:
|
||||
import pickle
|
||||
|
||||
|
||||
class ConqueSoleSharedMemory():
|
||||
|
||||
# ****************************************************************************
|
||||
# class properties
|
||||
|
||||
# {{{
|
||||
|
||||
# is the data being stored not fixed length
|
||||
fixed_length = False
|
||||
|
||||
# fill memory with this character when clearing and fixed_length is true
|
||||
fill_char = ' '
|
||||
|
||||
# serialize and unserialize data automatically
|
||||
serialize = False
|
||||
|
||||
# size of shared memory, in bytes / chars
|
||||
mem_size = None
|
||||
|
||||
# size of shared memory, in bytes / chars
|
||||
mem_type = None
|
||||
|
||||
# unique key, so multiple console instances are possible
|
||||
mem_key = None
|
||||
|
||||
# mmap instance
|
||||
shm = None
|
||||
|
||||
# character encoding, dammit
|
||||
encoding = 'ascii'
|
||||
|
||||
# pickle terminator
|
||||
TERMINATOR = None
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# constructor I guess
|
||||
|
||||
def __init__(self, mem_size, mem_type, mem_key, fixed_length=False, fill_char=' ', serialize=False, encoding='ascii'): # {{{
|
||||
|
||||
self.mem_size = mem_size
|
||||
self.mem_type = mem_type
|
||||
self.mem_key = mem_key
|
||||
self.fixed_length = fixed_length
|
||||
self.fill_char = fill_char
|
||||
self.serialize = serialize
|
||||
self.encoding = encoding
|
||||
self.TERMINATOR = str(chr(0)).encode(self.encoding)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# create memory block
|
||||
|
||||
def create(self, access='write'): # {{{
|
||||
|
||||
if access == 'write':
|
||||
mmap_access = mmap.ACCESS_WRITE
|
||||
else:
|
||||
mmap_access = mmap.ACCESS_READ
|
||||
|
||||
name = "conque_%s_%s" % (self.mem_type, self.mem_key)
|
||||
|
||||
self.shm = mmap.mmap(0, self.mem_size, name, mmap_access)
|
||||
|
||||
if not self.shm:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# read data
|
||||
|
||||
def read(self, chars=1, start=0): # {{{
|
||||
|
||||
# invalid reads
|
||||
if self.fixed_length and (chars == 0 or start + chars > self.mem_size):
|
||||
return ''
|
||||
|
||||
# go to start position
|
||||
self.shm.seek(start)
|
||||
|
||||
if not self.fixed_length:
|
||||
chars = self.shm.find(self.TERMINATOR)
|
||||
|
||||
if chars == 0:
|
||||
return ''
|
||||
|
||||
shm_str = self.shm.read(chars)
|
||||
|
||||
# return unpickled byte object
|
||||
if self.serialize:
|
||||
return pickle.loads(shm_str)
|
||||
|
||||
# decode byes in python 3
|
||||
if CONQUE_PYTHON_VERSION == 3:
|
||||
return str(shm_str, self.encoding)
|
||||
|
||||
# encoding
|
||||
if self.encoding != 'ascii':
|
||||
shm_str = unicode(shm_str, self.encoding)
|
||||
|
||||
return shm_str
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# write data
|
||||
|
||||
def write(self, text, start=0): # {{{
|
||||
|
||||
# simple scenario, let pickle create bytes
|
||||
if self.serialize:
|
||||
if CONQUE_PYTHON_VERSION == 3:
|
||||
tb = pickle.dumps(text, 0)
|
||||
else:
|
||||
tb = pickle.dumps(text, 0).encode(self.encoding)
|
||||
|
||||
else:
|
||||
tb = text.encode(self.encoding, 'replace')
|
||||
|
||||
self.shm.seek(start)
|
||||
|
||||
# write to memory
|
||||
if self.fixed_length:
|
||||
self.shm.write(tb)
|
||||
else:
|
||||
self.shm.write(tb + self.TERMINATOR)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# clear
|
||||
|
||||
def clear(self, start=0): # {{{
|
||||
|
||||
self.shm.seek(start)
|
||||
|
||||
if self.fixed_length:
|
||||
self.shm.write(str(self.fill_char * self.mem_size).encode(self.encoding))
|
||||
else:
|
||||
self.shm.write(self.TERMINATOR)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# close
|
||||
|
||||
def close(self):
|
||||
|
||||
self.shm.close()
|
||||
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,753 @@
|
|||
# FILE: autoload/conque_term/conque_sole_subprocess.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
""" ConqueSoleSubprocess {{{
|
||||
|
||||
Creates a new subprocess with it's own (hidden) console window.
|
||||
|
||||
Mirrors console window text onto a block of shared memory (mmap), along with
|
||||
text attribute data. Also handles translation of text input into the format
|
||||
Windows console expects.
|
||||
|
||||
Sample Usage:
|
||||
|
||||
sh = ConqueSoleSubprocess()
|
||||
sh.open("cmd.exe", "unique_str")
|
||||
|
||||
shm_in = ConqueSoleSharedMemory(mem_key = "unique_str", mem_type = "input", ...)
|
||||
shm_out = ConqueSoleSharedMemory(mem_key = "unique_str", mem_type = "output", ...)
|
||||
|
||||
output = shm_out.read(...)
|
||||
shm_in.write("dir\r")
|
||||
output = shm_out.read(...)
|
||||
|
||||
Requirements:
|
||||
|
||||
* Python for Windows extensions. Available at http://sourceforge.net/projects/pywin32/
|
||||
* Must be run from process attached to an existing console.
|
||||
|
||||
}}} """
|
||||
|
||||
import time
|
||||
import re
|
||||
import os
|
||||
import ctypes
|
||||
|
||||
from conque_globals import *
|
||||
from conque_win32_util import *
|
||||
from conque_sole_shared_memory import *
|
||||
|
||||
|
||||
class ConqueSoleSubprocess():
|
||||
|
||||
# Class properties {{{
|
||||
|
||||
#window = None
|
||||
handle = None
|
||||
pid = None
|
||||
|
||||
# input / output handles
|
||||
stdin = None
|
||||
stdout = None
|
||||
|
||||
# size of console window
|
||||
window_width = 160
|
||||
window_height = 40
|
||||
|
||||
# max lines for the console buffer
|
||||
buffer_width = 160
|
||||
buffer_height = 100
|
||||
|
||||
# keep track of the buffer number at the top of the window
|
||||
top = 0
|
||||
line_offset = 0
|
||||
|
||||
# buffer height is CONQUE_SOLE_BUFFER_LENGTH * output_blocks
|
||||
output_blocks = 1
|
||||
|
||||
# cursor position
|
||||
cursor_line = 0
|
||||
cursor_col = 0
|
||||
|
||||
# console data, array of lines
|
||||
data = []
|
||||
|
||||
# console attribute data, array of array of int
|
||||
attributes = []
|
||||
attribute_cache = {}
|
||||
|
||||
# default attribute
|
||||
default_attribute = 7
|
||||
|
||||
# shared memory objects
|
||||
shm_input = None
|
||||
shm_output = None
|
||||
shm_attributes = None
|
||||
shm_stats = None
|
||||
shm_command = None
|
||||
shm_rescroll = None
|
||||
shm_resize = None
|
||||
|
||||
# are we still a valid process?
|
||||
is_alive = True
|
||||
|
||||
# used for periodic execution of screen and memory redrawing
|
||||
screen_redraw_ct = 0
|
||||
mem_redraw_ct = 0
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# initialize class instance
|
||||
|
||||
def __init__(self): # {{{
|
||||
|
||||
pass
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# Create proccess cmd
|
||||
|
||||
def open(self, cmd, mem_key, options={}): # {{{
|
||||
|
||||
|
||||
|
||||
self.reset = True
|
||||
|
||||
try:
|
||||
# if we're already attached to a console, then unattach
|
||||
try:
|
||||
ctypes.windll.kernel32.FreeConsole()
|
||||
except:
|
||||
pass
|
||||
|
||||
# set buffer height
|
||||
self.buffer_height = CONQUE_SOLE_BUFFER_LENGTH
|
||||
|
||||
if 'LINES' in options and 'COLUMNS' in options:
|
||||
self.window_width = options['COLUMNS']
|
||||
self.window_height = options['LINES']
|
||||
self.buffer_width = options['COLUMNS']
|
||||
|
||||
# console window options
|
||||
si = STARTUPINFO()
|
||||
|
||||
# hide window
|
||||
si.dwFlags |= STARTF_USESHOWWINDOW
|
||||
si.wShowWindow = SW_HIDE
|
||||
#si.wShowWindow = SW_MINIMIZE
|
||||
|
||||
# process options
|
||||
flags = NORMAL_PRIORITY_CLASS | CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE
|
||||
|
||||
# created process info
|
||||
pi = PROCESS_INFORMATION()
|
||||
|
||||
|
||||
|
||||
# create the process!
|
||||
res = ctypes.windll.kernel32.CreateProcessW(None, u(cmd), None, None, 0, flags, None, u('.'), ctypes.byref(si), ctypes.byref(pi))
|
||||
|
||||
|
||||
|
||||
|
||||
self.pid = pi.dwProcessId
|
||||
self.handle = pi.hProcess
|
||||
|
||||
|
||||
|
||||
# attach ourselves to the new console
|
||||
# console is not immediately available
|
||||
for i in range(10):
|
||||
time.sleep(1)
|
||||
try:
|
||||
|
||||
res = ctypes.windll.kernel32.AttachConsole(self.pid)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
break
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
# get input / output handles
|
||||
self.stdout = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
|
||||
self.stdin = ctypes.windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
|
||||
|
||||
# set buffer size
|
||||
size = COORD(self.buffer_width, self.buffer_height)
|
||||
res = ctypes.windll.kernel32.SetConsoleScreenBufferSize(self.stdout, size)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# prev set size call needs to process
|
||||
time.sleep(0.2)
|
||||
|
||||
# set window size
|
||||
self.set_window_size(self.window_width, self.window_height)
|
||||
|
||||
# init shared memory
|
||||
self.init_shared_memory(mem_key)
|
||||
|
||||
# init read buffers
|
||||
self.tc = ctypes.create_unicode_buffer(self.buffer_width)
|
||||
self.ac = ctypes.create_unicode_buffer(self.buffer_width)
|
||||
|
||||
return True
|
||||
|
||||
except:
|
||||
|
||||
return False
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# create shared memory objects
|
||||
|
||||
def init_shared_memory(self, mem_key): # {{{
|
||||
|
||||
buf_info = self.get_buffer_info()
|
||||
|
||||
|
||||
|
||||
|
||||
self.shm_input = ConqueSoleSharedMemory(CONQUE_SOLE_INPUT_SIZE, 'input', mem_key)
|
||||
self.shm_input.create('write')
|
||||
self.shm_input.clear()
|
||||
|
||||
self.shm_output = ConqueSoleSharedMemory(self.buffer_height * self.buffer_width, 'output', mem_key, True)
|
||||
self.shm_output.create('write')
|
||||
self.shm_output.clear()
|
||||
|
||||
self.shm_attributes = ConqueSoleSharedMemory(self.buffer_height * self.buffer_width, 'attributes', mem_key, True, chr(buf_info.wAttributes), encoding='latin-1')
|
||||
self.shm_attributes.create('write')
|
||||
self.shm_attributes.clear()
|
||||
|
||||
self.shm_stats = ConqueSoleSharedMemory(CONQUE_SOLE_STATS_SIZE, 'stats', mem_key, serialize=True)
|
||||
self.shm_stats.create('write')
|
||||
self.shm_stats.clear()
|
||||
|
||||
self.shm_command = ConqueSoleSharedMemory(CONQUE_SOLE_COMMANDS_SIZE, 'command', mem_key, serialize=True)
|
||||
self.shm_command.create('write')
|
||||
self.shm_command.clear()
|
||||
|
||||
self.shm_resize = ConqueSoleSharedMemory(CONQUE_SOLE_RESIZE_SIZE, 'resize', mem_key, serialize=True)
|
||||
self.shm_resize.create('write')
|
||||
self.shm_resize.clear()
|
||||
|
||||
self.shm_rescroll = ConqueSoleSharedMemory(CONQUE_SOLE_RESCROLL_SIZE, 'rescroll', mem_key, serialize=True)
|
||||
self.shm_rescroll.create('write')
|
||||
self.shm_rescroll.clear()
|
||||
|
||||
return True
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# check for and process commands
|
||||
|
||||
def check_commands(self): # {{{
|
||||
|
||||
cmd = self.shm_command.read()
|
||||
|
||||
if cmd:
|
||||
|
||||
# shut it all down
|
||||
if cmd['cmd'] == 'close':
|
||||
|
||||
# clear command
|
||||
self.shm_command.clear()
|
||||
|
||||
self.close()
|
||||
return
|
||||
|
||||
cmd = self.shm_resize.read()
|
||||
|
||||
if cmd:
|
||||
|
||||
# clear command
|
||||
self.shm_resize.clear()
|
||||
|
||||
# resize console
|
||||
if cmd['cmd'] == 'resize':
|
||||
|
||||
|
||||
|
||||
# only change buffer width if it's larger
|
||||
if cmd['data']['width'] > self.buffer_width:
|
||||
self.buffer_width = cmd['data']['width']
|
||||
|
||||
# always change console width and height
|
||||
self.window_width = cmd['data']['width']
|
||||
self.window_height = cmd['data']['height']
|
||||
|
||||
# reset the console
|
||||
buf_info = self.get_buffer_info()
|
||||
self.reset_console(buf_info, add_block=False)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# read from windows console and update output buffer
|
||||
|
||||
def read(self, timeout=0): # {{{
|
||||
|
||||
# no point really
|
||||
if self.screen_redraw_ct == 0 and not self.is_alive():
|
||||
stats = {'top_offset': 0, 'default_attribute': 0, 'cursor_x': 0, 'cursor_y': self.cursor_line, 'is_alive': 0}
|
||||
|
||||
self.shm_stats.write(stats)
|
||||
return
|
||||
|
||||
# check for commands
|
||||
self.check_commands()
|
||||
|
||||
# emulate timeout by sleeping timeout time
|
||||
if timeout > 0:
|
||||
read_timeout = float(timeout) / 1000
|
||||
|
||||
time.sleep(read_timeout)
|
||||
|
||||
# get cursor position
|
||||
buf_info = self.get_buffer_info()
|
||||
curs_line = buf_info.dwCursorPosition.Y
|
||||
curs_col = buf_info.dwCursorPosition.X
|
||||
|
||||
# set update range
|
||||
if curs_line != self.cursor_line or self.top != buf_info.srWindow.Top or self.screen_redraw_ct == CONQUE_SOLE_SCREEN_REDRAW:
|
||||
self.screen_redraw_ct = 0
|
||||
|
||||
read_start = self.top
|
||||
read_end = buf_info.srWindow.Bottom + 1
|
||||
else:
|
||||
|
||||
read_start = curs_line
|
||||
read_end = curs_line + 1
|
||||
|
||||
# vars used in for loop
|
||||
coord = COORD(0, 0)
|
||||
chars_read = ctypes.c_int(0)
|
||||
|
||||
# read new data
|
||||
for i in range(read_start, read_end):
|
||||
|
||||
coord.Y = i
|
||||
|
||||
res = ctypes.windll.kernel32.ReadConsoleOutputCharacterW(self.stdout, ctypes.byref(self.tc), self.buffer_width, coord, ctypes.byref(chars_read))
|
||||
ctypes.windll.kernel32.ReadConsoleOutputAttribute(self.stdout, ctypes.byref(self.ac), self.buffer_width, coord, ctypes.byref(chars_read))
|
||||
|
||||
t = self.tc.value
|
||||
a = self.ac.value
|
||||
|
||||
|
||||
|
||||
|
||||
# add data
|
||||
if i >= len(self.data):
|
||||
self.data.append(t)
|
||||
self.attributes.append(a)
|
||||
else:
|
||||
self.data[i] = t
|
||||
self.attributes[i] = a
|
||||
|
||||
# write new output to shared memory
|
||||
if self.mem_redraw_ct == CONQUE_SOLE_MEM_REDRAW:
|
||||
self.mem_redraw_ct = 0
|
||||
|
||||
self.shm_output.write(''.join(self.data))
|
||||
self.shm_attributes.write(''.join(self.attributes))
|
||||
else:
|
||||
|
||||
self.shm_output.write(text=''.join(self.data[read_start:read_end]), start=read_start * self.buffer_width)
|
||||
self.shm_attributes.write(text=''.join(self.attributes[read_start:read_end]), start=read_start * self.buffer_width)
|
||||
|
||||
# write cursor position to shared memory
|
||||
stats = {'top_offset': buf_info.srWindow.Top, 'default_attribute': buf_info.wAttributes, 'cursor_x': curs_col, 'cursor_y': curs_line, 'is_alive': 1}
|
||||
self.shm_stats.write(stats)
|
||||
|
||||
|
||||
# adjust screen position
|
||||
self.top = buf_info.srWindow.Top
|
||||
self.cursor_line = curs_line
|
||||
|
||||
# check for reset
|
||||
if curs_line > buf_info.dwSize.Y - 200:
|
||||
self.reset_console(buf_info)
|
||||
|
||||
# increment redraw counters
|
||||
self.screen_redraw_ct += 1
|
||||
self.mem_redraw_ct += 1
|
||||
|
||||
return None
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# clear the console and set cursor at home position
|
||||
|
||||
def reset_console(self, buf_info, add_block=True): # {{{
|
||||
|
||||
# sometimes we just want to change the buffer width,
|
||||
# in which case no need to add another block
|
||||
if add_block:
|
||||
self.output_blocks += 1
|
||||
|
||||
# close down old memory
|
||||
self.shm_output.close()
|
||||
self.shm_output = None
|
||||
|
||||
self.shm_attributes.close()
|
||||
self.shm_attributes = None
|
||||
|
||||
# new shared memory key
|
||||
mem_key = 'mk' + str(time.time())
|
||||
|
||||
# reallocate memory
|
||||
self.shm_output = ConqueSoleSharedMemory(self.buffer_height * self.buffer_width * self.output_blocks, 'output', mem_key, True)
|
||||
self.shm_output.create('write')
|
||||
self.shm_output.clear()
|
||||
|
||||
# backfill data
|
||||
if len(self.data[0]) < self.buffer_width:
|
||||
for i in range(0, len(self.data)):
|
||||
self.data[i] = self.data[i] + ' ' * (self.buffer_width - len(self.data[i]))
|
||||
self.shm_output.write(''.join(self.data))
|
||||
|
||||
self.shm_attributes = ConqueSoleSharedMemory(self.buffer_height * self.buffer_width * self.output_blocks, 'attributes', mem_key, True, chr(buf_info.wAttributes), encoding='latin-1')
|
||||
self.shm_attributes.create('write')
|
||||
self.shm_attributes.clear()
|
||||
|
||||
# backfill attributes
|
||||
if len(self.attributes[0]) < self.buffer_width:
|
||||
for i in range(0, len(self.attributes)):
|
||||
self.attributes[i] = self.attributes[i] + chr(buf_info.wAttributes) * (self.buffer_width - len(self.attributes[i]))
|
||||
self.shm_attributes.write(''.join(self.attributes))
|
||||
|
||||
# notify wrapper of new output block
|
||||
self.shm_rescroll.write({'cmd': 'new_output', 'data': {'blocks': self.output_blocks, 'mem_key': mem_key}})
|
||||
|
||||
# set buffer size
|
||||
size = COORD(X=self.buffer_width, Y=self.buffer_height * self.output_blocks)
|
||||
|
||||
res = ctypes.windll.kernel32.SetConsoleScreenBufferSize(self.stdout, size)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# prev set size call needs to process
|
||||
time.sleep(0.2)
|
||||
|
||||
# set window size
|
||||
self.set_window_size(self.window_width, self.window_height)
|
||||
|
||||
# init read buffers
|
||||
self.tc = ctypes.create_unicode_buffer(self.buffer_width)
|
||||
self.ac = ctypes.create_unicode_buffer(self.buffer_width)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# write text to console. this function just parses out special sequences for
|
||||
# special key events and passes on the text to the plain or virtual key functions
|
||||
|
||||
def write(self): # {{{
|
||||
|
||||
# get input from shared mem
|
||||
text = self.shm_input.read()
|
||||
|
||||
# nothing to do here
|
||||
if text == '':
|
||||
return
|
||||
|
||||
|
||||
|
||||
# clear input queue
|
||||
self.shm_input.clear()
|
||||
|
||||
# split on VK codes
|
||||
chunks = CONQUE_SEQ_REGEX_VK.split(text)
|
||||
|
||||
# if len() is one then no vks
|
||||
if len(chunks) == 1:
|
||||
self.write_plain(text)
|
||||
return
|
||||
|
||||
|
||||
|
||||
# loop over chunks and delegate
|
||||
for t in chunks:
|
||||
|
||||
if t == '':
|
||||
continue
|
||||
|
||||
if CONQUE_SEQ_REGEX_VK.match(t):
|
||||
|
||||
self.write_vk(t[2:-2])
|
||||
else:
|
||||
self.write_plain(t)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
|
||||
def write_plain(self, text): # {{{
|
||||
|
||||
li = INPUT_RECORD * len(text)
|
||||
list_input = li()
|
||||
|
||||
for i in range(0, len(text)):
|
||||
# create keyboard input
|
||||
ke = KEY_EVENT_RECORD()
|
||||
ke.bKeyDown = ctypes.c_byte(1)
|
||||
ke.wRepeatCount = ctypes.c_short(1)
|
||||
|
||||
cnum = ord(text[i])
|
||||
ke.wVirtualKeyCode = ctypes.windll.user32.VkKeyScanW(cnum)
|
||||
ke.wVirtualScanCode = ctypes.c_short(ctypes.windll.user32.MapVirtualKeyW(int(cnum), 0))
|
||||
|
||||
if cnum > 31:
|
||||
ke.uChar.UnicodeChar = u(chr(cnum))
|
||||
elif cnum == 3:
|
||||
ctypes.windll.kernel32.GenerateConsoleCtrlEvent(0, self.pid)
|
||||
ke.uChar.UnicodeChar = u(chr(cnum))
|
||||
ke.wVirtualKeyCode = ctypes.windll.user32.VkKeyScanW(cnum + 96)
|
||||
ke.dwControlKeyState = LEFT_CTRL_PRESSED
|
||||
else:
|
||||
ke.uChar.UnicodeChar = u(chr(cnum))
|
||||
if cnum in CONQUE_WINDOWS_VK_INV:
|
||||
ke.wVirtualKeyCode = cnum
|
||||
else:
|
||||
ke.wVirtualKeyCode = ctypes.windll.user32.VkKeyScanW(cnum + 96)
|
||||
ke.dwControlKeyState = LEFT_CTRL_PRESSED
|
||||
|
||||
kc = INPUT_RECORD(KEY_EVENT)
|
||||
kc.Event.KeyEvent = ke
|
||||
list_input[i] = kc
|
||||
|
||||
|
||||
|
||||
# write input array
|
||||
events_written = ctypes.c_int()
|
||||
res = ctypes.windll.kernel32.WriteConsoleInputW(self.stdin, list_input, len(text), ctypes.byref(events_written))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
|
||||
def write_vk(self, vk_code): # {{{
|
||||
|
||||
|
||||
li = INPUT_RECORD * 1
|
||||
|
||||
# create keyboard input
|
||||
ke = KEY_EVENT_RECORD()
|
||||
ke.uChar.UnicodeChar = u(chr(0))
|
||||
ke.wVirtualKeyCode = ctypes.c_short(int(vk_code))
|
||||
ke.wVirtualScanCode = ctypes.c_short(ctypes.windll.user32.MapVirtualKeyW(int(vk_code), 0))
|
||||
ke.bKeyDown = ctypes.c_byte(1)
|
||||
ke.wRepeatCount = ctypes.c_short(1)
|
||||
|
||||
# set enhanced key mode for arrow keys
|
||||
if vk_code in CONQUE_WINDOWS_VK_ENHANCED:
|
||||
|
||||
ke.dwControlKeyState = ENHANCED_KEY
|
||||
|
||||
kc = INPUT_RECORD(KEY_EVENT)
|
||||
kc.Event.KeyEvent = ke
|
||||
list_input = li(kc)
|
||||
|
||||
# write input array
|
||||
events_written = ctypes.c_int()
|
||||
res = ctypes.windll.kernel32.WriteConsoleInputW(self.stdin, list_input, 1, ctypes.byref(events_written))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
|
||||
def close(self): # {{{
|
||||
|
||||
# record status
|
||||
self.is_alive = False
|
||||
try:
|
||||
stats = {'top_offset': 0, 'default_attribute': 0, 'cursor_x': 0, 'cursor_y': self.cursor_line, 'is_alive': 0}
|
||||
self.shm_stats.write(stats)
|
||||
except:
|
||||
pass
|
||||
|
||||
pid_list = (ctypes.c_int * 10)()
|
||||
num = ctypes.windll.kernel32.GetConsoleProcessList(pid_list, 10)
|
||||
|
||||
|
||||
|
||||
current_pid = os.getpid()
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# kill subprocess pids
|
||||
for pid in pid_list[0:num]:
|
||||
if not pid:
|
||||
break
|
||||
|
||||
# kill current pid last
|
||||
if pid == current_pid:
|
||||
continue
|
||||
try:
|
||||
self.close_pid(pid)
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
# kill this process
|
||||
try:
|
||||
self.close_pid(current_pid)
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
def close_pid(self, pid):
|
||||
|
||||
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, 0, pid)
|
||||
ctypes.windll.kernel32.TerminateProcess(handle, -1)
|
||||
ctypes.windll.kernel32.CloseHandle(handle)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# check process health
|
||||
|
||||
def is_alive(self): # {{{
|
||||
|
||||
status = ctypes.windll.kernel32.WaitForSingleObject(self.handle, 1)
|
||||
|
||||
if status == 0:
|
||||
|
||||
self.is_alive = False
|
||||
|
||||
return self.is_alive
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# ****************************************************************************
|
||||
# return screen data as string
|
||||
|
||||
def get_screen_text(self): # {{{
|
||||
|
||||
return "\n".join(self.data)
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
|
||||
def set_window_size(self, width, height): # {{{
|
||||
|
||||
|
||||
|
||||
# get current window size object
|
||||
window_size = SMALL_RECT(0, 0, 0, 0)
|
||||
|
||||
# buffer info has maximum window size data
|
||||
buf_info = self.get_buffer_info()
|
||||
|
||||
|
||||
# set top left corner
|
||||
window_size.Top = 0
|
||||
window_size.Left = 0
|
||||
|
||||
# set bottom right corner
|
||||
if buf_info.dwMaximumWindowSize.X < width:
|
||||
|
||||
window_size.Right = buf_info.dwMaximumWindowSize.X - 1
|
||||
else:
|
||||
window_size.Right = width - 1
|
||||
|
||||
if buf_info.dwMaximumWindowSize.Y < height:
|
||||
|
||||
window_size.Bottom = buf_info.dwMaximumWindowSize.Y - 1
|
||||
else:
|
||||
window_size.Bottom = height - 1
|
||||
|
||||
|
||||
|
||||
# set the window size!
|
||||
res = ctypes.windll.kernel32.SetConsoleWindowInfo(self.stdout, ctypes.c_bool(True), ctypes.byref(window_size))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# reread buffer info to get final console max lines
|
||||
buf_info = self.get_buffer_info()
|
||||
|
||||
self.window_width = buf_info.srWindow.Right + 1
|
||||
self.window_height = buf_info.srWindow.Bottom + 1
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# get buffer info, used a lot
|
||||
|
||||
def get_buffer_info(self): # {{{
|
||||
|
||||
buf_info = CONSOLE_SCREEN_BUFFER_INFO()
|
||||
ctypes.windll.kernel32.GetConsoleScreenBufferInfo(self.stdout, ctypes.byref(buf_info))
|
||||
|
||||
return buf_info
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,304 @@
|
|||
# FILE: autoload/conque_term/conque_sole_wrapper.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
""" ConqueSoleSubprocessWrapper {{{
|
||||
|
||||
Subprocess wrapper to deal with Windows insanity. Launches console based python,
|
||||
which in turn launches originally requested command. Communicates with cosole
|
||||
python through shared memory objects.
|
||||
|
||||
}}} """
|
||||
|
||||
import ctypes
|
||||
import time
|
||||
|
||||
|
||||
class ConqueSoleWrapper():
|
||||
|
||||
# class properties {{{
|
||||
|
||||
shm_key = ''
|
||||
|
||||
# process info
|
||||
handle = None
|
||||
pid = None
|
||||
|
||||
# queue input in this bucket
|
||||
bucket = None
|
||||
|
||||
# console size
|
||||
# NOTE: columns should never change after open() is called
|
||||
lines = 24
|
||||
columns = 80
|
||||
|
||||
# shared memory objects
|
||||
shm_input = None
|
||||
shm_output = None
|
||||
shm_attributes = None
|
||||
shm_stats = None
|
||||
shm_command = None
|
||||
shm_rescroll = None
|
||||
shm_resize = None
|
||||
|
||||
# console python process
|
||||
proc = None
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# unused
|
||||
|
||||
def __init__(self): # {{{
|
||||
self.bucket = u('')
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# run communicator process which will in turn run cmd
|
||||
|
||||
def open(self, cmd, options={}, python_exe='python.exe', communicator_py='conque_sole_communicator.py'): # {{{
|
||||
|
||||
self.lines = options['LINES']
|
||||
self.columns = options['COLUMNS']
|
||||
|
||||
# create a shm key
|
||||
self.shm_key = 'mk' + str(time.time())
|
||||
|
||||
# python command
|
||||
cmd_line = '%s "%s" %s %d %d %s' % (python_exe, communicator_py, self.shm_key, int(self.columns), int(self.lines), cmd)
|
||||
|
||||
|
||||
# console window attributes
|
||||
flags = NORMAL_PRIORITY_CLASS | DETACHED_PROCESS
|
||||
si = STARTUPINFO()
|
||||
pi = PROCESS_INFORMATION()
|
||||
|
||||
# start the stupid process already
|
||||
try:
|
||||
res = ctypes.windll.kernel32.CreateProcessW(None, u(cmd_line), None, None, 0, flags, None, u('.'), ctypes.byref(si), ctypes.byref(pi))
|
||||
except:
|
||||
|
||||
raise
|
||||
|
||||
# handle
|
||||
self.pid = pi.dwProcessId
|
||||
|
||||
|
||||
|
||||
# init shared memory objects
|
||||
self.init_shared_memory(self.shm_key)
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# read output from shared memory
|
||||
|
||||
def read(self, start_line, num_lines, timeout=0): # {{{
|
||||
|
||||
# emulate timeout by sleeping timeout time
|
||||
if timeout > 0:
|
||||
read_timeout = float(timeout) / 1000
|
||||
|
||||
time.sleep(read_timeout)
|
||||
|
||||
output = []
|
||||
attributes = []
|
||||
|
||||
# get output
|
||||
for i in range(start_line, start_line + num_lines + 1):
|
||||
output.append(self.shm_output.read(self.columns, i * self.columns))
|
||||
attributes.append(self.shm_attributes.read(self.columns, i * self.columns))
|
||||
|
||||
return (output, attributes)
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# get current cursor/scroll position
|
||||
|
||||
def get_stats(self): # {{{
|
||||
|
||||
try:
|
||||
rescroll = self.shm_rescroll.read()
|
||||
if rescroll != '' and rescroll != None:
|
||||
|
||||
|
||||
|
||||
self.shm_rescroll.clear()
|
||||
|
||||
# close down old memory
|
||||
self.shm_output.close()
|
||||
self.shm_output = None
|
||||
|
||||
self.shm_attributes.close()
|
||||
self.shm_attributes = None
|
||||
|
||||
# reallocate memory
|
||||
|
||||
self.shm_output = ConqueSoleSharedMemory(CONQUE_SOLE_BUFFER_LENGTH * self.columns * rescroll['data']['blocks'], 'output', rescroll['data']['mem_key'], True)
|
||||
self.shm_output.create('read')
|
||||
|
||||
self.shm_attributes = ConqueSoleSharedMemory(CONQUE_SOLE_BUFFER_LENGTH * self.columns * rescroll['data']['blocks'], 'attributes', rescroll['data']['mem_key'], True, encoding='latin-1')
|
||||
self.shm_attributes.create('read')
|
||||
|
||||
stats_str = self.shm_stats.read()
|
||||
if stats_str != '':
|
||||
self.stats = stats_str
|
||||
else:
|
||||
return False
|
||||
except:
|
||||
|
||||
return False
|
||||
|
||||
return self.stats
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# get process status
|
||||
|
||||
def is_alive(self): # {{{
|
||||
if not self.shm_stats:
|
||||
return True
|
||||
|
||||
stats_str = self.shm_stats.read()
|
||||
if stats_str:
|
||||
return (stats_str['is_alive'])
|
||||
else:
|
||||
return True
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# write input to shared memory
|
||||
|
||||
def write(self, text): # {{{
|
||||
|
||||
self.bucket += u(text, 'ascii', 'replace')
|
||||
|
||||
|
||||
|
||||
istr = self.shm_input.read()
|
||||
|
||||
if istr == '':
|
||||
|
||||
self.shm_input.write(self.bucket[:500])
|
||||
self.bucket = self.bucket[500:]
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# write virtual key code to shared memory using proprietary escape seq
|
||||
|
||||
def write_vk(self, vk_code): # {{{
|
||||
|
||||
seq = "\x1b[" + str(vk_code) + "VK"
|
||||
self.write(seq)
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# idle
|
||||
|
||||
def idle(self): # {{{
|
||||
|
||||
|
||||
self.shm_command.write({'cmd': 'idle', 'data': {}})
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# resume
|
||||
|
||||
def resume(self): # {{{
|
||||
|
||||
self.shm_command.write({'cmd': 'resume', 'data': {}})
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# shut it all down
|
||||
|
||||
def close(self): # {{{
|
||||
|
||||
self.shm_command.write({'cmd': 'close', 'data': {}})
|
||||
time.sleep(0.2)
|
||||
|
||||
# }}}
|
||||
|
||||
#########################################################################
|
||||
# resize console window
|
||||
|
||||
def window_resize(self, lines, columns): # {{{
|
||||
|
||||
self.lines = lines
|
||||
|
||||
# we don't shrink buffer width
|
||||
if columns > self.columns:
|
||||
self.columns = columns
|
||||
|
||||
self.shm_resize.write({'cmd': 'resize', 'data': {'width': columns, 'height': lines}})
|
||||
|
||||
# }}}
|
||||
|
||||
# ****************************************************************************
|
||||
# create shared memory objects
|
||||
|
||||
def init_shared_memory(self, mem_key): # {{{
|
||||
|
||||
self.shm_input = ConqueSoleSharedMemory(CONQUE_SOLE_INPUT_SIZE, 'input', mem_key)
|
||||
self.shm_input.create('write')
|
||||
self.shm_input.clear()
|
||||
|
||||
self.shm_output = ConqueSoleSharedMemory(CONQUE_SOLE_BUFFER_LENGTH * self.columns, 'output', mem_key, True)
|
||||
self.shm_output.create('write')
|
||||
|
||||
self.shm_attributes = ConqueSoleSharedMemory(CONQUE_SOLE_BUFFER_LENGTH * self.columns, 'attributes', mem_key, True, encoding='latin-1')
|
||||
self.shm_attributes.create('write')
|
||||
|
||||
self.shm_stats = ConqueSoleSharedMemory(CONQUE_SOLE_STATS_SIZE, 'stats', mem_key, serialize=True)
|
||||
self.shm_stats.create('write')
|
||||
self.shm_stats.clear()
|
||||
|
||||
self.shm_command = ConqueSoleSharedMemory(CONQUE_SOLE_COMMANDS_SIZE, 'command', mem_key, serialize=True)
|
||||
self.shm_command.create('write')
|
||||
self.shm_command.clear()
|
||||
|
||||
self.shm_resize = ConqueSoleSharedMemory(CONQUE_SOLE_RESIZE_SIZE, 'resize', mem_key, serialize=True)
|
||||
self.shm_resize.create('write')
|
||||
self.shm_resize.clear()
|
||||
|
||||
self.shm_rescroll = ConqueSoleSharedMemory(CONQUE_SOLE_RESCROLL_SIZE, 'rescroll', mem_key, serialize=True)
|
||||
self.shm_rescroll.create('write')
|
||||
self.shm_rescroll.clear()
|
||||
|
||||
return True
|
||||
|
||||
# }}}
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
# FILE: autoload/conque_term/conque_subprocess.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""
|
||||
ConqueSubprocess
|
||||
|
||||
Create and interact with a subprocess through a pty.
|
||||
|
||||
Usage:
|
||||
|
||||
p = ConqueSubprocess()
|
||||
p.open('bash', {'TERM':'vt100'})
|
||||
output = p.read()
|
||||
p.write('cd ~/vim' + "\r")
|
||||
p.write('ls -lha' + "\r")
|
||||
output += p.read(timeout = 500)
|
||||
p.close()
|
||||
"""
|
||||
|
||||
if CONQUE_PLATFORM == 'nix':
|
||||
import os
|
||||
import signal
|
||||
import pty
|
||||
import tty
|
||||
import select
|
||||
import fcntl
|
||||
import termios
|
||||
import struct
|
||||
|
||||
|
||||
class ConqueSubprocess:
|
||||
|
||||
# process id
|
||||
pid = 0
|
||||
|
||||
# stdout+stderr file descriptor
|
||||
fd = None
|
||||
|
||||
# constructor
|
||||
def __init__(self): # {{{
|
||||
self.pid = 0
|
||||
# }}}
|
||||
|
||||
# create pty + subprocess
|
||||
def open(self, command, env={}): # {{{
|
||||
|
||||
# parse command
|
||||
command_arr = command.split()
|
||||
executable = command_arr[0]
|
||||
args = command_arr
|
||||
|
||||
# try to fork a new pty
|
||||
try:
|
||||
self.pid, self.fd = pty.fork()
|
||||
|
||||
except:
|
||||
|
||||
return False
|
||||
|
||||
# child proc, replace with command after altering terminal attributes
|
||||
if self.pid == 0:
|
||||
|
||||
# set requested environment variables
|
||||
for k in env.keys():
|
||||
os.environ[k] = env[k]
|
||||
|
||||
# set some attributes
|
||||
try:
|
||||
attrs = tty.tcgetattr(1)
|
||||
attrs[0] = attrs[0] ^ tty.IGNBRK
|
||||
attrs[0] = attrs[0] | tty.BRKINT | tty.IXANY | tty.IMAXBEL
|
||||
attrs[2] = attrs[2] | tty.HUPCL
|
||||
attrs[3] = attrs[3] | tty.ICANON | tty.ECHO | tty.ISIG | tty.ECHOKE
|
||||
attrs[6][tty.VMIN] = 1
|
||||
attrs[6][tty.VTIME] = 0
|
||||
tty.tcsetattr(1, tty.TCSANOW, attrs)
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
# replace this process with the subprocess
|
||||
os.execvp(executable, args)
|
||||
|
||||
# else master, do nothing
|
||||
else:
|
||||
pass
|
||||
|
||||
# }}}
|
||||
|
||||
# read from pty
|
||||
# XXX - select.poll() doesn't work in OS X!!!!!!!
|
||||
def read(self, timeout=1): # {{{
|
||||
|
||||
output = ''
|
||||
read_timeout = float(timeout) / 1000
|
||||
|
||||
try:
|
||||
# read from fd until no more output
|
||||
while 1:
|
||||
s_read, s_write, s_error = select.select([self.fd], [], [], read_timeout)
|
||||
|
||||
lines = ''
|
||||
for s_fd in s_read:
|
||||
try:
|
||||
lines = os.read(self.fd, 32)
|
||||
except:
|
||||
pass
|
||||
output = output + lines.decode('utf-8')
|
||||
|
||||
if lines == '':
|
||||
break
|
||||
except:
|
||||
pass
|
||||
|
||||
return output
|
||||
# }}}
|
||||
|
||||
# I guess this one's not bad
|
||||
def write(self, input): # {{{
|
||||
try:
|
||||
if CONQUE_PYTHON_VERSION == 2:
|
||||
os.write(self.fd, input)
|
||||
else:
|
||||
os.write(self.fd, bytes(input, 'utf-8'))
|
||||
except:
|
||||
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# signal process
|
||||
def signal(self, signum): # {{{
|
||||
try:
|
||||
os.kill(self.pid, signum)
|
||||
except:
|
||||
pass
|
||||
# }}}
|
||||
|
||||
# close process
|
||||
def close(self): # {{{
|
||||
self.signal(15)
|
||||
# }}}
|
||||
|
||||
# get process status
|
||||
def is_alive(self): #{{{
|
||||
|
||||
p_status = True
|
||||
|
||||
try:
|
||||
if os.waitpid(self.pid, os.WNOHANG)[0]:
|
||||
p_status = False
|
||||
except:
|
||||
p_status = False
|
||||
|
||||
return p_status
|
||||
|
||||
# }}}
|
||||
|
||||
# update window size in kernel, then send SIGWINCH to fg process
|
||||
def window_resize(self, lines, columns): # {{{
|
||||
try:
|
||||
fcntl.ioctl(self.fd, termios.TIOCSWINSZ, struct.pack("HHHH", lines, columns, 0, 0))
|
||||
os.kill(self.pid, signal.SIGWINCH)
|
||||
except:
|
||||
pass
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,473 @@
|
|||
# FILE: autoload/conque_term/conque_win32_util.py {{{
|
||||
# AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
# WEBSITE: http://conque.googlecode.com
|
||||
# MODIFIED: 2010-11-15
|
||||
# VERSION: 2.0, for Vim 7.0
|
||||
# LICENSE:
|
||||
# Conque - Vim terminal/console emulator
|
||||
# Copyright (C) 2009-2010 Nico Raffo
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE. }}}
|
||||
|
||||
"""Python structures used for ctypes interaction"""
|
||||
|
||||
from ctypes import *
|
||||
|
||||
# Constants
|
||||
|
||||
# create process flag constants {{{
|
||||
|
||||
CREATE_BREAKAWAY_FROM_JOB = 0x01000000
|
||||
CREATE_DEFAULT_ERROR_MODE = 0x04000000
|
||||
CREATE_NEW_CONSOLE = 0x00000010
|
||||
CREATE_NEW_PROCESS_GROUP = 0x00000200
|
||||
CREATE_NO_WINDOW = 0x08000000
|
||||
CREATE_PROTECTED_PROCESS = 0x00040000
|
||||
CREATE_PRESERVE_CODE_AUTHZ_LEVEL = 0x02000000
|
||||
CREATE_SEPARATE_WOW_VDM = 0x00000800
|
||||
CREATE_SHARED_WOW_VDM = 0x00001000
|
||||
CREATE_SUSPENDED = 0x00000004
|
||||
CREATE_UNICODE_ENVIRONMENT = 0x00000400
|
||||
|
||||
|
||||
DETACHED_PROCESS = 0x00000008
|
||||
EXTENDED_STARTUPINFO_PRESENT = 0x00080000
|
||||
INHERIT_PARENT_AFFINITY = 0x00010000
|
||||
|
||||
# }}}
|
||||
|
||||
# process priority constants {{{
|
||||
|
||||
ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000
|
||||
BELOW_NORMAL_PRIORITY_CLASS = 0x00004000
|
||||
HIGH_PRIORITY_CLASS = 0x00000080
|
||||
IDLE_PRIORITY_CLASS = 0x00000040
|
||||
NORMAL_PRIORITY_CLASS = 0x00000020
|
||||
REALTIME_PRIORITY_CLASS = 0x00000100
|
||||
|
||||
# }}}
|
||||
|
||||
# startup info constants {{{
|
||||
|
||||
STARTF_FORCEONFEEDBACK = 0x00000040
|
||||
STARTF_FORCEOFFFEEDBACK = 0x00000080
|
||||
STARTF_PREVENTPINNING = 0x00002000
|
||||
STARTF_RUNFULLSCREEN = 0x00000020
|
||||
STARTF_TITLEISAPPID = 0x00001000
|
||||
STARTF_TITLEISLINKNAME = 0x00000800
|
||||
STARTF_USECOUNTCHARS = 0x00000008
|
||||
STARTF_USEFILLATTRIBUTE = 0x00000010
|
||||
STARTF_USEHOTKEY = 0x00000200
|
||||
STARTF_USEPOSITION = 0x00000004
|
||||
STARTF_USESHOWWINDOW = 0x00000001
|
||||
STARTF_USESIZE = 0x00000002
|
||||
STARTF_USESTDHANDLES = 0x00000100
|
||||
|
||||
# }}}
|
||||
|
||||
# show window constants {{{
|
||||
|
||||
SW_FORCEMINIMIZE = 11
|
||||
SW_HIDE = 0
|
||||
SW_MAXIMIZE = 3
|
||||
SW_MINIMIZE = 6
|
||||
SW_RESTORE = 9
|
||||
SW_SHOW = 5
|
||||
SW_SHOWDEFAULT = 10
|
||||
SW_SHOWMAXIMIZED = 3
|
||||
SW_SHOWMINIMIZED = 2
|
||||
SW_SHOWMINNOACTIVE = 7
|
||||
SW_SHOWNA = 8
|
||||
SW_SHOWNOACTIVATE = 4
|
||||
SW_SHOWNORMAL = 1
|
||||
|
||||
# }}}
|
||||
|
||||
# input event types {{{
|
||||
|
||||
FOCUS_EVENT = 0x0010
|
||||
KEY_EVENT = 0x0001
|
||||
MENU_EVENT = 0x0008
|
||||
MOUSE_EVENT = 0x0002
|
||||
WINDOW_BUFFER_SIZE_EVENT = 0x0004
|
||||
|
||||
# }}}
|
||||
|
||||
# key event modifiers {{{
|
||||
|
||||
CAPSLOCK_ON = 0x0080
|
||||
ENHANCED_KEY = 0x0100
|
||||
LEFT_ALT_PRESSED = 0x0002
|
||||
LEFT_CTRL_PRESSED = 0x0008
|
||||
NUMLOCK_ON = 0x0020
|
||||
RIGHT_ALT_PRESSED = 0x0001
|
||||
RIGHT_CTRL_PRESSED = 0x0004
|
||||
SCROLLLOCK_ON = 0x0040
|
||||
SHIFT_PRESSED = 0x0010
|
||||
|
||||
# }}}
|
||||
|
||||
# process access {{{
|
||||
|
||||
PROCESS_CREATE_PROCESS = 0x0080
|
||||
PROCESS_CREATE_THREAD = 0x0002
|
||||
PROCESS_DUP_HANDLE = 0x0040
|
||||
PROCESS_QUERY_INFORMATION = 0x0400
|
||||
PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
|
||||
PROCESS_SET_INFORMATION = 0x0200
|
||||
PROCESS_SET_QUOTA = 0x0100
|
||||
PROCESS_SUSPEND_RESUME = 0x0800
|
||||
PROCESS_TERMINATE = 0x0001
|
||||
PROCESS_VM_OPERATION = 0x0008
|
||||
PROCESS_VM_READ = 0x0010
|
||||
PROCESS_VM_WRITE = 0x0020
|
||||
|
||||
# }}}
|
||||
|
||||
# input / output handles {{{
|
||||
|
||||
STD_INPUT_HANDLE = c_ulong(-10)
|
||||
STD_OUTPUT_HANDLE = c_ulong(-11)
|
||||
STD_ERROR_HANDLE = c_ulong(-12)
|
||||
|
||||
# }}}
|
||||
|
||||
CONQUE_WINDOWS_VK = { # {{{
|
||||
'VK_LBUTTON': 0x0001,
|
||||
'VK_RBUTTON': 0x0002,
|
||||
'VK_CANCEL': 0x0003,
|
||||
'VK_BACK': 0x0008,
|
||||
'VK_TAB': 0x0009,
|
||||
'VK_CLEAR': 0x000C,
|
||||
'VK_RETURN': 0x0D,
|
||||
'VK_SHIFT': 0x10,
|
||||
'VK_CONTROL': 0x11,
|
||||
'VK_MENU': 0x12,
|
||||
'VK_PAUSE': 0x0013,
|
||||
'VK_CAPITAL': 0x0014,
|
||||
'VK_ESCAPE': 0x001B,
|
||||
'VK_SPACE': 0x0020,
|
||||
'VK_PRIOR': 0x0021,
|
||||
'VK_NEXT': 0x0022,
|
||||
'VK_END': 0x0023,
|
||||
'VK_HOME': 0x0024,
|
||||
'VK_LEFT': 0x0025,
|
||||
'VK_UP': 0x0026,
|
||||
'VK_RIGHT': 0x0027,
|
||||
'VK_DOWN': 0x0028,
|
||||
'VK_SELECT': 0x0029,
|
||||
'VK_PRINT': 0x002A,
|
||||
'VK_EXECUTE': 0x002B,
|
||||
'VK_SNAPSHOT': 0x002C,
|
||||
'VK_INSERT': 0x002D,
|
||||
'VK_DELETE': 0x002E,
|
||||
'VK_HELP': 0x002F,
|
||||
'VK_0': 0x0030,
|
||||
'VK_1': 0x0031,
|
||||
'VK_2': 0x0032,
|
||||
'VK_3': 0x0033,
|
||||
'VK_4': 0x0034,
|
||||
'VK_5': 0x0035,
|
||||
'VK_6': 0x0036,
|
||||
'VK_7': 0x0037,
|
||||
'VK_8': 0x0038,
|
||||
'VK_9': 0x0039,
|
||||
'VK_A': 0x0041,
|
||||
'VK_B': 0x0042,
|
||||
'VK_C': 0x0043,
|
||||
'VK_D': 0x0044,
|
||||
'VK_E': 0x0045,
|
||||
'VK_F': 0x0046,
|
||||
'VK_G': 0x0047,
|
||||
'VK_H': 0x0048,
|
||||
'VK_I': 0x0049,
|
||||
'VK_J': 0x004A,
|
||||
'VK_K': 0x004B,
|
||||
'VK_L': 0x004C,
|
||||
'VK_M': 0x004D,
|
||||
'VK_N': 0x004E,
|
||||
'VK_O': 0x004F,
|
||||
'VK_P': 0x0050,
|
||||
'VK_Q': 0x0051,
|
||||
'VK_R': 0x0052,
|
||||
'VK_S': 0x0053,
|
||||
'VK_T': 0x0054,
|
||||
'VK_U': 0x0055,
|
||||
'VK_V': 0x0056,
|
||||
'VK_W': 0x0057,
|
||||
'VK_X': 0x0058,
|
||||
'VK_Y': 0x0059,
|
||||
'VK_Z': 0x005A,
|
||||
'VK_LWIN': 0x005B,
|
||||
'VK_RWIN': 0x005C,
|
||||
'VK_APPS': 0x005D,
|
||||
'VK_SLEEP': 0x005F,
|
||||
'VK_NUMPAD0': 0x0060,
|
||||
'VK_NUMPAD1': 0x0061,
|
||||
'VK_NUMPAD2': 0x0062,
|
||||
'VK_NUMPAD3': 0x0063,
|
||||
'VK_NUMPAD4': 0x0064,
|
||||
'VK_NUMPAD5': 0x0065,
|
||||
'VK_NUMPAD6': 0x0066,
|
||||
'VK_NUMPAD7': 0x0067,
|
||||
'VK_NUMPAD8': 0x0068,
|
||||
'VK_MULTIPLY': 0x006A,
|
||||
'VK_ADD': 0x006B,
|
||||
'VK_SEPARATOR': 0x006C,
|
||||
'VK_SUBTRACT': 0x006D,
|
||||
'VK_DECIMAL': 0x006E,
|
||||
'VK_DIVIDE': 0x006F,
|
||||
'VK_F1': 0x0070,
|
||||
'VK_F2': 0x0071,
|
||||
'VK_F3': 0x0072,
|
||||
'VK_F4': 0x0073,
|
||||
'VK_F5': 0x0074,
|
||||
'VK_F6': 0x0075,
|
||||
'VK_F7': 0x0076,
|
||||
'VK_F8': 0x0077,
|
||||
'VK_F9': 0x0078,
|
||||
'VK_F10': 0x0079,
|
||||
'VK_F11': 0x007A,
|
||||
'VK_F12': 0x007B,
|
||||
'VK_F13': 0x007C,
|
||||
'VK_F14': 0x007D,
|
||||
'VK_F15': 0x007E,
|
||||
'VK_F16': 0x007F,
|
||||
'VK_F17': 0x0080,
|
||||
'VK_F18': 0x0081,
|
||||
'VK_F19': 0x0082,
|
||||
'VK_F20': 0x0083,
|
||||
'VK_F21': 0x0084,
|
||||
'VK_F22': 0x0085,
|
||||
'VK_F23': 0x0086,
|
||||
'VK_F24': 0x0087,
|
||||
'VK_NUMLOCK': 0x0090,
|
||||
'VK_SCROLL': 0x0091,
|
||||
'VK_LSHIFT': 0x00A0,
|
||||
'VK_RSHIFT': 0x00A1,
|
||||
'VK_LCONTROL': 0x00A2,
|
||||
'VK_RCONTROL': 0x00A3,
|
||||
'VK_LMENU': 0x00A4,
|
||||
'VK_RMENU': 0x00A5
|
||||
}
|
||||
|
||||
CONQUE_WINDOWS_VK_INV = dict([v, k] for k, v in CONQUE_WINDOWS_VK.items())
|
||||
|
||||
CONQUE_WINDOWS_VK_ENHANCED = {
|
||||
str(int(CONQUE_WINDOWS_VK['VK_UP'])): 1,
|
||||
str(int(CONQUE_WINDOWS_VK['VK_DOWN'])): 1,
|
||||
str(int(CONQUE_WINDOWS_VK['VK_LEFT'])): 1,
|
||||
str(int(CONQUE_WINDOWS_VK['VK_RIGHT'])): 1,
|
||||
str(int(CONQUE_WINDOWS_VK['VK_HOME'])): 1,
|
||||
str(int(CONQUE_WINDOWS_VK['VK_END'])): 1
|
||||
}
|
||||
|
||||
# }}}
|
||||
|
||||
# structures used for CreateProcess
|
||||
|
||||
# Odd types {{{
|
||||
|
||||
LPBYTE = POINTER(c_ubyte)
|
||||
LPTSTR = POINTER(c_char)
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
class STARTUPINFO(Structure): # {{{
|
||||
_fields_ = [("cb", c_ulong),
|
||||
("lpReserved", LPTSTR),
|
||||
("lpDesktop", LPTSTR),
|
||||
("lpTitle", LPTSTR),
|
||||
("dwX", c_ulong),
|
||||
("dwY", c_ulong),
|
||||
("dwXSize", c_ulong),
|
||||
("dwYSize", c_ulong),
|
||||
("dwXCountChars", c_ulong),
|
||||
("dwYCountChars", c_ulong),
|
||||
("dwFillAttribute", c_ulong),
|
||||
("dwFlags", c_ulong),
|
||||
("wShowWindow", c_short),
|
||||
("cbReserved2", c_short),
|
||||
("lpReserved2", LPBYTE),
|
||||
("hStdInput", c_void_p),
|
||||
("hStdOutput", c_void_p),
|
||||
("hStdError", c_void_p),]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class PROCESS_INFORMATION(Structure): # {{{
|
||||
_fields_ = [("hProcess", c_void_p),
|
||||
("hThread", c_void_p),
|
||||
("dwProcessId", c_ulong),
|
||||
("dwThreadId", c_ulong),]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class MEMORY_BASIC_INFORMATION(Structure): # {{{
|
||||
_fields_ = [("BaseAddress", c_void_p),
|
||||
("AllocationBase", c_void_p),
|
||||
("AllocationProtect", c_ulong),
|
||||
("RegionSize", c_ulong),
|
||||
("State", c_ulong),
|
||||
("Protect", c_ulong),
|
||||
("Type", c_ulong),]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class SECURITY_ATTRIBUTES(Structure): # {{{
|
||||
_fields_ = [("Length", c_ulong),
|
||||
("SecDescriptor", c_void_p),
|
||||
("InheritHandle", c_bool)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class COORD(Structure): # {{{
|
||||
_fields_ = [("X", c_short),
|
||||
("Y", c_short)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class SMALL_RECT(Structure): # {{{
|
||||
_fields_ = [("Left", c_short),
|
||||
("Top", c_short),
|
||||
("Right", c_short),
|
||||
("Bottom", c_short)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class CONSOLE_SCREEN_BUFFER_INFO(Structure): # {{{
|
||||
_fields_ = [("dwSize", COORD),
|
||||
("dwCursorPosition", COORD),
|
||||
("wAttributes", c_short),
|
||||
("srWindow", SMALL_RECT),
|
||||
("dwMaximumWindowSize", COORD)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class CHAR_UNION(Union): # {{{
|
||||
_fields_ = [("UnicodeChar", c_wchar),
|
||||
("AsciiChar", c_char)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class CHAR_INFO(Structure): # {{{
|
||||
_fields_ = [("Char", CHAR_UNION),
|
||||
("Attributes", c_short)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class KEY_EVENT_RECORD(Structure): # {{{
|
||||
_fields_ = [("bKeyDown", c_byte),
|
||||
("pad2", c_byte),
|
||||
('pad1', c_short),
|
||||
("wRepeatCount", c_short),
|
||||
("wVirtualKeyCode", c_short),
|
||||
("wVirtualScanCode", c_short),
|
||||
("uChar", CHAR_UNION),
|
||||
("dwControlKeyState", c_int)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class MOUSE_EVENT_RECORD(Structure): # {{{
|
||||
_fields_ = [("dwMousePosition", COORD),
|
||||
("dwButtonState", c_int),
|
||||
("dwControlKeyState", c_int),
|
||||
("dwEventFlags", c_int)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class WINDOW_BUFFER_SIZE_RECORD(Structure): # {{{
|
||||
_fields_ = [("dwSize", COORD)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class MENU_EVENT_RECORD(Structure): # {{{
|
||||
_fields_ = [("dwCommandId", c_uint)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
|
||||
# }}}
|
||||
|
||||
class FOCUS_EVENT_RECORD(Structure): # {{{
|
||||
_fields_ = [("bSetFocus", c_byte)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
# }}}
|
||||
|
||||
class INPUT_UNION(Union): # {{{
|
||||
_fields_ = [("KeyEvent", KEY_EVENT_RECORD),
|
||||
("MouseEvent", MOUSE_EVENT_RECORD),
|
||||
("WindowBufferSizeEvent", WINDOW_BUFFER_SIZE_RECORD),
|
||||
("MenuEvent", MENU_EVENT_RECORD),
|
||||
("FocusEvent", FOCUS_EVENT_RECORD)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
# }}}
|
||||
|
||||
class INPUT_RECORD(Structure): # {{{
|
||||
_fields_ = [("EventType", c_short),
|
||||
("Event", INPUT_UNION)]
|
||||
|
||||
def to_str(self):
|
||||
return ''
|
||||
# }}}
|
||||
|
||||
# vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,462 @@
|
|||
*ConqueTerm* Plugin to run a shell inside a Vim buffer
|
||||
|
||||
The ConqueTerm plugin will turn a Vim buffer into a terminal emulator, allowing
|
||||
you to run and interact with a shell or shell application inside the buffer.
|
||||
|
||||
1. Installation |conque-term-installation|
|
||||
2. Usage |conque-term-usage|
|
||||
3. Config Options |conque-term-options|
|
||||
4. VimScript API |conque-term-api|
|
||||
5. Misc |conque-term-misc|
|
||||
|
||||
==============================================================================
|
||||
|
||||
1. Installation *conque-term-installation*
|
||||
|
||||
Conque is designed for both Unix and Windows operating systems, however the
|
||||
requirements are slightly different. Please check section below corresponding
|
||||
to your installed OS.
|
||||
|
||||
1.1 Requirements for Unix *conque-term-requirements*
|
||||
|
||||
* [G]Vim 7.0+ with +python and/or +python3
|
||||
* Python 2.3+ and/or 3.x
|
||||
* Unix-like OS: Linux, OS X, Solaris, Cygwin, etc
|
||||
|
||||
The most common stumbling block is getting a version of Vim which has the
|
||||
python interface enabled. Most all software package managers will have a copy
|
||||
of Vim with Python support, so that is often the easiest way to get it. If
|
||||
you're compiling Vim from source, be sure to use the --enable-pythoninterp
|
||||
option, or --enable-python3interp for Python 3. On OS X the best option is
|
||||
MacVim, which installs with Python support by default.
|
||||
|
||||
1.2 Requirements for Windows *conque-term-windows*
|
||||
|
||||
* [G]Vim 7.3 with +python and/or +python3
|
||||
* Python 2.7 and/or 3.1
|
||||
* Modern Windows OS (XP or later)
|
||||
|
||||
Conque only officially supports the latest GVim 7.3 Windows installer
|
||||
available at www.vim.org. If you are currently using Vim 7.2 or earlier you
|
||||
will need to upgrade to 7.3 for Windows support. The Windows installer already
|
||||
has the +python/+python3 interface built in.
|
||||
|
||||
The official 7.3 release of Vim for Windows only works with Python versions
|
||||
2.7 and/or 3.1. You can download and install Python from their website
|
||||
http://www.python.org/download
|
||||
|
||||
If you are compiling Vim + Python from source on Windows, the requirements
|
||||
become only Vim 7.3+ and Python 2.7+.
|
||||
|
||||
|
||||
1.3 Installation *conque-term-installation-instructions*
|
||||
|
||||
Download the latest vimball from http://conque.googlecode.com
|
||||
|
||||
Open the .vba file with Vim and run the following commands:
|
||||
>
|
||||
:so %
|
||||
:q
|
||||
<
|
||||
That's it! The :ConqueTerm command will be available the next time you start
|
||||
Vim. You can delete the .vba file when you've verified Conque was successfully
|
||||
installed.
|
||||
|
||||
==============================================================================
|
||||
|
||||
2. Usage *conque-term-usage*
|
||||
|
||||
Type :ConqueTerm <command> to launch an application in the current buffer. Eg:
|
||||
>
|
||||
:ConqueTerm bash
|
||||
:ConqueTerm mysql -h localhost -u joe_lunchbox Menu
|
||||
:ConqueTerm Powershell.exe
|
||||
<
|
||||
Use :ConqueTermSplit or :ConqueTermVSplit to open Conque in a new horizontal
|
||||
or vertical buffer. Use :ConqueTermTab to open Conque in a new tab.
|
||||
|
||||
In insert mode you can interact with the shell as you would expect in a
|
||||
normal terminal. All key presses will be sent to the terminal, including
|
||||
control characters. See |conque-term-special-keys| for more information,
|
||||
particularly regarding the <Esc> key.
|
||||
|
||||
In normal mode you can use Vim commands to browse your terminal output and
|
||||
scroll back through the history. Most all Vim functionality will work, such
|
||||
as searching, yanking or highlighting text.
|
||||
|
||||
|
||||
2.1 Special keys *conque-term-special-keys*
|
||||
|
||||
There are several keys which can be configured to have special behavior with
|
||||
Conque.
|
||||
|
||||
Send text to Conque *conque-term-F9*
|
||||
|
||||
If you want to send some text from a file you are editing in another buffer
|
||||
to be run in Conque, select the desired text visually then press the <F9>
|
||||
key. If you have multiple Conque buffers, the text will be sent to the most
|
||||
recently created buffer. Alternatively you can yank the text, switch to your
|
||||
terminal, then paste it with the normal 'p' key. This feature can be
|
||||
configured to use a different key with the |ConqueTerm_SendVisKey| option.
|
||||
|
||||
Toggle terminal input mode *conque-term-F8*
|
||||
|
||||
If you want to use insert mode to edit the terminal screen, press <F8>. You
|
||||
will now be able to edit the terminal output freely without your cursor
|
||||
jumping the the active prompt line. This may be useful if you want to reformat
|
||||
terminal output for readability.
|
||||
|
||||
While the terminal is paused new output will not be displayed on the screen
|
||||
until you press <F8> again to resume.
|
||||
|
||||
You can configure Conque to use a different key with the |ConqueTerm_ToggleKey|
|
||||
option.
|
||||
|
||||
Sending the <Esc> key press *conque-term-Esc*
|
||||
|
||||
By default if you press the <Esc> key in a Conque buffer you will leave insert
|
||||
mode. But what if you want the key press to be sent to your terminal? There
|
||||
are two options. By default, pressing <Esc> twice will send one <Esc> key
|
||||
press to the terminal, while pressing it once will leave insert mode.
|
||||
|
||||
Alternatively you can use the |ConqueTerm_EscKey| option to choose a
|
||||
different key for leaving insert mode. If a custom key is set, then all <Esc>
|
||||
key presses will be sent to the terminal.
|
||||
|
||||
|
||||
==============================================================================
|
||||
|
||||
3. Options *conque-term-options*
|
||||
|
||||
You can set the following options in your .vimrc (default values shown)
|
||||
|
||||
|
||||
3.1 Insert mode when entering buffer *ConqueTerm_InsertOnEnter*
|
||||
|
||||
If set to 1 then you will automatically go into insert mode when you enter the
|
||||
buffer. This diverges from normal Vim behavior. If 0 you will still be in
|
||||
normal mode.
|
||||
>
|
||||
let g:ConqueTerm_InsertOnEnter = 0
|
||||
<
|
||||
3.2 Enable <C-w> in insert mode *ConqueTerm_CWInsert*
|
||||
|
||||
If set to 1 then you can leave the Conque buffer using the <C-w> commands
|
||||
while you're still in insert mode. If set to 0 then the <C-w> character will
|
||||
be sent to the terminal. If both this option and ConqueTerm_InsertOnEnter are
|
||||
set you can go in and out of the terminal buffer while never leaving insert
|
||||
mode.
|
||||
>
|
||||
let g:ConqueTerm_CWInsert = 0
|
||||
<
|
||||
3.3 Use a custom key for leaving insert mode *ConqueTerm_EscKey*
|
||||
|
||||
If a custom key is set, then all <Esc> key presses will be sent to the
|
||||
terminal and you must use this custom key to leave insert mode. If left to the
|
||||
default value of '<Esc>' then you must press it twice to send the escape
|
||||
character to the terminal, while pressing it once will leave insert mode.
|
||||
|
||||
Note: You cannot use a key which is internally coded with the escape
|
||||
character. This includes the <F-> keys and often the <A-> and <M-> keys.
|
||||
Picking a control key, such as <C-k> will be your best bet.
|
||||
>
|
||||
let g:ConqueTerm_EscKey = '<Esc>'
|
||||
<
|
||||
3.4 Send selected text to Conque *ConqueTerm_SendVisKey*
|
||||
|
||||
Use this key to send the currently selected text to the most recently created
|
||||
Conque buffer.
|
||||
>
|
||||
let g:ConqueTerm_SendVisKey = '<F9>'
|
||||
<
|
||||
3.5 Toggle terminal input mode *ConqueTerm_ToggleKey*
|
||||
|
||||
Press this key to pause terminal input and output display. You will then be
|
||||
able to edit the terminal screen as if it were a normal text buffer. Press
|
||||
this key again to resume terminal mode.
|
||||
>
|
||||
let g:ConqueTerm_ToggleKey = '<F8>'
|
||||
<
|
||||
3.6 Enable or disable colors *ConqueTerm_Color*
|
||||
|
||||
Set to 1 to enable colors, 0 to disable. Syntax highlighting in Vim can be
|
||||
slow if your terminal is color intensive. Disabling color can make the
|
||||
terminal render significantly faster.
|
||||
>
|
||||
let g:ConqueTerm_Color = 1
|
||||
<
|
||||
3.7 Choose your terminal type, Unix ONLY *ConqueTerm_TERM*
|
||||
|
||||
Use this option to tell Conque what type of terminal it should identify itself
|
||||
as. Conque officially uses the more limited VT100 terminal type for
|
||||
developement and testing, although it supports some more advanced features
|
||||
such as colors and title strings.
|
||||
|
||||
You can change this setting to a more advanced type, namely 'xterm', but your
|
||||
results may vary depending on which programs you're running.
|
||||
>
|
||||
let g:ConqueTerm_TERM = 'vt100'
|
||||
<
|
||||
3.8 Choose Vim syntax type *ConqueTerm_Syntax*
|
||||
|
||||
Set the buffer syntax. The default 'conque' has highlighting for MySQL, but
|
||||
not much else.
|
||||
>
|
||||
let g:ConqueTerm_Syntax = 'conque'
|
||||
<
|
||||
3.9 Keep updating terminal buffer *ConqueTerm_ReadUnfocused*
|
||||
|
||||
If set to 1 then your Conque buffers will continue to update after you've
|
||||
switched to another buffer.
|
||||
|
||||
Note: Conque buffers may continue to update, but they will not scroll down as
|
||||
new lines are added beyond the bottom of the visible buffer area. This is a
|
||||
limitation of the Vim scripting language for which I haven't found a
|
||||
workaround.
|
||||
>
|
||||
let g:ConqueTerm_ReadUnfocused = 1
|
||||
<
|
||||
3.10 Regex for highlighting your prompt *ConqueTerm_PromptRegex*
|
||||
|
||||
Use this regular expression for sytax highlighting your terminal prompt. Your
|
||||
terminal will generally run faster if you use Vim highlighting instead of
|
||||
terminal colors for your prompt. You can also use it to do more advanced
|
||||
syntax highlighting for the prompt line.
|
||||
>
|
||||
let g:ConqueTerm_PromptRegex = '^\w\+@[0-9A-Za-z_.-]\+:[0-9A-Za-z_./\~,:-]\+\$'
|
||||
<
|
||||
3.11 Close buffer when program exits *ConqueTerm_CloseOnEnd*
|
||||
|
||||
If you want your terminal buffer to be closed and permanently deleted when the
|
||||
program running inside of it exits, set this option to 1. Otherwise the buffer
|
||||
will become a simple text buffer after the program exits, and you can edit the
|
||||
program output in insert mode.
|
||||
>
|
||||
let g:ConqueTerm_CloseOnEnd = 0
|
||||
<
|
||||
3.12 Python version *ConqueTerm_PyVersion*
|
||||
|
||||
Conque will work with either Python 2.x or 3.x, assuming the interfaces have
|
||||
been installed. By default it will try to use Python 2 first, then will try
|
||||
Python 3. If you want Conque to use Python 3, set this variable to 3.
|
||||
|
||||
Note: even if you set this to 3, if you don't have the python3 interface
|
||||
Conque will fall back to using Python 2.
|
||||
>
|
||||
let g:ConqueTerm_PyVersion = 2
|
||||
<
|
||||
3.13 Python executable, Windows ONLY *ConqueTerm_PyExe*
|
||||
|
||||
The Windows version of Conque needs to know the path to the python.exe
|
||||
executable for the version of Python Conque is using. If you installed Python
|
||||
in the default location, or added the Python directory to your system path,
|
||||
Conque should be able to find python.exe without you changing this variable.
|
||||
|
||||
For example, you might set this to 'C:\Program Files\Python27\python.exe'
|
||||
>
|
||||
let g:ConqueTerm_PyExe = ''
|
||||
<
|
||||
3.14 Function Keys *ConqueTerm_SendFunctionKeys*
|
||||
|
||||
By default, function keys (the F1-F12 row at the top of your keyboard) are not
|
||||
passed to the terminal. Set this option to 1 to send these key events.
|
||||
|
||||
Note: Unless you configured |ConqueTerm_SendVisKey| and |ConqueTerm_ToggleKey|
|
||||
to use different keys, <F8> and <F9> will not be sent to the terminal even if
|
||||
you set this option to 1.
|
||||
>
|
||||
let g:ConqueTerm_SendFunctionKeys = 0
|
||||
<
|
||||
|
||||
==============================================================================
|
||||
|
||||
4. VimScript API (Beta) *conque-term-api*
|
||||
|
||||
The Conque scripting API allows you to create and interact with Conque
|
||||
terminals with the VimScript language. This API is still in beta stage.
|
||||
|
||||
4.1 conque_term#open({command}, [buf_opts], [remain]) *conque-term-open*
|
||||
|
||||
The open() function will create a new terminal buffer and start your command.
|
||||
|
||||
The {command} must be an executable, either an absolute path or relative to
|
||||
your system path.
|
||||
|
||||
You can pass in a list of vim commands [buf_opts] which will be executed after
|
||||
the new buffer is created but before the command is started. These are
|
||||
typically commands to alter the size, position or configuration of the buffer
|
||||
window.
|
||||
|
||||
Note: If you don't pass in a command such as 'split', the terminal will open
|
||||
in the current buffer.
|
||||
|
||||
If you don't want the new terminal buffer to become the new active buffer, set
|
||||
[remain] to 1. Only works if you create a split screen using [options].
|
||||
|
||||
Returns a Conque terminal object.
|
||||
|
||||
Examples:
|
||||
>
|
||||
let my_terminal = conque_term#open('/bin/bash')
|
||||
let my_terminal = conque_term#open('ipython', ['split', 'resize 20'], 1)
|
||||
<
|
||||
4.2 conque_term#subprocess({command}) *conque-term-subprocess*
|
||||
|
||||
Starts a new subprocess with your {command}, but no terminal buffer is ever
|
||||
created. This may be useful if you need asynchronous interaction with a
|
||||
subprocess, but want to handle the output on your own.
|
||||
|
||||
Returns a Conque terminal object.
|
||||
|
||||
Example:
|
||||
>
|
||||
let my_subprocess = conque_term#subprocess('tail -f /var/log/foo.log')
|
||||
<
|
||||
4.3 conque_term#get_instance( [terminal_number] ) *conque-term-get-instance*
|
||||
|
||||
Use the get_instance() function to retrieve an existing terminal object. The
|
||||
terminal could have been created either with the user command :ConqueTerm or
|
||||
with an API call to conque_term#open() or subprocess().
|
||||
|
||||
Use the optional [terminal_number] to retrieve a specific terminal instance.
|
||||
Otherwise if the current buffer is a Conque terminal, it will be returned,
|
||||
else the most recently created terminal. The terminal number is what you see
|
||||
at the end of a terminal buffer name, e.g. "bash - 2".
|
||||
|
||||
Returns a Conque terminal object.
|
||||
|
||||
Example:
|
||||
>
|
||||
nnoremap <F4> :call conque_term#get_instance().writeln('clear')<CR>
|
||||
<
|
||||
4.4 CONQUE_OBJECT.write(text) *conque-term-write*
|
||||
|
||||
Once you have a terminal object from open(), subprocess() or get_instance()
|
||||
you can send text input to it with the write() method.
|
||||
|
||||
No return value.
|
||||
|
||||
Examples:
|
||||
>
|
||||
call my_terminal.write("whoami\n")
|
||||
call my_terminal.write("\<C-c>")
|
||||
<
|
||||
4.5 CONQUE_OBJECT.writeln(text) *conque-term-writeln*
|
||||
|
||||
The same as write() except adds a \n character to the end if your input.
|
||||
|
||||
Examples:
|
||||
>
|
||||
call my_subprocess.writeln('make')
|
||||
<
|
||||
4.6 CONQUE_OBJECT.read( [timeout], [update_buffer] ) *conque-term-read*
|
||||
|
||||
Read new output from a Conque terminal subprocess. New output will be returned
|
||||
as a string, and the terminal buffer will also be updated by default.
|
||||
|
||||
If you are reading immediately after calling the write() method, you may want
|
||||
to wait [timeout] milliseconds for output to be ready.
|
||||
|
||||
If you want to prevent the output from being displayed in the terminal buffer,
|
||||
set [update_buffer] to 0. This option has no effect if the terminal was
|
||||
created with the subprocess() function, since there never is a buffer to
|
||||
update.
|
||||
|
||||
Returns output string.
|
||||
|
||||
Note: The terminal buffer will not automatically scroll down if the new output
|
||||
extends beyond the bottom of the visible buffer. Vim doesn't allow "unfocused"
|
||||
buffers to be scrolled at the current version, although hopefully this will
|
||||
change.
|
||||
|
||||
Examples:
|
||||
>
|
||||
call my_terminal.writeln('whoami')
|
||||
let output = my_terminal.read(500)
|
||||
call my_terminal.writeln('ls -lha')
|
||||
let output = my_terminal.read(1000, 1)
|
||||
<
|
||||
4.7 CONQUE_OBJECT.set_callback( {funcname} ) *conque-term-set-callback*
|
||||
|
||||
Register a callback function for this subprocess instance. This function will
|
||||
automatically be called whenever new output is available. Only practical with
|
||||
subprocess() objects.
|
||||
|
||||
Conque checkes for new subprocess output once a second when Vim is idle. If
|
||||
new output is found your function will be called.
|
||||
|
||||
Pass in the callback function name {funcname} as a string.
|
||||
|
||||
No return value.
|
||||
|
||||
Note: this method requires the g:ConqueTerm_ReadUnfocused option to be set.
|
||||
|
||||
Note: this method is experimental, results may vary.
|
||||
|
||||
Example:
|
||||
>
|
||||
let sp = conque_term#subprocess('tail -f /home/joe/log/error_log')
|
||||
|
||||
function! MyErrorAlert(output)
|
||||
echo a:output
|
||||
endfunction
|
||||
|
||||
call sp.set_callback('MyErrorAlert')
|
||||
<
|
||||
4.8 CONQUE_OBJECT.close() *conque-term-close*
|
||||
|
||||
Kill your terminal subprocess. Sends the ABORT signal. You probably want to
|
||||
close your subprocess in a more graceful manner with the write() method, but
|
||||
this can be used when needed. Does not close the terminal buffer, if it
|
||||
exists.
|
||||
|
||||
This method will be called on all existing Conque subprocesses when Vim exits.
|
||||
|
||||
Example:
|
||||
>
|
||||
let term = conque_term#open('ping google.com', ['belowright split'])
|
||||
call term.read(5000)
|
||||
call term.close()
|
||||
<
|
||||
|
||||
==============================================================================
|
||||
|
||||
5. Misc *conque-term-misc*
|
||||
|
||||
|
||||
5.1 Known bugs *conque-term-bugs*
|
||||
|
||||
The following are known limitations:
|
||||
|
||||
- Font/color highlighting is imperfect and slow. If you don't care about
|
||||
color in your shell, set g:ConqueTerm_Color = 0 in your .vimrc
|
||||
- Conque only supports the extended ASCII character set for input, not utf-8.
|
||||
- VT100 escape sequence support is not complete.
|
||||
- Alt/Meta key support in Vim isn't great in general, and conque is no
|
||||
exception. Pressing <Esc><Esc>x or <Esc><M-x> instead of <M-x> works in
|
||||
most cases.
|
||||
|
||||
|
||||
5.2 Contribute *conque-term-contribute*
|
||||
|
||||
The two contributions most in need are improvements to Vim itself. I currently
|
||||
use hacks to capture key press input from the user, and to poll the terminal
|
||||
for more output. The Vim todo.txt document lists proposed improvements to give
|
||||
users this behavior without hacks. Having a key press event should allow
|
||||
Conque to work with multi- byte input. If you are a Vim developer, please
|
||||
consider prioritizing these two items:
|
||||
|
||||
- todo.txt (Autocommands, line ~3137)
|
||||
8 Add an event like CursorHold that is triggered repeatedly, not just
|
||||
once after typing something.
|
||||
|
||||
|
||||
5.3 Feedback *conque-term-feedback*
|
||||
|
||||
Bugs, suggestions and patches are all welcome.
|
||||
|
||||
For more information visit http://conque.googlecode.com
|
||||
|
||||
Check out the latest from svn at http://conque.googlecode.com/svn/trunk/
|
||||
|
||||
vim:tw=78:ts=8:ft=help:norl:
|
||||
38
vim/doc/tags
38
vim/doc/tags
|
|
@ -108,6 +108,21 @@
|
|||
:VCSUnlock vcscommand.txt /*:VCSUnlock*
|
||||
:VCSUpdate vcscommand.txt /*:VCSUpdate*
|
||||
:VCSVimDiff vcscommand.txt /*:VCSVimDiff*
|
||||
ConqueTerm conque_term.txt /*ConqueTerm*
|
||||
ConqueTerm_CWInsert conque_term.txt /*ConqueTerm_CWInsert*
|
||||
ConqueTerm_CloseOnEnd conque_term.txt /*ConqueTerm_CloseOnEnd*
|
||||
ConqueTerm_Color conque_term.txt /*ConqueTerm_Color*
|
||||
ConqueTerm_EscKey conque_term.txt /*ConqueTerm_EscKey*
|
||||
ConqueTerm_InsertOnEnter conque_term.txt /*ConqueTerm_InsertOnEnter*
|
||||
ConqueTerm_PromptRegex conque_term.txt /*ConqueTerm_PromptRegex*
|
||||
ConqueTerm_PyExe conque_term.txt /*ConqueTerm_PyExe*
|
||||
ConqueTerm_PyVersion conque_term.txt /*ConqueTerm_PyVersion*
|
||||
ConqueTerm_ReadUnfocused conque_term.txt /*ConqueTerm_ReadUnfocused*
|
||||
ConqueTerm_SendFunctionKeys conque_term.txt /*ConqueTerm_SendFunctionKeys*
|
||||
ConqueTerm_SendVisKey conque_term.txt /*ConqueTerm_SendVisKey*
|
||||
ConqueTerm_Syntax conque_term.txt /*ConqueTerm_Syntax*
|
||||
ConqueTerm_TERM conque_term.txt /*ConqueTerm_TERM*
|
||||
ConqueTerm_ToggleKey conque_term.txt /*ConqueTerm_ToggleKey*
|
||||
NERDComAbout NERD_commenter.txt /*NERDComAbout*
|
||||
NERDComAlignedComment NERD_commenter.txt /*NERDComAlignedComment*
|
||||
NERDComAltDelim NERD_commenter.txt /*NERDComAltDelim*
|
||||
|
|
@ -232,6 +247,29 @@ bufexplorer-todo bufexplorer.txt /*bufexplorer-todo*
|
|||
bufexplorer-usage bufexplorer.txt /*bufexplorer-usage*
|
||||
bufexplorer.txt bufexplorer.txt /*bufexplorer.txt*
|
||||
buffer-explorer bufexplorer.txt /*buffer-explorer*
|
||||
conque-term-Esc conque_term.txt /*conque-term-Esc*
|
||||
conque-term-F8 conque_term.txt /*conque-term-F8*
|
||||
conque-term-F9 conque_term.txt /*conque-term-F9*
|
||||
conque-term-api conque_term.txt /*conque-term-api*
|
||||
conque-term-bugs conque_term.txt /*conque-term-bugs*
|
||||
conque-term-close conque_term.txt /*conque-term-close*
|
||||
conque-term-contribute conque_term.txt /*conque-term-contribute*
|
||||
conque-term-feedback conque_term.txt /*conque-term-feedback*
|
||||
conque-term-get-instance conque_term.txt /*conque-term-get-instance*
|
||||
conque-term-installation conque_term.txt /*conque-term-installation*
|
||||
conque-term-installation-instructions conque_term.txt /*conque-term-installation-instructions*
|
||||
conque-term-misc conque_term.txt /*conque-term-misc*
|
||||
conque-term-open conque_term.txt /*conque-term-open*
|
||||
conque-term-options conque_term.txt /*conque-term-options*
|
||||
conque-term-read conque_term.txt /*conque-term-read*
|
||||
conque-term-requirements conque_term.txt /*conque-term-requirements*
|
||||
conque-term-set-callback conque_term.txt /*conque-term-set-callback*
|
||||
conque-term-special-keys conque_term.txt /*conque-term-special-keys*
|
||||
conque-term-subprocess conque_term.txt /*conque-term-subprocess*
|
||||
conque-term-usage conque_term.txt /*conque-term-usage*
|
||||
conque-term-windows conque_term.txt /*conque-term-windows*
|
||||
conque-term-write conque_term.txt /*conque-term-write*
|
||||
conque-term-writeln conque_term.txt /*conque-term-writeln*
|
||||
cvscommand-changes vcscommand.txt /*cvscommand-changes*
|
||||
g:bufExplorerDefaultHelp bufexplorer.txt /*g:bufExplorerDefaultHelp*
|
||||
g:bufExplorerDetailedHelp bufexplorer.txt /*g:bufExplorerDetailedHelp*
|
||||
|
|
|
|||
|
|
@ -0,0 +1,139 @@
|
|||
" FILE: plugin/conque_term.vim {{{
|
||||
" AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
" WEBSITE: http://conque.googlecode.com
|
||||
" MODIFIED: 2010-11-15
|
||||
" VERSION: 2.0, for Vim 7.0
|
||||
" LICENSE:
|
||||
" Conque - Vim terminal/console emulator
|
||||
" Copyright (C) 2009-2010 Nico Raffo
|
||||
"
|
||||
" MIT License
|
||||
"
|
||||
" Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
" of this software and associated documentation files (the "Software"), to deal
|
||||
" in the Software without restriction, including without limitation the rights
|
||||
" to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
" copies of the Software, and to permit persons to whom the Software is
|
||||
" furnished to do so, subject to the following conditions:
|
||||
"
|
||||
" The above copyright notice and this permission notice shall be included in
|
||||
" all copies or substantial portions of the Software.
|
||||
"
|
||||
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
" AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
" LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
" OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
" THE SOFTWARE.
|
||||
" }}}
|
||||
|
||||
" See docs/conque_term.txt for help or type :help conque_term
|
||||
|
||||
if exists('g:ConqueTerm_Loaded') || v:version < 700
|
||||
finish
|
||||
endif
|
||||
|
||||
" **********************************************************************************************************
|
||||
" **** CONFIG **********************************************************************************************
|
||||
" **********************************************************************************************************
|
||||
|
||||
" {{{
|
||||
|
||||
" automatically go into insert mode when entering buffer {{{
|
||||
if !exists('g:ConqueTerm_InsertOnEnter')
|
||||
let g:ConqueTerm_InsertOnEnter = 0
|
||||
endif " }}}
|
||||
|
||||
" Allow user to use <C-w> keys to switch window in insert mode. {{{
|
||||
if !exists('g:ConqueTerm_CWInsert')
|
||||
let g:ConqueTerm_CWInsert = 0
|
||||
endif " }}}
|
||||
|
||||
" Choose key mapping to leave insert mode {{{
|
||||
" If you choose something other than '<Esc>', then <Esc> will be sent to terminal
|
||||
" Using a different key will usually fix Alt/Meta key issues
|
||||
if !exists('g:ConqueTerm_EscKey')
|
||||
let g:ConqueTerm_EscKey = '<Esc>'
|
||||
endif " }}}
|
||||
|
||||
" Use this key to send selected text to conque. {{{
|
||||
if !exists('g:ConqueTerm_SendVisKey')
|
||||
let g:ConqueTerm_SendVisKey = '<F9>'
|
||||
endif " }}}
|
||||
|
||||
" Use this key to toggle terminal key mappings. {{{
|
||||
if !exists('g:ConqueTerm_ToggleKey')
|
||||
let g:ConqueTerm_ToggleKey = '<F8>'
|
||||
endif " }}}
|
||||
|
||||
" Enable color. {{{
|
||||
" If your apps use a lot of color it will slow down the shell.
|
||||
if !exists('g:ConqueTerm_Color')
|
||||
let g:ConqueTerm_Color = 1
|
||||
endif " }}}
|
||||
|
||||
" TERM environment setting {{{
|
||||
if !exists('g:ConqueTerm_TERM')
|
||||
let g:ConqueTerm_TERM = 'vt100'
|
||||
endif " }}}
|
||||
|
||||
" Syntax for your buffer {{{
|
||||
if !exists('g:ConqueTerm_Syntax')
|
||||
let g:ConqueTerm_Syntax = 'conque_term'
|
||||
endif " }}}
|
||||
|
||||
" Keep on updating the shell window after you've switched to another buffer {{{
|
||||
if !exists('g:ConqueTerm_ReadUnfocused')
|
||||
let g:ConqueTerm_ReadUnfocused = 0
|
||||
endif " }}}
|
||||
|
||||
" Use this regular expression to highlight prompt {{{
|
||||
if !exists('g:ConqueTerm_PromptRegex')
|
||||
let g:ConqueTerm_PromptRegex = '^\w\+@[0-9A-Za-z_.-]\+:[0-9A-Za-z_./\~,:-]\+\$'
|
||||
endif " }}}
|
||||
|
||||
" Choose which Python version to attempt to load first {{{
|
||||
" Valid values are 2, 3 or 0 (no preference)
|
||||
if !exists('g:ConqueTerm_PyVersion')
|
||||
let g:ConqueTerm_PyVersion = 2
|
||||
endif " }}}
|
||||
|
||||
" Path to python.exe. (Windows only) {{{
|
||||
" By default, Conque will check C:\PythonNN\python.exe then will search system path
|
||||
" If you have installed Python in an unusual location and it's not in your path, fill in the full path below
|
||||
" E.g. 'C:\Program Files\Python\Python27\python.exe'
|
||||
if !exists('g:ConqueTerm_PyExe')
|
||||
let g:ConqueTerm_PyExe = ''
|
||||
endif " }}}
|
||||
|
||||
" Automatically close buffer when program exits {{{
|
||||
if !exists('g:ConqueTerm_CloseOnEnd')
|
||||
let g:ConqueTerm_CloseOnEnd = 0
|
||||
endif " }}}
|
||||
|
||||
" Send function key presses to terminal {{{
|
||||
if !exists('g:ConqueTerm_SendFunctionKeys')
|
||||
let g:ConqueTerm_SendFunctionKeys = 0
|
||||
endif " }}}
|
||||
|
||||
" }}}
|
||||
|
||||
" **********************************************************************************************************
|
||||
" **** Startup *********************************************************************************************
|
||||
" **********************************************************************************************************
|
||||
|
||||
" Startup {{{
|
||||
|
||||
let g:ConqueTerm_Loaded = 1
|
||||
let g:ConqueTerm_Idx = 0
|
||||
let g:ConqueTerm_Version = 200
|
||||
|
||||
command! -nargs=+ -complete=shellcmd ConqueTerm call conque_term#open(<q-args>)
|
||||
command! -nargs=+ -complete=shellcmd ConqueTermSplit call conque_term#open(<q-args>, ['belowright split'])
|
||||
command! -nargs=+ -complete=shellcmd ConqueTermVSplit call conque_term#open(<q-args>, ['belowright vsplit'])
|
||||
command! -nargs=+ -complete=shellcmd ConqueTermTab call conque_term#open(<q-args>, ['tabnew'])
|
||||
|
||||
" }}}
|
||||
|
||||
" vim:foldmethod=marker
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
" FILE: syntax/conque_term.vim {{{
|
||||
" AUTHOR: Nico Raffo <nicoraffo@gmail.com>
|
||||
" WEBSITE: http://conque.googlecode.com
|
||||
" MODIFIED: 2010-11-15
|
||||
" VERSION: 2.0, for Vim 7.0
|
||||
" LICENSE:
|
||||
" Conque - Vim terminal/console emulator
|
||||
" Copyright (C) 2009-2010 Nico Raffo
|
||||
"
|
||||
" MIT License
|
||||
"
|
||||
" Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
" of this software and associated documentation files (the "Software"), to deal
|
||||
" in the Software without restriction, including without limitation the rights
|
||||
" to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
" copies of the Software, and to permit persons to whom the Software is
|
||||
" furnished to do so, subject to the following conditions:
|
||||
"
|
||||
" The above copyright notice and this permission notice shall be included in
|
||||
" all copies or substantial portions of the Software.
|
||||
"
|
||||
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
" AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
" LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
" OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
" THE SOFTWARE.
|
||||
" }}}
|
||||
|
||||
|
||||
" *******************************************************************************************************************
|
||||
" MySQL *************************************************************************************************************
|
||||
" *******************************************************************************************************************
|
||||
|
||||
" TODO Move these to syntax which is only executed for mysql
|
||||
"syn match MySQLTableBodyG "^\s*\w\+:\(.\+\)\=$" contains=MySQLTableHeadG,MySQLNullG,MySQLBool,MySQLNumberG,MySQLStorageClass oneline skipwhite skipnl
|
||||
"syn match MySQLTableHeadG "^\s*\w\+:" contains=MySQLTableColon skipwhite contained
|
||||
"syn match MySQLTableColon ":" contained
|
||||
|
||||
syn match MySQLTableHead "^ *|.*| *$" nextgroup=MySQLTableDivide contains=MySQLTableBar oneline skipwhite skipnl
|
||||
syn match MySQLTableBody "^ *|.*| *$" nextgroup=MySQLTableBody,MySQLTableEnd contains=MySQLTableBar,MySQLNull,MySQLBool,MySQLNumber,MySQLStorageClass oneline skipwhite skipnl
|
||||
syn match MySQLTableEnd "^ *+[+=-]\++ *$" oneline
|
||||
syn match MySQLTableDivide "^ *+[+=-]\++ *$" nextgroup=MySQLTableBody oneline skipwhite skipnl
|
||||
syn match MySQLTableStart "^ *+[+=-]\++ *$" nextgroup=MySQLTableHead oneline skipwhite skipnl
|
||||
syn match MySQLNull " NULL " contained contains=MySQLTableBar
|
||||
syn match MySQLStorageClass " PRI " contained
|
||||
syn match MySQLStorageClass " MUL " contained
|
||||
syn match MySQLStorageClass " UNI " contained
|
||||
syn match MySQLStorageClass " CURRENT_TIMESTAMP " contained
|
||||
syn match MySQLStorageClass " auto_increment " contained
|
||||
syn match MySQLTableBar "|" contained
|
||||
syn match MySQLNumber "|\? *\d\+\(\.\d\+\)\? *|" contained contains=MySQLTableBar
|
||||
syn match MySQLQueryStat "^\d\+ rows\? in set.*" oneline
|
||||
syn match MySQLPromptLine "^.\?mysql> .*$" contains=MySQLKeyword,MySQLPrompt,MySQLString oneline
|
||||
syn match MySQLPromptLine "^ -> .*$" contains=MySQLKeyword,MySQLPrompt,MySQLString oneline
|
||||
syn match MySQLPrompt "^.\?mysql>" contained oneline
|
||||
syn match MySQLPrompt "^ ->" contained oneline
|
||||
syn case ignore
|
||||
syn keyword MySQLKeyword select count max sum avg date show table tables status like as from left right outer inner join contained
|
||||
syn keyword MySQLKeyword where group by having limit offset order desc asc show contained and interval is null on
|
||||
syn case match
|
||||
syn region MySQLString start=+'+ end=+'+ skip=+\\'+ contained oneline
|
||||
syn region MySQLString start=+"+ end=+"+ skip=+\\"+ contained oneline
|
||||
syn region MySQLString start=+`+ end=+`+ skip=+\\`+ contained oneline
|
||||
|
||||
|
||||
hi def link MySQLPrompt Identifier
|
||||
hi def link MySQLTableHead Title
|
||||
hi def link MySQLTableBody Normal
|
||||
hi def link MySQLBool Boolean
|
||||
hi def link MySQLStorageClass StorageClass
|
||||
hi def link MySQLNumber Number
|
||||
hi def link MySQLKeyword Keyword
|
||||
hi def link MySQLString String
|
||||
|
||||
" terms which have no reasonable default highlight group to link to
|
||||
hi MySQLTableHead term=bold cterm=bold gui=bold
|
||||
if &background == 'dark'
|
||||
hi MySQLTableEnd term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
hi MySQLTableDivide term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
hi MySQLTableStart term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
hi MySQLTableBar term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
hi MySQLNull term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
hi MySQLQueryStat term=NONE cterm=NONE gui=NONE ctermfg=238 guifg=#444444
|
||||
elseif &background == 'light'
|
||||
hi MySQLTableEnd term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
hi MySQLTableDivide term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
hi MySQLTableStart term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
hi MySQLTableBar term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
hi MySQLNull term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
hi MySQLQueryStat term=NONE cterm=NONE gui=NONE ctermfg=247 guifg=#9e9e9e
|
||||
endif
|
||||
|
||||
|
||||
" *******************************************************************************************************************
|
||||
" Bash **************************************************************************************************************
|
||||
" *******************************************************************************************************************
|
||||
|
||||
" Typical Prompt
|
||||
if g:ConqueTerm_PromptRegex != ''
|
||||
silent execute "syn match ConquePromptLine '" . g:ConqueTerm_PromptRegex . ".*$' contains=ConquePrompt,ConqueString oneline"
|
||||
silent execute "syn match ConquePrompt '" . g:ConqueTerm_PromptRegex . "' contained oneline"
|
||||
hi def link ConquePrompt Identifier
|
||||
endif
|
||||
|
||||
" Strings
|
||||
syn region ConqueString start=+'+ end=+'+ skip=+\\'+ contained oneline
|
||||
syn region ConqueString start=+"+ end=+"+ skip=+\\"+ contained oneline
|
||||
syn region ConqueString start=+`+ end=+`+ skip=+\\`+ contained oneline
|
||||
hi def link ConqueString String
|
||||
|
||||
" vim: foldmethod=marker
|
||||
14
vim/vimrc
14
vim/vimrc
|
|
@ -137,9 +137,13 @@ nnoremap <silent> <Leader>l :set list!<CR>
|
|||
nnoremap <silent> <Leader>f :set fullscreen!<CR>
|
||||
nnoremap <silent> <Leader>x :set paste!<CR>
|
||||
nnoremap <silent> <Leader>n :NERDTreeToggle<CR>
|
||||
nnoremap <silent> <Leader>t :Tlist<CR>
|
||||
nnoremap <silent> <Leader>T :Tlist<CR>
|
||||
nnoremap <silent> <Leader>N :set number!<CR>
|
||||
nnoremap <silent> <Leader>b :HSBufExplorer<CR>
|
||||
|
||||
nnoremap <silent> <Leader>ts :ConqueTermSplit zsh<CR>
|
||||
nnoremap <silent> <Leader>tt :ConqueTermTab zsh<CR>
|
||||
|
||||
map <silent> <Leader>c <plug>NERDCommenterToggle
|
||||
|
||||
" nnoremap <silent> Y y$
|
||||
|
|
@ -153,9 +157,15 @@ vnoremap <silent> <S-Down> j
|
|||
vnoremap <silent> <S-Up> k
|
||||
|
||||
" Terminal/Filemanager integration
|
||||
nnoremap <silent> <F9> :OpenTerminal<CR>
|
||||
" nnoremap <silent> <F9> :OpenTerminal<CR>
|
||||
nnoremap <silent> <F10> :OpenFilemanager<CR><CR>
|
||||
|
||||
" Conque setup
|
||||
let g:ConqueTerm_InsertOnEnter = 1
|
||||
let g:ConqueTerm_TERM = 'xterm'
|
||||
let g:ConqueTerm_CloseOnEnd = 1
|
||||
let g:ConqueTerm_SendVisKey = ',tp'
|
||||
|
||||
" Tab selection by number
|
||||
nnoremap <silent> <D-1> 1gt
|
||||
nnoremap <silent> <D-2> 2gt
|
||||
|
|
|
|||
Loading…
Reference in New Issue