dotfiles/env/.local/scripts/hypr/launch

#!/usr/bin/env bash

THIS_FILE=${BASH_SOURCE[0]}
THIS=$(basename "$THIS_FILE")

usage() {
  cat <<EOF

Launch or focus / close a window based on pattern contained within the window
class name. (Default is to focus the window). 

This is used in keybinds and by other scripts as a general entrypoint for managing applications.

USAGE:

  $ $THIS [OPTIONS] PATTERN [LAUNCH_CMD...]

OPTIONS:

  -f | --or-focus:           Focus the window matching the pattern, if it exists.
  -c | --or-close:           Close the window matching the pattern, if it exists.
  -o | --focus-active-only:  Focus only if window is on active workspace, otherwise launch a new
                             instance.
  -x | --close-active-only:  Close only windows on active workspace matching the pattern.
  -s | --special <name>:     Launch or toggle a special workspace.
  -n | --new-instance:       Launch a new instance of an application.
  -h | --help:               Show this help page.

NOTES:

In general only one flag should be passed to determine the action mode.

Passing both any of the close or focus flags together will result in an error if a window is found matching
the pattern, if no window is found then one will still be launched without any errors.

If the special option is passed then we will not attempt to close a window. If the script is
invoked with the special option set, we check if there is a window matching the pattern, if there
is and the currently active window is on the same workspace passed in to the special option, then
we toggle the workspace closed.  This allows the same keybind to be used to launch an application
in a special workspace as well as toggle the workspace closed.

EOF
}

action="focuswindow"
close_flag="0"
close_active_only_flag="0"
focus_flag="0"
focus_active_only_flag="0"
new_instance_flag="0"
launch_cmd=()
pattern=""
special_flag="0"
special=""
SCRIPTS=${SCRIPTS:-$HOME/.local/scripts}

while [[ $# -gt 0 ]]; do
  if [[ $1 == "-c" ]] || [[ $1 == "--or-close" ]]; then
    close_flag="1"
    action="closewindow"
  elif [[ $1 == "-f" ]] || [[ $1 == "--or-focus" ]]; then
    focus_flag="1"
    action="focuswindow"
  elif [[ $1 == "-s" ]] || [[ $1 == "--special" ]]; then
    shift
    special_flag="1"
    special=$1
  elif [[ $1 == "-o" ]] || [[ $1 == "--focus-active-only" ]]; then
    focus_flag="1"
    focus_active_only_flag="1"
    action="focuswindow"
  elif [[ $1 == "-x" ]] || [[ $1 == "--close-active-only" ]]; then
    close_flag="1"
    close_active_only_flag="1"
    action="closewindow"
  elif [[ $1 == "-n" ]] || [[ $1 == "--new-instance" ]]; then
    new_instance_flag="1"
  elif [[ $1 == "-h" ]] || [[ $1 == "--help" ]]; then
    usage && exit 0
  elif [[ -z $pattern ]]; then
    pattern=$1
  else
    launch_cmd+=("$1")
  fi
  shift
done

log() {
  logging log --source "$THIS_FILE" "$@"
}

# Redirects all output of hyprctl dispatch commands.
hypr_dispatch() {
  hyprctl dispatch "$@" >/dev/null 2>&1
}

toggle_special() {
  if [[ -z $special ]]; then
    log --error " No name supplied for special workspace."
    exit 1
  fi
  hypr_dispatch togglespecialworkspace $special
}

launch_application() {
  log "Launching..."
  log "'${launch_cmd[@]}'"
  eval exec ${launch_cmd[@]}
}

################################################################################
# MAIN
################################################################################

# Setup logging file and label
source "$SCRIPTS/hypr/logging"
setup-logging "/tmp/$THIS.log" "$THIS"

if [[ -z $pattern ]]; then
  log --error "Must supply a pattern to match the window class."
  usage && exit 1
elif [[ -z $launch_cmd ]]; then
  log --error "Must supply a launch command to match the window class."
  usage && exit 1
fi

log "Pattern: $pattern"
addresses=$(hyprctl clients -j | jq ".[] | select(.class | contains(\"$pattern\")) | .address")

# If no addresses, then launch the application.
if [[ -z $addresses ]] || [[ $new_instance_flag == "1" ]]; then
  log "No addresses found or new instance flag set."
  # Toggle special workspace if applicable.
  if [[ $special_flag == "1" ]]; then
    log "Toggling special workspace."
    toggle_special
  fi
  launch_application && exit 0
fi

active_window_workspace=$(hyprctl activewindow -j | jq -r '.workspace.name')

# Check if we have special flag and active window is on the special workspace.  If so
# we just toggle the special workspace.  This keeps "special" apps alive, but closes and / opens
# the special workspace when invoked.
if [[ $special_flag == "1" ]] && [[ $active_window_workspace =~ $special ]]; then
  toggle_special && exit 0
fi

# Check if both close and focus flags were passed, so we don't do the
# wrong thing.
if [[ $focus_flag == "1" ]] && [[ $close_flag == "1" ]]; then
  log --error "Both focus and close flag were passed."
  exit 1
fi

for address in ${addresses[@]}; do
  # Clean the address of quotes.
  address=${address//\"/}
  log "Handling address: '$address'"

  if [[ $focus_active_only_flag == "1" ]] || [[ $close_active_only_flag == "1" ]]; then
    # get the workspace name for the address.
    workspace=$(hyprctl clients -j | jq -r ".[] | select(.address == \"$address\") | .workspace.name")

    # check that the window is on the active workspace.
    if [[ $active_window_workspace == $workspace ]]; then
      log "Performing action: '$action', on window: '$address'"
      hypr_dispatch $action "address:$address"
      # early out if focusing a window.
      [[ $focus_active_only_flag ]] && exit 0
    else
      # the window is not on the active workspace, so skip it.
      log "Skipping window: $address"
    fi
  else
    # We don't have the focus_active_only_flag or close_active_only_flag set, so we perform
    # the action on the window.
    log "Performing action: '$action', on window: '$address'"
    hypr_dispatch $action "address:$address"
  fi
done

# If we made it here and focus_active_only_flag was set, then we did not
# find a window on the active workspace, so we launch a new window.
if [[ $focus_active_only_flag == "1" ]]; then
  launch_application
fi