282 lines
9.6 KiB
Bash
Executable File
282 lines
9.6 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# focus - small window helpers for xfwm4
|
|
# focus next|prev move focus right/left through windows (stops at the ends)
|
|
# focus up|down focus the nearest window directly above/below, if any
|
|
# focus tile master/stack tiling: active window left, the rest stacked right
|
|
# (a single window is simply maximized)
|
|
# Deps: wmctrl xdotool xprop xwininfo
|
|
set -u
|
|
|
|
# ---- config -----------------------------------------------------------------
|
|
MASTER_RATIO=50 # master width as % of the usable width
|
|
GAP=0 # px between windows and around the screen edge
|
|
USE_WORKAREA=1 # 1 = ask xfwm4 for the usable area (already excludes panels)
|
|
PANEL_TOP=0 # extra px to keep free on each side; if USE_WORKAREA=0,
|
|
PANEL_BOTTOM=0 # put your panel sizes here instead
|
|
PANEL_LEFT=0
|
|
PANEL_RIGHT=0
|
|
SETTLE=0.05 # seconds to let xfwm4 finish un-maximizing before moving
|
|
VERIFY=1 # 1 = measure each window afterwards and fix pixel offsets
|
|
VERIFY_TRIES=2 # correction passes per window
|
|
|
|
# ---- generic helpers --------------------------------------------------------
|
|
die() { echo "${0##*/}: $*" >&2; exit 1; }
|
|
usage() { echo "usage: ${0##*/} next|prev|up|down|tile" >&2; exit 1; }
|
|
|
|
# window geometry from wmctrl, keyed by id (filled by collect_windows)
|
|
declare -A GX GY GW GH
|
|
|
|
need() {
|
|
local c
|
|
for c in "$@"; do command -v "$c" >/dev/null || die "missing dependency: $c"; done
|
|
}
|
|
|
|
# Active window id in wmctrl's 0x%08x format (0x00000000 if none)
|
|
active_window() {
|
|
local d
|
|
d=$(xdotool getactivewindow 2>/dev/null) || d=0
|
|
printf '0x%08x' "$d"
|
|
}
|
|
|
|
# index_of ID -> prints index in WINS, or -1
|
|
index_of() {
|
|
local i
|
|
for i in "${!WINS[@]}"; do
|
|
[[ ${WINS[i]} == "$1" ]] && { echo "$i"; return; }
|
|
done
|
|
echo -1
|
|
}
|
|
|
|
# collect_windows focus|tile -> fills WINS, ordered left to right on screen
|
|
# (then top to bottom), so "next" moves right and "prev" moves left.
|
|
# focus: normal windows + dialogs, minimized included (focusing restores them)
|
|
# vert: normal windows + dialogs, minimized skipped (they have no real position)
|
|
# tile: normal windows only, minimized skipped
|
|
collect_windows() {
|
|
local mode=$1 cur id desk x y w h props
|
|
local -a found=()
|
|
cur=$(xdotool get_desktop) || die "cannot read current desktop"
|
|
WINS=()
|
|
while read -r id desk x y w h _; do
|
|
[[ $desk == "$cur" || $desk == -1 ]] || continue # this desktop or sticky
|
|
props=$(xprop -id "$id" _NET_WM_WINDOW_TYPE _NET_WM_STATE 2>/dev/null) || continue
|
|
|
|
if [[ $props == *"_NET_WM_WINDOW_TYPE(ATOM)"* ]]; then
|
|
if [[ $mode == tile ]]; then
|
|
[[ $props == *_NET_WM_WINDOW_TYPE_NORMAL* ]] || continue
|
|
else
|
|
[[ $props == *_NET_WM_WINDOW_TYPE_NORMAL* || $props == *_NET_WM_WINDOW_TYPE_DIALOG* ]] || continue
|
|
fi
|
|
fi
|
|
[[ $props == *_NET_WM_STATE_SKIP_TASKBAR* ]] && continue # panels, desktop, notifyd
|
|
[[ $mode != focus && $props == *_NET_WM_STATE_HIDDEN* ]] && continue
|
|
|
|
GX[$id]=$x GY[$id]=$y GW[$id]=$w GH[$id]=$h
|
|
|
|
found+=("$x $y $id")
|
|
done < <(wmctrl -lG)
|
|
|
|
(( ${#found[@]} )) || return 0
|
|
while read -r _ _ id; do WINS+=("$id"); done < <(printf '%s\n' "${found[@]}" | sort -n -k1,1 -k2,2)
|
|
}
|
|
|
|
# ---- focus ------------------------------------------------------------------
|
|
focus_cycle() {
|
|
local dir=$1 n idx
|
|
collect_windows focus
|
|
n=${#WINS[@]}
|
|
(( n > 0 )) || return 0
|
|
|
|
idx=$(index_of "$(active_window)")
|
|
if (( idx < 0 )); then
|
|
# nothing of ours focused (desktop/panel): enter at the matching end
|
|
[[ $dir == next ]] && idx=0 || idx=$(( n - 1 ))
|
|
elif [[ $dir == next ]]; then
|
|
(( idx < n - 1 )) || return 0 # already rightmost: stop, no wrap
|
|
(( idx += 1 ))
|
|
else
|
|
(( idx > 0 )) || return 0 # already leftmost: stop, no wrap
|
|
(( idx -= 1 ))
|
|
fi
|
|
wmctrl -ia "${WINS[idx]}"
|
|
}
|
|
|
|
# focus_vertical up|down -- nearest window straight above/below the active one.
|
|
# "Straight above/below" = shares some horizontal span with it. No match: do nothing.
|
|
focus_vertical() {
|
|
local dir=$1 act id ax1 ax2 acy cy dy best="" best_dy=-1
|
|
collect_windows vert
|
|
act=$(active_window)
|
|
[[ -n ${GX[$act]+x} ]] || return 0
|
|
|
|
ax1=${GX[$act]}; ax2=$(( ax1 + GW[$act] ))
|
|
acy=$(( GY[$act] + GH[$act] / 2 ))
|
|
|
|
for id in "${WINS[@]}"; do
|
|
[[ $id == "$act" ]] && continue
|
|
(( GX[$id] < ax2 && GX[$id] + GW[$id] > ax1 )) || continue # no horizontal overlap
|
|
cy=$(( GY[$id] + GH[$id] / 2 ))
|
|
if [[ $dir == up ]]; then dy=$(( acy - cy )); else dy=$(( cy - acy )); fi
|
|
(( dy > 0 )) || continue # wrong side
|
|
if (( best_dy < 0 || dy < best_dy )); then best=$id best_dy=$dy; fi
|
|
done
|
|
|
|
[[ -n $best ]] && wmctrl -ia "$best"
|
|
return 0
|
|
}
|
|
|
|
# ---- geometry helpers -------------------------------------------------------
|
|
# workarea -> WA_X WA_Y WA_W WA_H (usable rectangle on this desktop)
|
|
workarea() {
|
|
local cur raw i
|
|
local -a a
|
|
cur=$(xdotool get_desktop)
|
|
raw=$(xprop -root _NET_WORKAREA 2>/dev/null)
|
|
if (( USE_WORKAREA )) && [[ $raw == *=* ]]; then
|
|
IFS=', ' read -r -a a <<< "${raw#*= }"
|
|
i=$(( cur * 4 ))
|
|
(( i + 3 < ${#a[@]} )) || i=0
|
|
WA_X=${a[i]} WA_Y=${a[i+1]} WA_W=${a[i+2]} WA_H=${a[i+3]}
|
|
else
|
|
read -r WA_W WA_H < <(xdotool getdisplaygeometry)
|
|
WA_X=0 WA_Y=0
|
|
fi
|
|
(( WA_X += PANEL_LEFT, WA_Y += PANEL_TOP,
|
|
WA_W -= PANEL_LEFT + PANEL_RIGHT, WA_H -= PANEL_TOP + PANEL_BOTTOM ))
|
|
}
|
|
|
|
# frame_extents ID -> FL FR FT FB (decoration size; 0 if not reported)
|
|
frame_extents() {
|
|
local raw
|
|
FL=0 FR=0 FT=0 FB=0
|
|
raw=$(xprop -id "$1" _NET_FRAME_EXTENTS 2>/dev/null) || return 0
|
|
[[ $raw == *=* ]] && IFS=', ' read -r FL FR FT FB <<< "${raw#*= }"
|
|
}
|
|
|
|
# client_position ID -> CX CY (real on-screen top-left of the client area)
|
|
client_position() {
|
|
read -r CX CY < <(xwininfo -id "$1" 2>/dev/null | awk '
|
|
/Absolute upper-left X/ {x=$NF} /Absolute upper-left Y/ {y=$NF}
|
|
END {print x+0, y+0}')
|
|
}
|
|
|
|
# ---- window actions ---------------------------------------------------------
|
|
# Drop states that make xfwm4 ignore move/resize (maximized, xfwm4 edge-tiling, fullscreen, shaded)
|
|
reset_state() {
|
|
wmctrl -ir "$1" -b remove,maximized_vert,maximized_horz
|
|
wmctrl -ir "$1" -b remove,fullscreen,shaded
|
|
}
|
|
|
|
# maximize ID -- clear fullscreen/shaded, then set the WM's maximized state
|
|
maximize() {
|
|
wmctrl -ir "$1" -b remove,fullscreen,shaded
|
|
wmctrl -ir "$1" -b add,maximized_vert,maximized_horz
|
|
wmctrl -ia "$1"
|
|
}
|
|
|
|
# place ID X Y W H -- X Y W H is the OUTER rectangle including decorations
|
|
place() {
|
|
local id=$1 x=$2 y=$3 w=$4 h=$5 cw ch
|
|
frame_extents "$id"
|
|
cw=$(( w - FL - FR )); (( cw < 1 )) && cw=1
|
|
ch=$(( h - FT - FB )); (( ch < 1 )) && ch=1
|
|
# gravity 1 (NorthWest): x,y = top-left of the frame, w,h = client size
|
|
wmctrl -ir "$id" -e "1,$x,$y,$cw,$ch"
|
|
}
|
|
|
|
# verify ID X Y W H -- measure where the window really landed and nudge it if off
|
|
verify() {
|
|
local id=$1 x=$2 y=$3 w=$4 h=$5 try dx dy
|
|
for (( try = 0; try < VERIFY_TRIES; try++ )); do
|
|
frame_extents "$id"
|
|
client_position "$id"
|
|
dx=$(( CX - (x + FL) ))
|
|
dy=$(( CY - (y + FT) ))
|
|
(( dx == 0 && dy == 0 )) && return 0
|
|
place "$id" $(( x - dx )) $(( y - dy )) "$w" "$h"
|
|
sleep "$SETTLE"
|
|
done
|
|
}
|
|
|
|
# ---- layout -----------------------------------------------------------------
|
|
# layout_master_stack N -> fills RECTS with "x y w h" outer rectangles, index 0 = master
|
|
# Integer remainders are handed out so the tiles cover the area exactly, no 1px gaps.
|
|
layout_master_stack() {
|
|
local n=$1 x0 y0 w0 h0 mw sw sx avail base rem i y hh
|
|
RECTS=()
|
|
x0=$(( WA_X + GAP )); y0=$(( WA_Y + GAP ))
|
|
w0=$(( WA_W - 2 * GAP )); h0=$(( WA_H - 2 * GAP ))
|
|
|
|
if (( n == 1 )); then
|
|
RECTS+=("$x0 $y0 $w0 $h0")
|
|
return
|
|
fi
|
|
|
|
mw=$(( (w0 - GAP) * MASTER_RATIO / 100 ))
|
|
sw=$(( w0 - GAP - mw ))
|
|
sx=$(( x0 + mw + GAP ))
|
|
RECTS+=("$x0 $y0 $mw $h0")
|
|
|
|
(( n -= 1 ))
|
|
avail=$(( h0 - (n - 1) * GAP ))
|
|
base=$(( avail / n )); rem=$(( avail % n ))
|
|
y=$y0
|
|
for (( i = 0; i < n; i++ )); do
|
|
hh=$(( base + (i < rem ? 1 : 0) ))
|
|
RECTS+=("$sx $y $sw $hh")
|
|
(( y += hh + GAP ))
|
|
done
|
|
}
|
|
|
|
# ---- tile -------------------------------------------------------------------
|
|
tile() {
|
|
local n idx master i
|
|
(( VERIFY )) && need xwininfo
|
|
collect_windows tile
|
|
n=${#WINS[@]}
|
|
(( n > 0 )) || return 0
|
|
|
|
# only one window: let xfwm4 maximize it (real maximized state, not fullscreen)
|
|
if (( n == 1 )); then
|
|
maximize "${WINS[0]}"
|
|
return 0
|
|
fi
|
|
|
|
# active window becomes master, the rest keep their order in the stack
|
|
idx=$(index_of "$(active_window)")
|
|
if (( idx > 0 )); then
|
|
master=${WINS[idx]}
|
|
WINS=("$master" "${WINS[@]:0:idx}" "${WINS[@]:idx+1}")
|
|
fi
|
|
|
|
workarea
|
|
layout_master_stack "$n"
|
|
|
|
for i in "${!WINS[@]}"; do reset_state "${WINS[i]}"; done
|
|
sleep "$SETTLE"
|
|
|
|
for i in "${!WINS[@]}"; do
|
|
# shellcheck disable=SC2086
|
|
place "${WINS[i]}" ${RECTS[i]}
|
|
done
|
|
|
|
if (( VERIFY )); then
|
|
sleep "$SETTLE"
|
|
for i in "${!WINS[@]}"; do
|
|
# shellcheck disable=SC2086
|
|
verify "${WINS[i]}" ${RECTS[i]}
|
|
done
|
|
fi
|
|
|
|
wmctrl -ia "${WINS[0]}"
|
|
}
|
|
|
|
# ---- main -------------------------------------------------------------------
|
|
need wmctrl xdotool xprop
|
|
case ${1:-next} in
|
|
next|prev) focus_cycle "${1:-next}" ;;
|
|
up|down) focus_vertical "$1" ;;
|
|
tile) tile ;;
|
|
*) usage ;;
|
|
esac
|