How to Find and Grid Windows of a Specific Application – Bash Scripting

bashscriptswindow-managerwmctrl

I'm trying to write a script to identify all open chrome windows and move them into a grid layout on a large screen

I'm not sure how to find out what the best resolutions would be so I was going to manually add them in to a array so if 1 chrome window was available then maximise that, if 2 chrome windows available then go to a array for sizes for that?

At the moment I can move every window on the screen (does break my display when doing this) but I can see to work out how to move just the chrome screens?

The script below are some ideas I had but please point in the correct direction as at the moment the script doesn't work

#!/bin/bash
#Chrome window crontroller 


# Monitor 1920 X 1800

# Choose array for number of screens available 

# Different screen positions 
G=0
win1_X=5;      win1_Y=24;    win1_W=639;   win1_H=499;
win2_X=642;    win2_Y=24;    win2_W=639;   win2_H=499;
win3_X=1280;   win3_Y=24;    win3_W=639;   win3_H=499;
win4_X=5;      win4_Y=552;   win4_W=639;   win4_H=499;

ChromesAvailable()
{
    CA=$(wmctrl -lx | grep Chromium | wc -l)
}


GetNumOfChrome()
{
  WID=$(wmctrl -l | grep n | awk '{print$1}')
  #echo "INFO: window id = $WID"
}


PlaceWindow()
{
  X=${n}_X; Y=${n}_Y; W=${n}_W; H=${n}_H; 
  wmctrl -i -r "$WID" -e $G,${!X},${!Y},${!W},${!H}
}

if [ "$#" -gt 0 ]; then
 case "$1" in

        *)
            echo "ERROR: invalid option $1"
            echo "see --help for usage"
            exit 1
            ;;
  esac
  exit 0
else
for n in win{1..4}; do
    GetNumOfChrome
    PlaceWindow
done

fi

Edited – To explain things better 🙂

Using grep n will load every open window on the system so I tried to use grep Chromimum but the script doesn't like this

 GetNumOfChrome()
    {
      WID=$(wmctrl -l | grep n | awk '{print$1}')
      #echo "INFO: window id = $WID"
    }

Best Answer

A different approach is to arrange the windows form a pre- defined(customizable) grid (columns/rows)

An example:

enter image description here

rearranged into (cols set to 3, rows set to 2):

enter image description here

rearranged into (cols set to 4, rows set to 2):

enter image description here

The script below can be used to do that. As said, the number of columns&rows can be set, as well as the padding between the windows. The script calculates then the positions the windows should be arranged into, as well as their sizes.

Using the wmctrl command on Unity

The wmctrl command shows some peculiarities when used to move windows to- or very nearby the launcher or the panel. Therefore the margins:

left_margin = 70; top_margin = 30

cannot be set to zero. You have to keep at least a few px distance to both the panel and the launcher. I'd suggest leaving both margins- values as they are. All other values, padding, columns and rows you can play around with and set it as you like.

The script

#!/usr/bin/env python3
import subprocess
import getpass
import sys

#--- set your preferences below: columns, rows, padding between windows, margin(s)
cols = 2; rows = 2; padding = 10; left_margin = 70; top_margin = 30
#---

get = lambda cmd: subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
def get_res():
    xr = get("xrandr").split(); pos = xr.index("current")
    return [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]

# get resolution
res = get_res()
# define (calculate) the area to divide
area_h = res[0] - left_margin; area_v = res[1] - top_margin
# create a list of calculated coordinates
x_coords = [int(left_margin+area_h/cols*n) for n in range(cols)]
y_coords = [int(top_margin+area_v/rows*n) for n in range(rows)]
coords = sum([[(cx, cy) for cx in x_coords] for cy in y_coords], [])
# calculate the corresponding window size, given the padding, margins, columns and rows
w_size = [str(int(area_h/cols - padding)), str(int(area_v/rows - padding))]
# find windows of the application, identified by their pid
pids = [p.split()[0] for p in get("ps -e").splitlines() if sys.argv[1] in p]
w_list = sum([[w.split()[0] for w in get("wmctrl -lp").splitlines() if p in w] for p in pids], [])
print(pids, w_list, coords)
# remove possibly maximization, move the windows
for n, w in enumerate(w_list):
    data = (",").join([str(item) for item in coords[n]])+","+(",").join(w_size)
    cmd1 = "wmctrl -ir "+w+" -b remove,maximized_horz"
    cmd2 = "wmctrl -ir "+w+" -b remove,maximized_vert"
    cmd3 = "wmctrl -ir "+w+" -e 0,"+data
    for cmd in [cmd1, cmd2, cmd3]:
        subprocess.Popen(["/bin/bash", "-c", cmd])

How to use

Make sure wmctrl is installed :)
Copy thye script into an empty file, save it as rearrange_windows.py
In the head section of the script, set your preferences

Run it by the command:

python3 /path/to/rearrange_windows.py <application>

example: to rearrange chromium windows:

python3 /path/to/rearrange_windows.py chromium

to rearrange chrome windows

python3 /path/to/rearrange_windows.py chrome

Note

The script can be used to put windows of any application into a grid, since the process name of the application is used as an argument.

EDIT

Dynamic version

below a dynamic version of the script, as requested in a comment. This version of the script calculates the number of columns and rows, depending on the number of windows. The proportions of the rearranged window(s) is similar to the proportions of the screen.

The setup and the use is pretty much the same as the version above, only the number of columns and rows is now set automatically.

#!/usr/bin/env python3
import subprocess
import getpass
import sys
import math

#--- set your preferences below: padding between windows, margin(s)
padding = 10; left_margin = 70; top_margin = 30
#---

get = lambda cmd: subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
def get_res():
    xr = get("xrandr").split(); pos = xr.index("current")
    return [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]

# find windows of the application, identified by their pid
pids = [p.split()[0] for p in get("ps -e").splitlines() if sys.argv[1] in p]
w_list = sum([[w.split()[0] for w in get("wmctrl -lp").splitlines() if p in w] for p in pids], [])
# calculate the columns/rows, depending on the number of windows
cols = math.ceil(math.sqrt(len(w_list))); rows = cols
# define (calculate) the area to divide
res = get_res()
area_h = res[0] - left_margin; area_v = res[1] - top_margin
# create a list of calculated coordinates
x_coords = [int(left_margin+area_h/cols*n) for n in range(cols)]
y_coords = [int(top_margin+area_v/rows*n) for n in range(rows)]
coords = sum([[(cx, cy) for cx in x_coords] for cy in y_coords], [])
# calculate the corresponding window size, given the padding, margins, columns and rows
if cols != 0:
    w_size = [str(int(area_h/cols - padding)), str(int(area_v/rows - padding))]
# remove possibly maximization, move the windows
for n, w in enumerate(w_list):
    data = (",").join([str(item) for item in coords[n]])+","+(",").join(w_size)
    cmd1 = "wmctrl -ir "+w+" -b remove,maximized_horz"
    cmd2 = "wmctrl -ir "+w+" -b remove,maximized_vert"
    cmd3 = "wmctrl -ir "+w+" -e 0,"+data
    for cmd in [cmd1, cmd2, cmd3]:
        subprocess.call(["/bin/bash", "-c", cmd])

See below the examples with a varying number of opened windows:

enter image description here

Explanation (second script)

Finding the specific windows

The command:
```
wmctrl -lp
```
lists all windows, in the format:
```
0x19c00085  0 14838  jacob-System-Product-Name *Niet-opgeslagen document 1 - gedit
```
where the first column is the window's unique id, and the third column is the pid of the application that owns the window.
The command:
```
ps -e
```
lists all processes, in the format:
```
14838 ?        00:00:02 gedit
```
where the first column is the application's pid, the last one is the process name.

By comparing these two lists, we can find all windows (id of-) which belong to a specific application (called w_list in the script, as the result of line 17/18 in the script):

pids = [p.split()[0] for p in get("ps -e").splitlines() if sys.argv[1] in p]
w_list = sum([[w.split()[0] for w in get("wmctrl -lp").splitlines() if p in w] for p in pids], [])

Calculating the number of rows/columns

If we make the windows of the same proportions as the screen, that means the number of columns is equal to the number of rows.
That implies that both the number of colums and rows are equal to the rounded up square root of the number of windows to rearrange. That is done in line 20:
```
cols = math.ceil(math.sqrt(len(w_list))); rows = cols
```

Calculating the window size and position

Once we have the number of columns, all we need to do is divide the available area (screen resolution - left margin/top margin) in the columns/rows and we have the targeted window size, which is then diminished by the padding, as set in the head of the script:
```
w_size = [str(int(area_h/cols - padding)), str(int(area_v/rows - padding))]
```
The horizontal (x) positions are the result of the product(s) of the horizontal window size (including padding) times the column number, in a range of the number of columns. for example: if I have 3 colums of 300 px, the resulting x-positions are:
```
[0, 300, 600]
```

The vertical (y) positions are calculated likewise. Both lists are then combined into a list of coordinates, in which the windows will be rearranged.

This is done in line 26-28 of the script:

x_coords = [int(left_margin+area_h/cols*n) for n in range(cols)]
y_coords = [int(top_margin+area_v/rows*n) for n in range(rows)]
coords = sum([[(cx, cy) for cx in x_coords] for cy in y_coords], [])

The actual rearranging finally (after unmaximizing possibly maximized windows) is done from line 33 and further.

How it works in practice

The solution exists from a script, which can be run with two options -set and -run:

To set up (open) an arbitrary number of terminal windows, in this example 3:
```
target_term -set 3
```
Three new terminals will open up, their window id is remembered in a hidden file:

For clarity reasons I minimized the terminal window I ran the command from :)
Now that I created three windows, I can send commands to either one of them with the run command (e.g.):
```
target_term -run 2 echo "Monkey eats banana since it ran out of peanuts"
```
As shown below, the command ran in the second terminal:

Subsequently, I can send a command to the first terminal:
```
 target_term -run 1 sudo apt-get update
```
making sudo apt-get update run in terminal 1:

and so on...

How to set up

The script needs both wmctrl and xdotool:
```
sudo apt-get install wmctrl xdotool
```
Copy the script below into an empty file, safe it as target_term (no extension!) in ~/bin (create the directory ~/bin if necessary.
Make the script executable (don't forget) and either log out/in or run:
```
source ~/.profile
```
Now setup your terminal windows, with the number of required windows as an argument:
```
target_term -set <number_of_windows>
```
Now you can "send" commands to either one of your terminals with the command:
```
target_term -run <terminal_number> <command_to_run>
```

The script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time
#--- set your terminal below
application = "gnome-terminal"
#---

option = sys.argv[1]
data = os.environ["HOME"]+"/.term_list"

def current_windows():
    w_list = subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8")
    w_lines = [l for l in w_list.splitlines()]
    try:
        pid = subprocess.check_output(["pgrep", application]).decode("utf-8").strip()
        return [l for l in w_lines if str(pid) in l]
    except subprocess.CalledProcessError:
        return []

def arr_windows(n):
    w_count1 = current_windows()
    for requested in range(n):
        subprocess.Popen([application])
    called = []
    while len(called) < n:
        time.sleep(1)
        w_count2 = current_windows()
        add = [w for w in w_count2 if not w in w_count1]
        [called.append(w.split()[0]) for w in add if not w in called]
        w_count1 = w_count2

    return called

def run_intterm(w, command):
    subprocess.call(["xdotool", "windowfocus", "--sync", w])
    subprocess.call(["xdotool", "type", command+"\n"]) 

if option == "-set":
    open(data, "w").write("")
    n = int(sys.argv[2])
    new = arr_windows(n)
    for w in new:
        open(data, "a").write(w+"\n")
elif option == "-run":
    t_term = open(data).read().splitlines()[int(sys.argv[2])-1]
    command = (" ").join(sys.argv[3:])
    run_intterm(t_term, command)

Notes

The script is set for gnome-terminal, but can be used for any terminal (or other program as well) by changing the application in the head section of the script:
```
#--- set your terminal below
application = "gnome-terminal"
#---
```
The commands above can (of course) be run from a script as well in case you'd lile to use it for some kind of a simulation.
The script waits until both the targeted window has focus and the command is done typing, so the command will always land in the right terminal window.
No need to say that the script only works with the terminal setup (windows) that was called by the command:
```
target_term -set
```
The terminal windows will then be "labelled" by the script, like you mention in your question.
In case you start a new target_term session, the hidden file, created by the script will simply be overwritten, so there is no need to remove it otherwise.

Best Answer

Using the wmctrl command on Unity

The script

How to use

Note

EDIT

Dynamic version

Explanation (second script)

Related Solutions

Monitor and Move/Rename New Files in Directory – How to Guide

How to Send Commands to Specific Terminal Windows

How it works in practice

How to set up

The script

Notes

Related Question