Jumping directionally between floating windows

[torgeir]

If I have two floating windows close to each other, can I somehow easily jump from one to the other, preferably using "directional commands" rather than cycling through all floating windows, similarly to how I would yabai -m window --focus west (to move to the window left of the focused one) if they were tiled?

Edit: typo

[asmvik]

The directional commands only apply to managed windows. You'd have to script something yourself using the query system. I believe something like this has been done previously in one of the closed issues, but I don't remember what to search for to locate it.

docs for query: https://github.com/koekeishiya/yabai/blob/master/doc/yabai.asciidoc#query

[torgeir]

A variant of this might work #1326

[torgeir]

Here's take 1, that does not jump directionally, but rather cycles windows that are floating, if the script is run from a floating window. If it is run from a tiled window it will jump between tiled windows.

is_float=$(yabai -m query --windows --window | jq '."is-floating"')

if [ "$is_float" = "true" ]; then
  yabai -m window --focus $(yabai -m query --windows | \
    jq -e --argjson pos 1 '(.[] | select(."has-focus")) as {$id, $app}
      | map(select(."is-floating" == true))
      | sort_by(.space, .frame.x, .frame.y)
      | map(.id)
      | .[(index($id)+($pos))%length]')
else
  yabai -m window --focus east  || yabai -m display --focus east
fi

Edit: Change 1 to -1 to move in the other direction. I put this in a script and bind it like this

alt - h : ~/bin/yabai-left.sh
alt - l : ~/bin/yabai-right.sh

[AlgusDark]

You could also make only one script and pass the $pos

#!/bin/zsh

while [[ "$#" -gt 0 ]]
  do
    case $1 in
      -f|--focus)
        if [ "$2" = "prev" ]
        then
          pos=-1
        else
          pos=1
        fi
        ;;
    esac
    shift
  done

pos=${pos:-1}

focus="$(yabai -m query --windows | \
    jq -e --argjson pos $pos '
      first(.[] | select(."has-focus")) as {id:$id, space:$space}
        | map( select( ."is-floating" and .space == $space) )
        | sort_by(.frame.x, .frame.y)
        | map(.id)
        | .[( (index($id) // if $pos == 1 then -1 else length end) + $pos ) % length]
    ')"

yabai -m window --focus "$focus"

Then I just do it like:

lalt - u : "$SKHD_SCRIPTS_DIR/cycle_app" --focus prev
lalt - o : "$SKHD_SCRIPTS_DIR/cycle_app" --focus next

[thalesmello]

I particularly wanted a directional window navigation that would ignore any windows hiding behind other windows. It took a while, but after spending enough time on jq, I finally got it working. I'm sharing it here in case it would help anyone.

yabai -m query --windows --space | jq --arg dir "$direction" '
        def hidden($under; $above):
        ($under.x >= $above.x
        and ($under.x + $under.w) <=($above.x + $above.w)
        and $under.y >= $above.y
        and ($under.y + $under.h) <= ($above.y + $above.h));
        def intersect($under; $above):
        $above |
        [[.x, .y], [.x+.w, .y], [.x, .y+.h], [.x+.w,.y+.h]]
        | map(. as [$x, $y] | {$x, $y})
        | first(.[] | select(
                ($under.x < .x)
                and (.x < $under.x + $under.w)
                and ($under.y < .y)
                and (.y < $under.y + $under.h)));

        def visible_area($under_list; $many):
        $under_list
        | [.[0], .[1:]] as [$under, $tail]
        | debug({$under, $tail, $many})
        | if $under == null then 0
        elif ($many | any(hidden($under; .))) then visible_area($tail; $many)
        else (
                [first($many[] | intersect($under; .))] as [$intersect]
                | if $intersect == null then (($under.w * $under.h) + visible_area($tail; $many))
                else visible_area(([
                        {x: $under.x, y: $under.y, w: ($intersect.x - $under.x), h: ($intersect.y - $under.y)},
                        {x: $intersect.x, y: $under.y, w: ($under.w - $intersect.x + $under.x), h: ($intersect.y - $under.y)},
                        {x: $under.x, y: $intersect.y, w: ($intersect.x - $under.x), h: ($under.h - $intersect.y + $under.y)},
                        {x: $intersect.x, y: $intersect.y, w: ($under.w - $intersect.x + $under.x), h: ($under.h - $intersect.y + $under.y)}
                ]|map(select((.h>0) and (.w>0)))) + $tail; $many) end
        )
        end;
        .
        | map(select(."is-visible" and (."is-sticky"|not)))
        | reverse
        | { under: .[0], many: .[1:] }
        | [recurse({ under: .many[0], many: .many[1:] }; .under != null)]
        | map(.under.visible_area = visible_area([.under.frame]; .many|map(.frame)))
        | map(.under)
        | map(.percentage_visible = (.visible_area / (.frame|.w*.h)))
        | map(select(.percentage_visible > 0.01))
        | (first(.[] | select(."has-focus")) // .[-1]) as {$id, $title, frame: $zero}
        | sort_by(
if $dir == "east" then [.frame.x, .id]
elif $dir == "west" then [-.frame.x, -.id]
elif $dir == "south" then [.frame.y, .id]
elif $dir == "north" then [-.frame.y, -.id]
end
        )
        | .[(map(.id) | index($id))+1:]
        | map(.zero = $zero | .zero_title = $title)
        | map(.distance = 
        if ($dir == "east" or $dir == "west") then ((.frame.x - $zero.x|abs) + pow(.frame.y - $zero.y; 2))
        elif ($dir == "north" or $dir == "south") then ((.frame.y - $zero.y|abs) + pow(.frame.x - $zero.x; 2))
        end
        )
        | sort_by(.distance)
        | first.id'

The above script will output the id of the window in the current space that has a part of it visible on the screen that is in the direction of the $dir variable.

[GladioFeng]

outstanding