Imposta automaticamente il numero di aree di lavoro; aggiungere e rimuovere colonne e righe, a seconda delle esigenze
Sotto una versione di uno (il) script backround che aggiungerà automaticamente aree di lavoro se hai inserito l'ultima colonna o riga della matrice dell'area di lavoro.
È così che funziona:
Se arrivi all'ultima colonna o riga, vengono aggiunte altre finestre:
Se le aree di lavoro non vengono utilizzate per 5-10 secondi e non sono presenti finestre, le aree di lavoro aggiuntive verranno nuovamente rimosse. Tuttavia, manterrai sempre una riga aggiuntiva in basso e una colonna aggiuntiva a destra della finestra corrente:
Il copione:
#!/usr/bin/env python3
import subprocess
import time
import math
# --- set default workspaces below (horizontally, vertically)
hsize = 2
vsize = 2
# --- set the maximum number of workspaces below
max_ws = 10
def set_workspaces(size, axis):
subprocess.Popen([
"dconf", "write", "/org/compiz/profiles/unity/plugins/core/"+axis,
str(size)
])
def get_res():
resdata = subprocess.check_output(["xrandr"]).decode("utf-8").split()
curr = resdata.index("current")
return (int(resdata[curr+1]), int(resdata[curr+3].replace(",", "")))
def wspace():
try:
sp = subprocess.check_output(["wmctrl", "-d"]).decode("utf-8").split()
return ([int(n) for n in sp[3].split("x")],
[int(n) for n in sp[5].split(",")])
except subprocess.CalledProcessError:
pass
def clean_up(curr_col, curr_row):
try:
w_list = [l.split() for l in subprocess.check_output(["wmctrl", "-lG"]).decode("utf-8").splitlines()]
xpos = max([math.ceil((int(w[2])+span[1][0])/res[0]) for w in w_list])
min_x = max(xpos, curr_col+1, hsize)
if xpos >= hsize:
set_workspaces(min_x, "hsize")
else:
set_workspaces(min_x, "hsize")
ypos = max([math.ceil((int(w[3])+span[1][1])/res[1]) for w in w_list])
min_y = max(ypos, curr_row+1, vsize)
if ypos >= vsize:
set_workspaces(min_y, "vsize")
else:
set_workspaces(min_y, "vsize")
except subprocess.CalledProcessError:
pass
res = get_res()
t = 0
while True:
span = wspace()
if span != None:
cols = int(span[0][0]/res[0]); rows = int(span[0][1]/res[1])
currcol = int((span[1][0]+res[0])/res[0])
if all([currcol == cols, cols*rows < max_ws]):
set_workspaces(cols+1, "hsize")
currrow = int((span[1][1]+res[1])/res[1])
if all([currrow == rows, cols*rows < max_ws]):
set_workspaces(rows+1, "vsize")
if t == 10:
clean_up(currcol, currrow)
t = 0
else:
t = t+1
time.sleep(1)
Come usare
- Copia lo script qui sotto in un file vuoto, salvalo come
add_space.py
Nella sezione head dello script, modifica le righe se ti piacciono le altre impostazioni (numero massimo di aree di lavoro, matrice predefinita, ad es. 2x2):
# --- set default workspaces below (horizontally, vertically)
hsize = 2
vsize = 2
# --- set the maximum number of workspaces below
max_ws = 10
Prova- eseguilo con il comando:
python3 /path/to/add_space.py
Se tutto funziona correttamente, aggiungilo alle applicazioni di avvio: Dash> Applicazioni di avvio> Aggiungi il comando:
/bin/bash -c "sleep 15 && python3 /path/to/add_space.py`
Nota
Come sempre, lo script è estremamente "a basso consumo" e non aggiunge alcun carico evidente al tuo processore.
Spiegazione
La storia che segue è un po 'complicata e principalmente una spiegazione sul concetto e sulla procedura , piuttosto che sulla codifica. Leggi solo se sei interessato.
Come calcolare le aree di lavoro necessarie (colonne di esempio)
L'output di wmctrl -dassomiglia a:
0 * DG: 3360x2100 VP: 1680,1050 WA: 65,24 1615x1026 N/A
Nell'output, VP: 1680,1050ci fornisce informazioni su dove siamo nell'area di lavoro di spanning (la matrice di tutte le finestre). Questa informazione è utile solo se abbiamo anche la risoluzione dello schermo, poiché ad esempio 1680potrebbe essere la larghezza di due (improbabile, ma comunque) o una volta lo schermo.
Fortunatamente, possiamo analizzare la risoluzione dello schermo dal comando xrandr.
Quindi se sappiamo che la dimensione x dello schermo è 1680e siamo attualmente attivi VP: 1680,1050, sappiamo che siamo nella seconda colonna nella matrice dell'area di lavoro. Poiché conosciamo anche le dimensioni della matrice totale ( DG: 3360x2100, anche dall'output di wmctrl -d), sappiamo che la matrice corrente include due colonne (3360/1680) e siamo sull'ultima ".
Lo script invierà quindi un'istruzione per aggiungere una colonna alla matrice dal comando:
dconf write /org/compiz/profiles/unity/plugins/core/hsize <current_viewport_column+1>
Questo è il principio
Come calcolare le aree di lavoro da rimuovere (colonne di esempio)
Una volta ogni 10 secondi, lo script esegue il comando per elencare tutte le finestre attualmente aperte, con il comando:
wmctrl -lG
Questo ci dà anche informazioni sulla posizione della finestra, simile a:
0x04604837 0 3425 24 1615 1026 jacob-System-Product-Name Niet-opgeslagen document 2 - gedit
Nell'output, 3425è la posizione x della finestra. Questa cifra è tuttavia relativa all'area di lavoro corrente (lato sinistro). Per conoscere la posizione assoluta della finestra (x-saggio) nella matrice dello spazio di lavoro, dobbiamo aggiungere il primo numero delle informazioni della finestra corrente (ad esempio VP: 1680,1050, dall'output di wmctrl -d).
Tuttavia, per motivi di semplicità, supponiamo che siamo in viewport 1,1(topleft viewport), quindi la posizione relativa della finestra è uguale alla sua posizione assoluta.
Poiché la risoluzione dello schermo è 1680, sappiamo che la finestra è sulla colonna 3425/1680, arrotondata per eccesso, poiché tutto ciò che si 3360 and 5040trova è sulla stessa colonna nella matrice (tra 3 e 4 volte la risoluzione). Per un corretto calcolo usiamo math.ceil()( python)
Poiché lo script pratica anche la regola per avere sempre uno spazio di lavoro aggiuntivo a destra / in basso, dobbiamo impostare il numero di colonne sul valore più alto di:
- la colonna corrente dell'area di lavoro + 1
- l' ultima colonna con una finestra su di essa
- il numero predefinito di colonne, come impostato nell'intestazione dello script
E così lo script fa :)
Le righe sono gestite esattamente nella stessa procedura.
