Come aggiungere automaticamente spazi di lavoro, solo se ne ho bisogno?

Supponiamo che io stia utilizzando 4 aree di lavoro e, per inciso, ne abbia bisogno di più, esiste un processo automatizzato o, se impossibile, un modo semplice per aggiungere accidentalmente più aree di lavoro (invece di installare Ubuntu tweak ecc. ecc.).

Risposta accettata:

Imposta automaticamente il numero di spazi di lavoro; aggiungi e rimuovi colonne e righe, a seconda delle tue esigenze

Sotto una versione di uno (il) script di backround che aggiungerà automaticamente spazi di lavoro se hai inserito l'ultima colonna o riga della matrice dell'area di lavoro.

Ecco come funziona:

1. Se arrivi all'ultima colonna o riga, vengono aggiunte ulteriori finestre:

   

2. Se i tuoi spazi di lavoro non vengono utilizzati per 5-10 secondi e non ci sono finestre su di esso, gli spazi di lavoro aggiuntivi verranno nuovamente rimossi. Tuttavia, manterrai sempre una riga in più sotto e una colonna in più a destra della visualizzazione 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 si usa

1. Copia lo script qui sotto in un file vuoto, salvalo come add_space.py

2. Nella sezione principale dello script, modifica le righe se ti piacciono altre impostazioni (numero massimo di spazi di lavoro, matrice predefinita es. 2×2):

   # --- set default workspaces below (horizontally, vertically)
   hsize = 2
   vsize = 2
   # --- set the maximum number of workspaces below
   max_ws = 10
   

3. Provalo con il comando:

   python3 /path/to/add_space.py
   

4. Se tutto funziona correttamente, aggiungilo alle tue 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 qui sotto è un po' complicata e principalmente una spiegazione del concetto e la procedura , piuttosto che la codifica. Leggi solo se sei interessato.

Come calcolare gli spazi di lavoro necessari (colonne di esempio)

L'output di wmctrl -d assomiglia a:

0  * DG: 3360x2100  VP: 1680,1050  WA: 65,24 1615x1026  N/A

Nell'output, VP: 1680,1050 ci fornisce informazioni su dove ci troviamo nell'area di lavoro estesa (la matrice di tutte le finestre). Questa informazione è utile solo se abbiamo anche la risoluzione dello schermo, poiché ad es. 1680 potrebbe 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 è 1680 e attualmente siamo su VP: 1680,1050 , sappiamo di essere nella seconda colonna nella matrice dell'area di lavoro. Poiché conosciamo anche la dimensione della matrice totale (DG: 3360x2100 , anche dall'output di wmctrl -d ), sappiamo che la matrice attuale include due colonne (3360/1680) e siamo sull'"ultima".

Correlati:Linux:come aggiungere parametri di avvio al kernel con bcfg dalla shell EFI?

Lo script invierà quindi un'istruzione per aggiungere una colonna alla matrice tramite il comando:

dconf write /org/compiz/profiles/unity/plugins/core/hsize <current_viewport_column+1>

Questo è il principio.

Come calcolare gli spazi di lavoro da rimuovere (esempio colonne)

Una volta ogni 10 secondi, lo script esegue il comando per elencare tutte le finestre attualmente aperte, con il comando:

wmctrl -lG

Questo ci fornisce 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 allo spazio di lavoro corrente (lato sinistro). Per conoscere la posizione assoluta della finestra (x-wise) nella matrice dell'area di lavoro, dobbiamo aggiungere il primo numero delle informazioni della finestra corrente (es. VP: 1680,1050 , dall'output di wmctrl -d ).
Supponiamo tuttavia, per motivi di semplicità, di essere su viewport 1,1 (vista in alto a sinistra), quindi la posizione relativa della finestra uguale la sua posizione assoluta.

Poiché la risoluzione dello schermo è 1680 , sappiamo che la finestra è sulla colonna 3425/1680 , arrotondato per eccesso, poiché tutto compreso tra 3360 and 5040 si trova sulla stessa colonna della matrice (tra 3 e 4 volte la risoluzione). Per un calcolo corretto utilizziamo math.ceil() (python )

Dal momento che lo script anche pratica la regola per avere sempre uno spazio di lavoro extra a destra/in basso, dobbiamo impostare il numero di colonne su il più alto valore di:

• la corrente colonna dell'area di lavoro + 1
• l'ultimo colonna con una finestra su di essa
• il numero predefinito di colonne, come impostato nell'intestazione dello script

E così fa la sceneggiatura 🙂

Le righe vengono gestite esattamente con la stessa procedura.