@ -1,42 +1,47 @@
# lightline.vim
A light and configurable statusline/tabline for Vim
A light and configurable statusline/tabline plugin for Vim
https://github.com/itchyny/lightline.vim
### powerline theme (default)
### powerline (default)
### wombat (with the patched font)
### wombat
### jellybeans (with the patched font)
### jellybeans
### solarized theme ( dark)
### solarized dark
### solarized theme ( light)
### solarized light
### PaperColor theme ( light)
### PaperColor light
### seoul256 theme
### seoul256
### landscape theme (with the patched font)
### Dracula
With branch name, read-only mark and modified mark.
### one
### landscape
landscape is my colorscheme, which is a high-contrast cui-supported colorscheme, available at https://github.com/itchyny/landscape.vim
@ -46,553 +51,293 @@ landscape is my colorscheme, which is a high-contrast cui-supported colorscheme,
+ [vim-airline ](https://github.com/bling/vim-airline ) is a nice plugin, but it uses too much functions of other plugins, which should be done by users in `.vimrc` .
## Spirit of this plugin
+ Minimalism. The core script is very small.
+ Configurability. You can create your own component and easily add to the statusline/tabline.
+ Orthogonality. Any plugin should not change the settings of another plugin. Such plugin-crossing settings should be written by users in `.vimrc` .
## Author
itchyny (https://github.com/itchyny)
## License
This software is released under the MIT License, see LICENSE.
+ Minimalism. The core script is very small to achive enough functions as a statusline plugin.
+ Configurability. You can create your own component and easily add to the statusline and the tabline.
+ Orthogonality. The plugin does not rely on the implementation of other plugins. Such plugin crossing settings should be configured by users.
## Installation
### Manually
1. Put all files under $VIM.
### Pathogen
### [Pathogen ](https://github.com/tpope/vim-pathogen )
1. Install with the following command.
git clone https://github.com/itchyny/lightline.vim ~/.vim/bundle/lightline.vim
### Vundle (https://github.com/VundleVim/Vundle.vim )
### [Vundle ](https://github.com/VundleVim/Vundle.vim )
1. Add the following configuration to your `.vimrc` .
Plugin 'itchyny/lightline.vim'
2. Install with `:PluginInstall` .
### NeoBundle (https://github.com/Shougo/neobundle.vim )
### [NeoBundle ](https://github.com/Shougo/neobundle.vim )
1. Add the following configuration to your `.vimrc` .
NeoBundle 'itchyny/lightline.vim'
2. Install with `:NeoBundleInstall` .
### vim-plug (https://github.com/junegunn/vim-plug )
### [vim-plug ](https://github.com/junegunn/vim-plug )
1. Add the following configuration to your `.vimrc` .
Plug 'itchyny/lightline.vim'
2. Install with `:PlugInstall` .
## Configuration tutorial
By default, the statusline looks like:
## Introduction
After installing this plugin, you restart the editor and will get a cool statusline.
If you use the wombat colorscheme, add the following settings to your `.vimrc` (or \_vimrc on Windows):
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ }
```
to get:
The color of the statusline changes due to the mode of Vim. Try typing something, selecting in visual mode and replacing some texts.
If your statusline looks like
If the statusline looks like
and the cool statuslines appear only on `:vsp` , add
add the following configuration to your `.vimrc` .
```vim
set laststatus=2
```
to your `.vimrc` .
If you have problem like
If the statusline does not be coloured like
then add
then modify `TERM` in your shell configuration (`.zshrc` for example)
```sh
export TERM=xterm-256color
```
to your `.*shrc` and add
and then add the following configure to your `.vimrc` .
```vim
if !has('gui_running')
set t_Co=256
endif
```
to your `.vimrc` .
Your statusline appears to work correctly? If yes, great, thanks for choosing lightline.vim! If no, please file a issue report to the [issue tracker ](https://github.com/itchyny/lightline.vim/issues ).
If the colors of the statusline do not change from the default colors, move the settings of `g:lightline` before setting the colorscheme.
If you are reloading your `.vimrc` via `autocmd` and get this problem
when saving it you need to add the nested flag to your `autocmd` like so
By the way, `-- INSERT --` is unnecessary anymore because the mode information is displayed in the statusline.
If you want to get rid of it, configure as follows.
```vim
augroup reload_vimrc
autocmd!
autocmd bufwritepost $MYVIMRC nested source $MYVIMRC
augroup END
set noshowmode
```
## Colorscheme configuration
The lightline.vim plugin provides multiple colorschemes to meet your editor colorscheme.
Do not be confused, editor colorscheme rules how codes look like in buffers and lightline.vim has independent colorscheme feature, which rules how the statusline looks like.
Colors appear correctly? Now let's see how to change the appearance.
You may think that the default read-only mark is not so cool:
Then edit the read-only component.
The lightline components are stored in `g:lightline.component` .
So you add the settings of `g:lightline.component.readonly` in your `.vimrc` . (the following settings are effective with the patched font for vim-powerline):
If you are using wombat colorscheme, add the following setting to your `.vimrc` ,
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component': {
\ 'readonly': '%{& readonly?"โญค":""}',
\ }
\ }
```
How nice!
restart Vim and the statusline looks like:
But the boundaries are quadrilateral. You may miss the powerline.
You have installed a cool font for powerlines, so you can use it.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component': {
\ 'readonly': '%{& readonly?"โญค":""}',
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
```
Hurrah! Cool!
If the colors of the statusline do not change, move the settings of `g:lightline` before setting the editor colorscheme.
There are many lightline colorschemes available as screenshots shown above. See `:h g:lightline.colorscheme` for the complete list.
If your statusline looks like:
## Advanced configuration
The default appearance of lightline.vim is carefully designed that the tutorial is enough here for most people.
So please read this section if you really want to configure and enjoy the configurability of lightline.vim.
the patched font is not installed.
Sometimes people want to display information of other plugins.
For example git branch information, syntax check errors and some statuses of plugins.
There are two kinds of patched fonts:
The lightline.vim plugin does not provide any plugin integration by default.
This plugin considers orthogonality to be one of the important ideas, which means that the plugin does not rely on implementation of other plugins.
Once a plugin starts to integrate with some famous plugins, it should be kept updated to follow the changes of the plugins, and should accept integration requests with new plugins and it will suffer from performance regression due to plugin availability checks.
+ The patched fonts for [vim-powerline ](https://github.com/Lokaltog/vim-powerline ): see https://github.com/Lokaltog/vim-powerline/tree/develop/fontpatcher
+ The patched fonts for [powerline ](https://github.com/Lokaltog/powerline ): see https://github.com/Lokaltog/powerline-fonts
Instead, lightline.vim provides a simple API that user can easily integrate with other plugins.
Once you understand how to configure and how it will be displayed in the statusline, you can also tell how to integrate with your favorite plugins.
Create or download a font and install it .
And add the `guifont` setting to your `.vimrc` (see `:help 'guifont'` for more detail) .
If you are using the vim in a terminal, the font cannot be controlled in `.vimrc` .
Open the setting of the terminal and select the patched font .
Let's start to configure the appearance .
The statusline is composed by multiple components .
It shows the current mode, filename, modified status on the left, and file format, encoding, filetype and cursor positions on the right .
So in order to add something in the statusline, you firstly create a new component and specify the place .
This tutorial is based on the former, the font for vim-powerline (Inconsolata for Powerline).
If you have installed the patched font for powerline, use the following settings instead.
This is the hello world of lightline.vim component.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component': {
\ 'readonly': '%{& readonly?"๎ข
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'readonly', 'filename', 'modified', 'helloworld' ] ]
\ },
\ 'separator': { 'left': '๎ฐ ๎ฒ
\ 'subseparator': { 'left': '๎ฑ ๎ณ
\ }
```
If you have installed the font for powerline and your statusline looks like
remove
```vim
set ambiwidth=double
```
from your `.vimrc` . If you want to keep this setting, use the patched font for vim-powerline.
+ https://github.com/Lokaltog/vim-powerline/tree/develop/fontpatcher
If you will not install a patched font, use ascii characters like:
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component': {
\ 'readonly': '%{& readonly?"x":""}',
\ 'helloworld': 'Hello, world!'
\ },
\ 'separator': { 'left': '', 'right': '' },
\ 'subseparator': { 'left': '|', 'right': '|' }
\ }
```
If the triangles do not appear (but you get some spaces or weird characters like < bf> or ยฟ), firstly try adding
```vim
set encoding=utf-8
scriptencoding utf-8
```
to the head of your `.vimrc` .
Still you have weird characters, use the unicode numbers. For powerline font
users:
```vim
\ 'separator': { 'left': "\ue0b0", 'right': "\ue0b2" },
\ 'subseparator': { 'left': "\ue0b1", 'right': "\ue0b3" }
```
For vim-powerline font users:
```vim
\ 'separator': { 'left': "\u2b80", 'right': "\u2b82" },
\ 'subseparator': { 'left': "\u2b81", 'right': "\u2b83" }
```
Almost all of things go well with the patched font but if the triangle looks weird:
If you are using iTerm2, change the following settings of iTerm2:
+ set `Profiles>Colors>Minimum contrast` to the Lowest.
+ set `Profiles>Window>Transparency` to the Opaquest.
For other terminals, this weird-triangle problem will be resolved by disabling transparency or contrast adjustment.
If you want to get rid of the extraneous default vim mode information that is now provided by lightline:
```vim
set noshowmode
```
The statusline will look like:
Now, let's get back to the tutorial (with the patched font for vim-powerline).
You look into a help file to find the marks annoying.
You have succeeded in displaying `Hello, world!` in the statusline.
The `helloworld` component is added to `g:lightline.active.left` and its content is configured in `g:lightline.component` .
The component contents are simply added to `&statusline` .
Try `:echo &statusline` , it might be a little bit complicated, but you will find `Hello, world!` somewhere.
Help files are read-only and no-modifiable? We know that!
OK, so you again edit the components.
You can use `'statusline'` syntax for lightline.vim components.
Consult `:h 'statusline'` to see what's available here.
For example, if you want to print the value of character under the cursor in hexadecimal, configure as
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component ': {
\ 'readonly': '%{& filetype=="help"?"":& readonly?"โญค":""}' ,
\ 'modified': '%{& filetype=="help"?"":& modified?"+":& modifiable?"":"-"}'
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'readonly', 'filename', 'modified', 'charvaluehex' ] ]
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
```
Huh? Weird!
The subseparators are visible even if the components are empty.
In order to hide the subseparators, you can set expressions to `g:lightline.component_visible_condition` , which should be 1 only when the corresponding component is not empty.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'component': {
\ 'readonly': '%{& filetype=="help"?"":& readonly?"โญค":""}',
\ 'modified': '%{& filetype=="help"?"":& modified?"+":& modifiable?"":"-"}'
\ },
\ 'component_visible_condition': {
\ 'readonly': '(& filetype!="help"&& & readonly)',
\ 'modified': '(& filetype!="help"&& (& modified||!& modifiable))'
\ 'charvaluehex': '0x%B'
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
```
Okay. It works nice.
The configuration `component_visible_condition` is used to control the visibility of the subseparators.
You cannot use this variable to control the visibility of the components themselves.
How does lightline decide the components to show in the statusline?
It's very simple.
The variables to select components are `g:lightline.active.left` and `g:lightline.active.right` .
For example, you add the `g:lightline.active.left` in `.vimrc` .
You want the character value information on the right hand side? OK, configure as
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'readonly', 'filename', 'modified' ] ]
\ 'right': [ [ 'lineinfo' ],
\ [ 'percent' ],
\ [ 'fileformat', 'fileencoding', 'filetype', 'charvaluehex' ] ]
\ },
\ 'component': {
\ 'readonly': '%{& filetype=="help"?"":& readonly?"โญค":""}',
\ 'modified': '%{& filetype=="help"?"":& modified?"+":& modifiable?"":"-"}'
\ 'charvaluehex': '0x%B'
\ },
\ 'component_visible_condition': {
\ 'readonly': '(& filetype!="help"&& & readonly)',
\ 'modified': '(& filetype!="help"&& (& modified||!& modifiable))'
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
```
If the plugin arranges all the components (in a situation you `set paste` and the file `.vimrc` is read-only, try to modify):
Again look into `g:lightline.active.left` .
```vim
let g:lightline = {
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'readonly', 'filename', 'modified' ] ] ...
```
The mode and paste component are displayed in the same group.
The read-only, filename and modified component are in the second group.
It corresponds to the structure of `g:lightline.active.left` .
You can configure the components in the statusline by the following four variables:
+ `g:lightline.active.left`
+ `g:lightline.active.right`
+ `g:lightline.inactive.left`
+ `g:lightline.inactive.right`
Of course, your configurations in `.vimrc` have priority over the default settings in lightline .
We have learned how to add a simple component.
- See `:h 'statusline'` to check the statusline flags.
- Add a new component to `g:lightline.component` .
- Add the component name to `g:lightline.active.left` or `g:lightline.active.right` .
You can also configure the statusline of inactive buffers by adding the component to `g:lightline.inactive.left` or `g:lightline.inactive.right` .
Git branch is important for us.
And it is a default component in [powerline ](https://github.com/Lokaltog/powerline ) and [vim-powerline ](https://github.com/Lokaltog/vim-powerline ).
However, lightline does not provide the branch feature by default.
In order to show the branch in the statusline, you firstly install the [vim-fugitive ](https://github.com/tpope/vim-fugitive ) plugin.
Then edit the `g:lightline` in your `.vimrc` .
+ Add your fugitive component to `g:lightline.component` .
+ Add the condition when the fugitive component has information to `g:lightline.component_visible_condition` .
+ Add the component by inserting `'fugitive'` to `g:lightline.active.left` .
Now let's add some integrations with other plugin.
The name of the git branch is important these days.
But lightline.vim does not provide this information by default because it is also one of plugin crossing configurations, and not all people want the integration.
In order to show the branch name in the statusline, install some plugins which provides the branch information.
The [vim-fugitive ](https://github.com/tpope/vim-fugitive ) plugin is a famous plugin so let's integrate lightline.vim with it.
If you don't like to install full git integration but just want to display the branch name in the statusline, you can use the [vim-gitbranch ](https://github.com/itchyny/vim-gitbranch ) plugin which provides `gitbranch#name` function.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'fugitive', 'readonly', 'filename', 'modified' ] ]
\ },
\ 'component': {
\ 'readonly': '%{& filetype=="help"?"":& readonly?"โญค":""}',
\ 'modified': '%{& filetype=="help"?"":& modified?"+":& modifiable?"":"-"}',
\ 'fugitive': '%{exists("*fugitive#head")?fugitive#head():""}'
\ [ 'gitbranch', 'readonly', 'filename', 'modified' ] ]
\ },
\ 'component_visible_condition': {
\ 'readonly': '(& filetype!="help"&& & readonly)',
\ 'modified': '(& filetype!="help"&& (& modified||!& modifiable))',
\ 'fugitive': '(exists("*fugitive#head") && ""!=fugitive#head())'
\ 'component_function': {
\ 'gitbranch': 'fugitive#head'
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
```
Okay, the branch component is added!
Okay, now the statusline shows that we are coding at the master branch.
What do we learn from this example?
- Find out the function which is suitable to use in the statusline.
- Create a function component. The previous `charvaluehex` component has `'statusline'` item configuration and registered in `g:lightline.component` . In the current example, we register the name of the function in `g:lightline.component_function` . It should return the string to be displayed in the statusline.
- Add the component name `gitbranch` to `g:lightline.active.left` or `g:lightline.active.right` .
Now, you might get tired of setting both `'component'` and `'component_visible_condition'` .
Or if you want to do something more complicated?
Here we have leaned two kinds of components.
- component: it has a `%` -prefixed item which you can find the meaning at `:h 'statusline'` . All the default components of lightline.vim are components in this style. See the default components at `:h g:lightline.component` .
- function component: the name of functions are registered. The function is called again and again so be careful not to register a heavy function. See the help with `:h g:lightline.component_function` .
In fact, the components can be created using functions.
Add your function names for components to `g:lightline.component_function` .
The function component is an important design for the configurability of lightline.vim.
By providing the configuration interface via functions, you can adjust the statusline information as you wish.
For the proof, let's look into some configuration examples in Q& A style.
### Can I hide the readonly component in the help buffer?
Yes, create a function component for `readonly` .
The configuration of function component has priority over the default component.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'fugitive', 'readonly', 'filename', 'modified' ] ]
\ },
\ 'component_function': {
\ 'fugitive': 'LightlineFugitive',
\ 'readonly': 'LightlineReadonly',
\ 'modified': 'LightlineModified'
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
function! LightlineModified()
if & filetype == "help"
return ""
elseif & modified
return "+"
elseif & modifiable
return ""
else
return ""
endif
function! LightlineReadonly()
return & readonly & & & filetype !=# 'help' ? 'RO' : ''
endfunction
```
### Can I hide the readonly component in other plugins buffer?
Yes, modify the `LightlineReadonly` function as you wish.
```vim
function! LightlineReadonly()
if & filetype == "help"
return ""
elseif & readonly
return "โญค"
else
return ""
endif
return & readonly && & filetype !~# '\v(help|vimfiler|unite)' ? 'RO' : ''
endfunction
function! LightlineFugitive()
return exists('*fugitive#head') ? fugitive#head() : ''
endfunction
let g:unite_force_overwrite_statusline = 0
let g:vimfiler_force_overwrite_statusline = 0
```
Fine and readable!
Finally, you come up with concatenating the three components: the read-only mark, the filename and the modified mark.
Now you may know what to do .
### Can I display the plugin information at the filename component?
Yes, overwrite the filename component.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'fugitive', 'filename' ] ]
\ },
\ 'component_function': {
\ 'fugitive': 'LightlineFugitive',
\ 'readonly': 'LightlineReadonly',
\ 'modified': 'LightlineModified',
\ 'filename': 'LightlineFilename'
\ 'filename': 'LightlineFilename',
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
function! LightlineModified()
if & filetype == "help"
return ""
elseif & modified
return "+"
elseif & modifiable
return ""
else
return ""
endif
endfunction
function! LightlineReadonly()
if & filetype == "help"
return ""
elseif & readonly
return "โญค"
else
return ""
endif
endfunction
function! LightlineFugitive()
return exists('*fugitive#head') ? fugitive#head() : ''
endfunction
function! LightlineFilename()
return ('' != LightlineReadonly() ? LightlineReadonly() . ' ' : '') .
\ ('' != expand('%:t') ? expand('%:t') : '[No Name]') .
\ ('' != LightlineModified() ? ' ' . LightlineModified() : '')
return & filetype ==# 'vimfiler' ? vimfiler#get_status_string() :
\ & filetype ==# 'unite' ? unite#get_status_string() :
\ & filetype ==# 'vimshell' ? vimshell#get_status_string() :
\ expand('%:t') !=# '' ? expand('%:t') : '[No Name]'
endfunction
```
Oops! We forgot the cool mark for the branch component! (work with the patched font for vim-powerline)
```vim
function! LightlineFugitive()
if exists("*fugitive#head")
let branch = fugitive#head()
return branch !=# '' ? 'โญ '.branch : ''
endif
return ''
endfunction
let g:unite_force_overwrite_statusline = 0
let g:vimfiler_force_overwrite_statusline = 0
let g:vimshell_force_overwrite_statusline = 0
```
How cool!!!
Of course, you can name your component as you wish.
### Can I display the plugin name at the mode component?
Yes, overwrite the mode component.
```vim
let g:lightline = {
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'my_component' ] ] },
\ 'component_function': {
\ 'my_component': 'LightlineComponent', ...
```
This is the end of the tutorial. For more information, see `:help lightline` . Good luck with your nice statuslines.
### Cool characters for the patched fonts
\ 'component_function': {
\ 'mode': 'LightlineMode',
\ },
\ }
Symbol | Default | powerline | vim-powerline
------------------ | ------- | ------------- | -------------
separator.left | '' | '๎ฐ
separator.right | '' | '๎ฒ
subseparator.left | '\|' | '๎ฑ
subseparator.right | '\|' | '๎ณ
branch symbol | -- | '๎
readonly symbol | -- | '๎ข
linecolumn symbol | -- | '๎ก
function! LightlineMode()
return expand('%:t') ==# '__Tagbar__' ? 'Tagbar':
\ expand('%:t') ==# 'ControlP' ? 'CtrlP' :
\ & filetype ==# 'unite' ? 'Unite' :
\ & filetype ==# 'vimfiler' ? 'VimFiler' :
\ & filetype ==# 'vimshell' ? 'VimShell' :
\ lightline#mode()
endfunction
```
### My settings
I show my settings. I use the patched font for vim-powerline .
### Can I trim the file format and encoding information on narrow windows?
Yes, check `winwidth(0)` and return empty string with some threshold .
```vim
let g:lightline = {
\ 'colorscheme': 'landscape',
\ 'mode_map': { 'c': 'NORMAL' },
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ], [ 'fugitive', 'filename' ] ]
\ },
\ 'component_function': {
\ 'modified': 'LightlineModified',
\ 'readonly': 'LightlineReadonly',
\ 'fugitive': 'LightlineFugitive',
\ 'filename': 'LightlineFilename',
\ 'fileformat': 'LightlineFileformat',
\ 'filetype': 'LightlineFiletype',
\ 'fileencoding': 'LightlineFileencoding',
\ 'mode': 'LightlineMode',
\ },
\ 'separator': { 'left': 'โฎ', 'right': 'โฎ' },
\ 'subseparator': { 'left': 'โฎ', 'right': 'โฎ' }
\ }
function! LightlineModified()
return & ft =~ 'help\|vimfiler\|gundo' ? '' : & modified ? '+' : & modifiable ? '' : '-'
endfunction
function! LightlineReadonly()
return & ft !~? 'help\|vimfiler\|gundo' && & readonly ? 'โญค' : ''
endfunction
function! LightlineFilename()
return ('' != LightlineReadonly() ? LightlineReadonly() . ' ' : '') .
\ (& ft == 'vimfiler' ? vimfiler#get_status_string() :
\ & ft == 'unite' ? unite#get_status_string() :
\ & ft == 'vimshell' ? vimshell#get_status_string() :
\ '' != expand('%:t') ? expand('%:t') : '[No Name]') .
\ ('' != LightlineModified() ? ' ' . LightlineModified() : '')
endfunction
function! LightlineFugitive()
if & ft !~? 'vimfiler\|gundo' && exists("*fugitive#head")
let branch = fugitive#head()
return branch !=# '' ? 'โญ '.branch : ''
endif
return ''
endfunction
function! LightlineFileformat()
return winwidth(0) > 70 ? & fileformat : ''
endfunction
@ -600,170 +345,34 @@ endfunction
function! LightlineFiletype()
return winwidth(0) > 70 ? (& filetype !=# '' ? & filetype : 'no ft') : ''
endfunction
function! LightlineFileencoding()
return winwidth(0) > 70 ? (& fenc !=# '' ? & fenc : & enc) : ''
endfunction
function! LightlineMode()
return winwidth(0) > 60 ? lightline#mode() : ''
endfunction
```
When the current window width is narrow, the mode component and the file information component collapse.
For example, the [gundo ](https://github.com/sjl/gundo.vim ) buffer is narrow.
Before:
After:
Nice looking, isn't it?
### For power users
For users who uses following plugins.
- [CtrlP ](https://github.com/kien/ctrlp.vim )
- [Tagbar ](https://github.com/majutsushi/tagbar )
- [Gundo ](http://github.com/sjl/gundo.vim )
- [NERDtree ](http://github.com/scrooloose/nerdtree )
- [Syntastic ](https://github.com/scrooloose/syntastic )
- [unite.vim ](https://github.com/Shougo/unite.vim )
- [vimfiler.vim ](https://github.com/Shougo/vimfiler.vim )
- [vimshell.vim ](https://github.com/Shougo/vimshell.vim )
### Can I trim the bar between the filename and modified sign?
Yes, by joining the two components.
```vim
let g:lightline = {
\ 'colorscheme': 'wombat',
\ 'active': {
\ 'left': [ [ 'mode', 'paste' ], [ 'fugitive', 'filename' ], ['ctrlpmark'] ],
\ 'right': [ [ 'syntastic', 'lineinfo' ], ['percent'], [ 'fileformat', 'fileencoding', 'filetype' ] ]
\ 'left': [ [ 'mode', 'paste' ],
\ [ 'readonly', 'filename' ] ],
\ },
\ 'component_function': {
\ 'fugitive': 'LightlineFugitive',
\ 'filename': 'LightlineFilename',
\ 'fileformat': 'LightlineFileformat',
\ 'filetype': 'LightlineFiletype',
\ 'fileencoding': 'LightlineFileencoding',
\ 'mode': 'LightlineMode',
\ 'ctrlpmark': 'CtrlPMark',
\ },
\ 'component_expand': {
\ 'syntastic': 'SyntasticStatuslineFlag',
\ },
\ 'component_type': {
\ 'syntastic': 'error',
\ },
\ 'subseparator': { 'left': '|', 'right': '|' }
\ }
function! LightlineModified()
return & ft =~ 'help' ? '' : & modified ? '+' : & modifiable ? '' : '-'
endfunction
function! LightlineReadonly()
return & ft !~? 'help' & & & readonly ? 'RO' : ''
endfunction
function! LightlineFilename()
let fname = expand('%:t')
return fname == 'ControlP' & & has_key(g:lightline, 'ctrlp_item') ? g:lightline.ctrlp_item :
\ fname == '__Tagbar__' ? g:lightline.fname :
\ fname =~ '__Gundo\|NERD_tree' ? '' :
\ & ft == 'vimfiler' ? vimfiler#get_status_string() :
\ & ft == 'unite' ? unite#get_status_string() :
\ & ft == 'vimshell' ? vimshell#get_status_string() :
\ ('' != LightlineReadonly() ? LightlineReadonly() . ' ' : '') .
\ ('' != fname ? fname : '[No Name]') .
\ ('' != LightlineModified() ? ' ' . LightlineModified() : '')
endfunction
function! LightlineFugitive()
try
if expand('%:t') !~? 'Tagbar\|Gundo\|NERD' && & ft !~? 'vimfiler' && exists('*fugitive#head')
let mark = '' " edit here for cool mark
let branch = fugitive#head()
return branch !=# '' ? mark.branch : ''
endif
catch
endtry
return ''
endfunction
function! LightlineFileformat()
return winwidth(0) > 70 ? & fileformat : ''
endfunction
function! LightlineFiletype()
return winwidth(0) > 70 ? (& filetype !=# '' ? & filetype : 'no ft') : ''
endfunction
function! LightlineFileencoding()
return winwidth(0) > 70 ? (& fenc !=# '' ? & fenc : & enc) : ''
endfunction
function! LightlineMode()
let fname = expand('%:t')
return fname == '__Tagbar__' ? 'Tagbar' :
\ fname == 'ControlP' ? 'CtrlP' :
\ fname == '__Gundo__' ? 'Gundo' :
\ fname == '__Gundo_Preview__' ? 'Gundo Preview' :
\ fname =~ 'NERD_tree' ? 'NERDTree' :
\ & ft == 'unite' ? 'Unite' :
\ & ft == 'vimfiler' ? 'VimFiler' :
\ & ft == 'vimshell' ? 'VimShell' :
\ winwidth(0) > 60 ? lightline#mode() : ''
endfunction
function! CtrlPMark()
if expand('%:t') =~ 'ControlP' & & has_key(g:lightline, 'ctrlp_item')
call lightline#link('iR'[g:lightline.ctrlp_regex])
return lightline#concatenate([g:lightline.ctrlp_prev, g:lightline.ctrlp_item
\ , g:lightline.ctrlp_next], 0)
else
return ''
endif
endfunction
let g:ctrlp_status_func = {
\ 'main': 'CtrlPStatusFunc_1',
\ 'prog': 'CtrlPStatusFunc_2',
\ }
function! CtrlPStatusFunc_1(focus, byfname, regex, prev, item, next, marked)
let g:lightline.ctrlp_regex = a:regex
let g:lightline.ctrlp_prev = a:prev
let g:lightline.ctrlp_item = a:item
let g:lightline.ctrlp_next = a:next
return lightline#statusline(0)
endfunction
function! CtrlPStatusFunc_2(str)
return lightline#statusline(0)
endfunction
let g:tagbar_status_func = 'TagbarStatusFunc'
function! TagbarStatusFunc(current, sort, fname, ...) abort
let g:lightline.fname = a:fname
return lightline#statusline(0)
let filename = expand('%:t') !=# '' ? expand('%:t') : '[No Name]'
let modified = & modified ? ' +' : ''
return filename . modified
endfunction
augroup AutoSyntastic
autocmd!
autocmd BufWritePost *.c,* .cpp call s:syntastic()
augroup END
function! s:syntastic()
SyntasticCheck
call lightline#update()
endfunction
let g:unite_force_overwrite_statusline = 0
let g:vimfiler_force_overwrite_statusline = 0
let g:vimshell_force_overwrite_statusline = 0
```
### Note for developers of other plugins
You can control the visibility and contents by writing simple functions.
Now you notice how much function component is important for the configurability of lightline.vim.
## Note for developers of other plugins
Appearance consistency matters.
The statusline is an important space for Vim users.
@ -771,9 +380,14 @@ Overwriting the statusline forcibly in your plugin is not a good idea.
It is not hospitality, but just an annoying feature.
If your plugin has such a feature, add an option to be modest.
A good design is the following .
A good design is as follows .
Firstly, give the users a clue to judge which buffer is the one your plugin creates.
The filename is a manner and the filetype is another.
Then, export a function which is useful to be shown in the statusline.
Lastly, for advanced users, set important information in buffer variables.
So that the users can obtain the condition of the plugin easily.
Lastly, for advanced users, set important information in buffer variables so that the users can obtain the condition of the plugin easily.
## Author
itchyny (https://github.com/itchyny)
## License
This software is released under the MIT License, see LICENSE.
amix
6 years ago