diff options
| -rw-r--r-- | .vim/autoload/screen.vim | 1081 | ||||
| -rw-r--r-- | .vim/doc/screen.txt | 390 | ||||
| -rw-r--r-- | .vim/plugin/screen.vim | 161 | ||||
| -rw-r--r-- | .vimrc | 17 |
4 files changed, 1643 insertions, 6 deletions
diff --git a/.vim/autoload/screen.vim b/.vim/autoload/screen.vim new file mode 100644 index 0000000..66de7f6 --- /dev/null +++ b/.vim/autoload/screen.vim @@ -0,0 +1,1081 @@ +" Author: Eric Van Dewoestine <ervandew@gmail.com> +" +" License: {{{ +" Copyright (c) 2009 - 2011 +" All rights reserved. +" +" Redistribution and use of this software in source and binary forms, with +" or without modification, are permitted provided that the following +" conditions are met: +" +" * Redistributions of source code must retain the above +" copyright notice, this list of conditions and the +" following disclaimer. +" +" * Redistributions in binary form must reproduce the above +" copyright notice, this list of conditions and the +" following disclaimer in the documentation and/or other +" materials provided with the distribution. +" +" * Neither the name of Eric Van Dewoestine nor the names of its +" contributors may be used to endorse or promote products derived from +" this software without specific prior written permission of +" Eric Van Dewoestine. +" +" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +" IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +" THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +" PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +" PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +" }}} + +let s:save_cpo=&cpo +set cpo&vim + +" Script Variables {{{ + + if has('win32') || has('win64') || has('win32unix') + let s:terminals = ['bash'] + elseif has('mac') && has('gui_running') + let s:terminals = ['Terminal.app'] + else + let s:terminals = [ + \ 'gnome-terminal', 'konsole', + \ 'urxvt', 'multi-aterm', 'aterm', 'mrxvt', 'rxvt', + \ 'xterm', + \ ] + endif + +" }}} + +" ScreenShellCommands() {{{ +function! screen#ScreenShellCommands() + command -nargs=? -complete=shellcmd ScreenShell + \ :call screen#ScreenShell('<args>', 'horizontal') + command -nargs=? -complete=customlist,screen#CommandCompleteScreenSessions + \ ScreenShellAttach :call screen#ScreenShellAttach('<args>') + + if !has('gui_running') && + \ !g:ScreenShellExternal && + \ (g:ScreenImpl == 'Tmux' || g:ScreenShellGnuScreenVerticalSupport != '') + command -nargs=? -complete=shellcmd ScreenShellVertical + \ :call screen#ScreenShell('<args>', 'vertical') + endif +endfunction " }}} + +" ScreenShell(cmd, orientation) {{{ +" Open a split shell. +function! screen#ScreenShell(cmd, orientation) + if g:ScreenImpl !~ '^\(GnuScreen\|Tmux\)$' + echohl WarningMsg + echom 'Unsupported g:ScreenImpl value "' . g:ScreenImpl . '". ' . + \ 'Supported values included "GnuScreen" or "Tmux".' + echohl Normal + return + endif + + if !s:screen{g:ScreenImpl}.isValid() + return + endif + + let s:orientation = a:orientation + + " Specifies a name to be supplied to vim's --servername arg when invoked in + " a new screen session. + if !exists('g:ScreenShellServerName') + " Perform this here so that g:ScreenShellExternal can be set after vim + " starts. + let s:servername = g:ScreenShellExternal ? '' : 'vim' + else + let s:servername = g:ScreenShellServerName + endif + + try + let bootstrap = + \ g:ScreenImpl =~ 'GnuScreen\|Tmux' && + \ !has('gui_running') && + \ !exists('g:ScreenShellBootstrapped') && + \ expand('$TERM') !~ '^screen' + + " if using an external shell without the need to set the vim servername, + " then don't bootstrap + if bootstrap + if g:ScreenShellExternal && + \ (s:servername == '' || g:ScreenImpl == 'Tmux' || + \ !has('clientserver') || has('win32') || has('win64')) + let bootstrap = 0 + endif + endif + + if bootstrap + call s:ScreenBootstrap(a:cmd) + else + call s:ScreenInit(a:cmd) + endif + finally + " wrapping in a try without catching anything just cleans up the vim error + " produced by an exception thrown from one of the above functions. + endtry +endfunction " }}} + +" ScreenShellAttach(session) {{{ +" Attach to an existing screen session. +function! screen#ScreenShellAttach(session) + if !s:screen{g:ScreenImpl}.isValid() + return + endif + + let g:ScreenShellSession = s:screen{g:ScreenImpl}.attachSession(a:session) + + if g:ScreenShellSession != '0' + if !exists(':ScreenSend') + command -nargs=0 -range=% ScreenSend :call <SID>ScreenSend(<line1>, <line2>) + let g:ScreenShellSend = s:ScreenSendFuncRef() + let g:ScreenShellFocus = s:ScreenFocusFuncRef() + endif + + if g:ScreenShellAttachTargetCurrent + let g:ScreenShellWindow = 'screenshell' + call s:screen{g:ScreenImpl}.setTitle() + endif + endif +endfunction " }}} + +" s:ScreenBootstrap(cmd) {{{ +" Bootstrap a new screen session. +function! s:ScreenBootstrap(cmd) + try + let g:ScreenShellBootstrapped = 1 + let g:ScreenShellSession = s:screen{g:ScreenImpl}.newSessionName() + + wa + let save_sessionoptions = &sessionoptions + set sessionoptions+=globals + set sessionoptions-=tabpages + let sessionfile = substitute(tempname(), '\', '/', 'g') + exec 'mksession ' . sessionfile + + " when transitioning from windows vim to cygwin vim, the session file + " needs to be purged of windows line endings. + if has('win32') || has('win64') + let winrestcmd = winrestcmd() + try + exec '1split ' . sessionfile + set ff=unix + exec "%s/\<c-m>$//g" + wq + finally + exec winrestcmd + endtry + endif + + " support for taglist + if exists(':TlistSessionSave') && + \ exists('g:TagList_title') && + \ bufwinnr(g:TagList_title) + let g:ScreenShellTaglistSession = sessionfile . '.taglist' + exec 'TlistSessionSave ' . g:ScreenShellTaglistSession + exec 'silent! !echo "Tlist | TlistSessionLoad ' . + \ g:ScreenShellTaglistSession . '" >> "' . sessionfile . '"' + endif + + let bufend = bufnr('$') + let bufnum = 1 + while bufnum <= bufend + if bufnr(bufnum) != -1 + call setbufvar(bufnum, 'save_swapfile', getbufvar(bufnum, '&swapfile')) + call setbufvar(bufnum, '&swapfile', 0) + + " suppress prompt and auto reload changed files for the user when + " returning to this vim session + augroup screenshell_filechanged + exec 'autocmd! FileChangedShell <buffer=' . bufnum . '>' + exec 'autocmd FileChangedShell <buffer=' . bufnum . '> ' . + \ 'let v:fcs_choice = (v:fcs_reason == "changed" ? "reload" : "ask") | ' . + \ 'autocmd! screenshell_filechanged FileChangedShell <buffer=' . bufnum . '>' + augroup END + endif + let bufnum = bufnum + 1 + endwhile + + " supply a servername when starting vim if supported + let server = '' + if has('clientserver') && s:servername != '' + let server = '--servername "' . s:servername . '" ' + endif + + " when transitioning from windows console vim to cygwin vim, we don't know + " if the cygwin version support clientserver, so error on the safe side + " (in my environment the cygwin vim doesn't support client server). + if has('win32') || has('win64') + let server = '' + endif + + call s:screen{g:ScreenImpl}.bootstrap(server, sessionfile, a:cmd) + finally + redraw! + + unlet g:ScreenShellBootstrapped + + " if there was an error writing files, then we didn't get far enough to + " need this cleanup. + if exists('save_sessionoptions') + let &sessionoptions = save_sessionoptions + call delete(sessionfile) + + " remove taglist session file + if exists('g:ScreenShellTaglistSession') + call delete(g:ScreenShellTaglistSession) + endif + + redraw! + + let possible_detach = 0 + let bufnum = 1 + let winrestcmd = winrestcmd() + new + try + while bufnum <= bufend + if bufnr(bufnum) != -1 + try + call setbufvar(bufnum, '&swapfile', getbufvar(bufnum, 'save_swapfile')) + catch /E325/ + let possible_detach = 1 + exec 'buffer ' . bufnum + try + redraw + edit + catch + endtry + endtry + endif + let bufnum = bufnum + 1 + endwhile + finally + quit! + exec winrestcmd + endtry + + if possible_detach + echohl WarningMsg + echom 'Warning: detatching from a screen session started by ' . + \ ':ScreenShell may result in conflicting swap files like those ' . + \ 'just encountered. Due to this possibility, detaching from a ' . + \ 'screen session started by :ScreenShell is discouraged. ' . + \ 'Instead you should issue a :ScreenQuit or exit the vim ' . + \ 'instance in screen normally (:qa)' + echohl None + endif + endif + endtry +endfunction " }}} + +" s:ScreenInit(cmd) {{{ +" Initialize the current screen session. +function! s:ScreenInit(cmd) + let g:ScreenShellWindow = 'screenshell' + " use a portion of the command as the title, if supplied + "if a:cmd != '' && a:cmd !~ '^\s*vim\>' + " let g:ScreenShellWindow = s:ScreenCmdName(a:cmd)[:15] + "endif + + let external = 0 + let owner = '' + if g:ScreenImpl =~ 'GnuScreen\|Tmux' + " when already running in a screen session, never use an external shell + let external = !exists('g:ScreenShellBootstrapped') && + \ expand('$TERM') =~ '^screen' ? 0 : g:ScreenShellExternal + " w/ gvim always use an external shell + let external = has('gui_running') ? 1 : external + endif + + if exists('g:ScreenShellBootstrapped') + let owner = 'session' + endif + + " use screen regions + if !external + let result = s:screen{g:ScreenImpl}.openRegion(a:cmd) + let owner = 'region' + + " use an external terminal + else + let g:ScreenShellSession = exists('g:ScreenShellSession') ? + \ g:ScreenShellSession : s:screen{g:ScreenImpl}.newSessionName() + + " This block should only be hit in console mode with external terminal + + " vim server name set. + " Not supported by tmux since it doesn't appear that you can have + " more than one terminal connected to a session without them all + " focusing the same window. + if !has('gui_running') && + \ exists('g:ScreenShellBootstrapped') && + \ g:ScreenImpl != 'Tmux' + + let result = s:screen{g:ScreenImpl}.newWindow(0) + let owner = 'window' + + if !v:shell_error + let result = s:screen{g:ScreenImpl}.newTerminalMulti() + + if !v:shell_error && result != '0' && a:cmd != '' + let result = s:screen{g:ScreenImpl}.send(a:cmd) + endif + endif + + else + let result = s:screen{g:ScreenImpl}.newTerminal() + let owner = 'terminal' + + if has('win32') || has('win64') || has('win32unix') || has('mac') + " like, the sleep hack below, but longer for windows. + sleep 3000m + else + " looks like this is needed for ubuntu as well... ugg. + sleep 1000m + endif + + if !v:shell_error && result != '0' + " Hack, but should be plenty of time to let screen get to a state + " where it will apply the title command. + sleep 500m + let result = s:screen{g:ScreenImpl}.setTitle() + + if g:ScreenImpl == 'Tmux' + let g:ScreenShellTmuxPane = s:screen{g:ScreenImpl}.activePane() + endif + + " execute the supplied command if any + if !v:shell_error && a:cmd != '' + let result = s:screen{g:ScreenImpl}.send(a:cmd) + endif + endif + endif + endif + + if v:shell_error + if exists(':ScreenQuit') + delcommand ScreenQuit + endif + echoerr result + else + if !exists(':ScreenSend') + command -nargs=0 -range=% ScreenSend :call <SID>ScreenSend(<line1>, <line2>) + exec "command -nargs=0 ScreenQuit :call <SID>ScreenQuit('" . owner . "', 0)" + if g:ScreenShellQuitOnVimExit + augroup screen_shell + autocmd! + exec "autocmd VimLeave * call <SID>ScreenQuit('" . owner . "', 1)" + augroup END + endif + + let g:ScreenShellSend = s:ScreenSendFuncRef() + let g:ScreenShellFocus = s:ScreenFocusFuncRef() + " remove :ScreenShell command to avoid accidentally calling it again. + delcommand ScreenShell + delcommand ScreenShellAttach + if exists(':ScreenShellVertical') + delcommand ScreenShellVertical + endif + + " Hook for creating keybindings (or similar) + let g:ScreenShellActive = 1 + let g:ScreenShellCmd = a:cmd + try + doautoall ScreenShellEnter User + catch /E216/ + endtry + endif + endif +endfunction " }}} + +" s:ScreenSend(string or list<string> or line1, line2) {{{ +" Send lines to the screen shell. +function! s:ScreenSend(...) + if a:0 == 1 + let argtype = type(a:1) + if argtype == 1 + let lines = split(a:1, "\n") + elseif argtype == 3 + let lines = a:1 + else + echoe 'ScreenShell: Argument must be a string or list.' + return + endif + elseif a:0 == 2 + if type(a:1) != 0 || type(a:2) != 0 + echoe 'ScreenShell: Arguments must be positive integer line numbers.' + return + endif + + let lines = getline(a:1, a:2) + let mode = visualmode(1) + if mode != '' && line("'<") == a:1 + if mode == "v" + let start = col("'<") - 1 + let end = col("'>") - 1 + " slice in end before start in case the selection is only one line + let lines[-1] = lines[-1][: end] + let lines[0] = lines[0][start :] + elseif mode == "\<c-v>" + let start = col("'<") + if col("'>") < start + let start = col("'>") + endif + let start = start - 1 + call map(lines, 'v:val[start :]') + endif + endif + else + echoe 'ScreenShell: Invalid number of arguments for ScreenSend.' + return + endif + + if g:ScreenShellExpandTabs + let expanded = '' + let index = 0 + while index < &shiftwidth + let expanded .= ' ' + let index += 1 + endwhile + call map(lines, 'substitute(v:val, "\\t", expanded, "g")') + endif + + let result = s:screen{g:ScreenImpl}.send(lines) + + if v:shell_error + echoerr result + endif +endfunction " }}} + +" s:ScreenFocus() {{{ +function! s:ScreenFocus() + let result = s:screen{g:ScreenImpl}.focus() + + if v:shell_error + echoerr result + endif +endfun " }}} + +" s:ScreenSendFuncRef() {{{ +function! s:ScreenSendFuncRef() + let sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_ScreenSendFuncRef$') + return function(printf('<SNR>%s_ScreenSend', sid)) +endfun " }}} + +" s:ScreenFocusFuncRef() {{{ +function! s:ScreenFocusFuncRef() + let sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_ScreenFocusFuncRef$') + return function(printf('<SNR>%s_ScreenFocus', sid)) +endfun " }}} + +" s:ScreenQuit(owner, onleave) {{{ +" Quit the current screen session (short cut to manually quiting vim and +" closing all screen windows. +function! s:ScreenQuit(owner, onleave) + if exists('g:ScreenShellBootstrapped') + if !a:onleave + wa + endif + + let bufend = bufnr('$') + let bufnum = 1 + while bufnum <= bufend + if bufnr(bufnum) != -1 + call setbufvar(bufnum, '&swapfile', 0) + endif + let bufnum = bufnum + 1 + endwhile + else + call screen#ScreenShellCommands() + delcommand ScreenQuit + delcommand ScreenSend + unlet g:ScreenShellSend + unlet g:ScreenShellFocus + augroup screen_shell + autocmd! + augroup END + + " Hook for creating keybindings (or similar) + let g:ScreenShellActive = 0 + let g:ScreenShellCmd = '' + try + doautoall ScreenShellExit User + catch /E216/ + endtry + endif + + let result = '' + if exists('g:ScreenShellBootstrapped') || + \ a:owner == 'session' || + \ a:owner == 'terminal' + let result = s:screen{g:ScreenImpl}.quit() + elseif a:owner == 'region' || a:owner == 'window' + let result = s:screen{g:ScreenImpl}.close(a:owner) + endif + + unlet g:ScreenShellTmuxPane + + if v:shell_error + if result !~ 'No screen session found' + echoerr result + endif + endif +endfunction " }}} + +" s:ScreenCmdName(cmd) {{{ +" Generate a name for the given command. +function! s:ScreenCmdName(cmd) + let cmd = substitute(a:cmd, '^\s*\(\S\+\)\s.*', '\1', '') + " if the command is a path to one, use the tail of the path + if cmd =~ '/' + let cmd = fnamemodify(cmd, ':t') + endif + return cmd +endfunction " }}} + +" s:StartTerminal(command) {{{ +function! s:StartTerminal(command) + let terminal = s:GetTerminal() + if !s:ValidTerminal(terminal) + echoerr 'Unable to find a terminal, please set g:ScreenShellTerminal' + return + endif + + " handle using cygwin bash + if has('win32') || has('win64') || has('win32unix') + let result = '' + let command = 'start "' . terminal . '"' + if has('win32unix') + let command = substitute(command, '\', '/', 'g') + let command = 'cmd /c ' . command + endif + let command .= ' --login -c "' . a:command . '"' + exec 'silent !' . command + redraw! + + elseif has('mac') && has('gui_running') + let result = '' + exec s:MacGuiCmd(a:command, terminal) + + " gnome-terminal needs quotes around the screen call, but konsole and + " rxvt based terms (urxvt, aterm, mrxvt, etc.) don't work properly with + " quotes. xterm seems content either way, so we'll treat gnome-terminal + " as the odd ball here. + elseif terminal == 'gnome-terminal' + let result = system(terminal . ' -e "' . a:command . '" &') + + else + let result = system(terminal . ' -e ' . a:command . ' &') + endif + return result +endfunction " }}} + +" s:GetScreenSessions() {{{ +" Gets a list of screen [session, state] pairs. +function! s:GetScreenSessions() + let results = split(system('screen -wipe'), "\n") + call filter(results, 'v:val =~ "(\\w\\+)"') + call map(results, '[' . + \ 'substitute(v:val, "^\\s*\\(\\S*\\).*", "\\1", ""), ' . + \ 'tolower(substitute(v:val, "(\\(\\w\\+\\))$", "\\1", ""))]') + return results +endfunction " }}} + +" s:GetSize() {{{ +function! s:GetSize() + if s:orientation == 'vertical' + let size = g:ScreenShellWidth + let sizefunc = 'winwidth' + else + let size = g:ScreenShellHeight + let sizefunc = 'winheight' + endif + + if size <= 0 + exec 'let size = ' . sizefunc . '(winnr()) / 2' + endif + return size +endfunction " }}} + +" s:GetTerminal() {{{ +" Generate a name for the given command. +function! s:GetTerminal() + if g:ScreenShellTerminal == '' + for term in s:terminals + if s:ValidTerminal(term) + let g:ScreenShellTerminal = term + break + endif + endfor + endif + return g:ScreenShellTerminal +endfunction " }}} + +" s:ValidTerminal(term) {{{ +function! s:ValidTerminal(term) + if a:term == '' + return 0 + endif + + " assumes that Terminal.app, or whatever the user may have set, is available + if has('mac') && has('gui_running') + return 1 + endif + + if has('win32unix') + if !executable(a:term) + let term = substitute(a:term, '\', '/', 'g') + let term = substitute(system('cygpath "' . term . '"'), '\n', '', 'g') + return executable(term) + endif + endif + + return executable(a:term) +endfunction " }}} + +" s:MacGuiCmd(cmd, term) {{{ +function! s:MacGuiCmd(cmd, term) + if a:term != '0' + return 'silent !osascript -e "tell application \"' . a:term . + \ '\"" -e "do script \"' . a:cmd . '\"" -e "end tell"' + endif + + let cmd = substitute(a:cmd, '"', "'", 'g') + return 'silent !osascript -e "do shell script \"' . cmd . '\""' +endfunction " }}} + +" CommandCompleteScreenSessions(argLead, cmdLine, cursorPos) {{{ +function! screen#CommandCompleteScreenSessions(argLead, cmdLine, cursorPos) + let cmdLine = strpart(a:cmdLine, 0, a:cursorPos) + let cmdTail = strpart(a:cmdLine, a:cursorPos) + let argLead = substitute(a:argLead, cmdTail . '$', '', '') + + if g:ScreenImpl == 'GnuScreen' + let sessions = s:GetScreenSessions() + if has('win32') || has('win64') || has('win32unix') + call filter(sessions, 'v:val[1] != "detached"') + endif + call map(sessions, 'v:val[0]') + if cmdLine !~ '[^\\]\s$' + call filter(sessions, 'v:val =~ "^' . argLead . '"') + endif + + return sessions + endif + + return [] +endfunction " }}} + +let s:screenGnuScreen = {} + +function s:screenGnuScreen.isValid() dict " {{{ + if !executable('screen') + echoerr 'gnu screen not found in your path' + return 0 + endif + return 1 +endfunction " }}} + +function s:screenGnuScreen.attachSession(session) dict " {{{ + let sessions = s:GetScreenSessions() + if a:session != '' + let session = [] + for s in sessions + if s[0] == a:session + let session = s + break + endif + endfor + + if len(session) == 0 + echoerr 'unable to find the gnu screen session "' . a:session . '"' + return + endif + elseif len(sessions) > 0 + if has('win32') || has('win64') || has('win32unix') + call filter(sessions, 'v:val[1] != "detached"') + endif + let session = sessions[0] + else + echoerr 'unable to find any gnu screen sessions' + return + endif + + if session[1] == 'detached' + if has('win32') || has('win64') || has('win32unix') + echoerr 'attaching to a session in the "Detached" state is not ' . + \ 'supported on windows due to deficiencies in the cygwin version ' . + \ 'of gnu screen.' + return + endif + let result = self.newTerminalResume() + if result == '0' + return + endif + if v:shell_error + echoerr result + endif + endif + + return session[0] +endfunction " }}} + +function s:screenGnuScreen.bootstrap(server, sessionfile, cmd) dict " {{{ + let vertical = s:orientation == 'vertical' ? 'Vertical' : '' + exec 'silent! !screen -S ' . g:ScreenShellSession . + \ ' vim ' . a:server . + \ '-c "silent source ' . escape(a:sessionfile, ' ') . '" ' . + \ '-c "ScreenShell' . vertical . ' ' . a:cmd . '"' +endfunction " }}} + +function s:screenGnuScreen.newSessionName() dict " {{{ + return substitute(tempname(), '\W', '', 'g') +endfunction " }}} + +function s:screenGnuScreen.newTerminal() dict " {{{ + return s:StartTerminal('screen -S ' . g:ScreenShellSession) +endfunction " }}} + +function s:screenGnuScreen.newTerminalMulti() dict " {{{ + return s:StartTerminal('screen -S ' . g:ScreenShellSession . ' -x') +endfunction " }}} + +function s:screenGnuScreen.newTerminalResume() dict " {{{ + return s:StartTerminal('screen -r ' . g:ScreenShellSession) +endfunction " }}} + +function s:screenGnuScreen.newWindow(focus) dict " {{{ + return self.exec(printf( + \ '-X eval "screen -t %s" %s', + \ g:ScreenShellWindow, + \ a:focus ? '""' : '"other"')) +endfunction " }}} + +function s:screenGnuScreen.openRegion(cmd) dict " {{{ + let splitcmd = 'split' + if s:orientation == 'vertical' + if g:ScreenShellGnuScreenVerticalSupport == 'patch' + let splitcmd = 'vert_split' + elseif g:ScreenShellGnuScreenVerticalSupport == 'native' + let splitcmd = 'split -v' + else + echohl WarningMsg + echom 'Unsupported g:ScreenShellGnuScreenVerticalSupport value "' . + \ g:ScreenShellGnuScreenVerticalSupport . '". ' . + \ 'Supported values included "patch" or "native".' + echohl Normal + let s:orientation = '' + endif + endif + + let focus = g:ScreenShellInitialFocus == 'shell' ? '' : ' "focus up"' + let chdir = exists('g:ScreenShellBootstrapped') ? '' : '"chdir \"' . getcwd() . '\"" ' + let result = self.exec('-X eval ' . + \ '"' . splitcmd . '" ' . + \ '"focus down" ' . + \ '"resize ' . s:GetSize() . '" ' . + \ chdir . + \ '"screen -t ' . g:ScreenShellWindow . '"' . + \ focus) + + " if we ran a chdir, reset it + if chdir != '' + call self.exec('-X eval "chdir"') + endif + + if !v:shell_error && a:cmd != '' + let result = self.send(a:cmd) + endif + + return result +endfunction " }}} + +function s:screenGnuScreen.setTitle() dict " {{{ + return self.exec('-X title ' . g:ScreenShellWindow) +endfunction " }}} + +function s:screenGnuScreen.send(value) dict " {{{ + let lines = type(a:value) == 3 ? a:value : [a:value] + let tmp = tempname() + call writefile(lines, tmp) + try + if exists('g:ScreenShellWindow') + let result = self.exec( + \ '-p ' . g:ScreenShellWindow . ' -X eval ' . + \ '"msgminwait 0" ' . + \ '"msgwait 0" ' . + \ '"readbuf ' . tmp . '" ' . + \ '"at ' . g:ScreenShellWindow . ' paste ." ' . + \ '"msgwait 5" ' . + \ '"msgminwait 1"') + else + let result = self.exec( + \ '-X eval ' . + \ '"msgminwait 0" ' . + \ '"msgwait 0" ' . + \ '"readbuf ' . tmp . '" ' . + \ '"paste ." ' . + \ '"msgwait 5" ' . + \ '"msgminwait 1"') + endif + finally + call delete(tmp) + endtry + return result +endfunction " }}} + +function s:screenGnuScreen.focus() dict " {{{ + return self.exec('-X focus bottom') +endfunction " }}} + +function s:screenGnuScreen.close(type) dict " {{{ + call self.focus() + if a:type == 'region' + call self.exec('-X kill') + return self.exec('-X remove') + endif + return self.exec('-X kill') +endfunction " }}} + +function s:screenGnuScreen.quit() dict " {{{ + return self.exec('-X quit') +endfunction " }}} + +function s:screenGnuScreen.exec(cmd) dict " {{{ + let cmd = 'screen ' + if exists('g:ScreenShellSession') + let cmd .= '-S ' . g:ScreenShellSession . ' ' + endif + let cmd .= a:cmd + + if has('win32unix') + let result = '' + exec 'silent! !' . cmd + redraw! + elseif has('mac') && has('gui_running') + let term = s:GetTerminal() + let result = '' + exec s:MacGuiCmd(cmd, '0') + else " system() works for windows gvim too + let result = system(cmd) + endif + return result +endfunction " }}} + +let s:screenTmux = {} + +function s:screenTmux.isValid() dict " {{{ + if !executable('tmux') + echoerr 'tmux not found in your path' + return 0 + endif + + if has('win32') || has('win64') + echoerr 'ScreenShell does not currently support tmux on windows.' + return 0 + endif + + return 1 +endfunction " }}} + +function s:screenTmux.activePane() dict "{{{ + " tmux 1.4: (active) label for current pane + " tmux 1.5: Unique %paneid for every pane + let line = self.exec('list-panes | grep "(active)$"') + let paneid = matchstr(line, '\v\%\d+ \(active\)') + if !empty(paneid) + return matchstr(paneid, '\v^\%\d+') + else + return matchstr(line, '\v^\d+') + endif +endfunction " }}} + +function s:screenTmux.attachSession(session) dict " {{{ + " TODO: currently unable to implement this since we use -S which creates a + " new server, which a tmux list-sessions wouldn't be able to talk to. As + " for sessions created on the default server, we can get the list of + " sessions, but tmux doesn't appear to have a way to send commands targeting + " a specific session, which is why we use -S to target servers. + echom 'Attaching to an existing session is currently not supported with tmux.' + return +endfunction " }}} + +function s:screenTmux.bootstrap(server, sessionfile, cmd) dict " {{{ + let vertical = s:orientation == 'vertical' ? 'Vertical' : '' + exec printf('silent! !tmux %s -S %s new-session ' . + \ '"vim %s -c \"silent source %s\" -c \"ScreenShell' . vertical . ' %s\""', + \ g:ScreenShellTmuxInitArgs, g:ScreenShellSession, + \ a:server, escape(a:sessionfile, ' '), a:cmd) +endfunction " }}} + +function s:screenTmux.newSessionName() dict " {{{ + return tempname() +endfunction " }}} + +function s:screenTmux.newTerminal() dict " {{{ + return s:StartTerminal(printf( + \ 'tmux %s -S %s', g:ScreenShellTmuxInitArgs, g:ScreenShellSession)) +endfunction " }}} + +function s:screenTmux.newTerminalResume() dict " {{{ + return s:StartTerminal(printf( + \ 'tmux %s -S %s attach-session', + \ g:ScreenShellTmuxInitArgs, g:ScreenShellSession)) +endfunction " }}} + +function s:screenTmux.newWindow(focus) dict " {{{ + let result = self.exec('new-window -n ' . g:ScreenShellWindow . (a:focus ? '' : ' -d')) + let g:ScreenShellTmuxPane = self.activePane() + return result +endfunction " }}} + +function s:screenTmux.openRegion(cmd) dict " {{{ + let orient = s:orientation == 'vertical' ? '-h ' : '' + let focus = g:ScreenShellInitialFocus == 'shell' ? '' : (' ; select-pane -t ' . self.activePane()) + + let result = self.exec('split ' . orient . '-l ' . s:GetSize()) + if v:shell_error | return result | endif + + let g:ScreenShellTmuxPane = self.activePane() + + let result = self.exec('rename-window ' . g:ScreenShellWindow . focus) + if v:shell_error | return result | endif + + if !v:shell_error && a:cmd != '' + let result = self.send(a:cmd) + if v:shell_error | return result | endif + endif +endfunction " }}} + +function s:screenTmux.setTitle() dict " {{{ + return self.exec('rename-window ' . g:ScreenShellWindow) +endfunction " }}} + +function s:screenTmux.send(value) dict " {{{ + let vimpane = self.activePane() + let lines = type(a:value) == 3 ? a:value : [a:value] + let tmp = tempname() + call writefile(lines, tmp) + try + let result = self.focus() + if v:shell_error + return result + endif + let result = self.exec(printf( + \ 'load-buffer %s ; ' . + \ 'paste-buffer', tmp + \ )) + if exists('g:ScreenShellWindow') && !g:ScreenShellExternal + call self.exec('select-pane -t ' . vimpane) + endif + finally + call delete(tmp) + endtry + return result +endfunction " }}} + +function s:screenTmux.focus() dict " {{{ + if !exists('g:ScreenShellWindow') + return + endif + + let result = self.exec('list-windows') + if v:shell_error + return result + endif + + let windows = filter( + \ split(result, "\n"), + \ 'v:val =~ "^\\s*\\d\\+:\\s\\+' . g:ScreenShellWindow . '"') + if len(windows) + let window = substitute(windows[0], '^\s*\(\d\+\):.*', '\1', '') + let result = self.exec('select-window -t:' . window) + if v:shell_error + return result + endif + endif + + if !g:ScreenShellExternal + let result = self.exec('select-pane -t ' . g:ScreenShellTmuxPane) + endif + return result +endfunction " }}} + +function s:screenTmux.quit() dict " {{{ + return self.exec('kill-session') +endfunction " }}} + +function s:screenTmux.close(type) dict " {{{ + let result = self.focus() + if v:shell_error + return result + endif + return self.exec('kill-pane') +endfunction " }}} + +function s:screenTmux.exec(cmd) dict " {{{ + let tmux = 'tmux ' + let cmd = a:cmd + + if exists('g:ScreenShellSession') + let tmux .= '-S ' . g:ScreenShellSession . ' ' + endif + + " hack to account for apparent bug in tmux when redirecting stdout to a file + " when attempting to list windows + if cmd =~ 'list-windows' + let cmd .= ' | cat' + endif + + return system(tmux . escape(cmd, ';')) +endfunction " }}} + +let s:screenConque = {} + +function s:screenConque.isValid() dict " {{{ + if !exists(':ConqueTerm') + echoerr 'The conque plugin does not appear to be loaded' + return 0 + endif + + return 1 +endfunction " }}} + +function s:screenConque.openRegion(cmd) dict " {{{ + " without this, the conque behavior isn't very useful + let g:ConqueTerm_ReadUnfocused = 1 + + let split = s:orientation == 'vertical' ? 'bot vsplit' : 'bot split' + let remain = g:ScreenShellInitialFocus == 'vim' ? 1 : 0 + let cmd = a:cmd != '' ? a:cmd : 'bash' + + call conque_term#open(cmd, [split], remain) + + " maybe a bug with conque, bug the cmd output doesn't seem to start until + " insert mode is entered. + startinsert +endfunction " }}} + +function s:screenConque.send(value) dict " {{{ + let lines = type(a:value) == 3 ? a:value : [a:value] + + let term = conque_term#get_instance() + for line in lines + call term.writeln(line) + endfor +endfunction " }}} + +function s:screenConque.quit() dict " {{{ + call conque_term#get_instance().close() +endfunction " }}} + +let &cpo = s:save_cpo + +" vim:ft=vim:fdm=marker diff --git a/.vim/doc/screen.txt b/.vim/doc/screen.txt new file mode 100644 index 0000000..12c78fe --- /dev/null +++ b/.vim/doc/screen.txt @@ -0,0 +1,390 @@ +*screen.txt* + +Author: Eric Van Dewoestine <ervandew@gmail.com> + +This plugin is licensed under the terms of the BSD License. Please see +screen.vim for the license in its entirety. + +----------------------------------------------------------------------------- +Screen *screen* + +Introduction |screen-intro| +Screen Usage |screen-usage| + :ScreenShell |screen-shell| + :ScreenShellAttach |screen-shellattach| + :ScreenSend |screen-send| + :ScreenQuit |screen-quit| +Screen Options |screen-options| + Terminal muliplexer |screen-impl| + Shell height |screen-shellheight| + Quit on exit |screen-quitonexit| + External shell |screen-externalshell| + Server name |screen-servername| + Terminal |screen-terminal| +Custom mappings |screen-mappings| +Script integration |screen-scriptintegration| +Gotchas |screen-gotchas| +Troubleshooting |screen-troubleshooting| + +----------------------------------------------------------------------------- +Introduction *screen-intro* + +This plugin aims to simulate an embedded shell in vim by allowing you to +easily convert your current vim session into one running in gnu screen with a +split gnu screen window containing a shell, and to quickly send +statements/code to whatever program is running in that shell (bash, python, +irb, etc.). Spawning the shell in your favorite terminal emulator is also +supported for gvim users or anyone else that just prefers an external shell. + +Currently tested on Linux and Windows (win32 gvim and cygwin vim), but +should also work on any unix based platform where screen is supported (OSX, +BSD, Solaris, etc.). Note that in my testing of cygwin, invocations of screen +were significantly slower and less fluid than on Linux. The Windows +experience is better when using gvim to spawn a cygwin shell running screen. + +Tmux Users: On non-windows systems, tmux is also supported in place of gnu +screen. To use tmux simply add the following to your vimrc: + let g:ScreenImpl = 'Tmux' + + Note: With tmux, :ScreenShellAttach is currently not supported. + +Windows Users: Whether you are using gvim or not, you will need cygwin +installed with cygwin's bin directory in your windows PATH. + +----------------------------------------------------------------------------- +Screen usage *screen-usage* + +Here is a sample workflow utilizing screen.vim to execute some python code in +the python interactive interpreter: + + 1. Edit a python file + $ vim something.py + + 2. Decide you want to run all or pieces of the code in an interactive python + shell + :ScreenShell python + + 3. Send code from a vim buffer to the shell + :ScreenSend + + 4. Quit the screen session and return to your original vim session + :ScreenQuit + or + :qa + +Below is a comprehensive list of the commands which screen.vim provides: + +:ScreenShell [cmd] *screen-shell* *:ScreenShell* + Starts a screen hosted shell performing the following steps depending on + your environment. + + When running a console vim on a unix based OS (Linux, BSD, OSX): + 1. save a session file from your currently running vim instance + (current tab only) + 2. start gnu screen with vim running in it + 3. load your saved session file + 4. create a lower gnu screen split window and start a shell, or if + g:ScreenShellExternal is set, start an external terminal with + screen running. + 5. if a command was supplied to :ScreenShell, run it in the new + shell. + Ex. :ScreenShell ipython + + Note: If you are already in a gnu screen session, then only steps + 4 and 5 above will be run. + + When running gvim: + 1. start an external terminal with screen running. + 2. if a command was supplied to :ScreenShell, run it in the new + shell. + Ex. :ScreenShell ipython + +:ScreenShellVertical [cmd] *screen-shell-vertical* *:ScreenShellVertical* + Just like |:ScreenShell| but when creating the split region for the shell, a + vertical split is used instead of the default horizontal split. Supported + via tmux by default, but gnu screen requires the vertical split patch + (http://fungi.yuggoth.org/vsp4s/) or the unreleased screen 4.1 code and you + must explicitly enable support for gnu screen vertical splitting in + screen.vim by adding the following to your vimrc, indicating whether you are + using a patched gnu screen or the 4.1 code base: + let g:ScreenShellGnuScreenVerticalSupport = 'patch' + or + let g:ScreenShellGnuScreenVerticalSupport = 'native' + + +:ScreenShellAttach [session] *screen-shellattach* *:ScreenShellAttach* + Sets the necessary internal variables to allow :ScreenSend invocations to + send to the specified screen session. If no session is provided, then the + first session found is used. If the session is in the "Detached" state, + then a new terminal is opened with a new screen instance attached to the + session. Attaching to a detached session is not currently supported on + windows due to deficiencies in the cygwin version of gnu screen. + + Note: for screen sessions attached to via this mechanism, :ScreenSend + invocations will send the text to the active screen window instead of + targeting the 'shell' window when used from :ScreenShell. However, this + behavior can be configured via the g:ScreenShellAttachTargetCurrent + variable, which when non 0, will set the title on the currently focused gnu + screen window and target it for all send commands. + +:ScreenSend + Send the visual selection or the entire buffer contents to the running gnu + screen shell window. + +:ScreenQuit + Save all currently modified vim buffers and quit gnu screen, returning you + to your previous vim instance running outside of gnu screen + + Note: :ScreenQuit is not available if you where already in a gnu + screen session when you ran :ScreenShell. + Note: By default, if the gnu screen session was started by + :ScreenShell, then exiting vim will quit the gnu screen session as + well (configurable via g:ScreenShellQuitOnVimExit). + + +----------------------------------------------------------------------------- +Screen Options *screen-options* + +Screen is configured via several global variables that you can set in your +|vimrc| file according to your needs. Below is a comprehensive list of the +variables available. + +Terminal Multiplexer *screen-impl* + *g:ScreenImpl* + +g:ScreenImpl (default value: 'GnuScreen') + +This sets the name of the terminal multiplexer you want to use. Support +values include 'GnuScreen' or 'Tmux'. + + +Shell height *screen-shellheight* + *g:ScreenShellHeight* + +g:ScreenShellHeight (default value: 15) + +Sets the height of the gnu screen (or tmux) region used for the shell. When +the value is less than or equal to 0, then half of vim's reported window +height will be used. + + +Shell width *screen-shellwidth* + *g:ScreenShellWidth* + +g:ScreenShellWidth (default value: -1) + +Sets the width of the gnu screen (or tmux) region used for the shell when +splitting the region vertically (vertical split support in gnu screen requires +the vertical split patch). When the value is less than or equal to 0, then +half of vim's reported window width will be used. + + +Quit on exit *screen-quitonexit* + *g:ScreenShellQuitOnVimExit* + +g:ScreenShellQuitOnVimExit (default value: 1) + +When non-zero and the gnu screen (or tmux) session was started by this script, +the screen session will be closed when vim exits. + + +External Shell *screen-externalshell* + *g:ScreenShellExternal* + +g:ScreenShellExternal (default value: 0) + +When non-zero and not already in a screen session, an external shell will be +spawned instead of using a split region for the shell. Note: when using gvim, +an external shell is always used. + + +Initial focus *screen-focus* + *g:ScreenShellInitialFocus* + +g:ScreenShellInitialFocus (default value: 'vim') + +When set to 'shell' the newly created shell region will be focused when first +creating the shell region. + + +Server Name *screen-servername* + *g:ScreenShellServerName* + +g:ScreenShellServerName (default value: 'vim') + +If the gnu screen session is started by this plugin, then the value of this +setting will be used for the servername arg of the vim instance started in the +new gnu screen session (not applicable for gvim users). The default is 'vim' +unless you have g:ScreenShellExternal enabled, in which case, if you still +want to restart vim in a screen session with a servername, then simply set +this variable in your vimrc. + + +Terminal *screen-terminal* + *g:ScreenShellTerminal* + +g:ScreenShellTerminal (default value: '') + +When g:ScreenShellExternal is enabled or you are running gvim, this value will +be used as the name of the terminal executable to be used. If this value is +empty, a list of common terminals will be tried until one is found. + + +Expand Tabs *screen-expandtabs* + *g:ScreenShellExpandTabs* + +g:ScreenShellExpandTabs (default value: 0) + +When sending text from vim to an external program, that program may interpret +tabs as an attempt to perform completion resulting in the text sent not +performing the function you intended. As a work around, you can set this +setting to a non 0 value resulting in all tabs being expanded to spaces before +sending the text to screen/tmux. + +----------------------------------------------------------------------------- +Custom Mappings *screen-mappings* + +Defining custom key mappings for for screen.vim can be accomplished like with +any other plugin: > + nmap <C-c><C-c> :ScreenShell<cr> +> + +But you may want to have different mappings depending on the whether you have +an active screen shell open or not. For this case screen.vim provides a couple +autocmd groups which you can use to listen for entering or exiting of a screen +shell session. Here is an example which sets some global key bindings based +on the screen shell state: > + + function! s:ScreenShellListener() + if g:ScreenShellActive + nmap <C-c><C-c> :ScreenSend<cr> + nmap <C-c><C-x> :ScreenQuit<cr> + else + nmap <C-c><C-c> :ScreenShell<cr> + endif + endfunction + + nmap <C-c><C-c> :ScreenShell<cr> + augroup ScreenShellEnter + autocmd User * call <SID>ScreenShellListener() + augroup END + augroup ScreenShellExit + autocmd User * call <SID>ScreenShellListener() + augroup END +> + +You can also take this a step further and do the same as the above, but do so +on a per filetype basis, where the key binding are buffer local and interact +with the filetype's associated interpreter. Here is an example which can be +put in a python ftplugin: > + + function! s:ScreenShellListener() + if g:ScreenShellActive + if g:ScreenShellCmd == 'python' + nmap <buffer> <C-c><C-c> :ScreenSend<cr> + else + nmap <buffer> <C-c><C-c> <Nop> + endif + else + nmap <buffer> <C-c><C-c> :ScreenShell python<cr> + endif + endfunction + + call s:ScreenShellListener() + augroup ScreenShellEnter + autocmd User *.py call <SID>ScreenShellListener() + augroup END + augroup ScreenShellExit + autocmd User *.py call <SID>ScreenShellListener() + augroup END +> + +Note how the :ScreenShell mapping starts the python interpreter. Before +mapping the :ScreenSend command, the function also checks if the shell was +started with the 'python' command, allowing you to unmap (<Nop> in this case +to counter act any global defined mapping) the send command if some other +shell command is running (irb, lisp interpreter, etc). + +----------------------------------------------------------------------------- +Script Integration *screen-scriptintegration* + +To permit integration with your own, or 3rd party, scripts, a funcref is made +globally available while the screen shell mode is enabled, allowing you to +send your own strings to the attached shell. + +Here are some examples of using this funcref to send some commands to bash: > + :call ScreenShellSend("echo foo\necho bar") + :call ScreenShellSend('echo -e "foo\nbar"') + :call ScreenShellSend("echo -e \"foo\\nbar\"") +> + +Sending a list of strings is also supported: > + :call ScreenShellSend(["echo foo", "echo bar"]) +> + +You can test that the funcref exists using: > + exists('ScreenShellSend') +> + +In addition to sending text to the screen shell, another funcref is available +allowing you to focus the shell region in screen. Note: focusing an external +screen shell is not supported. + +To focus the shell region from vim you can invoke the funcref like so: > + :call ScreenShellFocus() +> + +This will focus the bottom most region which is expected to be the one running +your shell or other program. + + +----------------------------------------------------------------------------- +Gotchas *screen-gotchas* + +While running vim in gnu screen, if you detach the session instead of +quitting, then when returning to the non-screen vim, vim will complain about +swap files already existing. So try to avoid detaching. + +Not all vim plugins support saving state to or loading from vim session files, +so when running :ScreenShell some buffers may not load correctly if they are +backed by such a plugin. + + +----------------------------------------------------------------------------- +Troubleshooting *screen-troubleshooting* + +Below are a list of possible issues you may encounter and some info on +resolving those issues. + +- When already in a screen session, running :ScreenShell results in a nested + screen session instead of using the existing one. + *screen-bootstrap* + + When running :ScreenShell from a console version of vim, screen.vim examines + the $TERM environment variable which it expects to start with 'screen' + ('screen', 'screen-256color', etc.) if you are in an existing screen/tmux + session. Should the TERM value not start with 'screen', then screen.vim + assumes that a screen session must be started for you. + + The cause of TERM not containing a 'screen' values is usually the result of + having a non-screen term value in your ~/.screenrc or the term value you are + using doesn't have a corresponding terminfo file resulting in $TERM being + set to some other value. Take a look at the |screen-256color| docs below for + more information. + +- 256 color support *screen-256color* + + To enable 256 color support in screen you'll need to add the following to + your ~/.screenrc: + + term screen-256color + + Please note that this will set your $TERM to 'screen-256color' which will + require that your system has a corresponding terminfo file. Not all systems + have this installed by default so you may need to install an additional + package: + + ubuntu - $ apt-get install ncurses-term + + +vim:tw=78:ts=8:ft=help:norl: diff --git a/.vim/plugin/screen.vim b/.vim/plugin/screen.vim new file mode 100644 index 0000000..1eb7bd7 --- /dev/null +++ b/.vim/plugin/screen.vim @@ -0,0 +1,161 @@ +" Author: Eric Van Dewoestine <ervandew@gmail.com> +" Version: 1.5 +" GetLatestVimScripts: 2711 1 :AutoInstall: screen.vim +" +" Description: {{{ +" This plugin aims to simulate an embedded shell in vim by allowing you to +" easily convert your current vim session into one running in gnu screen +" with a split gnu screen window containing a shell, and to quickly send +" statements/code to whatever program is running in that shell (bash, +" python, irb, etc.). Spawning the shell in your favorite terminal emulator +" is also supported for gvim users or anyone else that just prefers an +" external shell. +" +" }}} +" +" License: {{{ +" Copyright (c) 2009 - 2011 +" All rights reserved. +" +" Redistribution and use of this software in source and binary forms, with +" or without modification, are permitted provided that the following +" conditions are met: +" +" * Redistributions of source code must retain the above +" copyright notice, this list of conditions and the +" following disclaimer. +" +" * Redistributions in binary form must reproduce the above +" copyright notice, this list of conditions and the +" following disclaimer in the documentation and/or other +" materials provided with the distribution. +" +" * Neither the name of Eric Van Dewoestine nor the names of its +" contributors may be used to endorse or promote products derived from +" this software without specific prior written permission of +" Eric Van Dewoestine. +" +" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +" IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +" THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +" PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +" PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +" }}} + +let s:save_cpo=&cpo +set cpo&vim + +" Global Variables {{{ + + let g:ScreenVersion = '1.5' + let g:ScreenShellActive = 0 + let g:ScreenShellCmd = '' + + if !exists('g:ScreenImpl') + let g:ScreenImpl = 'GnuScreen' + "let g:ScreenImpl = 'Tmux' + endif + + if !exists('g:ScreenShellTmuxInitArgs') + let g:ScreenShellTmuxInitArgs = '' + endif + + " Sets the height of the gnu screen (or tmux) region used for the shell. + if !exists('g:ScreenShellHeight') + let g:ScreenShellHeight = 15 + endif + + " Sets the width of the screen window used for the shell. + if !exists('g:ScreenShellWidth') + let g:ScreenShellWidth = -1 + endif + + " Specifies whether or not to quit gnu screen when vim is closed and the + " screen session was started via :ScreenShell. + if !exists('g:ScreenShellQuitOnVimExit') + let g:ScreenShellQuitOnVimExit = 1 + endif + + " When not 0, open the spawned shell in an external window (not currently + " supported when running in cygwin). + if !exists('g:ScreenShellExternal') + let g:ScreenShellExternal = 0 + endif + + " Sets whether to focus 'vim' or the 'shell' when a shell region is opened. + if !exists('g:ScreenShellInitialFocus') + let g:ScreenShellInitialFocus = 'vim' + endif + + " When g:ScreenShellExternal is set, this variable specifies the preferred + " shell to use. If not set, some common terminals will be tried. + if !exists('g:ScreenShellTerminal') + let g:ScreenShellTerminal = '' + endif + + " Sets whether, and using which method, gnu screen supports vertical splits + if !exists('g:ScreenShellGnuScreenVerticalSupport') + let g:ScreenShellGnuScreenVerticalSupport = '' + endif + + " Sets whether the current screen region should be targeted when attaching + " to an existing screen session. + if !exists('g:ScreenShellAttachTargetCurrent') + let g:ScreenShellAttachTargetCurrent = 0 + endif + + " Sets whether tabs should be expand to prevent completion attempts by the + " target application when sending text to it. + if !exists('g:ScreenShellExpandTabs') + let g:ScreenShellExpandTabs = 0 + endif + +" }}} + +" Commands {{{ + + if !exists(':ScreenShell') + " unfortunately, to reap the benefits of an autoload scripts, we can't + " call this, but instead have to copy the commands inline. + "call screen#ScreenShellCommands() + + command -nargs=? -complete=shellcmd ScreenShell + \ :call screen#ScreenShell('<args>', 'horizontal') + command -nargs=? -complete=customlist,screen#CommandCompleteScreenSessions + \ ScreenShellAttach :call screen#ScreenShellAttach('<args>') + + if !has('gui_running') && + \ !g:ScreenShellExternal && + \ (g:ScreenImpl == 'Tmux' || g:ScreenShellGnuScreenVerticalSupport != '') + command -nargs=? -complete=shellcmd ScreenShellVertical + \ :call screen#ScreenShell('<args>', 'vertical') + endif + endif + +" }}} + +" Autocmds {{{ + + " while nice for vim screen window titles, this can kind of screw things up + " since when exiting vim there could now be more than one screen window with + " the title 'shell'. + "if expand('$TERM') =~ '^screen' + " augroup vim_screen + " autocmd! + " autocmd VimEnter,BufWinEnter,WinEnter * + " \ exec "silent! !echo -ne '\\ek" . expand('%:t') . "\\e\\\\'" + " autocmd VimLeave * exec "silent! !echo -ne '\\ekshell\\e\\\\'" + " augroup END + "endif + +" }}} + +let &cpo = s:save_cpo + +" vim:ft=vim:fdm=marker @@ -2,7 +2,8 @@ " circa 2006-2010 " enable plugins -:filetype plugin on +filetype plugin on +"filetype plugin indent on if has('syntax') && (&t_Co > 2) syntax on @@ -12,10 +13,9 @@ set history=50 set wildmode=list:longest,full set showmode set showcmd -set shiftwidth=2 -set tabstop=2 -autocmd FileType * set tabstop=2|set shiftwidth=2 -autocmd FileType python set tabstop=4|set shiftwidth=4 +set shiftwidth=4 +set tabstop=4 +autocmd FileType * set tabstop=4|set shiftwidth=4 set expandtab set shiftround set autoindent @@ -56,6 +56,11 @@ noremap <A-j> <C-w>j<CR> noremap <A-k> <C-w>k<CR> noremap <A-l> <C-w>l<CR> +"For screen.vim send block to SendScreen function (eg Scheme interpreter) +vmap <C-c><C-c> :ScreenSend<CR> +nmap <C-c><C-c> vip<C-c><C-c> +nmap <C-x><C-e> :ScreenSend<CR> + " Searching stuff set incsearch set ignorecase @@ -66,7 +71,7 @@ set smartcase noremap <Up> gk noremap <Down> gj -autocmd BufRead *.py set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class +"autocmd BufRead *.py set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class " for Project Fortress au BufNewFile,BufRead *.fsi,*.fss set ft=fortress |