¿Hay alguna manera de almacenar el diseño actual del escritorio?

Lo que quiero es poder guardar las posiciones actuales de mis aplicaciones, así que cuando voy a abrir las mismas y ejecutar algo, se reorganizarán como estaban.

Por ejemplo, si voy a abrir un sublime y tres ventanas de terminal, me gustaría poder guardarlo de alguna manera.

No me importa si es una aplicación o una herramienta de línea de comandos, siempre que pueda guardar fácilmente las posiciones de mis aplicaciones.

Soy un gran admirador de Moom , pero desafortunadamente solo funciona en MacOS y realmente lo extraño cuando estoy en Ubuntu. Es compatible con más funciones y si sabes algo parecido a mi problema principal, también está bien.

Nota

El script fue parcheado / reparado el 16 de enero de 2017, solucionando algunas aplicaciones cuyo nombre de proceso difiere del comando para ejecutar la aplicación . Posiblemente, esto ocurre ocasionalmente en aplicaciones. Si alguien encuentra uno, por favor deje un comentario.

Script para recordar y restaurar la disposición de las ventanas y sus aplicaciones correspondientes.

El siguiente script se puede ejecutar con dos opciones. Digamos que tiene la disposición de la ventana de la siguiente manera:

Para leer (recordar) la distribución de ventanas actual y sus aplicaciones, ejecute el script con la opción:

<script> -read

Luego cierre todas las ventanas:

Luego, para configurar el último arreglo de ventanas recordado, ejecútelo con la opción:

<script> -run

y se restaurará el último arreglo de ventana recordado:

Esto también funcionará después de un reinicio.

Al poner los dos comandos debajo de dos teclas de acceso directo diferentes, puede "grabar" su disposición de ventanas, apagar su computadora y recuperar la misma disposición de ventanas después de (por ejemplo) un reinicio.

Qué hace el guión y qué no

Corre con la opción -read

• El script usa wmctrlpara enumerar todas las ventanas, en todos los espacios de trabajo, sus posiciones, sus tamaños, las aplicaciones a las que pertenecen
• Luego, el script "convierte" las posiciones de la ventana de posiciones relativas (al espacio de trabajo actual, como en la salida de wmctrl) a posiciones absolutas , en sus espacios de trabajo de expansión. Por lo tanto, no importa si las ventanas que desea recordar están en un solo espacio de trabajo o se distribuyen en diferentes espacios de trabajo.
• La secuencia de comandos "recuerda" la disposición de la ventana actual, escribiéndola en un archivo invisible en su directorio de inicio.

Corre con la opción -run

• el guión lee el último arreglo de ventana recordado; inicia las aplicaciones correspondientes, mueve las ventanas a las posiciones recordadas, también con la ayuda dewmctrl

El script no recuerda los archivos que posiblemente podrían abrirse en las ventanas, ni (por ejemplo) los sitios web que se abrieron en una ventana del navegador.

Cuestiones

La combinación de wmctrly Unitytiene algunos errores, algunos ejemplos:

• Las coordenadas de la ventana, según lo leen, wmctrldifieren ligeramente del comando para colocar las ventanas, como se menciona aquí . Por lo tanto, las posiciones de ventana recuperadas pueden diferir ligeramente de la posición original.
• Los wmctrlcomandos funcionan un poco impredecibles si el borde de la ventana está muy cerca Unity Launcherdel panel o del panel.
• Las ventanas "recordadas" deben estar completamente dentro de los bordes de un espacio de trabajo para que el wmctrlcomando de ubicación funcione bien.

Algunas aplicaciones abren nuevas ventanas por defecto en la misma ventana en una nueva pestaña (como gedit). Lo arreglé gedit, pero por favor, menciónalo si encuentras más excepciones.

La secuencia de comandos

#!/usr/bin/env python3
import subprocess
import os
import sys
import time

wfile = os.environ["HOME"]+"/.windowlist"
arg = sys.argv[1]

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def check_window(w_id):
    w_type = get("xprop -id "+w_id)
    if " _NET_WM_WINDOW_TYPE_NORMAL" in w_type:
        return True
    else:
        return False

def get_res():
    # get resolution and the workspace correction (vector)
    xr = subprocess.check_output(["xrandr"]).decode("utf-8").split()
    pos = xr.index("current")
    res = [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]
    vp_data = subprocess.check_output(["wmctrl", "-d"]).decode("utf-8").split()
    curr_vpdata = [int(n) for n in vp_data[5].split(",")]
    return [res, curr_vpdata]

app = lambda pid: subprocess.check_output(["ps", "-p",  pid, "-o", "comm="]).decode("utf-8").strip()

def read_windows():
    res = get_res()
    w_list =  [l.split() for l in get("wmctrl -lpG").splitlines()]
    relevant = [[w[2],[int(n) for n in w[3:7]]] for w in w_list if check_window(w[0]) == True]
    for i, r in enumerate(relevant):      
        relevant[i] = app(r[0])+" "+str((" ").join([str(n) for n in r[1]]))
    with open(wfile, "wt") as out:
        for l in relevant:
            out.write(l+"\n")

def open_appwindow(app, x, y, w, h):
    ws1 = get("wmctrl -lp"); t = 0
    # fix command for certain apps that open in new tab by default
    if app == "gedit":
        option = " --new-window"
    else:
        option = ""
    # fix command if process name and command to run are different
    if "gnome-terminal" in app:
        app = "gnome-terminal"
    elif "chrome" in app:
        app = "/usr/bin/google-chrome-stable"


    subprocess.Popen(["/bin/bash", "-c", app+option])
    # fix exception for Chrome (command = google-chrome-stable, but processname = chrome)
    app = "chrome" if "chrome" in app else app
    while t < 30:      
        ws2 = [w.split()[0:3] for w in get("wmctrl -lp").splitlines() if not w in ws1]
        procs = [[(p, w[0]) for p in get("ps -e ww").splitlines() \
                  if app in p and w[2] in p] for w in ws2]
        if len(procs) > 0:
            time.sleep(0.5)
            w_id = procs[0][0][1]
            cmd1 = "wmctrl -ir "+w_id+" -b remove,maximized_horz"
            cmd2 = "wmctrl -ir "+w_id+" -b remove,maximized_vert"
            cmd3 = "wmctrl -ir "+procs[0][0][1]+" -e 0,"+x+","+y+","+w+","+h
            for cmd in [cmd1, cmd2, cmd3]:   
                subprocess.call(["/bin/bash", "-c", cmd])
            break
        time.sleep(0.5)
        t = t+1

def run_remembered():
    res = get_res()[1]
    try:
        lines = [l.split() for l in open(wfile).read().splitlines()]
        for l in lines:          
            l[1] = str(int(l[1]) - res[0]); l[2] = str(int(l[2]) - res[1] - 24)
            open_appwindow(l[0], l[1], l[2], l[3], l[4])   
    except FileNotFoundError:
        pass

if arg == "-run":
    run_remembered()
elif arg == "-read":
    read_windows()

Como instalar

Antes de comenzar, asegúrese de que wmctrlesté instalado:

sudo apt-get install wmctrl

Luego:

1. Copie el script en un archivo vacío, guárdelo como recall_windowsen ~/bin. Cree el directorio si es necesario. Si el directorio aún no existía, ejecútelo source ~/.profileo cierre la sesión / inicie sesión después de crear el directorio. Ahora estará en$PATH
2. Haga que el script sea ejecutable (!).

3. Ahora abrir un par de ventanas, gedit, firefoxo lo que sea, y la prueba a ejecutar la secuencia de comandos en un terminal ejecutando el comando (sin prefijo de ruta es necesario):

   recall_windows -read
   

4. cierra las ventanas. Ahora corre en una terminal:

   recall_windows -run
   

La configuración de su ventana ahora debería restaurarse

Si todo funciona bien, agregue dos comandos a las teclas de acceso directo: Elija: Configuración del sistema> "Teclado"> "Accesos directos"> "Accesos directos personalizados". Haga clic en "+" y agregue los comandos:

recall_windows -read

y

recall_windows -run

a dos teclas de acceso directo diferentes

Escribí una pequeña herramienta de biblioteca / línea de comando que permite guardar y restaurar sesiones y tiene soporte para diferentes configuraciones de monitores, así como escritorios virtuales.

Instalación

npm install -g linux-window-session-manager

Uso

Guarde la sesión actual en ~ / .lwsm / sessionData / DEFAULT.json

lwsm save

Guarde la sesión actual en ~ / .lwsm / sessionData / my-session.json

lwsm save my-session   

Restaurar la sesión desde ~ / .lwsm / sessionData / DEFAULT.json

lwsm restore

Restaurar la sesión desde ~ / .lwsm / sessionData / my-session.json

lwsm restore my-session   

Cierre con gracia todas las aplicaciones en ejecución antes de comenzar la sesión

lwsm restore --closeAllOpenWindows

Compruébalo: https://github.com/johannesjo/linux-window-session-manager

No existe tal programa. Puede instalar compiz cub:

sudo apt-get install compiz compizconfig-settings-manager compiz-fusion-plugins-extra compiz-fusion-plugins-main compiz-plugins

y sigue este tutorial

Compiz es la herramienta de escritorio más avanzada para Unity / GNOME

No sé de una manera simple de lograr esto.

Sin embargo, rara vez lo necesito por una razón muy simple: suspender. Suspender e hibernar son tus amigos. No solo guarda las posiciones de las ventanas, sino que también guarda todo el estado de su sistema. Raramente apago la computadora por completo, excepto para recargar una nueva versión del kernel.