DOCS: Move most of the README to the wiki

This commit is contained in:
Dylan Araps 2017-06-22 20:51:12 +10:00
parent 6cc3a91ce5
commit 326a3cb8f3

249
README.md
View File

@ -26,21 +26,8 @@
* [Applying the theme to new terminals.](#applying-the-theme-to-new-terminals)
* [Making the colorscheme persist on reboot.](#making-the-colorscheme-persist-on-reboot)
* [Usage](#usage)
* [Plugins](#plugins)
* [Hyper Terminal](#hyper-terminal)
* [Customization](#customization)
* [i3](#i3)
* [rofi](#rofi)
* [vim](#vim)
* [Emacs](#emacs)
* [polybar](#polybar)
* [iTerm2](#iterm2)
* [Shell Variables](#shell-variables)
* [SCSS variables](#scss-variables)
* [CSS variables](#css-variables)
* [PuTTY](#putty)
* [Scripting](#scripting)
* [Terminal.sexy](#terminalsexy)
* [Customization](#customization)
* [**https://github.com/dylanaraps/wal.py/wiki**](#httpsgithubcomdylanarapswalpywiki)
<!-- vim-markdown-toc -->
@ -145,234 +132,8 @@ optional arguments:
```
### Customization
## Plugins
See the `wal` wiki!
Listed below are plugins for other programs that add support for `wal` colors.
### Hyper Terminal
https://github.com/dneustadt/hyper-wal
## Customization
I've written another script \[1\] for personal use only that updates my `lemonbar`, `dunst` and `startpage` colors with the new ones from `wal` when run.
What I've done is bind both `wal` and my custom script to the same key so that after `wal` has done its thing my custom script applies the colors to the rest of my environment.
```sh
# i3 config.
# ...
# Cycle wallpapers and apply new colorscheme.
bindsym $mod+w exec "wal -i $HOME/Pictures/Wallpapers -o wal-set"
```
Now whenever I press `Win+w` a random wallpaper is chosen and all of the programs on my system start using the new colors immediately.
I've also set `wal` and my custom script to start with X. This means that when I boot my PC a random wallpaper is chosen and colors are generated + applied to all of my programs.
```sh
# .xinitrc
wal -i "$HOME/Pictures/Wallpapers" -o wal-set
exec i3
```
Have a look at my script to see how `wal` is used and how the programs get reloaded with the new colors.
\[1\] https://github.com/dylanaraps/bin/blob/master/wal-set
**NOTE:** `wal` stores the exported files in `$HOME/.cache/wal/`
### i3
To use `wal` with i3 you have to make some modifications to your i3 config file.
i3 can read colors from `Xresources` into config variables! This allows us to change i3's colors dynamically. On run `wal` will detect that you're running i3 and reload your config for you. If you've set it up correctly i3 will then use your new colorscheme.
Example:
```sh
# Set colors from Xresources
# Change 'color7' and 'color2' to whatever colors you want i3 to use
# from the generated scheme.
# NOTE: The '#f0f0f0' in the lines below is the color i3 will use if
# it fails to get colors from Xresources for some reason.
set_from_resource $fg i3wm.color7 #f0f0f0
set_from_resource $bg i3wm.color2 #f0f0f0
# class border backgr. text indicator child_border
client.focused $bg $bg $fg $bg $bg
client.focused_inactive $bg $bg $fg $bg $bg
client.unfocused $bg $bg $fg $bg $bg
client.urgent $bg $bg $fg $bg $bg
client.placeholder $bg $bg $fg $bg $bg
client.background $bg
# PROTIP: You can also dynamically set dmenu's colors this way:
bindsym $mod+d exec dmenu_run -nb "$fg" -nf "$bg" -sb "$bg" -sf "$fg"
```
### rofi
`wal` updates rofi's colors for you out of the box, automatically.
### vim
I've created a vim colorscheme for use with with the colors `wal` generates and you can install it using any vim package manager. The colorscheme uses your terminal colors so it'll adapt to the colorscheme changes automatically.
You can find the colorscheme here: https://github.com/dylanaraps/wal.vim
Example:
```vim
! Using plug
Plug 'dylanaraps/wal.vim'
colorscheme wal
```
### Emacs
Install [this package](https://github.com/cqql/xresources-theme), which will make Emacs use your X environment's colors instead of its default colors.
### polybar
Polybar can read colors from `Xresources` to set the bar's colors.
Example:
```vim
fg = ${xrdb:color7}
bg = ${xrdb:color2}
```
### iTerm2
There's a script called `wal2iterm` in `contrib/wal2iterm` which converts the generated colors to an importable iTerm2 colorscheme.
The themes are stored in the `wal` cache directory. (`${HOME}/.cache/wal/itermcolors`).
Example:
```sh
wal -i "IMAGE" -o "/path/to/wal2iterm/wal2iterm"
```
### Shell Variables
`wal` also exports the colorscheme as a list of shell variables that you can source for use in scripts and the shell.
Example:
```sh
# Add this line to your .bashrc or a shell script.
source "$HOME/.cache/wal/colors.sh"
```
In the shell:
```sh
# Once the file is sourced you can use the colors like this:
dylan ~ >echo "$color0"
#282A23
dylan ~ >echo "$color0 $color5"
#282A23 #BCC3CE
# lemonbar example
lemonbar -B "$color7" -F "$color0"
```
### SCSS variables
`wal` also exports the colorscheme as SCSS variables for use in webpages. I'm using this feature to update my startpage with the new colors dynamically.
Example:
```scss
// Example .scss file
// Import Colors
@import '/home/dylan/.cache/wal/colors.scss';
body {
background: $color0;
color: $color7;
}
```
### CSS variables
`wal` also exports the colors as CSS variables for use with Stylish or userChrome.css.
Example CSS:
```css
/* Import the CSS file.
NOTE: This must be at line 1 of your stylesheet. */
@import url('file:///home/dylan/.cache/wal/firefox.css')
/* Use the variables */
#nav-bar {
background-color: var(--color3) !important;
color: var(--color7) !important;
}
```
### PuTTY
`wal` also exports the colors so they can be used with PuTTY. After running `wal`, a file will be created (`$HOME/.cache/wal/colors-putty.reg`) that can be executed on a Windows machine to create a new PuTTY session with the generated colors. Once the file is executed, you can select `Wal` from the *Saved Sessions* list.
### Scripting
`wal` also exports the colors in a plain text format. This is helpful when you want use the plain colors in another script. See the script in `contrib/wal2iterm` for an example.
The file is called `colors` and just contains the hex values one per line in the order of 0-15.
Example `colors` file:
```
#0C2B32
#9C7648
#B78742
#B4884D
#AC8C64
#D19D62
#61828A
#F0DEC0
#666666
#9C7648
#B78742
#B4884D
#AC8C64
#D19D62
#61828A
#F0DEC0
```
Example usage in a script:
```sh
# Create an array with the plain hex colors ordered 0-15.
c=($(< "${cache_dir}/colors"))
# Remove the leading '#' if needed.
c=("${c[@]//\#}")
```
### Terminal.sexy
You can import `wal`'s colors into Terminal.sexy by copy-pasting the contents of the `xcolors` file located in the cache directory.
#### **https://github.com/dylanaraps/wal.py/wiki**