Posso definir Hot Corners para executar comandos personalizados no Unity?

Eu realmente gosto de cantos quentes. :-)

De alguma forma, é possível executar um comando personalizado em um canto quente, como mostrado abaixo?

CCSM

1. Instale o Gerenciador de configurações CompizConfig (CCSM). Execute no terminal:

   sudo apt-get install compizconfig-settings-manager

2. Abra o CCSM.

3. Vá para "Comandos"

4. Digite o comando desejado em um dos slots. Por exemplo:

   

5. Vá para a guia "Ligações de borda"

6. Clique em "Nenhum" e defina seu canto (ou borda) desejado, que corresponde ao comando que você acabou de definir

   

7. Mova o mouse para o canto

8. Agora seu comando foi executado!

   

Trabalho confirmado em 14.04.

Comandos personalizados

Se você estiver usando o Unity e o ccsm estiver instalado, a resposta de wjandrea é sua resposta, é claro. Caso contrário , ou para usar em outras distros, uma alternativa leve pode ser útil.

Com o script abaixo, você pode definir qualquer comando específico para cada um de seus hotcorners.

Como exemplo, fiz a seguinte configuração:

• Superior esquerdo Nenhuma ação
• Gedit no canto superior direito
• Inferior esquerdo Nenhuma ação
• Terminal inferior direito do Gnome

Claro que você também pode fazer com que os comandos executem scripts externos.

Além disso, você pode definir o tamanho do canto quente na linha:

cornersize = 10

Simplesmente mude o valor (pixels). O script define áreas (quadradas) para acionar seus comandos:

O script

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

cornersize = 20

commands = [
    None,
    "gedit",
    None,
    "gnome-terminal",
    ]

def get(cmd):
    return subprocess.check_output(cmd).decode("utf-8").strip()

def get_pos():
    return [int(s.split(":")[1]) for s in get(["xdotool", "getmouselocation"]).split()[:2]]

scrdata = get("xrandr").split(); resindex = scrdata.index("connected")+2
res = [int(n) for n in scrdata[resindex].split("+")[0].split("x")]

match1 = None

while True:
    time.sleep(1)
    xy = get_pos()
    x = xy[0]; y = xy[1]
    test = [
        [x < cornersize, y < cornersize],
        [x > res[0]-cornersize, y < cornersize],
        [x < cornersize, y > res[1]-cornersize],
        [x > res[0]-cornersize, y > res[1]-cornersize],
        ]
    match2 = [i for i, p in enumerate(test) if all(p)]
    if match2 != match1:
        if match2:
            cmd = commands[match2[0]]
            if cmd:
                subprocess.Popen(["/bin/bash", "-c", cmd])
    match1 = match2

Configuração

1. O script precisa xdotool

   sudo apt install xdotool

2. Copie o script para um arquivo vazio, salve i como hotcorners2.py

3. Na cabeça do script, defina seus comandos (observe as aspas)

   commands = [
       None,
       "gedit",
       None,
       "gnome-terminal",
   ]

   (posteriormente, superior esquerdo / direito, inferior esquerdo / direito)

4. Teste - execute o script:

   python3 /path/to/hotcorners2.py

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

   /bin/bash -c "sleep 5 && python3 /path/to/hotcorners2.py"

Notas

• Atualmente, o script é executado na (a primeira) tela. Pode ser facilmente editado para cuidar de várias telas, até fazer coisas diferentes em telas diferentes, mencione.
• Se algumas pessoas gostarem, podemos adicionar um gui e um ppa para uso conveniente e fácil instalação.

EDITAR

Se usarmos uma computação um pouco mais avançada, podemos usar um raio em vez de uma área quadrada para acionar os comandos (graças ao bom e velho @pythagoras):

Pequena diferença, mas apenas por diversão:

O script

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

# set distance (hotcorner sensitivity)
radius = 20

# top-left, top-right, bottom-left, bottom-right
commands = [
    None,
    "gedit",
    None,
    "gnome-terminal",
    ]

def get(cmd):
    return subprocess.check_output(cmd).decode("utf-8").strip()

def get_pos():
    return [int(s.split(":")[1]) for s in get(["xdotool", "getmouselocation"]).split()[:2]]

# get the resolution
scrdata = get("xrandr").split(); resindex = scrdata.index("connected")+2
res = [int(n) for n in scrdata[resindex].split("+")[0].split("x")]
# list the corners, could be more elegant no doubt
corners = [[0, 0], [res[0], 0], [0, res[1]], [res[0], res[1]]]

match1 = None

while True:
    time.sleep(1)
    pos = get_pos()
    # get the current difference from the mousepointer to each of the corner (radius)
    diff = [int(math.sqrt(sum([(c[i]-pos[i])**2 for i, n in enumerate(res)])))\
            for c in corners]
    # see if any of the corners is "approached" within the radius
    match2 = [diff.index(n) for n in diff if n < radius]
    # if so, and the corresponding command is not set to None, run it.
    if all([match2 != match1, match2]):
        cmd = commands[match2[0]]
        if cmd:
            subprocess.Popen(["/bin/bash", "-c", cmd])
    match1 = match2

Uso

É praticamente o mesmo. Defina seus comandos e o raio a ser disparado na seção principal do script.

NOTA:

A resposta de wjandrea é a resposta mais adequada para alguém que usa o Ubuntu ou o Ubuntu Kylin padrão (ou possui o compiz como seu gerenciador de exibição), assim, obtém meu voto positivo e respeito. A resposta fornecida abaixo também pode ser usada no Unity, mas provavelmente seria um pouco redundante. No entanto, em ambientes de desktop que não possuem compiz, pode-se usar o indicador apresentado abaixo. Eu testei brevemente no Lubuntu 16.04 VM, então eu sei que funciona lá e o tornei compatível com o Kylin 14.04 também. Para áreas de trabalho GNOME e MATE, você precisará ter o suporte para AppIndicators ativado primeiro para usar qualquer indicador.

Introdução

Eu implementei o indicator-edgerque permite acionar comandos definidos pelo usuário com base na posição do mouse em qualquer lugar ao longo das 4 bordas da tela. A versão original foi concluída em um dia, em aproximadamente 7 horas, portanto, é bastante minimalista, mas faz o trabalho.

O indicador é controlado via ~/.edger-commands.jsonarquivo, obviamente em jsonformato. Pode ser escrito manualmente pelo usuário ou definido através da DEFINE COMMANDSopção do indicador . A opção de ativação / desativação do acionamento é lembrada e gravada automaticamente no arquivo para conveniência do usuário. O arquivo de configuração de amostra seria assim:

{
    "right": "gnome-terminal",
    "top": "firefox",
    "left": "",
    "bottom": "gnome-screenshot",
    "enabled": true
}

Observe a "left"entrada no arquivo. Essa borda não está definida, mas devido à jsonsintaxe, é necessário ter uma string vazia, ou seja, aspas "".

Depois que o indicador detectar que o usuário colocou o mouse ao longo de qualquer uma das bordas (com margem de ~ 3 pixels), o indicador enviará uma notificação de bolha e executará o comando apropriado (se definido). A ativação do gatilho não será repetida, a menos que o usuário afaste o mouse da borda.

Como você pode ver na captura de tela acima, o indicador também possui saída de depuração na linha de comando. Se você encontrar algum erro, sinta-se à vontade para executá-lo no terminal, descubra qual erro ocorre e envie um relatório de erro apropriado na página de problemas do GitHub do projeto .

Atualmente, não há suporte para cantos (apenas arestas) e ele foi construído para a configuração de um monitor (obviamente, não é possível cobrir todas as bases dentro de 7 horas da criação), mas esses recursos poderão estar disponíveis no futuro.

Instalação e código fonte

O código fonte está disponível na página de projetos do GitHub ou via Launchpad . A instalação é realizada através dos seguintes comandos no terminal:

sudo add-apt-repository ppa:1047481448-2/sergkolo
sudo apt-get update
sudo apt-get install indicator-edger