Esiste un modo per archiviare il layout corrente del desktop?

22

Quello che voglio essere in grado di salvare le posizioni correnti delle mie applicazioni, così quando aprirò le stesse ed eseguirò qualcosa esse si riorganizzeranno com'erano.

Ad esempio, se aprirò una finestra sublime e tre terminal mi piacerebbe poterlo salvare in qualche modo.

Non mi interessa se si tratta di un'app o di uno strumento da riga di comando, a condizione di poter facilmente salvare le posizioni delle mie app.

Sono un grande fan di Moom , ma sfortunatamente funziona solo su MacOS e mi manca davvero su Ubuntu. Supporta più funzionalità e se sai qualcosa di simile ad esso in cima al mio problema principale va anche bene.

    
posta Lipis 27.09.2012 - 12:02
fonte

4 risposte

22

Nota

Lo script è stato corretto / riparato il 16 gennaio 2017, risolvendo alcune applicazioni il cui nome del processo differisce dal comando per eseguire l'applicazione . Forse, questo si verifica occasionalmente nelle applicazioni. Se qualcuno ne trova uno, per favore lascia un commento.

Script per ricordare e ripristinare la disposizione delle finestre e le loro applicazioni corrispondenti.

Lo script qui sotto può essere eseguito con due opzioni. Supponiamo che tu abbia la disposizione delle finestre come di seguito:

Per leggi (ricorda) la disposizione delle finestre corrente e le loro applicazioni, esegui lo script con l'opzione:

<script> -read

Quindi chiudi tutte le finestre:

Quindi per configura l'ultima disposizione delle finestre memorizzate, eseguila con l'opzione:

<script> -run

e l'ultima disposizione della finestra ricordata verrà ripristinata:

Funzionerà anche dopo un riavvio.

Mettendo i due comandi sotto due diversi tasti di scelta rapida, puoi "registrare" la disposizione delle finestre, spegnere il computer e richiamare la stessa disposizione delle finestre dopo (ad es.) un riavvio.

Cosa fa lo script e cosa fa non

Esegui con l'opzione -read

  • Lo script utilizza wmctrl per elencare tutte le finestre, tutte le aree di lavoro, le loro posizioni, le loro dimensioni, le applicazioni a cui appartengono
  • Lo script quindi "converte" le posizioni della finestra da posizioni relative (all'area di lavoro corrente, come nell'output di wmctrl ) a posizioni assolute , nelle aree di lavoro spanning. Pertanto, non importa se le finestre che vuoi ricordare si trovano su un solo spazio di lavoro o sono distribuite su aree di lavoro differenti.
  • Lo script quindi "memorizza" l'attuale disposizione della finestra, scrivendola in un file invisibile nella tua directory home.

Esegui con l'opzione -run

  • lo script legge l'ultima disposizione delle finestre memorizzate; avvia le applicazioni corrispondenti, sposta le finestre nelle posizioni memorizzate, anche con l'aiuto di wmctrl

Lo script non ricorda i file che potrebbero essere aperti in Windows, né (ad es.) i siti web che sono stati aperti in una finestra del browser.

Pubblicazioni

La combinazione di wmctrl e Unity ha alcuni bug, alcuni esempi:

  • le coordinate della finestra, come letto da wmctrl , differiscono leggermente dal comando per posizionare le finestre, come menzionato qui . Pertanto, le posizioni della finestra richiamate potrebbero leggermente differire dalla posizione originale.
  • I comandi wmctrl funzionano un po 'imprevedibili se il bordo della finestra è molto vicino a Unity Launcher o al pannello.
  • Le finestre "memorizzate" devono essere completamente all'interno dei bordi dell'area di lavoro per il comando di posizionamento wmctrl per funzionare correttamente.

Alcune applicazioni aprono nuove finestre per impostazione predefinita nella stessa finestra in una nuova scheda (come gedit ). L'ho corretto per gedit , ma per favore menzionalo se trovi altre eccezioni.

Lo script

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

Come impostare

Prima di iniziare, assicurati che sia installato wmctrl :

sudo apt-get install wmctrl

Quindi:

  1. Copia lo script in un file vuoto, salvalo come recall_windows in ~/bin . Crea la directory, se necessario. Se la directory non esiste ancora, eseguire source ~/.profile o disconnettersi / in dopo aver creato la directory. Ora sarà in $PATH
  2. Rendi lo script eseguibile (!).
  3. Ora apri alcune finestre, gedit , firefox o qualsiasi altra cosa, e prova-esegui lo script in un terminale eseguendo il comando (non è necessario il prefisso del percorso):

    recall_windows -read
    
  4. chiudi le finestre. Ora esegui un terminale:

    recall_windows -run
    

La configurazione della finestra dovrebbe ora essere ripristinata

Se tutto funziona correttamente, aggiungi due comandi ai tasti di scelta rapida: Scegli: Impostazioni di sistema & gt; "Tastiera" & gt; "Scorciatoie" & gt; "Scorciatoie personalizzate". Fai clic su "+" e aggiungi i comandi:

recall_windows -read

e

recall_windows -run

a due diversi tasti di scelta rapida

    
risposta data Jacob Vlijm 07.07.2015 - 19:25
fonte
2

non esiste un programma del genere. Puoi installare compiz cub:

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

e segui questo how-to

il compiz è lo strumento desktop più avanzato per unity / gnome

    
risposta data user91632 27.09.2012 - 12:52
fonte
1

Non conosco un modo semplice per raggiungere questo obiettivo.

Tuttavia, raramente ho bisogno di questo per una ragione molto semplice: sospendere. Sospendi e Ibernazione sono i tuoi amici. Non solo salvi le posizioni della finestra, ma salvi anche l'intero stato del tuo sistema. Raramente spengo completamente il computer, tranne che per ricaricare una nuova versione del kernel.

    
risposta data January 27.09.2012 - 12:23
fonte
0

Ho scritto un piccolo strumento di libreria / riga di comando che consente di salvare e ripristinare sessioni e supporta diverse configurazioni di monitor e desktop virtuali.

Installazione

npm install -g linux-window-session-manager

Uso

Salva la sessione corrente in ~ / .lwsm / sessionData / DEFAULT.json

lwsm save

Salva la sessione corrente in ~ / .lwsm / sessionData / my-session.json

lwsm save my-session   

Ripristina la sessione da ~ / .lwsm / sessionData / DEFAULT.json

lwsm restore

Ripristina la sessione da ~ / .lwsm / sessionData / my-session.json

lwsm restore my-session   

Chiudi con garbo tutte le app in esecuzione prima di avviare la sessione

lwsm restore --closeAllOpenWindows

Scoprilo: link

    
risposta data hugo der hungrige 25.04.2017 - 17:34
fonte

Leggi altre domande sui tag