sxhkdrc

# Keys are listed with an ordered preference of:
#   1. mod3 (hyper)
#   2. super
#   3. ctrl
#   4. alt
#   5. shift

# ╭──────────────────────────────────────────────────────────╮
# │                           Keys                           │
# ╰──────────────────────────────────────────────────────────╯ [[[

# xte "keyup h" "key Left"
## Autokey does this much better

# Modify keys with mod3 to mimic arrow keys
# mod3 + h
#     xdotool keyup h key --clearmodifiers Left

# mod3 + j
#     xdotool keyup j key --clearmodifiers Down
#
# mod3 + k
#     xdotool keyup k key --clearmodifiers Up
#
# mod3 + l
#     xdotool keyup l key --clearmodifiers Right

# Help: sxhkd keybindings
super + shift + question
  sxhkhmenu
# ]]]

# ╭──────────────────────────────────────────────────────────╮
# │                         Restart                          │
# ╰──────────────────────────────────────────────────────────╯ [[[

# Quit: bspwm
super + shift + escape
  prompt "Are you sure you would like to quit this Xsession" "bspc quit"

# Restart: bspwm
super + alt + shift + r
  notify-send "bpswm" "Configuration reloaded" && bspc wm -r

# Restart: sxhkd
super + shift + x
  killandnotify sxhkd "Config reloaded" && sxhkd &

# Restart: polybar
super + shift + p
  reloadpolybar

# Restart: dunst
super + shift + d
  killandnotify dunst "Dunst reloaded" && dunst &

# Happens when using `bustd`
# Restart: crashed items
super + shift + c
  notify-send "Crashed" "Items were reloaded" && restart-crashed
# ]]]

# ╭──────────────────────────────────────────────────────────╮
# │                          Screen                          │
# ╰──────────────────────────────────────────────────────────╯ [[[

# Screen: lock
super + Delete
  xidlehook-client --socket /tmp/xidlehook.sock control --action trigger --timer 1
# ]]]

# ╭──────────────────────────────────────────────────────────╮
# │                          Window                          │
# ╰──────────────────────────────────────────────────────────╯ [[[

# NODE_SEL :=
#
#   [NODE_SEL#]
#     (DIR|CYCLE_DIR|PATH|any|first_ancestor|last|newest|
#      older|newer|focused|pointed|biggest|smallest|
#      <node_id>
#     )[.[!]focused][.[!]active][.[!]automatic][.[!]local]
#      [.[!]leaf][.[!]window][.[!]STATE][.[!]FLAG][.[!]LAYER][.[!]SPLIT_TYPE]
#      [.[!]same_class][.[!]descendant_of][.[!]ancestor_of]
#
# STATE      := tiled | pseudo_tiled | floating | fullscreen
# FLAG       := hidden | sticky | private | locked | marked | urgent
# LAYER      := below | normal | above
# SPLIT_TYPE := horizontal | vertical
# PATH       := @[DESKTOP_SEL:][[/]JUMP](/JUMP)*
# JUMP       := first | 1 | second | 2 | brother | parent | DIR
# DIR        := north | west | south | east
# CYCLE_DIR  := next | prev

# ╭───────────────────────╮
# │ (Pseudo) Tiled Window │
# ╰───────────────────────╯ [[[

# State: toggle (tiled|pseudo_tiled)
mod3 + t
  bspc node -t tiled || bspc node -t pseudo_tiled

# (floating|fullscreen|monocle)
# State: all windows to tile
super + ctrl + t
  bspcp tile
# bspc desktop --layout tiled || bspcp tile

# Focus: cycle {next,prev} (tiled)
super + {_,shift + }t
  bspc node -f '{next,prev}.local.!hidden.!floating.!fullscreen.window'
# bspc node -f 'focused.!floating.!fullscreen.window#{next,prev}.local.!hidden.!floating.!fullscreen.window' \
#   || bspc node -f 'last.local.!focused.!hidden.!floating.!fullscreen.window' \
#   || bspc node -f 'any.local.!focused.!hidden.!floating.!fullscreen.window'

# Focus: in direction {left,down,up,right} (tiled)
alt + {h,j,k,l}
  bspc node -f {west,south,north,east}

# Rotate: cycle tree {90,-90}
mod3 + {_,shift +} r
  bspc node @/ --rotate {90,-90}

# Circulate: tree {backward,forward}
super + {_,shift +} r
    bspc node @/ --circulate {backward,forward}

# Circulate: tree {backward,forward}
super + shift + {comma,period}
    bspc node @/ --circulate {backward,forward}

# Swap: flip leaves of tree {vertical,horizontal}ly
alt + shift + {comma,period}
  bspc node @/ --flip {vertical,horizontal}

# (tiled)
# Swap: in direction {left,down,up,right}
alt + shift + {h,j,k,l}
  bspc node -s {west,south,north,east}
# bspwm-smart-move {west,south,north,east}

# Swap: size {biggest,smallest} node
alt + shift + {b,s}
  bspc node -s '{biggest,smallest}.!focused.!hidden.local.window'

# Transplant: in direction {left,down,up,right} (tiled)
ctrl + alt + shift + {h,j,k,l}
  bspc node -n {west,south,north,east}

# Transplant: size {biggest,smallest} node
ctrl + alt + shift + {b,s}
  bspc node -n '{biggest,smallest}.!focused.!hidden.local.window'

# Resize: {equalize,balance} ratios
super + ctrl + {_,shift + }0
  bspc node @/ -{E,B}
# bspc node {@/,_} --equalize
# bspc node {@/,_} --balance

# Resize: {left,down,up,right} by 50 (float: sides in)
# super + ctrl + {h,j,k,l}
#   bspwm-resize {west,south,north,east} 50

# Resize: {left,down,up,right} by 20 (float: sides in)
ctrl + alt + {h,j,k,l}
  bspwm-resize {west,south,north,east} 20

# Resize: {left,down,up,right} by 10 (float: sides out)
super + ctrl + alt + {h,j,k,l}
  n=10; \
  { d1=left;   d2=right;  dx=-$n; dy=0;   \
  , d1=bottom; d2=top;    dx=0;   dy=$n;  \
  , d1=top;    d2=bottom; dx=0;   dy=-$n; \
  , d1=right;  d2=left;   dx=$n;  dy=0;   \
  } \
  bspc node --resize $d1 $dx $dy || bspc node --resize $d2 $dx $dy

# Gaps: dynamically {-,+}
mod3 + shift + bracket{left,right}
  bspc config -d focused window_gap "$(($(bspc config -d focused window_gap) {-,+} 5 ))"
# ]]]

# ╭────────────────╮
# │ Monocle Window │
# ╰────────────────╯ [[[

# State: toggle (monocle|tiled)
mod3 + m
  bspc desktop -l next

# Rotate: cycle {left,down,up,right} (monocle)
super + alt + {Left,Down,Up,Right}
  m='.local'; \
  bspwm-monocle {west$m next$m,south$m prev$m,north$m next$m,east$m prev$m}

# Layer: alternate stacking layer (below|above) (doesn't switch focus)
super + shift + j
  bspc node -l below || bspc node -l above

# Layer: alternate stacking layer (above ? normal : below) (doesn't switch focus)
super + shift + h
  bspc node -l "$(bspc query -T -n | jq -r 'if .client.layer == "above" then "normal" else "below" end')"

# Layer: alternate stacking layer (below ? normal : above) (doesn't switch focus)
super + shift + l
  bspc node -l "$(bspc query -T -n | jq -r 'if .client.layer == "below" then "normal" else "above" end')"

# Layer: focus any (above|below) layer to the front
super + shift + k
  bspc node any.below -l normal -f || bspc node any.above -l normal -f
# ]]]

# ╭───────────────────╮
# │ Fullscreen Window │
# ╰───────────────────╯ [[[

# State: toggle (tiled|fullscreen)
mod3 + f
  bspc node -t tiled || bspc node -t fullscreen

# Rotate: cycle {prev,next} (fullscreen)
mod3 + bracket{left,right}
  bspc node -f '{prev,next}.!focused.window' && bspc node focused -t fullscreen

# This wont' focus the fullscreen
#   bspc node -f '{prev,next}.!focused.window' -t fullscreen
# ]]]

# ╭─────────────────╮
# │ Floating Window │
# ╰─────────────────╯ [[[

# State: toggle (floating|tiled)
mod3 + space
  bspc node focused.tiled -t floating || bspc node focused.floating -t tiled

# Focus: cycle {next,prev} (floating)
super + {_,shift + }f
  bspc node -f '{next,prev}.local.!hidden.floating.window'
# bspc node -f 'focused.floating#{next,prev}.local.!hidden.floating' \
#    || bspc node -f 'last.local.!focused.!hidden.floating' \
#    || bspc node -f  'any.local.!focused.!hidden.floating'

# (Alternative: Ctrl + Right Mouse | mod3 + c : {h,j,k,l})
# Move: {left,down,up,right} arrow key (floating)
ctrl + alt + {Left,Down,Up,Right}
  bspc node -v {-20 0,0 20,0 -20,20 0}
# ]]]

# ╭────────────╮
# │ Any Window │
# ╰────────────╯ [[[

# State: toggle last state
mod3 + a
  bspc node -t "$(bspc query -T -n | jq -r '.client.lastState')"

# TODO: Add fullscreen
# Keeps those layouts
# Focus: cycle {next,prev} (tiled|floating|monocle)
super + {j,k}
  bspc node -f '{next,prev}.local.!hidden.window'

  # bspc node -f '{next,prev}.local.window'
  # [[ $(bspc query -T -n last | jq -r '.client.lastState') == 'fullscreen' ]] && bspc node focused -t fullscreen

# bspc node -f 'focused.window#{next,prev}.local.!hidden.window' \
#    || bspc node -f 'last.local.!focused.!hidden.window' \
#    || bspc node -f 'any.local.!focused.!hidden.window';

# Keeps tiled|floating|monocle layout
# Focus: cycle {next,prev} (tiled|floating|monocle|hidden)
super + alt + {j,k}
  bspc node -f {next,prev}.local.window

# Focus: {older,newer} node history
super + {o,i}
  bspc wm -h off; \
  bspc node -f {older,newer}; \
  bspc wm -h on

# Focus: last window (tiled|floating|monocle)
super + comma
  bspc node -f 'last.local.!hidden.window'

# Focus: {parent,first child}
# super + {less,greater}
#   bspc node -f @{parent,first}

# Kind of confusing
# Focus: {parent,brother,first child,second child}
super + ctrl + {n,m,comma,period}
  bspc node -f @{parent,brother,first,second}

# Action: {close,kill} window
alt + shift + {_,ctrl + }x
  bspc node -{c,k}

# Action: {close,kill} window
# super + alt + {_,ctrl + }x
#   bspc node -{c,k}

# (equivalent to minimizing)
# Action: (open|close) window with menu
super + m
  whid dmenu

# (equivalent to minimizing)
# Action: close window
super + shift + m
  whid hide

# Action: reopen last closed window
super + ctrl + m
  whid last

# Flag: set hidden=on
super + ctrl + u
  bspc node -g hidden

# Flag: set hidden=off (any.hidden)
super + ctrl + shift + u
  bspc node any.hidden -g hidden=off

# Flag: toggle {marked,locked,sticky,private}
super + ctrl + alt + {m,x,y,z}
  bspwm-toggle-state {marked,locked,sticky,private}
# bspc node -g {marked,locked,sticky,private}

# bspc node -t {tiled,pseudo_tiled,floating,fullscreen}
# ]]]

# ╭──────────────╮
# │ Preselection │
# ╰──────────────╯ [[[

# Transplant: current with preselected area
super + ctrl + shift + y
  bspc node -n last.!automatic.local

# Enters manual-tiling mode that splits the current node
# Preselect:  {left,down,up,right} (cancel)
super + ctrl + shift + {h,j,k,l}
  bspc node --presel-dir '~{west,south,north,east}'

# Preselect: cancel {current node,desktop}
super + ctrl + {_,shift +} c
  {bspc node -p cancel,bspc query -N -d | xargs -I id -n 1 bspc node id -p cancel}

# Preselect: auto detect direction (cancel)
super + ctrl + Return
  bspwm-auto-presel

# Preselect: set splitting ratio {1-9}
super + ctrl + shift + {1-9}
  bspc node -o 0.{1-9}
# ]]]
# ]]]

# ╭──────────────────────────────────────────────────────────╮
# │                         Desktop                          │
# ╰──────────────────────────────────────────────────────────╯ [[[

# DESKTOP_SEL :=
#
#   [DESKTOP_SEL#]
#     (CYCLE_DIR|any|last|newest|older|newer|
#         [MONITOR_SEL:](focused|^<n>)|
#         <desktop_id>|<desktop_name>
#     )[.[!]focused][.[!]active][.[!]occupied][.[!]urgent][.[!]local]

# Desktop: {focus,send to} ({1-9,0})
super + {_,alt + }{1-9,0}
  bspc {desktop -f,node -d} '^{1-9,10}'

# Desktop: send and follow ({1-9,0})
super + ctrl + alt + {1-9,0}
  bspc node -d '^{1-9,10}' --follow

# Desktop: focus {prev,next}
super + bracket{left,right}
  bspc desktop -f {prev,next}.local

# Desktop: focus {prev,next}
super + {Left,Right}
  bspc desktop -f {prev,next}.local

# Desktop: focus {prev,next} occupied
super + shift + bracket{left,right}
  bspc desktop -f {prev.occupied,next.occupied}

# Desktop: focus {prev,next} occupied
# super + shift + {Left,Right}
#   bspc desktop -f {prev.occupied,next.occupied}

# Desktop: transpose {without,with} following
super + {_, shift + }u
  bspc desktop --swap next.active {_,--follow}
# ]]]

# ╭──────────────────────────────────────────────────────────╮
# │                         Monitor                          │
# ╰──────────────────────────────────────────────────────────╯ [[[

# MONITOR_SEL :=
#
#   [MONITOR_SEL#]
#     (DIR|CYCLE_DIR|any|last|newest|older|newer|focused|pointed|primary|^<n>|
#      <monitor_id>|<monitor_name>
#     )[.[!]focused][.[!]occupied]
# ]]]

# Monitor: focus {prev,next} occupied
super + shift + {Left,Right}
  bspc monitor -f {prev,next}

# ╭──────────────────────────────────────────────────────────╮
# │                          Other                           │
# ╰──────────────────────────────────────────────────────────╯ [[[

# ╭─────────────╮
# │ Receptacles │
# ╰─────────────╯ [[[

# A leaf node that doesn’t hold any window.
# When a node is inserted on a receptacle in automatic mode, it will replace the receptacle.
# A receptacle can be inserted on a node, preselected and killed.

# mod3 + x ; n ; r
#     bspc node -i
# ]]]

# ╭──────────────────╮
# │ Continuous Input │
# ╰──────────────────╯ [[[

# Resize: {left,down,up,right} by 50 (float: sides in)
mod3 + c : {h,j,k,l}
  bspwm-resize {west,south,north,east} 50

# Gaps: dynamically {-,+} (continous)
mod3 + c : bracket{left,right}
  bspc config -d focused window_gap "$(($(bspc config -d focused window_gap) {-,+} 5 ))"

# (Alternative: Ctrl + Right Mouse | ctrl + alt + {h,j,k,l})
# Move: {left,down,up,right} arrow key (floating)
mod3 + c : {Left,Down,Up,Right}
  bspc node -v {-20 0,0 20,0 -20,20 0}
# ]]]

# ╭────────╮
# │ Launch │
# ╰────────╯ [[[

# Launch: alacritty
super + Return
  alacritty

# Launch: tdrop
super + alt + Return
  tdrop -ma -w 1916 -y 0 alacritty

# Launch: open URL in clipboard
super + ctrl + alt + o
  handlr open "$(xsel -b)"

# Launch: rofi application launcher
mod3 + d
  rofi -show drun

# Launch: rofi
# mod3 x ; {x,b}
#    rofi -show {drun,window}

# Launch: {librewolf,brave,mullvad-browser,chromium,pcmanfm,thunderbird,signal}
mod3 + {b,v,o,g,p,period,s}
  {librewolf,brave,mullvad-browser,chromium,pcmanfm,thunderbird,signal-desktop}

# Launch: prs rofi script
super + ctrl + alt + p
  prs-copy

# # Launch: prs dmenu script
# super + ctrl + alt + p
#   prs-dmenu

# Launch: greenclip history
ctrl + alt + y
  rofi-greenclip

# Launch: color picker epick
super + alt + c
  epick

# Launch: color picker xcolor
super + alt + v
  xcolor -s clipboard

# Launch: ncmpcpp
super + F1
  alacritty --class ncmpcpp -e 'ncmpcpp'
# $TERMINAL -e ncmpcpp

# amixer-notify "toggle"
# amixer-notify "set" "{5%-,5%+}"
# pulsevolctrl-notify "output-vol" "alsa_output.pci-0000_00_1f.3.hdmi-stereo" {+2%, -2%}
# pulsevolctrl-notify "output-mute" "alsa_output.pci-0000_00_1f.3.hdmi-stereo"

# Launch: mpd toggle {previous,stop,play/pause,next}
shift + XF86Audio{Prev,Play,Next}
  playerctl -p "mpd" {previous,play-pause,next}

# Launch: [last] active player toggle {play/pause,previous,next}
XF86Audio{Prev,Play,Next}
  playerctl {previous,play-pause,next}

# Launch: dunst {toggle,close} history
mod3 + {_,shift + }n
  dunstctl {history-pop,close-all}

# Launch: dunst action
mod3 + a
  dunstctl action

# Launch: fzf-bluetooth
super + F7
  alacritty --class fzf-bluetooth -e 'fzf-bluetooth'
# $TERMINAL -e "fzf-bluetooth" &

# Launch: mailsync
super + F8
  mailsync

# Launch: toggle caffeinate
super + F10
  togglecaffeine

# Launch: remap keys
F11
  remaps && dunstify "remaps" "remapped"

# Launch: neomutt
alt + F12
  alacritty --class neomutt -e 'neomutt'
# $TERMINAL -e neomutt
# ]]]

# ╭───────────────╮
# │ Miscellaneous │
# ╰───────────────╯ [[[

# ╭────────╮
# │ Tabbed │
# ╰────────╯ [[[
# Add to tabbed container
# ctrl + alt + {Left,Down,Up,Right}
#     tabc attach $(bspc query -N -n) {$(bspc query -N -n west),$(bspc query -N -n south),$(bspc query -N -n north),$(bspc query -N -n east)}

# Create/remove from tabbed container
# super + z
#     id=$(bspc query -N -n); \
#     [[ "$(tabc printclass $id)" == "tabbed" ]] \
#     && tabc detach $id \
#     || tabc create $id

# Toggle autoattach in tabbed container
# super + shift + z
#     tabc autoattach $(bspc query -N -n)
# ]]]

# Volume: computer speaker {toggle,-5%,+5%}
XF86Audio{Mute,LowerVolume,RaiseVolume}
  volume-notify '' {toggle,-5%,+5%}

# Volume: bluetooth speaker {toggle,-5%,+5%}
shift + XF86Audio{Mute,LowerVolume,RaiseVolume}
  volume-notify 'bluetooth' {toggle,-5%,+5%}

# Scrot:
# Print
#   scrot -u -z '%Y-%m-%d_%H:%M:%S_$wx$h$n.png' -e 'mv $f ~/Pictures'

# Screenshot: flameshot capture entire screen
Print
  flameshot full -p ~/Pictures/screenshot

# Screenshot: flameshot GUI
Print + shift
  flameshot gui

# Screenshot: flameshot capture single screen
Print + super
  flameshot screen -p ~/Pictures/screenshot

# Screenshot: maimpick
Print + ctrl
  maimpick

# Screenshot: entire screen
ctrl + shift + 3
  prtscr

# Screenshot: selected region
ctrl + shift + 4
  prtregion --disk

# Screenshot: focused window
ctrl + shift + 5
  prtwindow

# Screenshot: focused window
super + ctrl + alt + u
  prtwindow
# ]]]
# ]]]

# NOTE: the presence of the tilde ~.
# If current state matches the given state, then the argument is interpreted as the last state
# mod4 + {shift + space,space,f}
#   bspc node -t ~{tiled,floating,fullscreen}

# vim: ft=sxhkdrc:et:sw=0:ts=2:sts=2:fdm=marker:fmr=[[[,]]]: