| """ |
| Atalho global do openTARS: uma combinação de teclas (padrão Ctrl+Alt+Espaço) |
| que abre a barra rápida de qualquer lugar. |
| |
| Quem "escuta" a tecla é o próprio ambiente de trabalho: o openTARS só |
| cadastra um atalho personalizado nas configurações dele, igual a quem vai |
| em Configurações > Teclado > Atalhos personalizados. Aparece lá, dá pra |
| mudar ou apagar por lá também. Suportados: GNOME (Ubuntu, Zorin, Pop!_OS, |
| Budgie), Cinnamon (Mint), MATE e XFCE. No KDE e nos demais, o comando a |
| cadastrar à mão é "opentars-gui --rapido". |
| |
| Por que não Super+Espaço: no GNOME/Zorin ele já troca o layout do |
| teclado, e dois atalhos iguais brigam. |
| |
| Uso: opentars --atalho mostra a situação |
| opentars --atalho ctrl+alt+space cadastra/troca |
| opentars --atalho off remove |
| """ |
|
|
| import os |
| import re |
| import shlex |
| import shutil |
| import subprocess |
| import sys |
| from pathlib import Path |
|
|
| import tars_i18n as i18n |
| import tars_plataforma as plataforma |
| from tars_i18n import t |
|
|
| PADRAO = "<Primary><Alt>space" |
| NOME = "openTARS" |
| MARCA_COMANDO = "--rapido" |
| |
| ACOES_NOME = "openTARS: ações de texto" |
| ACOES_MARCA = "--acoes" |
| ACOES_PADRAO = "<Primary><Alt>r" |
| TIMEOUT_SEG = 5 |
|
|
| GNOME_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys" |
| GNOME_CAMINHO = "/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/" |
| CINNAMON_SCHEMA = "org.cinnamon.desktop.keybindings" |
| CINNAMON_CAMINHO = "/org/cinnamon/desktop/keybindings/custom-keybindings/" |
| MATE_ATALHOS = "org.mate.Marco.global-keybindings" |
| MATE_COMANDOS = "org.mate.Marco.keybinding-commands" |
| XFCE_CANAL = "xfce4-keyboard-shortcuts" |
|
|
| |
| ESQUEMAS_DO_SISTEMA = { |
| "gnome": ("org.gnome.desktop.wm.keybindings", "org.gnome.shell.keybindings", |
| "org.gnome.mutter.keybindings", GNOME_SCHEMA), |
| "cinnamon": ("org.cinnamon.desktop.keybindings.wm", "org.cinnamon.desktop.keybindings.media-keys"), |
| "mate": ("org.mate.Marco.global-keybindings", "org.mate.Marco.window-keybindings"), |
| } |
|
|
| |
| NOMES_TECLAS = { |
| "space": "space", "espaco": "space", "espaço": "space", "espacio": "space", "espace": "space", |
| "leertaste": "space", "enter": "Return", "return": "Return", "tab": "Tab", "esc": "Escape", |
| "escape": "Escape", "home": "Home", "end": "End", "pageup": "Page_Up", "pagedown": "Page_Down", |
| "insert": "Insert", "delete": "Delete", "backspace": "BackSpace", |
| } |
|
|
| MODIFICADORES = { |
| "ctrl": "<Primary>", "control": "<Primary>", "primary": "<Primary>", "strg": "<Primary>", |
| "alt": "<Alt>", "shift": "<Shift>", "super": "<Super>", "win": "<Super>", "meta": "<Super>", |
| "mod4": "<Super>", |
| } |
|
|
|
|
| |
| |
| |
|
|
| def normalizar_combinacao(texto): |
| """"Ctrl+Alt+Space", "<Control><Alt>space", "super+t" -> formato GTK |
| ("<Primary><Alt>space"). None se não der pra entender.""" |
| texto = (texto or "").strip() |
| if not texto: |
| return None |
| if "<" in texto: |
| mods = re.findall(r"<([^>]+)>", texto) |
| tecla = re.sub(r"<[^>]+>", "", texto).strip() |
| else: |
| partes = [p.strip() for p in texto.replace("-", "+").split("+") if p.strip()] |
| if not partes: |
| return None |
| mods, tecla = partes[:-1], partes[-1] |
| saida = [] |
| for mod in mods: |
| convertido = MODIFICADORES.get(mod.lower()) |
| if not convertido: |
| return None |
| if convertido not in saida: |
| saida.append(convertido) |
| if not tecla or not saida: |
| return None |
| nome = tecla.lower() |
| if nome in NOMES_TECLAS: |
| tecla = NOMES_TECLAS[nome] |
| elif re.fullmatch(r"f\d{1,2}", nome): |
| tecla = nome.upper() |
| elif len(tecla) == 1: |
| tecla = nome |
| ordem = ["<Primary>", "<Shift>", "<Alt>", "<Super>"] |
| return "".join(sorted(saida, key=ordem.index)) + tecla |
|
|
|
|
| def legivel(combinacao): |
| """"<Primary><Alt>space" -> "Ctrl+Alt+Espaço" (no idioma escolhido).""" |
| nomes = {"<Primary>": "Ctrl", "<Control>": "Ctrl", "<Alt>": "Alt", "<Shift>": "Shift", "<Super>": "Super"} |
| mods = re.findall(r"<[^>]+>", combinacao or "") |
| tecla = re.sub(r"<[^>]+>", "", combinacao or "") |
| tecla = t("atalho.tecla_espaco") if tecla.lower() == "space" else tecla.upper() if len(tecla) == 1 else tecla.capitalize() |
| return "+".join([nomes.get(m, m.strip("<>")) for m in mods] + [tecla]) |
|
|
|
|
| def _mesma(a, b): |
| return normalizar_combinacao(a) == normalizar_combinacao(b) |
|
|
|
|
| def _eh_nosso(comando, marca=MARCA_COMANDO): |
| comando = comando or "" |
| return marca in comando and ("opentars" in comando.lower() or "tars_gui" in comando) |
|
|
|
|
| def comando_barra_rapida(marca=MARCA_COMANDO): |
| lancador = plataforma.lancador("opentars-gui") |
| if lancador: |
| return f"{lancador} {marca}" |
| gui = Path(__file__).resolve().with_name("tars_gui.py") |
| return f"{shlex.quote(sys.executable)} {shlex.quote(str(gui))} {marca}" |
|
|
|
|
| |
| |
| |
|
|
| def _rodar(*cmd): |
| try: |
| r = subprocess.run(cmd, capture_output=True, text=True, timeout=TIMEOUT_SEG) |
| return r.returncode, r.stdout.strip() |
| except Exception as e: |
| return -1, str(e) |
|
|
|
|
| def _gsettings_get(esquema, chave): |
| codigo, saida = _rodar("gsettings", "get", esquema, chave) |
| return saida if codigo == 0 else None |
|
|
|
|
| def _gsettings_set(esquema, chave, valor): |
| return _rodar("gsettings", "set", esquema, chave, valor)[0] == 0 |
|
|
|
|
| def _lista_gvariant(texto): |
| """"['a', 'b']", "@as []" ou uma string solta -> ['a', 'b']. O gsettings escreve entre aspas DUPLAS quando o |
| texto tem aspa simples (ex.: o comando com caminho entre aspas), por isso lê com o literal do Python.""" |
| import ast |
| t = re.sub(r"^\s*@\w+\s+", "", texto or "").strip() |
| try: |
| v = ast.literal_eval(t) |
| if isinstance(v, str): |
| return [v] |
| if isinstance(v, (list, tuple)): |
| return [str(x) for x in v] |
| return [] |
| except (ValueError, SyntaxError): |
| return re.findall(r"'((?:[^'\\]|\\.)*)'", texto or "") |
|
|
|
|
| def _gvariant_texto(valor): |
| return "'" + valor.replace("\\", "\\\\").replace("'", "\\'") + "'" |
|
|
|
|
| def _gvariant_lista(valores): |
| return "[" + ", ".join(_gvariant_texto(v) for v in valores) + "]" if valores else "@as []" |
|
|
|
|
| def _esquema_existe(esquema): |
| codigo, saida = _rodar("gsettings", "list-schemas") |
| return codigo == 0 and esquema in saida.split() |
|
|
|
|
| def _conflito_no_sistema(ambiente, combinacao): |
| """Nome da ação do sistema que já usa a combinação, se houver.""" |
| for esquema in ESQUEMAS_DO_SISTEMA.get(ambiente, ()): |
| codigo, saida = _rodar("gsettings", "list-recursively", esquema) |
| if codigo != 0: |
| continue |
| for linha in saida.splitlines(): |
| partes = linha.split(None, 2) |
| if len(partes) == 3 and any(_mesma(v, combinacao) for v in _lista_gvariant(partes[2])): |
| return f"{esquema} {partes[1]}" |
| return None |
|
|
|
|
| |
| |
| |
|
|
| def ambiente(): |
| atual = (os.environ.get("XDG_CURRENT_DESKTOP") or os.environ.get("DESKTOP_SESSION") or "").upper() |
| if "CINNAMON" in atual: |
| return "cinnamon" |
| if "MATE" in atual: |
| return "mate" |
| if "XFCE" in atual: |
| return "xfce" |
| if "KDE" in atual or "PLASMA" in atual: |
| return "kde" |
| if any(n in atual for n in ("GNOME", "UNITY", "BUDGIE", "ZORIN", "POP", "UBUNTU")): |
| return "gnome" |
| return None |
|
|
|
|
| _NOMES_AMBIENTE = {"gnome": "GNOME", "cinnamon": "Cinnamon", "mate": "MATE", "xfce": "XFCE", "kde": "KDE"} |
|
|
|
|
| def _gnome_itens(): |
| caminhos = _lista_gvariant(_gsettings_get(GNOME_SCHEMA, "custom-keybindings")) |
| itens = [] |
| for caminho in caminhos: |
| esquema = f"{GNOME_SCHEMA}.custom-keybinding:{caminho}" |
| itens.append({ |
| "caminho": caminho, |
| "comando": (_lista_gvariant(_gsettings_get(esquema, "command")) or [""])[0], |
| "atalho": (_lista_gvariant(_gsettings_get(esquema, "binding")) or [""])[0], |
| }) |
| return caminhos, itens |
|
|
|
|
| def _registrar_gnome(combinacao, nome=NOME, marca=MARCA_COMANDO): |
| if not shutil.which("gsettings") or not _esquema_existe(GNOME_SCHEMA): |
| return False, t("atalho.sem_suporte") |
| caminhos, itens = _gnome_itens() |
| nosso = next((i for i in itens if _eh_nosso(i["comando"], marca)), None) |
| outro = next((i for i in itens if i is not nosso and _mesma(i["atalho"], combinacao)), None) |
| if outro: |
| return False, t("atalho.conflito", acao=outro["comando"] or outro["caminho"]) |
| sistema = _conflito_no_sistema("gnome", combinacao) |
| if sistema: |
| return False, t("atalho.conflito", acao=sistema) |
| if nosso: |
| caminho = nosso["caminho"] |
| else: |
| usados = set(caminhos) |
| n = 0 |
| while f"{GNOME_CAMINHO}custom{n}/" in usados: |
| n += 1 |
| caminho = f"{GNOME_CAMINHO}custom{n}/" |
| esquema = f"{GNOME_SCHEMA}.custom-keybinding:{caminho}" |
| ok = (_gsettings_set(esquema, "name", _gvariant_texto(nome)) |
| and _gsettings_set(esquema, "command", _gvariant_texto(comando_barra_rapida(marca))) |
| and _gsettings_set(esquema, "binding", _gvariant_texto(combinacao))) |
| if ok and caminho not in caminhos: |
| ok = _gsettings_set(GNOME_SCHEMA, "custom-keybindings", _gvariant_lista(caminhos + [caminho])) |
| return ok, None if ok else t("atalho.falhou") |
|
|
|
|
| def _remover_gnome(marca=MARCA_COMANDO): |
| caminhos, itens = _gnome_itens() |
| nossos = [i["caminho"] for i in itens if _eh_nosso(i["comando"], marca)] |
| if not nossos: |
| return True |
| for caminho in nossos: |
| _rodar("gsettings", "reset-recursively", f"{GNOME_SCHEMA}.custom-keybinding:{caminho}") |
| return _gsettings_set(GNOME_SCHEMA, "custom-keybindings", _gvariant_lista([c for c in caminhos if c not in nossos])) |
|
|
|
|
| def _cinnamon_itens(): |
| nomes = _lista_gvariant(_gsettings_get(CINNAMON_SCHEMA, "custom-list")) |
| itens = [] |
| for nome in nomes: |
| esquema = f"{CINNAMON_SCHEMA}.custom-keybinding:{CINNAMON_CAMINHO}{nome}/" |
| itens.append({ |
| "nome": nome, |
| "comando": (_lista_gvariant(_gsettings_get(esquema, "command")) or [""])[0], |
| "atalhos": _lista_gvariant(_gsettings_get(esquema, "binding")), |
| }) |
| return nomes, itens |
|
|
|
|
| def _registrar_cinnamon(combinacao): |
| if not shutil.which("gsettings") or not _esquema_existe(CINNAMON_SCHEMA): |
| return False, t("atalho.sem_suporte") |
| nomes, itens = _cinnamon_itens() |
| nosso = next((i for i in itens if _eh_nosso(i["comando"])), None) |
| outro = next((i for i in itens if i is not nosso and any(_mesma(a, combinacao) for a in i["atalhos"])), None) |
| if outro: |
| return False, t("atalho.conflito", acao=outro["comando"] or outro["nome"]) |
| sistema = _conflito_no_sistema("cinnamon", combinacao) |
| if sistema: |
| return False, t("atalho.conflito", acao=sistema) |
| if nosso: |
| nome = nosso["nome"] |
| else: |
| n = 0 |
| while f"custom{n}" in nomes: |
| n += 1 |
| nome = f"custom{n}" |
| esquema = f"{CINNAMON_SCHEMA}.custom-keybinding:{CINNAMON_CAMINHO}{nome}/" |
| ok = (_gsettings_set(esquema, "name", _gvariant_texto(NOME)) |
| and _gsettings_set(esquema, "command", _gvariant_texto(comando_barra_rapida())) |
| and _gsettings_set(esquema, "binding", _gvariant_lista([combinacao]))) |
| if ok and nome not in nomes: |
| ok = _gsettings_set(CINNAMON_SCHEMA, "custom-list", _gvariant_lista(nomes + [nome])) |
| return ok, None if ok else t("atalho.falhou") |
|
|
|
|
| def _remover_cinnamon(): |
| nomes, itens = _cinnamon_itens() |
| nossos = [i["nome"] for i in itens if _eh_nosso(i["comando"])] |
| for nome in nossos: |
| _rodar("gsettings", "reset-recursively", f"{CINNAMON_SCHEMA}.custom-keybinding:{CINNAMON_CAMINHO}{nome}/") |
| return not nossos or _gsettings_set(CINNAMON_SCHEMA, "custom-list", _gvariant_lista([n for n in nomes if n not in nossos])) |
|
|
|
|
| def _registrar_mate(combinacao): |
| if not shutil.which("gsettings") or not _esquema_existe(MATE_COMANDOS): |
| return False, t("atalho.sem_suporte") |
| livre = None |
| for n in range(1, 13): |
| comando = (_lista_gvariant(_gsettings_get(MATE_COMANDOS, f"command-{n}")) or [""])[0] |
| atalho = (_lista_gvariant(_gsettings_get(MATE_ATALHOS, f"run-command-{n}")) or [""])[0] |
| if _eh_nosso(comando): |
| livre = n |
| break |
| if _mesma(atalho, combinacao): |
| return False, t("atalho.conflito", acao=comando or f"run-command-{n}") |
| if livre is None and not comando and atalho in ("", "disabled"): |
| livre = n |
| if livre is None: |
| return False, t("atalho.sem_espaco") |
| sistema = _conflito_no_sistema("mate", combinacao) |
| if sistema and f"run-command-{livre}" not in sistema: |
| return False, t("atalho.conflito", acao=sistema) |
| ok = (_gsettings_set(MATE_COMANDOS, f"command-{livre}", _gvariant_texto(comando_barra_rapida())) |
| and _gsettings_set(MATE_ATALHOS, f"run-command-{livre}", _gvariant_texto(combinacao))) |
| return ok, None if ok else t("atalho.falhou") |
|
|
|
|
| def _remover_mate(): |
| for n in range(1, 13): |
| comando = (_lista_gvariant(_gsettings_get(MATE_COMANDOS, f"command-{n}")) or [""])[0] |
| if _eh_nosso(comando): |
| _rodar("gsettings", "reset", MATE_COMANDOS, f"command-{n}") |
| _rodar("gsettings", "reset", MATE_ATALHOS, f"run-command-{n}") |
| return True |
|
|
|
|
| def _xfconf(*args): |
| return _rodar("xfconf-query", "-c", XFCE_CANAL, *args) |
|
|
|
|
| def _registrar_xfce(combinacao): |
| if not shutil.which("xfconf-query"): |
| return False, t("atalho.sem_suporte") |
| for base in ("/commands/custom/", "/xfwm4/custom/"): |
| codigo, atual = _xfconf("-p", base + combinacao) |
| if codigo == 0 and atual and not _eh_nosso(atual): |
| return False, t("atalho.conflito", acao=atual) |
| _remover_xfce() |
| ok = _xfconf("-p", "/commands/custom/" + combinacao, "-n", "-t", "string", "-s", comando_barra_rapida())[0] == 0 |
| return ok, None if ok else t("atalho.falhou") |
|
|
|
|
| def _remover_xfce(): |
| codigo, saida = _xfconf("-l", "-v") |
| if codigo != 0: |
| return False |
| for linha in saida.splitlines(): |
| partes = linha.split(None, 1) |
| if len(partes) == 2 and partes[0].startswith("/commands/custom/") and _eh_nosso(partes[1]): |
| _xfconf("-p", partes[0], "-r") |
| return True |
|
|
|
|
| _REGISTRAR = {"gnome": _registrar_gnome, "cinnamon": _registrar_cinnamon, "mate": _registrar_mate, "xfce": _registrar_xfce} |
| _REMOVER = {"gnome": _remover_gnome, "cinnamon": _remover_cinnamon, "mate": _remover_mate, "xfce": _remover_xfce} |
|
|
|
|
| |
| |
| |
|
|
| def registrar(combinacao=None): |
| """Cadastra (ou troca) o atalho. Devolve (ok, mensagem).""" |
| combinacao = normalizar_combinacao(combinacao) if combinacao else (i18n.ler_config().get("atalho") or PADRAO) |
| if not combinacao: |
| return False, t("atalho.invalido") |
| qual = ambiente() |
| funcao = _REGISTRAR.get(qual) |
| if funcao is None: |
| motivo = t("atalho.manual", ambiente=_NOMES_AMBIENTE.get(qual, qual or "?"), comando="opentars-gui --rapido") |
| i18n.salvar_config(atalho=combinacao, atalho_registrado=False, atalho_tentado=True) |
| return False, motivo |
| ok, motivo = funcao(combinacao) |
| i18n.salvar_config(atalho=combinacao, atalho_registrado=ok, atalho_tentado=True, |
| atalho_ambiente=_NOMES_AMBIENTE.get(qual, qual)) |
| if ok: |
| return True, t("atalho.registrado", atalho=legivel(combinacao), ambiente=_NOMES_AMBIENTE.get(qual, qual)) |
| return False, motivo |
|
|
|
|
| def remover(): |
| qual = ambiente() |
| funcao = _REMOVER.get(qual) |
| ok = funcao() if funcao else True |
| i18n.salvar_config(atalho_registrado=False, atalho_tentado=True, atalho_desligado=True) |
| return ok, t("atalho.removido") |
|
|
|
|
| def estado(): |
| config = i18n.ler_config() |
| combinacao = config.get("atalho") or PADRAO |
| info = {"combinacao": combinacao, "legivel": legivel(combinacao), "ambiente": config.get("atalho_ambiente"), |
| "registrado": bool(config.get("atalho_registrado"))} |
| if not info["registrado"]: |
| qual = ambiente() |
| if qual not in _REGISTRAR: |
| info["motivo"] = t("atalho.manual", ambiente=_NOMES_AMBIENTE.get(qual, qual or "?"), |
| comando="opentars-gui --rapido") |
| return info |
|
|
|
|
| def garantir_registrado(): |
| """Na primeira vez que a janela abre: cadastra o atalho padrão (uma |
| tentativa só; quem desligou com --atalho off não é incomodado).""" |
| config = i18n.ler_config() |
| if config.get("atalho_tentado") or config.get("atalho_desligado"): |
| return None |
| if os.environ.get("TARS_SEM_ATALHO") == "1": |
| return None |
| return registrar() |
|
|
|
|
| def para_windows(combinacao): |
| """'<Primary><Alt>r' -> (modificadores, código da tecla) do RegisterHotKey do Windows; None se a tecla não tiver código.""" |
| bits = {"primary": 2, "control": 2, "ctrl": 2, "alt": 1, "shift": 4, "super": 8} |
| modificadores = sum(bits.get(m.lower(), 0) for m in re.findall(r"<(\w+)>", combinacao or "")) |
| tecla = re.sub(r"<\w+>", "", combinacao or "") |
| especiais = {"space": 0x20, "Return": 0x0D, "Tab": 0x09, "Escape": 0x1B} |
| if tecla in especiais: |
| codigo = especiais[tecla] |
| elif len(tecla) == 1 and tecla.isascii() and tecla.isalnum(): |
| codigo = ord(tecla.upper()) |
| elif re.fullmatch(r"F([1-9]|1[0-2])", tecla): |
| codigo = 0x6F + int(tecla[1:]) |
| else: |
| return None |
| return modificadores, codigo |
|
|
|
|
| |
| _TECLAS_MAC = "asdfhgzxcv§bqweryt123465=97-80]ou[ip\nlj'k;\\,/nm." |
| _FUNCAO_MAC = (0x7A, 0x78, 0x63, 0x76, 0x60, 0x61, 0x62, 0x64, 0x65, 0x6D, 0x67, 0x6F) |
|
|
|
|
| def para_macos(combinacao): |
| """'<Primary><Alt>r' -> (modificadores, código da tecla) do RegisterEventHotKey do macOS; None se a tecla não tiver código. |
| <Primary> vira Control, não Command: o mesmo Ctrl+Alt+R dos outros sistemas (Command+Option+R já é de apps como o Safari).""" |
| bits = {"primary": 0x1000, "control": 0x1000, "ctrl": 0x1000, "alt": 0x0800, "shift": 0x0200, "super": 0x0100} |
| modificadores = sum(bits.get(m.lower(), 0) for m in re.findall(r"<(\w+)>", combinacao or "")) |
| tecla = re.sub(r"<\w+>", "", combinacao or "") |
| especiais = {"space": 0x31, "Return": 0x24, "Tab": 0x30, "Escape": 0x35} |
| if tecla in especiais: |
| codigo = especiais[tecla] |
| elif len(tecla) == 1 and tecla.isascii() and tecla.isalnum(): |
| codigo = _TECLAS_MAC.index(tecla.lower()) |
| elif re.fullmatch(r"F([1-9]|1[0-2])", tecla): |
| codigo = _FUNCAO_MAC[int(tecla[1:]) - 1] |
| else: |
| return None |
| return modificadores, codigo |
|
|
|
|
| def registrar_acoes(combinacao=None): |
| """5.2: cadastra o atalho das ações de texto (GNOME; no Windows e no macOS o próprio openTARS escuta). Devolve (ok, mensagem).""" |
| combinacao = normalizar_combinacao(combinacao) if combinacao else (i18n.ler_config().get("atalho_acoes") or ACOES_PADRAO) |
| if not combinacao: |
| return False, t("atalho.invalido") |
| sistema = plataforma.sistema() |
| if sistema in ("windows", "macos"): |
| if not (para_windows if sistema == "windows" else para_macos)(combinacao): |
| return False, t("atalho.invalido") |
| i18n.salvar_config(atalho_acoes=combinacao, atalho_acoes_registrado=True) |
| return True, t(f"atalho.acoes_{sistema}", atalho=legivel(combinacao)) |
| qual = ambiente() |
| if qual != "gnome": |
| return False, t("atalho.manual", ambiente=_NOMES_AMBIENTE.get(qual, qual or "?"), comando="opentars-gui " + ACOES_MARCA) |
| ok, motivo = _registrar_gnome(combinacao, ACOES_NOME, ACOES_MARCA) |
| i18n.salvar_config(atalho_acoes=combinacao, atalho_acoes_registrado=ok) |
| return (True, t("atalho.acoes_registrado", atalho=legivel(combinacao))) if ok else (False, motivo) |
|
|
|
|
| def remover_acoes(): |
| ok = _remover_gnome(ACOES_MARCA) if plataforma.sistema() == "linux" and ambiente() == "gnome" else True |
| i18n.salvar_config(atalho_acoes_registrado=False) |
| return ok, t("atalho.removido") |
|
|
|
|
| def comando_acoes(argumento): |
| """opentars --atalho-acoes [on|combinação|off]""" |
| argumento = (argumento or "").strip() |
| if not argumento or argumento.lower() in ("status", "estado"): |
| config = i18n.ler_config() |
| if config.get("atalho_acoes_registrado"): |
| print(t("atalho.acoes_registrado", atalho=legivel(config.get("atalho_acoes") or ACOES_PADRAO))) |
| else: |
| print(t("atalho.acoes_como", atalho=legivel(ACOES_PADRAO))) |
| return 0 |
| if argumento.lower() in ("off", "desligar", "remover", "none", "no", "nao", "não"): |
| ok, mensagem = remover_acoes() |
| else: |
| ok, mensagem = registrar_acoes(None if argumento.lower() in ("on", "ligar", "sim", "yes") else argumento) |
| print(mensagem) |
| return 0 if ok else 1 |
|
|
|
|
| def comando(argumento): |
| """opentars --atalho [combinação|off]""" |
| argumento = (argumento or "").strip() |
| if not argumento or argumento.lower() in ("status", "estado"): |
| info = estado() |
| if info["registrado"]: |
| print(t("atalho.registrado", atalho=info["legivel"], ambiente=info.get("ambiente") or "?")) |
| else: |
| print(info.get("motivo") or t("atalho.nao_registrado")) |
| print(t("atalho.como_registrar")) |
| return 0 |
| if argumento.lower() in ("off", "desligar", "remover", "none", "no", "nao", "não"): |
| ok, mensagem = remover() |
| print(mensagem) |
| return 0 if ok else 1 |
| ok, mensagem = registrar(argumento) |
| print(mensagem) |
| return 0 if ok else 1 |
|
|
