web-dev-qa-db-fra.com

Comment désactiver la commutation de la langue d'entrée dans le terminal

Dans Ubuntu 12.04, deux langues d’entrée sont installées: l’anglais et le russe. Je souhaite désactiver l’utilisation de la langue russe dans les terminaux. Ainsi, quel que soit le système sélectionné, le terminal aura toujours la langue de saisie anglaise.

Est-ce possible?

Le problème est que les caractères non anglais tapés par inadvertance peuvent être très pénibles (surtout les caractères invisibles).

PDATE:

Tout d’abord, je voudrais remercier tous les participants. Je suis vraiment ravi de la rapidité avec laquelle les gens essaient d’aider!

On dirait que je dois énoncer plus clairement le problème. Le problème est que non seulement j'aimerais activer l'anglais par défaut lorsque je crée une nouvelle fenêtre de terminal ou que je bascule vers une ancienne fenêtre de terminal, mais aussi de rendre impossible le passage de la langue de l'anglais au russe à l'intérieur de la fenêtre du terminal.

Maintenant, les résultats.

J'ai essayé gxneur - on dirait qu'il faut le construire à partir des sources, ce que je ne suis pas prêt à essayer. J'ai essayé de l'installer avec apt-get et je ne savais pas comment le configurer facilement. Et il n'a pas montré l'icône dans la barre des tâches. Alors je l'ai enlevé.

J'ai essayé le script Python et il s'arrête immédiatement avec la sortie suivante:

No such schema 'org.gnome.desktop.input-sources'
Traceback (most recent call last):
  File "./set_language.py", line 63, in <module>
    lang_list = read_prev()
  File "./set_language.py", line 52, in read_prev
    currlang = get_lang()
  File "./set_language.py", line 24, in get_lang
    curr_n = int(get(key[1]+key[0]+key[4]).strip().split()[-1])
  File "./set_language.py", line 20, in get
    return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
  File "/usr/lib/python3.2/subprocess.py", line 522, in check_output
    raise CalledProcessError(retcode, cmd, output=output)
subprocess.CalledProcessError: Command '['/bin/bash', '-c', 'gsettings get org.gnome.desktop.input-sources current']' returned non-zero exit status 1

Enfin, j'ai essayé le script Shell, il fonctionne mais ne semble pas fonctionner - je peux toujours passer facilement au russe en terminal. Et il dit aussi de temps en temps

No such schema 'org.gnome.desktop.input-sources'

Donc, dans l’ensemble, je n’ai pu faire fonctionner aucune des solutions.

Je suppose que l'essentiel ici est que ce que j'aimerais obtenir n'est pas si simple, alors c'est bien de ne pas l'avoir.

command-linelanguageinput-language
6
oltish

Note sur la réponse ci-dessous

La réponse avait été écrite à l'origine pour le 14.04, mais réécrite le 6 janvier 2017 pour fonctionner également sur (au moins) 16.04 et 16.10. wmctrl n'est plus nécessaire.

Script pour définir automatiquement une langue différente pour une seule application.

enter image description hereenter image description here

Ce qu'il fait

  • En exécutant le script en arrière-plan, l'utilisateur peut définir une langue différente pour une application spécifique (dans ce cas gnome-terminal). Il suffit de lancer le script et, avec l'application devant, de définir la langue souhaitée.
  • La langue sera mémorisée, dans le script (en cours d'exécution) ainsi que dans un fichier caché, à mémoriser lors de la prochaine exécution du script (au redémarrage de l'ordinateur).
  • Si l'utilisateur définit le focus sur une autre application, le script revient à la langue par défaut, quelle qu'elle soit. La langue par défaut sera également mémorisée, mais l'utilisateur peut la modifier à tout moment (la langue modifiée est également mémorisée).

Remarques

  • Le script utilise un ensemble étendu d’outils (fonctions) pour prendre en compte le fait que l’utilisateur doit pouvoir modifier l’ensemble des langues utilisées, et les langues doivent être mémorisées, comme suggéré dans le ou les commentaires. Néanmoins, il est très "léger", car il n’utilise la ou les fonctions que lorsque cela est nécessaire.

Le scénario

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

#--- set the "targeted" exceptional application below
app = "gnome-terminal"
#---

l_file = os.path.join(os.environ["HOME"], app+"_lang")
def_lang = os.path.join(os.environ["HOME"], "def_lang")
k = ["org.gnome.desktop.input-sources", "current", "sources"]

def get(cmd):
    # helper function
    try:
        return subprocess.check_output(cmd).decode("utf-8").strip()
    except subprocess.CalledProcessError:
        pass

def run(cmd):
    # helper function
    subprocess.Popen(cmd)

def front():
    # see if app has active window
    front = get(["xdotool", "getactivewindow"])
    data = get(["xprop", "-id", front])
    if all([front, data]):
        return app in get(["xprop", "-id", front])
    else:
        pass

def getlang():
    # get the currently set language (from index, in case the sources are changed)
    currindex = int(get(["gsettings", "get", k[0], k[1]]).split()[-1])
    return sources[currindex]

def get_stored(file):
    # read the set language
    return sources.index(ast.literal_eval(open(file).read().strip()))

def get_sources():
    return ast.literal_eval(get(["gsettings", "get", k[0], k[2]]))

sources = get_sources()
appfront1 = None
currlang1 = getlang()

while True:
    time.sleep(1)
    appfront2 = front()
    if appfront2 != None:
        currlang2 = getlang()
        # change of frontmost app (type)
        if appfront2 != appfront1:
            if appfront2:
                try:
                    run(["gsettings", "set", k[0], k[1], str(get_stored(l_file))])
                except FileNotFoundError:
                    open(l_file, "wt").write(str(currlang2))
            Elif not appfront2:
                try:
                    run(["gsettings", "set", k[0], k[1], str(get_stored(def_lang))])
                except FileNotFoundError:
                    open(def_lang, "wt").write(str(currlang2))
        Elif currlang2 != currlang1:
            f = l_file if appfront2 else def_lang
            open(f, "wt").write(str(currlang2))

        appfront1 = appfront2
        currlang1 = currlang2

Comment utiliser

  1. Le script utilise xdotool:

    Sudo apt-get install xdotool

  2. Copiez le script ci-dessus dans un fichier vide, enregistrez-le sous le nom set_language.py

  3. Testez-le avec la commande:

    python3 /path/to/set_language.py

    Pendant l'exécution du script:

    • définir la langue (par défaut).
    • ouvrez le terminal (gnome-), définissez la langue à utiliser avec le terminal
    • Basculez entre les deux et voyez si la langue change automatiquement.


    Vous pouvez changer la langue par défaut comme langue du terminal à tout moment . La ou les langues définies seront mémorisées.

  4. Si tout fonctionne comme prévu, ajoutez-le à Applications de démarrage: Ajoutez à Applications de démarrage: Dash> Applications de démarrage> Ajouter. Ajoutez la commande:

    python3 /path/to/set_language.py

Explication, la courte histoire (conceptuelle):

Le script utilise deux fichiers pour stocker les langues définies à la fois pour la langue par défaut et la langue utilisée dans l'application exceptionnelle (gnome-terminal dans ce cas, mais vous pouvez définir n'importe quelle application).

Le script effectue ensuite périodiquement (une fois par seconde) deux tests:

  1. Si la fenêtre active appartient à l'application exceptionnelle
  2. Quelle est la langue de saisie actuellement définie

Le script compare la situation avec les tests il y a une seconde. Puis si:

  1. il y a eu un changement d'application:

    exceptionnel -> défaut : lit le fichier de langue pour la langue par défaut et définit la langue. Si le fichier n'existe pas (jet), créez-le, stockez la langue actuelle par défaut.
    défaut -> exceptionnel : l'inverse.

  2. S'il y a eu un changement de langue (mais pas dans la classe de fenêtre):

    Nous pouvons supposer que l'utilisateur a défini une langue différente pour l'application exceptionnelle ou pour la langue d'entrée par défaut -> pour écrire la langue d'entrée actuellement utilisée dans le fichier correspondant (pour la langue par défaut ou pour la langue exceptionnelle).

3
Jacob Vlijm

Tout à coup, j'ai trouvé une solution très simple, qui ne nécessite aucun script.

Vous pouvez cliquer sur l'indicateur de langue, sélectionnez "Paramètres de saisie de texte ...".

Dans la fenêtre ouverte, cochez "Autoriser différentes sources pour chaque fenêtre" et

"Nouvelle fenêtre utilise la source par défaut".

enter image description here

Si la présentation par défaut est l'anglais, chaque application nouvellement ouverte sera lancée avec la présentation anglaise, y compris le terminal.

1
Pilot6

Le seul moyen que je connaisse est d'utiliser gxneur.

C'est un bug dans Ubuntu pour la mise en page automatique, mais c'est bon pour ce genre de paramètres. La commutation automatique peut être facilement désactivée.

Vous pouvez paramétrer leurs applications, telles que gnome-terminal, pour avoir une seule disposition.

Vous pouvez lire THIS TOPIC en russe par le mainteneur de gxneur.

Mais je serai aussi heureux s'il y a un meilleur moyen.

1
Pilot6