Establecer automáticamente el número de espacios de trabajo; agregar y eliminar columnas y filas, según sus necesidades
Debajo de una versión de (la) secuencia de comandos de fondo que agregará automáticamente espacios de trabajo si ingresó la última columna o fila de su matriz de espacio de trabajo.
Así es como funciona:
Si llega a la última columna o fila, se agregan ventanas gráficas adicionales:
Si sus espacios de trabajo no se utilizan durante 5-10 segundos y no hay ventanas, los espacios de trabajo adicionales se eliminarán nuevamente. Sin embargo, siempre mantendrá una fila adicional debajo y una columna adicional a la derecha de su ventana gráfica actual:
La secuencia de comandos:
#!/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)
Cómo utilizar
- Copie el script a continuación en un archivo vacío, guárdelo como
add_space.py
En la sección de encabezado del script, edite las líneas si desea otras configuraciones (número máximo de espacios de trabajo, matriz predeterminada, por ejemplo, 2x2):
# --- set default workspaces below (horizontally, vertically)
hsize = 2
vsize = 2
# --- set the maximum number of workspaces below
max_ws = 10
Prueba: ejecútelo con el comando:
python3 /path/to/add_space.py
Si todo funciona bien, agréguelo a sus aplicaciones de inicio: Tablero> Aplicaciones de inicio> Agregue el comando:
/bin/bash -c "sleep 15 && python3 /path/to/add_space.py`
Nota
Como siempre, el script es extremadamente "bajo en jugo" y no agrega ninguna carga notable a su procesador.
Explicación
La historia a continuación es un poco complicada y en su mayoría es una explicación sobre el concepto y el procedimiento , en lugar de la codificación. Solo lee si te interesa.
Cómo calcular los espacios de trabajo necesarios (columnas de ejemplo)
La salida de se wmctrl -dve así:
0 * DG: 3360x2100 VP: 1680,1050 WA: 65,24 1615x1026 N/A
En la salida, VP: 1680,1050nos da información sobre dónde estamos en el espacio de trabajo de expansión (la matriz de todas las ventanas gráficas). Esta información solo es útil si también tenemos la resolución de la pantalla, ya que, por ejemplo, 1680podría ser el ancho de dos (poco probable, pero aún) o una vez la pantalla.
Afortunadamente, podemos analizar la resolución de la pantalla desde el comando xrandr.
Entonces, si sabemos que el tamaño x de la pantalla es 1680y actualmente estamos encendidos VP: 1680,1050, sabemos que estamos en la segunda columna de la matriz del espacio de trabajo. Como también conocemos el tamaño de la matriz total ( DG: 3360x2100también de la salida de wmctrl -d), sabemos que la matriz actual incluye dos columnas (3360/1680), y estamos en la "última".
El script luego enviará una instrucción para agregar una columna a la matriz mediante el comando:
dconf write /org/compiz/profiles/unity/plugins/core/hsize <current_viewport_column+1>
Este es el principio.
Cómo calcular los espacios de trabajo para eliminar (columnas de ejemplo)
Una vez cada 10 segundos, el script ejecuta el comando para enumerar todas las ventanas abiertas actualmente, con el comando:
wmctrl -lG
Esto también nos da información sobre la posición de la ventana, como:
0x04604837 0 3425 24 1615 1026 jacob-System-Product-Name Niet-opgeslagen document 2 - gedit
En la salida, 3425es la posición x de la ventana. Sin embargo, esta cifra es relativa al espacio de trabajo actual (lado izquierdo). Para conocer la posición absoluta de la ventana (x-wise) en la matriz de espacio de trabajo, debemos agregar el primer número de la información de la ventana gráfica actual (p VP: 1680,1050. Ej. , De la salida de wmctrl -d).
Sin embargo, por razones de simplicidad, supongamos que estamos en viewport 1,1(topleft viewport), por lo que la posición relativa de la ventana es igual a su posición absoluta.
Dado que la resolución de la pantalla es 1680, sabemos que la ventana está en la columna 3425/1680, redondeada, ya que todo lo que 3360 and 5040está en medio está en la misma columna en la matriz (entre 3 y 4 veces la resolución). Para el cálculo adecuado usamos math.ceil()( python)
Dado que el script también practica la regla de tener siempre un espacio de trabajo adicional a la derecha / abajo, debemos establecer el número de columnas con el valor más alto de:
- la columna del espacio de trabajo actual + 1
- la última columna con una ventana
- el número predeterminado de columnas, como se establece en el encabezado del script
Y así lo hace el guión :)
Las filas se gestionan exactamente en el mismo procedimiento.
