Iniciando um aplicativo minimizado
Iniciar um aplicativo de maneira minimizada exige dois comandos:
- iniciando o aplicativo
- minimize sua janela
Portanto, o comando ou script precisa ser "inteligente"; o segundo comando deve aguardar a exibição da janela do aplicativo.
Solução geral para iniciar um aplicativo minimizado
O script abaixo faz isso e pode ser usado como uma solução geral para iniciar um aplicativo de maneira minimizada. Basta executá-lo na sintaxe:
<script> <command_to_run_the_application> <window_name>
O script
#!/usr/bin/env python3
import subprocess
import sys
import time
subprocess.Popen(["/bin/bash", "-c", sys.argv[1]])
windowname = sys.argv[2]
def read_wlist(w_name):
try:
l = subprocess.check_output(["wmctrl", "-l"]).decode("utf-8").splitlines()
return [w.split()[0] for w in l if w_name in w][0]
except (IndexError, subprocess.CalledProcessError):
return None
t = 0
while t < 30:
window = read_wlist(windowname)
time.sleep(0.1)
if window != None:
subprocess.Popen(["xdotool", "windowminimize", window])
break
time.sleep(1)
t += 1
Como usar
O script precisa dos dois wmctrl e xdotool :
sudo apt-get install wmctrl xdotool
Então:
- Copie o script em um arquivo vazio, salve-o como
startup_minimizd.py -
Teste: execute o script com (por exemplo)
gedito comando:python3 /path/to/startup_minimizd.py gedit gedit - Se tudo funcionar bem, adicione o comando (para seu aplicativo) a
Startup Applications
Explicação
- O script inicializa o aplicativo, executando o comando que você deu como primeiro argumento
- Em seguida, o script verifica a lista de janelas (com a ajuda de
wmctrl) para as janelas, nomeadas após seu segundo argumento. - Se a janela aparecer, ela será imediatamente minimizada com a ajuda de
xdotoolPara evitar um loop infinito se a janela não aparecer por algum motivo, o script pratica um limite de tempo de 30 segundos para que a janela apareça.
Nota
Não é necessário mencionar que você pode usar o script para vários aplicativos de uma só vez, já que você o executa com argumentos fora do script.
EDITAR
reconhecendo a janela pelo seu pid
Se o título da janela for inseguro ou variável, ou houver risco de conflito de nomes no nome da janela, usar o pid é um método mais confiável para usar.
O script abaixo é baseado no uso do pid do aplicativo, como na saída de wmctrl -lp e ps -ef .
A configuração é praticamente a mesma, mas o título da janela não é necessário nesta versão, então o comando para executá-la é:
python3 /path/to/startup_minimizd.py <command_to_run_application>
Assim como o primeiro script, ele precisa dos dois wmctrl e xdotool
O script
#!/usr/bin/env python3
import subprocess
import sys
import time
command = sys.argv[1]
command_check = command.split("/")[-1]
subprocess.Popen(["/bin/bash", "-c", command])
t = 1
while t < 30:
try:
w_list = [l.split() for l in subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8").splitlines()]
proc = subprocess.check_output(["pgrep", "-f", command_check]).decode("utf-8").strip().split()
match = sum([[l[0] for l in w_list if p in l] for p in proc], [])
subprocess.Popen(["xdotool", "windowminimize", match[0]])
break
except (IndexError, subprocess.CalledProcessError):
pass
t += 1
time.sleep(1)
Anote no segundo script
Embora, em geral, a segunda versão deva ser mais confiável, nos casos em que o aplicativo é iniciado por um script wrapper, o pid do comando será diferente do aplicativo que é finalmente chamado.
Nesses casos, recomendo usar o primeiro script.
EDIT2 uma versão específica do script para o Steam
Conforme solicitado em um comentário, abaixo de uma versão, feita especificamente para a inicialização do STEAM, foi minimizada.
Por que uma versão específica para o Steam?
Acontece que Steam se comporta bem diferente de um aplicativo "normal":
- Acontece que
Steamnão executa um pid, mas não menos que (no meu teste) oito! -
Steamé executado na inicialização com pelo menos duas janelas (uma janela semelhante a um splash), mas às vezes uma janela de mensagem adicional é exibida. - O Windows do Steam tem
pid 0, o que é um problema no script como era. - Depois que a janela principal é criada, a janela é levantada uma segunda vez depois de um segundo, portanto, uma minimização única não funcionará.
Esse comportamento excepcional de Steam pede uma versão especial do script, que é adicionada abaixo. O script é iniciado em Steam e, durante 12 segundos, fica de olho em todas as novas janelas do WM_CLASS correspondente, verificando se elas estão minimizadas. Se não, o script garante que eles serão.
Como o script original, este precisa que wmctrl e xdotool estejam instalados.
O script
#!/usr/bin/env python3
import subprocess
import time
command = "steam"
subprocess.Popen(["/bin/bash", "-c", command])
def get(cmd):
return subprocess.check_output(cmd).decode("utf-8").strip()
t = 0
while t < 12:
try:
w_list = [l.split()[0] for l in get(["wmctrl", "-l"]).splitlines()]
for w in w_list:
data = get(["xprop", "-id", w])
if all(["Steam" in data, not "_NET_WM_STATE_HIDDEN" in data]):
subprocess.Popen(["xdotool", "windowminimize", w])
except (IndexError, subprocess.CalledProcessError):
pass
t += 1
time.sleep(1)
Para usá-lo
- Basta copiá-lo em um arquivo vazio, salve-o como
runsteam_minimized.py -
Execute-o pelo comando:
python3 /path/to/runsteam_minimized.py