Comment puis-je ajouter automatiquement des espaces de travail, uniquement si j'en ai besoin?

Définissez automatiquement le nombre d'espaces de travail; ajouter et supprimer des colonnes et des lignes, selon vos besoins

Ci-dessous une version d'un (le) script backround qui ajoutera automatiquement des espaces de travail si vous avez entré la dernière colonne ou ligne de votre matrice d'espace de travail.

Voilà comment cela fonctionne:

Si vous arrivez à la dernière colonne ou ligne, des fenêtres supplémentaires sont ajoutées:
Si vos espaces de travail sont inutilisés pendant 5 à 10 secondes et qu'il n'y a pas de fenêtres dessus, les espaces de travail supplémentaires seront à nouveau supprimés. Cependant, vous conserverez toujours une ligne supplémentaire ci-dessous et une colonne supplémentaire à droite de votre fenêtre actuelle:

Le script:

#!/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)

Comment utiliser

Copiez le script ci-dessous dans un fichier vide, enregistrez-le sous add_space.py
Dans la section head du script, éditez les lignes si vous aimez les autres paramètres (nombre maximum d'espaces de travail, matrice par défaut 2x2 par exemple):
```
# --- set default workspaces below (horizontally, vertically)
hsize = 2
vsize = 2
# --- set the maximum number of workspaces below
max_ws = 10
```
Testez-le par la commande:
```
python3 /path/to/add_space.py
```
Si tout fonctionne bien, ajoutez-le à vos applications de démarrage: Dash> Startup Applications> Add the command:
```
/bin/bash -c "sleep 15 &&  python3 /path/to/add_space.py`
```

Remarque

Comme toujours, le script est extrêmement "faible en jus" et n'ajoute aucune charge notable à votre processeur.

Explication

L'histoire ci-dessous est un peu compliquée et surtout une explication sur le concept et la procédure , plutôt que sur le codage. Lisez uniquement si vous êtes intéressé.

Comment calculer les espaces de travail nécessaires (exemples de colonnes)

La sortie de wmctrl -dressemble à:

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

Dans la sortie, VP: 1680,1050nous donne des informations sur notre position dans l'espace de travail s'étendant (la matrice de toutes les fenêtres). Ces informations ne sont utiles que si nous avons également la résolution de l'écran, car par exemple 1680pourrait être la largeur de deux (peu probable, mais quand même) ou une fois l'écran.
Heureusement, nous pouvons analyser la résolution de l'écran à partir de la commande xrandr.

Ensuite, si nous savons que la taille x de l'écran est 1680et que nous sommes actuellement allumés VP: 1680,1050, nous savons que nous sommes sur la deuxième colonne de la matrice de l'espace de travail. Puisque nous connaissons également la taille de la matrice totale ( DG: 3360x2100, également à partir de la sortie de wmctrl -d), nous savons que la matrice actuelle comprend deux colonnes (3360/1680), et nous sommes sur la "dernière".

Le script enverra alors une instruction pour ajouter une colonne à la matrice par la commande:

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

Tel est le principe.

Comment calculer les espaces de travail à supprimer (exemples de colonnes)

Une fois toutes les 10 secondes, le script exécute la commande pour répertorier toutes les fenêtres actuellement ouvertes, avec la commande:

wmctrl -lG

Cela nous donne également des informations sur la position de la fenêtre, ressemblant à:

0x04604837  0 3425 24   1615 1026 jacob-System-Product-Name Niet-opgeslagen document 2 - gedit

Dans la sortie, 3425est la position x de la fenêtre. Ce chiffre est cependant relatif à l'espace de travail actuel (côté gauche). Pour connaître la position absolue de la fenêtre (dans le sens x) dans la matrice de l'espace de travail, nous devons ajouter le premier nombre des informations de la fenêtre courante (par exemple VP: 1680,1050, à partir de la sortie de wmctrl -d).
Supposons cependant, pour des raisons de simplicité, supposons que nous sommes sur la fenêtre 1,1(fenêtre topleft), donc la position relative de la fenêtre est égale à sa position absolue.

Puisque la résolution de l'écran est 1680, nous savons que la fenêtre est sur colonne 3425/1680, arrondie, car tout ce qui se 3360 and 5040trouve entre est sur la même colonne dans la matrice (entre 3 et 4 fois la résolution). Pour un calcul correct, nous utilisons math.ceil()( python)

Étant donné que le script pratique également la règle pour toujours avoir un espace de travail supplémentaire à droite / en dessous, nous devons définir le nombre de colonnes à la valeur la plus élevée de:

la colonne d'espace de travail actuelle + 1
la dernière colonne avec une fenêtre dessus
le nombre de colonnes par défaut, tel que défini dans l'en-tête du script

Et donc le script fait :)

Les lignes sont gérées exactement selon la même procédure.

Jacob Vlijm
la source

Wow, excellente réponse, déjà voté =)

@AB Merci! :) C'est le genre de choses que j'aime faire :)

Jacob Vlijm

@kernel_panic Wow, merci :) Je pense en fait à en faire un ppa, comme celui-ci: askubuntu.com/a/608295/72216, et celui-ci: askubuntu.com/a/560734/72216, enfin (à l'avenir) fusionner les trois en une seule application "workspace_tools" où ils peuvent être définis comme options ou quelque chose comme ça :).

Jacob Vlijm

@JacobVlijm Je supprimerais l'ancienne réponse d'ici pour des raisons de brièveté: elle sera toujours visible dans l'historique des modifications pour ceux qui sont intéressés ...

Fabby

Vous êtes les bienvenus ... Vous devriez passer par la salle de chat et tox plus souvent! : P