413 lines
14 KiB
Lua
413 lines
14 KiB
Lua
-- ~/.config/hypr/functions.lua
|
|
local M = {}
|
|
|
|
-- focusOrLaunch: checks if a window with the given class exists.
|
|
-- If it does, focuses it (and sends specific shortcuts if it's qutebrowser).
|
|
-- If not, optionally switches to a workspace and launches the app.
|
|
function M.focusOrLaunch(app_cmd, class_name, workspace_name)
|
|
local clients = hl.get_windows()
|
|
local found = false
|
|
|
|
for _, client in ipairs(clients) do
|
|
if client.class == class_name then
|
|
hl.dispatch(hl.dsp.focus({ window = "class:" .. class_name }))
|
|
-- Specific qutebrowser logic ported from your zsh script
|
|
if app_cmd:match("qutebrowser") then
|
|
hl.dispatch(hl.dsp.send_shortcut({ mods = "", key = "Escape", window = "class:" .. class_name }))
|
|
hl.dispatch(hl.dsp.send_shortcut({ mods = "", key = "0", window = "class:" .. class_name }))
|
|
hl.dispatch(hl.dsp.send_shortcut({ mods = "", key = "1", window = "class:" .. class_name }))
|
|
hl.dispatch(hl.dsp.send_shortcut({ mods = "ALT", key = "J", window = "class:" .. class_name }))
|
|
hl.dispatch(hl.dsp.send_shortcut({ mods = "", key = "Escape", window = "class:" .. class_name }))
|
|
end
|
|
found = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if not found then
|
|
if workspace_name and #workspace_name > 0 then
|
|
hl.dispatch(hl.dsp.focus({ workspace = workspace_name }))
|
|
end
|
|
hl.dispatch(hl.dsp.exec_cmd(app_cmd))
|
|
end
|
|
end
|
|
|
|
function M.getActiveWorkspaceName()
|
|
local f = io.popen("hyprctl -j activeworkspace | jq -r '.name'")
|
|
local active_ws_name = f:read("*a"):gsub("%s+", "")
|
|
f:close()
|
|
return active_ws_name
|
|
end
|
|
|
|
function M.mv2workspace()
|
|
local cmd = [[
|
|
bash -c '
|
|
WORKSPACES=$(hyprctl -j workspaces | jq -r ".[] | .name")
|
|
ACTIVE="$(hyprctl -j activewindow)"
|
|
CLASS="$(jq -r ".class" <<< "$ACTIVE")"
|
|
TITLE="$(jq -r ".title" <<< "$ACTIVE")"
|
|
ADDR="$(jq -r ".address" <<< "$ACTIVE")"
|
|
PROMPT="Move window of ${CLASS} with title '\''${TITLE}'\'' to which workspace? "
|
|
NEW_WS="$(echo "$WORKSPACES" | rofi -dmenu -p "$PROMPT")"
|
|
if [ -n "$NEW_WS" ]; then
|
|
hyprctl dispatch "hl.dsp.window.move({ workspace = \"$NEW_WS\", window = \"address:$ADDR\", follow = false })"
|
|
fi
|
|
'
|
|
]]
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.createWorkspace(after_name)
|
|
local after_str = after_name or ""
|
|
local cmd = string.format([[
|
|
bash -c '
|
|
NEW_NAME=$(rofi -dmenu -p "new workspace name" -l 0 < /dev/null | tr -d "[:space:]")
|
|
if [ -z "$NEW_NAME" ]; then exit 0; fi
|
|
|
|
ACTIVE_MON=$(hyprctl -j monitors | jq -r ".[] | select(.focused) | .name")
|
|
NEW_LINE=" { name = \"$NEW_NAME\", monitor = \"$ACTIVE_MON\" },"
|
|
FILE="$HOME/.config/hypr/workspace_config.lua"
|
|
|
|
AFTER="%s"
|
|
|
|
if [ -n "$AFTER" ] && grep -q "name *= *\"$AFTER\"" "$FILE"; then
|
|
sed -i "/name *= *\"$AFTER\"/a \\$NEW_LINE" "$FILE"
|
|
else
|
|
sed -i "/^}/i \\$NEW_LINE" "$FILE"
|
|
fi
|
|
hyprctl reload
|
|
'
|
|
]], after_str)
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.deleteWorkspace()
|
|
local cmd = [[
|
|
bash -c '
|
|
ACTIVE_WS=$(hyprctl -j activeworkspace | jq -r ".name")
|
|
if [ -z "$ACTIVE_WS" ]; then exit 0; fi
|
|
FILE="$HOME/.config/hypr/workspace_config.lua"
|
|
sed -i "/name *= *\"$ACTIVE_WS\"/d" "$FILE"
|
|
hyprctl dispatch "hl.dsp.focus({ workspace = \"m-1\" })"
|
|
hyprctl reload
|
|
'
|
|
]]
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.moveWorkspace(direction, target_monitor)
|
|
-- If no target_monitor is provided and direction is nil, prompt interactively via async bash to avoid deadlocks
|
|
if (not target_monitor or target_monitor == "") and not direction then
|
|
local cmd = [[
|
|
bash -c '
|
|
ACTIVE_WS=$(hyprctl -j activeworkspace | jq -r ".name")
|
|
if [ -z "$ACTIVE_WS" ]; then exit 0; fi
|
|
MONITORS=$(hyprctl -j monitors | jq -r ".[].name")
|
|
PROMPT="Move workspace '\''$ACTIVE_WS'\'' to which monitor? "
|
|
NEW_MON=$(echo "$MONITORS" | rofi -dmenu -p "$PROMPT")
|
|
if [ -n "$NEW_MON" ]; then
|
|
FILE="$HOME/.config/hypr/workspace_config.lua"
|
|
sed -i -E "/name *= *\"$ACTIVE_WS\"/ s/monitor *= *\"[^\"]+\"/monitor = \"$NEW_MON\"/" "$FILE"
|
|
hyprctl reload
|
|
fi
|
|
'
|
|
]]
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
return
|
|
end
|
|
|
|
-- NATIVE LUA PATH for directional shifts or explicit monitor arguments passed from keybinds
|
|
local active_ws_name = M.getActiveWorkspaceName()
|
|
if not active_ws_name or active_ws_name == "" then return end
|
|
|
|
local path = os.getenv("HOME") .. "/.config/hypr/workspace_config.lua"
|
|
local f_in = io.open(path, "r")
|
|
if not f_in then return end
|
|
|
|
local lines = {}
|
|
local ws_idx = nil
|
|
|
|
for line in f_in:lines() do
|
|
table.insert(lines, line)
|
|
if line:match('name%s*=%s*"' .. active_ws_name .. '"') then
|
|
ws_idx = #lines
|
|
end
|
|
end
|
|
f_in:close()
|
|
|
|
if not ws_idx then return end
|
|
|
|
if target_monitor and target_monitor ~= "" then
|
|
lines[ws_idx] = lines[ws_idx]:gsub('monitor%s*=%s*"[^"]+"', 'monitor = "' .. target_monitor .. '"')
|
|
end
|
|
|
|
if direction then
|
|
local first_idx = 2
|
|
local last_idx = #lines - 1
|
|
|
|
while first_idx < #lines and not lines[first_idx]:match("name%s*=") do first_idx = first_idx + 1 end
|
|
while last_idx > 1 and not lines[last_idx]:match("name%s*=") do last_idx = last_idx - 1 end
|
|
|
|
if first_idx <= last_idx then
|
|
local current_line = table.remove(lines, ws_idx)
|
|
local new_idx = ws_idx
|
|
|
|
if direction > 0 then
|
|
new_idx = ws_idx + 1
|
|
if new_idx > last_idx then
|
|
new_idx = first_idx
|
|
end
|
|
elseif direction < 0 then
|
|
new_idx = ws_idx - 1
|
|
if new_idx < first_idx then
|
|
new_idx = last_idx
|
|
end
|
|
end
|
|
|
|
table.insert(lines, new_idx, current_line)
|
|
end
|
|
end
|
|
|
|
local f_out = io.open(path, "w")
|
|
for _, line in ipairs(lines) do
|
|
f_out:write(line .. "\n")
|
|
end
|
|
f_out:close()
|
|
|
|
hl.dispatch(hl.dsp.exec_cmd("hyprctl reload"))
|
|
end
|
|
|
|
function M.pasteMacro(script_path)
|
|
local cmd = string.format([[
|
|
bash -c '
|
|
exec > /tmp/paste.log 2>&1
|
|
out="$(%s)"
|
|
echo -n "$out" | wl-copy
|
|
|
|
# 1. Wait a moment for physical keys to be released
|
|
sleep 0.3
|
|
# 2. Release modifiers logically, then execute CTRL+V
|
|
wtype -m logo -m ctrl -m shift -m alt -M ctrl -k v -m ctrl
|
|
|
|
# 3. Wait a full second to ensure Wayland apps finish reading the clipboard asynchronously
|
|
sleep 1.0
|
|
|
|
# 4. Scrub the password from cliphist securely
|
|
PREV=$(cliphist list | awk "NR==2")
|
|
cliphist list | awk "NR==1" | cliphist delete
|
|
if [ -n "$PREV" ]; then
|
|
echo "$PREV" | cliphist decode | wl-copy
|
|
else
|
|
wl-copy -c
|
|
fi
|
|
'
|
|
]], script_path)
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.pasteText(text)
|
|
local cmd = string.format([[
|
|
bash -c '
|
|
exec &> /tmp/$(date +%%FT%%H%%M%%S)_paste.log
|
|
echo -n "%s" | wl-copy
|
|
|
|
# Wait a moment for physical keys to be released, then execute CTRL+V
|
|
sleep 0.3
|
|
wtype -m logo -m ctrl -m shift -m alt -M ctrl -k v -m ctrl
|
|
# Note: We do not scrub cliphist here because dates are not sensitive passwords,
|
|
# which completely eliminates the paste race condition for dates!
|
|
'
|
|
]], text)
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.timetracker()
|
|
local cmd = [[
|
|
bash -c '
|
|
CHOICE=$(echo -e "Begin...\nEnd..." | rofi -dmenu -theme-str "inputbar {enabled: false;}" -i -matching prefix -auto-select -l 2)
|
|
if [ "$CHOICE" = "Begin..." ]; then
|
|
DATE_STR=$(date "+%F %T")
|
|
wtype -m logo -m ctrl -m shift -m alt -k Escape
|
|
wtype "I${DATE_STR}: Begin "
|
|
elif [ "$CHOICE" = "End..." ]; then
|
|
DATE_STR=$(date "+%F %T")
|
|
wtype -m logo -m ctrl -m shift -m alt -k Escape
|
|
wtype "I${DATE_STR}: End "
|
|
wtype -k Escape
|
|
wtype "kly\$jpo"
|
|
wtype "${DATE_STR}: Begin "
|
|
fi
|
|
'
|
|
]]
|
|
hl.dispatch(hl.dsp.exec_cmd(cmd))
|
|
end
|
|
|
|
function M.randomizeWallpaper()
|
|
local monitors = hl.get_monitors()
|
|
local home = os.getenv("HOME")
|
|
local april_dir = home .. "/images/April"
|
|
local sbm_dir = home .. "/images/Seven Beats Music"
|
|
local black_png = home .. "/images/black.png"
|
|
|
|
-- Determine if we are on the home WiFi ("keep")
|
|
local is_home_wifi = false
|
|
local f = io.popen("iwgetid -r 2>/dev/null")
|
|
if f then
|
|
local ssid = f:read("*a")
|
|
f:close()
|
|
if ssid and ssid:match("keep") then
|
|
is_home_wifi = true
|
|
end
|
|
end
|
|
|
|
-- Select image source based on location
|
|
local img_dir = april_dir
|
|
if #monitors > 1 then
|
|
img_dir = sbm_dir
|
|
elseif is_home_wifi then
|
|
img_dir = april_dir
|
|
end
|
|
|
|
local images = {}
|
|
local handle = io.popen('find "' .. img_dir .. '" -type f \\( -iname "*.jpg" -o -iname "*.png" -o -iname "*.jpeg" \\) 2>/dev/null')
|
|
if handle then
|
|
for line in handle:lines() do
|
|
table.insert(images, line)
|
|
end
|
|
handle:close()
|
|
end
|
|
|
|
if #images == 0 then
|
|
table.insert(images, black_png)
|
|
end
|
|
|
|
local conf_lines = {
|
|
"ipc = on",
|
|
"splash = false",
|
|
""
|
|
}
|
|
|
|
-- Pick a unique random image for each monitor
|
|
math.randomseed(os.time())
|
|
local used = {}
|
|
local matugen_cmds = {}
|
|
local primary_logical_name = "eDP-1"
|
|
for _, mon in ipairs(monitors) do
|
|
if mon.description and mon.description:match("E3LMTF071391") then
|
|
primary_logical_name = "DP-8"
|
|
end
|
|
end
|
|
|
|
for _, mon in ipairs(monitors) do
|
|
local img = nil
|
|
local attempts = 0
|
|
while attempts < #images do
|
|
local idx = math.random(1, #images)
|
|
if not used[idx] then
|
|
img = images[idx]
|
|
used[idx] = true
|
|
break
|
|
end
|
|
attempts = attempts + 1
|
|
end
|
|
if not img then img = images[1] end -- fallback if we run out of unique images
|
|
|
|
if img then
|
|
table.insert(conf_lines, "wallpaper {")
|
|
table.insert(conf_lines, " monitor = " .. mon.name)
|
|
table.insert(conf_lines, " path = " .. img)
|
|
table.insert(conf_lines, " fit_mode = cover")
|
|
table.insert(conf_lines, "}")
|
|
table.insert(conf_lines, "")
|
|
|
|
local logical_name = mon.name
|
|
if mon.description then
|
|
if mon.description:match("E3LMTF071438") then logical_name = "DP-7" end
|
|
if mon.description:match("E3LMTF071391") then logical_name = "DP-8" end
|
|
end
|
|
local matugen_cmd = "matugen image '" .. img .. "' -c /home/trey/src/dotfiles/matugen/matugen-" .. logical_name .. ".toml --source-color-index 0"
|
|
|
|
-- Push primary monitor to the end of the array so its global configs (like tmux) overwrite the others
|
|
if logical_name == primary_logical_name then
|
|
table.insert(matugen_cmds, matugen_cmd)
|
|
else
|
|
table.insert(matugen_cmds, 1, matugen_cmd)
|
|
end
|
|
end
|
|
end
|
|
|
|
if #matugen_cmds > 0 then
|
|
local all_cmds = table.concat(matugen_cmds, " ; ")
|
|
local reload_cmd = M.reloadAppsCmd()
|
|
hl.dispatch(hl.dsp.exec_cmd("bash -c \"" .. all_cmds .. " ; " .. reload_cmd .. "\""))
|
|
end
|
|
|
|
local c = io.open(home .. "/.config/hypr/hyprpaper.conf", "w")
|
|
if c then
|
|
c:write(table.concat(conf_lines, "\n"))
|
|
c:close()
|
|
end
|
|
|
|
-- Restart hyprpaper natively to avoid uwsm systemd rate limits on rapid monitor hotplugs
|
|
hl.dispatch(hl.dsp.exec_cmd("killall -q hyprpaper; sleep 0.2; hyprpaper &"))
|
|
end
|
|
|
|
function M.reloadAppsCmd()
|
|
-- Return a shell command to reload apps that don't auto-reload (executed sequentially after matugen)
|
|
local cmds = {
|
|
"tmux source ~/.config/tmux/tmux.conf",
|
|
"for pane in $(tmux list-panes -a -F '#{pane_id} #{pane_current_command}' | awk '$2 == \"vim\" {print $1}'); do tmux send-keys -t $pane Escape ':colorscheme matugen' Enter; done",
|
|
"killall -q -USR1 zsh"
|
|
}
|
|
return table.concat(cmds, " ; ")
|
|
end
|
|
|
|
function M.setupMonitors()
|
|
-- Automatically handle the wallpaper update natively
|
|
M.randomizeWallpaper()
|
|
|
|
local monitors = hl.get_monitors()
|
|
local logical_to_physical = {
|
|
["eDP-1"] = "eDP-1"
|
|
}
|
|
|
|
for _, mon in ipairs(monitors) do
|
|
if mon.description then
|
|
if mon.description:match("E3LMTF071438") then logical_to_physical["DP-7"] = mon.name end
|
|
if mon.description:match("E3LMTF071391") then logical_to_physical["DP-8"] = mon.name end
|
|
end
|
|
end
|
|
|
|
local home = os.getenv("HOME")
|
|
for logical, physical in pairs(logical_to_physical) do
|
|
local config_path = home .. "/.config/waybar/config-" .. logical .. ".jsonc"
|
|
local f = io.open(config_path, "r")
|
|
if f then
|
|
local content = f:read("*a")
|
|
f:close()
|
|
-- Replace any existing output value with the actual physical monitor name
|
|
content = content:gsub('"output":%s*"[^"]+"', '"output": "' .. physical .. '"')
|
|
local w = io.open(config_path, "w")
|
|
if w then
|
|
w:write(content)
|
|
w:close()
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Dynamically spawn waybar only for connected monitors, and use a robust kill sequence
|
|
-- inside the background script to prevent race conditions during rapid hotplug events
|
|
local waybar_cmds = {
|
|
"killall -q waybar",
|
|
"sleep 0.5",
|
|
"killall -q waybar"
|
|
}
|
|
for logical, _ in pairs(logical_to_physical) do
|
|
table.insert(waybar_cmds, string.format("nohup waybar -c ~/.config/waybar/config-%s.jsonc -s ~/.config/waybar/style-%s.css >/dev/null 2>&1 &", logical, logical))
|
|
end
|
|
|
|
hl.dispatch(hl.dsp.exec_cmd("bash -c '" .. table.concat(waybar_cmds, "\n") .. "'"))
|
|
end
|
|
|
|
return M
|