Como posso adicionar áreas de trabalho automaticamente, apenas se precisar delas?

Suponha que eu esteja usando quatro áreas de trabalho e que, aliás, preciso de mais, existe um processo automatizado ou, se impossível, uma maneira fácil de adicionar acidentalmente mais áreas de trabalho (em vez de instalar Ubuntu tweaketc. etc.).

Defina automaticamente o número de áreas de trabalho; adicione e remova colunas e linhas, dependendo de suas necessidades

Abaixo de uma versão de um script (o) backround que adicionará automaticamente os espaços de trabalho se você inserir a última coluna ou linha da matriz do espaço de trabalho.

É assim que funciona:

1. Se você chegar à última coluna ou linha, viewports adicionais serão adicionadas:

   

2. Se seus espaços de trabalho não forem utilizados por 5 a 10 segundos e não houver janelas, os espaços de trabalho adicionais serão removidos novamente. No entanto, você sempre manterá uma linha extra abaixo e uma coluna extra à direita da sua viewport atual:

   

O 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)

Como usar

1. Copie o script abaixo em um arquivo vazio, salve-o como add_space.py

2. Na seção principal do script, edite as linhas se desejar outras configurações (número máximo de áreas de trabalho, matriz padrão, por exemplo, 2x2):

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

3. Teste-execute pelo comando:

   python3 /path/to/add_space.py
   

4. Se tudo funcionar bem, adicione-o aos aplicativos de inicialização: Dash> Startup Applications> Add the command:

   /bin/bash -c "sleep 15 &&  python3 /path/to/add_space.py`
   

Nota

Como sempre, o script é extremamente "com pouco suco" e não adiciona nenhuma carga perceptível ao seu processador.

Explicação

A história abaixo é um pouco complicada e principalmente uma explicação sobre o conceito e o procedimento , e não sobre a codificação. Leia apenas se estiver interessado.

Como calcular os espaços de trabalho necessários (colunas de exemplo)

A saída de se wmctrl -dparece com:

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

Na saída, VP: 1680,1050fornece informações sobre onde estamos no espaço de trabalho de abrangência (a matriz de todas as viewports). Esta informação é útil apenas se também tivermos a resolução da tela, pois, por exemplo, 1680pode ter a largura de duas (improvável, mas ainda) ou uma vez a tela.
Felizmente, podemos analisar a resolução da tela a partir do comando xrandr.

Então, se sabemos que o tamanho x da tela é 1680e atualmente estamos ativados VP: 1680,1050, sabemos que estamos na segunda coluna na matriz da área de trabalho. Como também sabemos o tamanho da matriz total ( DG: 3360x2100também da saída de wmctrl -d), sabemos que a matriz atual inclui duas colunas (3360/1680) e estamos na "última".

O script enviará uma instrução para adicionar uma coluna à matriz pelo comando:

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

Esse é o princípio.

Como calcular os espaços de trabalho a serem removidos (colunas de exemplo)

Uma vez a cada 10 segundos, o script executa o comando para listar todas as janelas abertas no momento, com o comando:

wmctrl -lG

Isso também fornece informações sobre a posição da janela, parecendo:

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

Na saída, 3425é a posição x da janela. Esta figura é relativa ao espaço de trabalho atual (lado esquerdo). Para conhecer a posição absoluta da janela (x) na matriz da área de trabalho, precisamos adicionar o primeiro número das informações atuais da viewport (por exemplo VP: 1680,1050, a partir da saída de wmctrl -d).
Vamos, no entanto, por motivos de simplicidade, supor que estamos na janela de exibição 1,1(topleft viewport), portanto a posição relativa da janela é igual à sua posição absoluta.

Como a resolução da tela é 1680, sabemos que a janela está na coluna 3425/1680, arredondada para cima, pois tudo o que 3360 and 5040está no meio está na mesma coluna na matriz (entre 3 e 4 vezes a resolução). Para um cálculo adequado, usamos math.ceil()( python)

Como o script também pratica a regra para sempre ter um espaço de trabalho extra à direita / abaixo, precisamos definir o número de colunas para o valor mais alto de:

• a coluna atual da área de trabalho + 1
• a última coluna com uma janela
• o número padrão de colunas, conforme definido no cabeçalho do script

E assim o script faz :)

As linhas são gerenciadas exatamente no mesmo procedimento.

Tecnicamente, não há atalho para redimensionar áreas de trabalho, mas você pode usar o script simples abaixo e vinculá-lo a um atalho.

1. Pegue o script abaixo, salve-o na .local/share/applicationspasta ou onde quiser.
2. Verifique se o script foi feito executável com chmod 755 /path/to/script
3. Vincule-o a um atalho em Configurações do sistema -> Teclado -> Atalhos -> Atalhos personalizados

Por exemplo, eu tenho esta configuração:

O script está vinculado a ShiftCtrlAltI. Mas CtrlAltIpoderia funcionar também. Dou o caminho completo para o script, que é

/home/xieerqi/resize-workspaces.sh

E aqui está como deve ficar:

Roteiro

#!/bin/bash
# Author : Serg Kolo
# Date: Sept 19, 2015
# Purpose: simple script to resize 
# unity workspaces
# Written for: http://askubuntu.com/q/676046/295286

HEIGHT=$(gsettings get org.compiz.core:/org/compiz/profiles/unity/plugins/core/ hsize)
WIDTH=$(gsettings get org.compiz.core:/org/compiz/profiles/unity/plugins/core/ vsize)
NEWSIZE=$(zenity --entry --text="Current desktop set-up $HEIGHT x $WIDTH. Enter new setup in HEIGHTxWIDTH format"  --width=250 | tr 'x' ' ' )

ARRAY=( $NEWSIZE )
[ -z ${ARRAY[1]}  ] && exit
    gsettings set org.compiz.core:/org/compiz/profiles/unity/plugins/core/ hsize ${ARRAY[0]}
    gsettings set org.compiz.core:/org/compiz/profiles/unity/plugins/core/ vsize ${ARRAY[1]}

Muito simples de usar, muito simples de configurar