def init(self, pyeval='PowerlinePyeval', **kwargs): super(VimPowerline, self).init('vim', **kwargs) self.last_window_id = 1 self.pyeval = pyeval self.construct_window_statusline = self.create_window_statusline_constructor() if all((hasattr(vim.current.window, attr) for attr in ('options', 'vars', 'number'))): self.win_idx = self.new_win_idx else: self.win_idx = self.old_win_idx self._vim_getwinvar = vim_get_func('getwinvar', 'bytes') self._vim_setwinvar = vim_get_func('setwinvar')
def watchdogs(pl, err_format='ERR: {first_line} ({num})'): '''Show whether watchdogs has found any errors :param str err_format: Format string for errors. Highlight groups used ``watchdogs:error`` or ``error``. ''' bufnr = int(vim_get_func('bufnr')('')) errors = filter(lambda qf: qf['bufnr'] == bufnr, vim_get_func('getqflist')()) return [] if len(errors) == 0 else [{ 'contents': err_format.format(first_line=errors[0]['lnum'], num=len(errors)), 'highlight_groups': ['watchdogs:error', 'error'] }]
def webdevicons(pl, segment_info): webdevicons = vim_get_func('WebDevIconsGetFileTypeSymbol') name = buffer_name(segment_info) return [] if not webdevicons else [{ 'contents': webdevicons(name), 'highlight_groups': ['webdevicons', 'file_name'], }]
def unite_segment(pl): '''Return the unite.vim statusline ''' if int(vim_funcs['exists']('*unite#get_status_string')) > 0: unite_stl_func = vim_get_func('unite#get_status_string', rettype=str) return str(unite_stl_func()) else: return None
def syntastic_segment(pl): '''Return the syntastic statusline flag ''' if int(vim_funcs['exists']('*SyntasticStatuslineFlag')) > 0: syntastic_flag_func = vim_get_func('SyntasticStatuslineFlag', rettype=str) return str(syntastic_flag_func()) else: return None
def parse_status_string(): status = vim_get_func('unite#get_status_string')() try: sources, status = re.compile(r' \| ').split(status) except ValueError: return {} return { 'sources': sources, 'status': status, }
def is_active(pl, word='Table'): '''Show status for vim-table-mode :param str word: A string displayed when table-mode is active. Highlight groups used ``table_mode`` or ``line_current``. ''' try: is_active = int(vim_get_func('tablemode#IsActive')()) == 1 except: is_active = False return [] if not is_active else [{ 'contents': word, 'highlight_groups': ['table_mode', 'paste_indicator'], }]
def vim_func_segment(pl, func_name, *args): if int(vim_funcs['exists']('*' + func_name)) > 0: f = vim_get_func(func_name, rettype=str) return str(f(*args)) else: return None
from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib import wraps_saveargs as wraps from powerline.segments.common.vcs import BranchSegment from powerline.segments import with_docstring from powerline.lib.unicode import string, unicode try: from __builtin__ import xrange as range except ImportError: pass vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype='int'), 'getpos': vim_get_func('getpos'), 'fnamemodify': vim_get_func('fnamemodify', rettype='bytes'), 'line2byte': vim_get_func('line2byte', rettype='int'), 'line': vim_get_func('line', rettype='int'), } vim_modes = { 'n': 'NORMAL', 'no': 'N-OPER', 'v': 'VISUAL', 'V': 'V-LINE', '^V': 'V-BLCK', 's': 'SELECT', 'S': 'S-LINE', '^S': 'S-BLCK',
from __future__ import absolute_import import os try: import vim except ImportError: vim = {} # NOQA from powerline.bindings.vim import vim_get_func, getbufvar from powerline.theme import requires_segment_info from powerline.lib import memoize, humanize_bytes, add_divider_highlight_group from powerline.lib.vcs import guess from collections import defaultdict vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype=int), 'fnamemodify': vim_get_func('fnamemodify'), 'expand': vim_get_func('expand'), 'bufnr': vim_get_func('bufnr', rettype=int), } vim_modes = { 'n': 'NORMAL', 'no': 'N·OPER', 'v': 'VISUAL', 'V': 'V·LINE', '^V': 'V·BLCK', 's': 'SELECT', 'S': 'S·LINE', '^S': 'S·BLCK', 'i': 'INSERT',
def webdevicons_file_format(pl, segment_info): webdevicons_file_format = vim_get_func('WebDevIconsGetFileFormatSymbol') return [] if not webdevicons_file_format else [{ 'contents': webdevicons_file_format(), 'highlight_groups': ['webdevicons_file_format', 'file_format'], }]
def plugin_eval(expr): global plugin_eval plugin_eval = vim_get_func('<SNR>'+sid+'_Eval') return plugin_eval(expr)
class VimPowerline(Powerline): def __init__(self, pyeval='PowerlinePyeval'): super(VimPowerline, self).__init__('vim') self.last_window_id = 1 self.window_statusline = '%!' + pyeval + '(\'powerline.statusline({0})\')' def add_local_theme(self, key, config): '''Add local themes at runtime (during vim session). :param str key: Matcher name (in format ``{matcher_module}.{module_attribute}`` or ``{module_attribute}`` if ``{matcher_module}`` is ``powerline.matchers.vim``). Function pointed by ``{module_attribute}`` should be hashable and accept a dictionary with information about current buffer and return boolean value indicating whether current window matched conditions. See also :ref:`local_themes key description <config-ext-local_themes>`. :param dict config: :ref:`Theme <config-themes>` dictionary. :return: ``True`` if theme was added successfully and ``False`` if theme with the same matcher already exists. ''' self.update_renderer() key = self.get_matcher(key) try: self.renderer.add_local_theme(key, {'config': config}) except KeyError: return False else: return True def load_main_config(self): return _override_from( super(VimPowerline, self).load_main_config(), 'powerline_config_overrides') def load_theme_config(self, name): # Note: themes with non-[a-zA-Z0-9_] names are impossible to override # (though as far as I know exists() won’t throw). Won’t fix, use proper # theme names. return _override_from( super(VimPowerline, self).load_theme_config(name), 'powerline_theme_overrides__' + name) def get_local_themes(self, local_themes): if not local_themes: return {} self.get_matcher = gen_matcher_getter(self.ext, self.import_paths) return dict(((self.get_matcher(key), { 'config': self.load_theme_config(val) }) for key, val in local_themes.items())) def get_config_paths(self): try: return [vim_getvar('powerline_config_path')] except KeyError: return super(VimPowerline, self).get_config_paths() @staticmethod def get_segment_info(): return {} def reset_highlight(self): try: self.renderer.reset_highlight() except AttributeError: # Renderer object appears only after first `.render()` call. Thus if # ColorScheme event happens before statusline is drawn for the first # time AttributeError will be thrown for the self.renderer. It is # fine to ignore it: no renderer == no colors to reset == no need to # do anything. pass if all((hasattr(vim.current.window, attr) for attr in ('options', 'vars', 'number'))): def win_idx(self, window_id): r = None for window in vim.windows: try: curwindow_id = window.vars['powerline_window_id'] except KeyError: curwindow_id = self.last_window_id self.last_window_id += 1 window.vars['powerline_window_id'] = curwindow_id statusline = self.window_statusline.format(curwindow_id) if window.options['statusline'] != statusline: window.options['statusline'] = statusline if curwindow_id == window_id if window_id else window is vim.current.window: assert r is None, "Non-unique window ID" r = (window, curwindow_id, window.number) return r else: _vim_getwinvar = staticmethod(vim_get_func('getwinvar')) _vim_setwinvar = staticmethod(vim_get_func('setwinvar')) def win_idx(self, window_id): # NOQA r = None for winnr, window in zip(count(1), vim.windows): curwindow_id = self._vim_getwinvar(winnr, 'powerline_window_id') if curwindow_id: curwindow_id = int(curwindow_id) else: curwindow_id = self.last_window_id self.last_window_id += 1 self._vim_setwinvar(winnr, 'powerline_window_id', curwindow_id) statusline = self.window_statusline.format(curwindow_id) if self._vim_getwinvar(winnr, '&statusline') != statusline: self._vim_setwinvar(winnr, '&statusline', statusline) if curwindow_id == window_id if window_id else window is vim.current.window: assert r is None, "Non-unique window ID" r = (window, curwindow_id, winnr) return r def statusline(self, window_id): window, window_id, winnr = self.win_idx(window_id) or (None, None, None) if not window: return 'No window {0}'.format(window_id) return self.render(window, window_id, winnr) def new_window(self): window, window_id, winnr = self.win_idx(None) return self.render(window, window_id, winnr) if not hasattr(vim, 'bindeval'): # Method for PowerlinePyeval function. Is here to reduce the number of # requirements to __main__ globals to just one powerline object # (previously it required as well vim and json) @staticmethod def pyeval(): import __main__ vim.command('return ' + json.dumps(eval(vim.eval('a:e'), __main__.__dict__)))
from __future__ import absolute_import import os import re from powerline.bindings.vim import vim_get_func, getbufvar from powerline.segments.vim import vim_funcs vim_funcs['winnr'] = vim_get_func('winnr', rettype=int) vim_funcs['bufwinnr'] = vim_get_func('bufwinnr', rettype=int) vim_funcs['getwinvar'] = vim_get_func('getwinvar') def getbufwinvar(bufnr, var): return vim_funcs['getwinvar'](vim_funcs['bufwinnr'](bufnr), var) # ---------------------------------%<---------------------------------- def tagbar(matcher_info): name = matcher_info['buffer'].name return name and os.path.basename(name) == '__Tagbar__' def unite(matcher_info): return str(getbufvar(matcher_info['bufnr'], '&filetype')) == 'unite' def vimfiler(matcher_info): return str(getbufvar(matcher_info['bufnr'], '&filetype')) == 'vimfiler'
# from powerline.bindings.vim import (vim_get_func, getbufvar, vim_getbufoption, # buffer_name, vim_getwinvar) # from powerline.theme import requires_segment_info, requires_filesystem_watcher # from powerline.lib import add_divider_highlight_group # from powerline.lib.vcs import guess, tree_status # from powerline.lib.humanize_bytes import humanize_bytes # from powerline.lib import wraps_saveargs as wraps # from collections import defaultdict vim_funcs = { # 'fnamemodify': vim_get_func('fnamemodify'), # 'expand': vim_get_func('expand'), # 'bufnr': vim_get_func('bufnr', rettype=int), # 'line2byte': vim_get_func('line2byte', rettype=int), 'virtcol': vim_get_func('virtcol', rettype=int), 'getline': vim_get_func('getline'), } def character_info(pl): line_contents = vim_funcs['getline']('.') cursor_column = int(vim_funcs['virtcol']('.')) if line_contents and cursor_column <= len(line_contents): character = line_contents.decode('utf-8')[cursor_column - 1] codepoint = ord(character) if codepoint <= 255: highlight_group = "current_character" else: highlight_group = "current_character_utf"
def unite_status_string(pl): '''Return status string from unite.vim''' return vim_get_func('unite#get_status_string')()
try: import vim except ImportError: vim = {} # NOQA from powerline.bindings.vim import vim_get_func, getbufvar, vim_getbufoption, buffer_name, vim_getwinvar from powerline.theme import requires_segment_info, requires_filesystem_watcher from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess, tree_status from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib import wraps_saveargs as wraps from collections import defaultdict vim_funcs = { "virtcol": vim_get_func("virtcol", rettype=int), "getpos": vim_get_func("getpos"), "fnamemodify": vim_get_func("fnamemodify"), "expand": vim_get_func("expand"), "bufnr": vim_get_func("bufnr", rettype=int), "line2byte": vim_get_func("line2byte", rettype=int), "line": vim_get_func("line", rettype=int), } vim_modes = { "n": "NORMAL", "no": "N·OPER", "v": "VISUAL", "V": "V·LINE", "^V": "V·BLCK", "s": "SELECT",
from powerline.theme import requires_segment_info from powerline.bindings.vim import vim_get_func, getbufvar from powerline.lib import add_divider_highlight_group vim_funcs = {"tabpagebuflist": vim_get_func("tabpagebuflist", rettype=list)} @requires_segment_info def current_char(segment_info, **extra): try: pos = segment_info["window"].cursor char = segment_info["buffer"][pos[0] - 1][pos[1]] return "0x%02X" % ord(char) except Exception: return "0x00" @requires_segment_info @add_divider_highlight_group("background:divider") def file_encoding(segment_info, expected=["utf-8"], unknown_text="unknown", **extra): """Return file encoding/character set. :return: file encoding/character set or None if unknown or missing file encoding Divider highlight group used: ``background:divider``. """ enc = getbufvar(segment_info["bufnr"], "&fileencoding") if enc in expected: return None else:
# vim:fileencoding=utf-8:noet from __future__ import absolute_import from powerline.bindings.vim import vim_get_func from powerline import Powerline from powerline.lib import mergedicts from powerline.matcher import gen_matcher_getter import vim vim_exists = vim_get_func('exists', rettype=int) def _override_from(config, override_varname): if vim_exists(override_varname): # FIXME vim.eval has problem with numeric types, vim.bindeval may be # absent (and requires converting values to python built-in types), # vim.eval with typed call like the one I implemented in frawor is slow. # Maybe eval(vime.eval('string({0})'.format(override_varname)))? overrides = vim.eval(override_varname) mergedicts(config, overrides) return config class VimPowerline(Powerline): def __init__(self): super(VimPowerline, self).__init__('vim') def add_local_theme(self, key, config): '''Add local themes at runtime (during vim session).
# -*- coding: utf-8 -*- from __future__ import absolute_import from powerline.bindings.vim import vim_get_func from powerline.renderer import Renderer from powerline.colorscheme import ATTR_BOLD, ATTR_ITALIC, ATTR_UNDERLINE import vim vim_mode = vim_get_func('mode') vim_getwinvar = vim_get_func('getwinvar') vim_setwinvar = vim_get_func('setwinvar') mode_translations = { chr(ord('V') - 0x40): '^V', chr(ord('S') - 0x40): '^S', } class VimRenderer(Renderer): '''Powerline vim segment renderer.''' def __init__(self, *args, **kwargs): super(VimRenderer, self).__init__(*args, **kwargs) self.hl_groups = {} def render(self, window_id, winidx, current): '''Render all segments. This method handles replacing of the percent placeholder for vim statuslines, and it caches segment contents which are retrieved and
#! /usr/bin/env python -3 # -*- coding: utf-8 -*- import vim from subprocess import Popen, PIPE from powerline.bindings.vim import vim_get_func, getbufvar from powerline.segments.vim import window_cached, vim_funcs # from powerline.theme import requires_segment_info from powerline.lib.threaded import ThreadedSegment, with_docstring vim_funcs['exists'] = vim_get_func('exists', rettype=int) sort_indicator = { "on": "sort", "off": "name" } # --------%<-------- # helper functions # --------%>-------- def vim_func_segment(pl, func_name, *args): if int(vim_funcs['exists']('*' + func_name)) > 0: f = vim_get_func(func_name, rettype=str) return str(f(*args)) else: return None
class VimPowerline(Powerline): def init(self, pyeval='PowerlinePyeval', **kwargs): super(VimPowerline, self).init('vim', **kwargs) self.last_window_id = 1 self.pyeval = pyeval self.window_statusline = '%!' + pyeval + '(\'powerline.statusline({0})\')' default_log_stream = sys.stdout def add_local_theme(self, key, config): '''Add local themes at runtime (during vim session). :param str key: Matcher name (in format ``{matcher_module}.{module_attribute}`` or ``{module_attribute}`` if ``{matcher_module}`` is ``powerline.matchers.vim``). Function pointed by ``{module_attribute}`` should be hashable and accept a dictionary with information about current buffer and return boolean value indicating whether current window matched conditions. See also :ref:`local_themes key description <config-ext-local_themes>`. :param dict config: :ref:`Theme <config-themes>` dictionary. :return: ``True`` if theme was added successfully and ``False`` if theme with the same matcher already exists. ''' self.update_renderer() matcher = self.get_matcher(key) theme_config = {} for cfg_path in self.theme_levels: try: lvl_config = self.load_config(cfg_path, 'theme') except IOError: pass else: mergedicts(theme_config, lvl_config) mergedicts(theme_config, config) try: self.renderer.add_local_theme(matcher, {'config': theme_config}) except KeyError: return False else: # Hack for local themes support: when reloading modules it is not # guaranteed that .add_local_theme will be called once again, so # this function arguments will be saved here for calling from # .do_setup(). self.setup_kwargs.setdefault('_local_themes', []).append( (key, config)) return True @staticmethod def get_encoding(): return vim.eval('&encoding') def load_main_config(self): return _override_from( super(VimPowerline, self).load_main_config(), 'powerline_config_overrides') def load_theme_config(self, name): # Note: themes with non-[a-zA-Z0-9_] names are impossible to override # (though as far as I know exists() won’t throw). Won’t fix, use proper # theme names. return _override_from( super(VimPowerline, self).load_theme_config(name), 'powerline_theme_overrides__' + name) def get_local_themes(self, local_themes): if not local_themes: return {} return dict(((matcher, { 'config': self.load_theme_config(val) }) for matcher, key, val in ((( None if k == '__tabline__' else self.get_matcher(k)), k, v) for k, v in local_themes.items()) if (matcher or key == '__tabline__'))) def get_matcher(self, match_name): match_module, separator, match_function = match_name.rpartition('.') if not separator: match_module = 'powerline.matchers.{0}'.format(self.ext) match_function = match_name return self.get_module_attr(match_module, match_function, prefix='matcher_generator') def get_config_paths(self): try: return vim_getvar('powerline_config_paths') except KeyError: return super(VimPowerline, self).get_config_paths() def do_setup(self, pyeval=None, pycmd=None, can_replace_pyeval=True, _local_themes=()): import __main__ if not pyeval: pyeval = 'pyeval' if sys.version_info < (3, ) else 'py3eval' can_replace_pyeval = True if not pycmd: pycmd = get_default_pycmd() set_pycmd(pycmd) # pyeval() and vim.bindeval were both introduced in one patch if not hasattr(vim, 'bindeval') and can_replace_pyeval: vim.command((''' function! PowerlinePyeval(e) {pycmd} powerline.do_pyeval() endfunction ''').format(pycmd=pycmd)) pyeval = 'PowerlinePyeval' self.pyeval = pyeval self.window_statusline = '%!' + pyeval + '(\'powerline.statusline({0})\')' self.update_renderer() __main__.powerline = self if (bool(int(vim.eval("has('gui_running') && argc() == 0"))) and not vim.current.buffer.name and len(vim.windows) == 1): # Hack to show startup screen. Problems in GUI: # - Defining local value of &statusline option while computing global # value purges startup screen. # - Defining highlight group while computing statusline purges startup # screen. # This hack removes the “while computing statusline” part: both things # are defined, but they are defined right now. # # The above condition disables this hack if no GUI is running, Vim did # not open any files and there is only one window. Without GUI # everything works, in other cases startup screen is not shown. self.new_window() # Cannot have this in one line due to weird newline handling (in :execute # context newline is considered part of the command in just the same cases # when bar is considered part of the command (unless defining function # inside :execute)). vim.command is :execute equivalent regarding this case. vim.command('augroup Powerline') vim.command( ' autocmd! ColorScheme * :{pycmd} powerline.reset_highlight()'. format(pycmd=pycmd)) vim.command( ' autocmd! VimLeavePre * :{pycmd} powerline.shutdown()'.format( pycmd=pycmd)) vim.command('augroup END') # Hack for local themes support after reloading. for args in _local_themes: self.add_local_theme(*args) @staticmethod def get_segment_info(): return {} def reset_highlight(self): try: self.renderer.reset_highlight() except AttributeError: # Renderer object appears only after first `.render()` call. Thus if # ColorScheme event happens before statusline is drawn for the first # time AttributeError will be thrown for the self.renderer. It is # fine to ignore it: no renderer == no colors to reset == no need to # do anything. pass if all((hasattr(vim.current.window, attr) for attr in ('options', 'vars', 'number'))): def win_idx(self, window_id): r = None for window in vim.windows: try: curwindow_id = window.vars['powerline_window_id'] if r is not None and curwindow_id == window_id: raise KeyError except KeyError: curwindow_id = self.last_window_id self.last_window_id += 1 window.vars['powerline_window_id'] = curwindow_id statusline = self.window_statusline.format(curwindow_id) if window.options['statusline'] != statusline: window.options['statusline'] = statusline if curwindow_id == window_id if window_id else window is vim.current.window: r = (window, curwindow_id, window.number) return r else: _vim_getwinvar = staticmethod(vim_get_func('getwinvar')) _vim_setwinvar = staticmethod(vim_get_func('setwinvar')) def win_idx(self, window_id): r = None for winnr, window in zip(count(1), vim.windows): curwindow_id = self._vim_getwinvar(winnr, 'powerline_window_id') if curwindow_id and not (r is not None and curwindow_id == window_id): curwindow_id = int(curwindow_id) else: curwindow_id = self.last_window_id self.last_window_id += 1 self._vim_setwinvar(winnr, 'powerline_window_id', curwindow_id) statusline = self.window_statusline.format(curwindow_id) if self._vim_getwinvar(winnr, '&statusline') != statusline: self._vim_setwinvar(winnr, '&statusline', statusline) if curwindow_id == window_id if window_id else window is vim.current.window: r = (window, curwindow_id, winnr) return r def statusline(self, window_id): window, window_id, winnr = self.win_idx(window_id) or (None, None, None) if not window: return FailedUnicode('No window {0}'.format(window_id)) return self.render(window, window_id, winnr) def tabline(self): return self.render(*self.win_idx(None), is_tabline=True) def new_window(self): return self.render(*self.win_idx(None)) if not hasattr(vim, 'bindeval'): # Method for PowerlinePyeval function. Is here to reduce the number of # requirements to __main__ globals to just one powerline object # (previously it required as well vim and json) @staticmethod def do_pyeval(): import __main__ vim.command('return ' + json.dumps(eval(vim.eval('a:e'), __main__.__dict__))) def setup_components(self, components): if components is None: components = ('statusline', 'tabline') if 'statusline' in components: # Is immediately changed after new_window function is run. Good for # global value. vim.command( 'set statusline=%!{pyeval}(\'powerline.new_window()\')'.format( pyeval=self.pyeval)) if 'tabline' in components: vim.command( 'set tabline=%!{pyeval}(\'powerline.tabline()\')'.format( pyeval=self.pyeval))
# -*- coding: utf-8 -*- from __future__ import absolute_import from powerline.bindings.vim import vim_get_func from powerline import Powerline from powerline.lib import mergedicts from powerline.matcher import gen_matcher_getter import vim vim_exists = vim_get_func('exists', rettype=int) def _override_from(config, override_varname): if vim_exists(override_varname): # FIXME vim.eval has problem with numeric types, vim.bindeval may be # absent (and requires converting values to python built-in types), # vim.eval with typed call like the one I implemented in frawor is slow. # Maybe eval(vime.eval('string({0})'.format(override_varname)))? overrides = vim.eval(override_varname) mergedicts(config, overrides) return config class VimPowerline(Powerline): def __init__(self): super(VimPowerline, self).__init__('vim') def add_local_theme(self, key, config): '''Add local themes at runtime (during vim session).
# -*- coding: utf-8 -*- # vim:se fenc=utf8 noet: import os import re try: import vim except ImportError: vim = {} from powerline.bindings.vim import vim_get_func, getbufvar from powerline.theme import requires_segment_info vim_funcs = { 'col': vim_get_func('col', rettype=int), 'virtcol': vim_get_func('virtcol', rettype=int), 'getcwd': vim_get_func('getcwd'), 'fnamemodify': vim_get_func('fnamemodify'), } def _do_ex(command): '''Execute Ex command. Execute Ex command from args and return results string. ''' vim.command('redir => tmp_do_ex | silent! {0} | redir END'.format(command)) return vim.eval('tmp_do_ex') def col_current_virt(pl, gradient=True): '''Return the current cursor column.
try: import vim except ImportError: vim = {} # NOQA from powerline.bindings.vim import (vim_get_func, getbufvar, vim_getbufoption, buffer_name, vim_getwinvar) from powerline.theme import requires_segment_info from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess, tree_status from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib import wraps_saveargs as wraps from collections import defaultdict vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype=int), 'getpos': vim_get_func('getpos'), 'fnamemodify': vim_get_func('fnamemodify'), 'expand': vim_get_func('expand'), 'bufnr': vim_get_func('bufnr', rettype=int), 'line2byte': vim_get_func('line2byte', rettype=int), 'line': vim_get_func('line', rettype=int), } vim_modes = { 'n': 'NORMAL', 'no': 'N·OPER', 'v': 'VISUAL', 'V': 'V·LINE', '^V': 'V·BLCK', 's': 'SELECT',
except ImportError: vim = {} # NOQA from subprocess import Popen, PIPE from powerline.bindings.vim import vim_get_func, getbufvar from powerline.theme import requires_segment_info from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess, tree_status from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib.threaded import ThreadedSegment, KwThreadedSegment, with_docstring from powerline.lib import wraps_saveargs as wraps from collections import defaultdict vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype=int), 'fnamemodify': vim_get_func('fnamemodify', rettype=str), 'expand': vim_get_func('expand', rettype=str), 'bufnr': vim_get_func('bufnr', rettype=int), 'line2byte': vim_get_func('line2byte', rettype=int), 'exists': vim_get_func('exists', rettype=int), } vim_modes = { 'n': 'NORMAL', 'no': 'N·OPER', 'v': 'VISUAL', 'V': 'V·LINE', '^V': 'V·BLCK', 's': 'SELECT', 'S': 'S·LINE',
from powerline.theme import requires_segment_info from powerline.bindings.vim import vim_get_func, getbufvar from powerline.lib import add_divider_highlight_group vim_funcs = { 'tabpagebuflist': vim_get_func('tabpagebuflist', rettype=list), } @requires_segment_info def current_char(segment_info, **extra): try: pos = segment_info['window'].cursor char = segment_info['buffer'][pos[0] - 1][pos[1]] return "0x%02X" % ord(char) except Exception: return "0x00" @requires_segment_info @add_divider_highlight_group('background:divider') def file_encoding(segment_info, expected=['utf-8'], unknown_text='unknown', **extra): '''Return file encoding/character set. :return: file encoding/character set or None if unknown or missing file encoding Divider highlight group used: ``background:divider``. '''
# vim:fileencoding=utf-8:noet from __future__ import (unicode_literals, division, absolute_import, print_function) import sys import vim from powerline.bindings.vim import vim_get_func, vim_getoption, environ, current_tabpage from powerline.renderer import Renderer from powerline.colorscheme import ATTR_BOLD, ATTR_ITALIC, ATTR_UNDERLINE from powerline.theme import Theme from powerline.lib.unicode import unichr, register_strwidth_error vim_mode = vim_get_func('mode', rettype='unicode') if int(vim.eval('v:version')) >= 702: _vim_mode = vim_mode vim_mode = lambda: _vim_mode(1) mode_translations = { unichr(ord('V') - 0x40): '^V', unichr(ord('S') - 0x40): '^S', } class VimRenderer(Renderer): '''Powerline vim segment renderer.''' character_translations = Renderer.character_translations.copy() character_translations[ord('%')] = '%%'
from __future__ import (unicode_literals, division, absolute_import, print_function) import os import re import time try: import vim except ImportError: vim = {} from powerline.bindings.vim import vim_get_func, getbufvar, buffer_name from powerline.theme import requires_segment_info vim_funcs = { 'col': vim_get_func('col', rettype='int'), 'virtcol': vim_get_func('virtcol', rettype='int'), 'getcwd': vim_get_func('getcwd'), 'fnamemodify': vim_get_func('fnamemodify'), } def _do_ex(command): '''Execute Ex command. Execute Ex command from args and return results string. ''' vim.command('redir => tmp_do_ex | silent! {0} | redir END'.format(command)) return vim.eval('tmp_do_ex').decode('utf-8')
from powerline.bindings.vim import vim_get_func, environ from powerline.renderer import Renderer from powerline.colorscheme import ATTR_BOLD, ATTR_ITALIC, ATTR_UNDERLINE from powerline.theme import Theme import vim import sys try: from __builtin__ import unichr as chr except ImportError: pass vim_mode = vim_get_func('mode', rettype=str) mode_translations = { chr(ord('V') - 0x40): '^V', chr(ord('S') - 0x40): '^S', } class VimRenderer(Renderer): '''Powerline vim segment renderer.''' character_translations = Renderer.character_translations.copy() character_translations[ord('%')] = '%%' segment_info = Renderer.segment_info.copy() segment_info.update(environ=environ)
# vim:fileencoding=utf-8:noet from __future__ import (unicode_literals, division, absolute_import, print_function) import sys import vim from powerline.bindings.vim import vim_get_func, vim_getoption, environ, current_tabpage, get_vim_encoding from powerline.renderer import Renderer from powerline.colorscheme import ATTR_BOLD, ATTR_ITALIC, ATTR_UNDERLINE from powerline.theme import Theme from powerline.lib.unicode import unichr, register_strwidth_error vim_mode = vim_get_func('mode', rettype='unicode') if int(vim.eval('v:version')) >= 702: _vim_mode = vim_mode vim_mode = lambda: _vim_mode(1) mode_translations = { unichr(ord('V') - 0x40): '^V', unichr(ord('S') - 0x40): '^S', } class VimRenderer(Renderer): '''Powerline vim segment renderer.''' character_translations = Renderer.character_translations.copy() character_translations[ord('%')] = '%%'
import os try: import vim except ImportError: vim = {} # NOQA from powerline.bindings.vim import vim_get_func, getbufvar, vim_getbufoption from powerline.theme import requires_segment_info from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess, tree_status from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib import wraps_saveargs as wraps from collections import defaultdict vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype=int), 'fnamemodify': vim_get_func('fnamemodify', rettype=str), 'expand': vim_get_func('expand', rettype=str), 'bufnr': vim_get_func('bufnr', rettype=int), 'line2byte': vim_get_func('line2byte', rettype=int), } vim_modes = { 'n': 'NORMAL', 'no': 'N·OPER', 'v': 'VISUAL', 'V': 'V·LINE', '^V': 'V·BLCK', 's': 'SELECT', 'S': 'S·LINE', '^S': 'S·BLCK',
# vim:fileencoding=utf-8:noet from __future__ import absolute_import from powerline.bindings.vim import vim_get_func from powerline.renderer import Renderer from powerline.colorscheme import ATTR_BOLD, ATTR_ITALIC, ATTR_UNDERLINE from powerline.theme import Theme import vim import sys vim_mode = vim_get_func('mode', rettype=str) mode_translations = { chr(ord('V') - 0x40): '^V', chr(ord('S') - 0x40): '^S', } class VimRenderer(Renderer): '''Powerline vim segment renderer.''' def __init__(self, *args, **kwargs): if not hasattr(vim, 'strwidth'): # Hope nobody want to change this at runtime if vim.eval('&ambiwidth') == 'double': kwargs = dict(**kwargs) kwargs['ambigious'] = 2 super(VimRenderer, self).__init__(*args, **kwargs) self.hl_groups = {} def shutdown(self):
from __future__ import (unicode_literals, division, absolute_import, print_function) from powerline.bindings.vim import (buffer_name, vim_get_func) from powerline.lib.vcs import guess from powerline.theme import (requires_filesystem_watcher, requires_segment_info) import re import os try: import vim except ImportError: vim = object() vim_funcs = { 'fnamemodify': vim_get_func('fnamemodify', rettype='bytes'), 'getcwd': vim_get_func('getcwd') } SCHEME_RE = re.compile(b'^\\w[\\w\\d+\\-.]*(?=:)') @requires_filesystem_watcher @requires_segment_info def repo_directory(pl, segment_info, create_watcher): name = buffer_name(segment_info) file_directory = vim_funcs['fnamemodify'](name, ':h') if not name: return None match = SCHEME_RE.match(name) if match: repo_directory = file_directory
from powerline.theme import requires_segment_info, requires_filesystem_watcher from powerline.lib import add_divider_highlight_group from powerline.lib.vcs import guess from powerline.lib.humanize_bytes import humanize_bytes from powerline.lib import wraps_saveargs as wraps from powerline.segments.common.vcs import BranchSegment, StashSegment from powerline.segments import with_docstring from powerline.lib.unicode import string, unicode try: from __builtin__ import xrange as range except ImportError: pass vim_funcs = { 'virtcol': vim_get_func('virtcol', rettype='int'), 'getpos': vim_get_func('getpos'), 'fnamemodify': vim_get_func('fnamemodify', rettype='bytes'), 'line2byte': vim_get_func('line2byte', rettype='int'), 'line': vim_get_func('line', rettype='int'), } vim_modes = { 'n': 'NORMAL', 'no': 'N-OPER', 'v': 'VISUAL', 'V': 'V-LINE', '^V': 'V-BLCK', 's': 'SELECT', 'S': 'S-LINE', '^S': 'S-BLCK',
# -*- coding: utf-8 -*- # vim:se fenc=utf8 noet: import os import re try: import vim except ImportError: vim = {} from powerline.bindings.vim import vim_get_func, getbufvar from powerline.theme import requires_segment_info vim_funcs = { 'col': vim_get_func('col', rettype=int), 'virtcol': vim_get_func('virtcol', rettype=int), 'getcwd': vim_get_func('getcwd'), } def _do_ex(command): '''Execute Ex command. Execute Ex command from args and return results string. ''' vim.command('redir => tmp_do_ex | silent! {0} | redir END'.format(command)) return vim.eval('tmp_do_ex') def col_current_virt(pl, gradient=True): '''Return the current cursor column. Since default 'col_current()' function returns current OR virtual column