como tornar o docky disponível apenas em um espaço de trabalho?

Question

Existe uma maneira de tornar o docky disponível apenas em um espaço de trabalho e não em qualquer outro espaço de trabalho no Ubuntu 14.04.

    

Answer 1

Um script de segundo plano para tornar o docky executado em espaços de trabalho específicos (ou não)

Baseado exatamente no mesmo mecanismo que esta resposta , abaixo de um script de segundo plano que inicia / interrompe o Docky launcher , dependendo do espaço de trabalho atual.

O mecanismo em si é praticamente testado. Dito isto, na questão ligada é testado com a definição de Unity Launchers diferentes e a definição de diferentes papéis de parede por área de trabalho, não iniciando / parando Docky . Isso, no entanto, não faz diferença alguma, e nas horas que testei, correu sem um único erro.

Como usar

1. O script precisa de wmctrl :

   sudo apt-get install wmctrl
   

2. Copie o script abaixo em um arquivo vazio, salve-o como docky_perworkspace.py

3. Teste o script:

   • Iniciar Docky

   • Inicie o script com o comando:

     python3 /path/to/docky_perworkspace.py
     

   • Agora o Docky é executado em todos os espaços de trabalho. Navegue até os espaços de trabalho que você não deseja que Docky apareça e execute (enquanto estiver no espaço de trabalho):

     pkill docky
     

   N.B. Use pkill docky , não feche o docky a partir do seu próprio menu!

4. Isso é muito bonito. Se você quiser alterar a configuração, simplesmente inicie ou mate o docky no espaço de trabalho que deseja executar ou não; o roteiro vai lembrar sua preferência.

5. Se tudo funcionar bem, adicione-o aos seus aplicativos de inicialização: Dash > Aplicativos de inicialização > Adicione o comando:

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

O script

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

datadir = os.environ["HOME"]+"/.config/docky_run"
if not os.path.exists(datadir):
    os.makedirs(datadir)
workspace_data = datadir+"/docky_set_"

def get_runs():
    try:
        subprocess.check_output(["pgrep", "docky"]).decode("utf-8")
        return True
    except:
        return False

def get_res():
    # get resolution
    xr = subprocess.check_output(["xrandr"]).decode("utf-8").split()
    pos = xr.index("current")
    return [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]

def current():
    # get the current viewport
    res = get_res()
    vp_data = subprocess.check_output(
        ["wmctrl", "-d"]
        ).decode("utf-8").split()
    dt = [int(n) for n in vp_data[3].split("x")]
    cols = int(dt[0]/res[0])
    curr_vpdata = [int(n) for n in vp_data[5].split(",")]
    curr_col = int(curr_vpdata[0]/res[0])+1
    curr_row = int(curr_vpdata[1]/res[1])
    return str(curr_col+curr_row*cols)

curr_ws1 = current()
runs1 = get_runs()

while True:
    time.sleep(1)
    runs2 = get_runs()
    curr_ws2 = current()
    datafile = workspace_data+curr_ws2
    if curr_ws2 == curr_ws1:
        if runs2 != runs1:
            open(datafile, "wt").write(str(runs2))
    else:
        if not os.path.exists(datafile):
            open(datafile, "wt").write(str(runs2))
        else:
            curr_set = eval(open(datafile).read())
            if all([curr_set == True, runs2 == False]):
                subprocess.Popen(["docky"])
            elif all([curr_set == False, runs2 == True]):
                subprocess.Popen(["pkill", "docky"])           
    curr_ws1 = curr_ws2
    runs1 = get_runs()

Explicação

O script rastreia o espaço de trabalho atual (não importa quantas áreas de trabalho você tenha). Por área de trabalho, um arquivo é criado em /.config/docky_run , no qual é "gravado" se o docky deve estar presente ou não na área de trabalho de referência ( True ou False )

Se você permanecer no mesmo espaço de trabalho, mas o docky for iniciado ou inativado (seu pid aparece ou termina), o script "entende" que você fez a alteração no espaço de trabalho de referência e o arquivo está atualizado .

Se a área de trabalho for alterada, o script verá se o arquivo existe, lê-o e inicia ou mata o docky (ou não faz nada se não for necessário), de acordo com o conteúdo do arquivo e situação atual. Se o arquivo ainda não existir (porque você está usando o espaço de trabalho pela primeira vez desde que iniciou o script pela primeira vez), o arquivo é criado e configurado para a situação atual (última).

Como as configurações por espaço de trabalho são lembradas em arquivos, elas serão lembradas mesmo depois de uma reinicialização.