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.