Posso definir Hot Corners para executar comandos personalizados no Unity?


13

Eu realmente gosto de cantos quentes. :-)

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

insira a descrição da imagem aqui


Não acho que seja possível com as hotcorners especificamente (pelo menos não com a forma como o Unity as usa), mas é possível disparar scripts quando o mouse é colocado em uma área específica da tela. Por exemplo, consulte askubuntu.com/a/758307/295286 , seção Passe o mouse sobre a ação. Vou analisar mais sobre hotcorners, mas se não der certo, o script personalizado está OK?
— Sergiy Kolodyazhnyy

Multi-monitor ou único?
— Jacob Vlijm

Oi orschiro, postado. Mencione se tudo está claro (ou não).
— Jacob Vlijm

Ei, vejo que há mais hotcorners aqui do que na minha resposta. Quantas você prefere?
— Jacob Vlijm

2
@JacobVlijm, Serg, veja minha resposta.
— Wjandrea

Respostas:


10

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:

    Captura de tela do CCSM - comando

  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

    Captura de tela do CCSM - cantos quentes

  7. Mova o mouse para o canto

  8. Agora seu comando foi executado!

    Captura de tela do CCSM - execução de comando

Trabalho confirmado em 14.04.


Mais fácil de todas as soluções propostas. Se o comando desejado for realizado melhor através de um script, basta fazer o comando compiz apontar para esse script ou apenas o nome do script se o script estiver em uma pasta bin em $ PATH. A única desvantagem possível é que a unidade / compiz sabe 'perder' aleatoriamente comandos do conjunto de usuários, ou seja, aqueles que não estão integrados. Como integrar um comando do usuário está além do escopo desta pergunta.
— doug

@wjandrea Por isso, é implementado depois de tudo. Compiz não aproveita para me surpreender. Boa resposta, mais adequada ao que o OP busca. + 1'ed
— Sergiy Kolodyazhnyy

Infelizmente, você está certo, haha. Sim, exatamente o que o OP pediu.
— Jacob Vlijm

Você me ajudou várias vezes com suas edições e respostas. Tenha um "cookie", como ole'Serg costumava dizer ... realmente tem meia dúzia :)
— WinEunuuchs2Unix

6

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:

insira a descrição da imagem aqui

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):

insira a descrição da imagem aqui

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.


5

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.

insira a descrição da imagem aqui

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.

insira a descrição da imagem aqui

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.