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:
Se você chegar à última coluna ou linha, viewports adicionais serão adicionadas:
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
- Copie o script abaixo em um arquivo vazio, salve-o como
add_space.py
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
Teste-execute pelo comando:
python3 /path/to/add_space.py
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.
