Emacs, Linux et mises en page de clavier internationales

Question

Y a-t-il un moyen facile d'utiliser les associations de touches Emacs lorsque vous utilisez une disposition de clavier non-anglaise (russe) ?

Chaque fois qu'une disposition internationale est activée, toutes les frappes sont interprétées littéralement, M- au lieu de M-a. En conséquence, je ne peux pas utiliser les commandes.

Il serait également utile que Linux interprète les touches non préfixées et les touches préfixées majuscules selon une disposition internationale, tout en gardant le reste en anglais.

Answer 1

Vous pouvez définir la méthode de saisie (un grand merci à kindahero) en tapant

M-x set-input-method RET cyrillic-yawerty RET

ou

M-x set-input-method RET cyrillic-jcuken RET

---

Pour le sauvegarder de manière permanente, ajoutez

(setq default-input-method "cyrillic-yawerty")

dans le fichier de configuration ~/.emacs (et utilisez C-\ pour basculer entre les mises en page de clavier).

Answer 2

Voici une solution alternative qui utilise la langue du système d'exploitation, basée sur la réponse de syndikat.

Quelques traductions clés manquent, mais il devrait être facile de les ajouter.

;; UTILISATION : 
;; Mettez ceci dans votre .emacs :
;;
;; (translate-keystrokes-ru->en)
;; (add-hook 'text-mode-hook
;;           (lambda () (literal-insert-mode 1)))
;;
;; Seuls les tampons avec literal-insert-mode actif seront sensibles à la
;; langue de l'environnement. Les combinaisons de touches préfixées resteront utilisables.

(defun translate-keystrokes-ru->en ()
  "Fait en sorte qu'emacs produise des caractères anglais, indépendamment
de si le clavier du système d'exploitation est anglais ou russe"
  (flet ((make-key-stroke (prefix char)
           (eval `(kbd ,(if (and (string-match "^C-" prefix)
                                 (string-match "[A-Z]" (string char)))
                            (concat "S-" prefix (string (downcase char)))
                            (concat prefix (string char)))))))
    (let ((case-fold-search nil)
          (keys-pairs (mapcar* 'cons
                               "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖ\ЭЯЧСМИТЬБЮ№"
                               "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:\"ZXCVBNM<>#"))
          (prefixes '(""    "s-"    "M-"    "M-s-"
                      "C-"  "C-s-"  "C-M-"  "C-M-s-")))
      (mapc (lambda (prefix)
              (mapc (lambda (pair)
                      (define-key key-translation-map
                          (make-key-stroke prefix (car pair))
                        (make-key-stroke prefix (cdr pair))))
                    keys-pairs))
            prefixes))))

(defun literal-insert ()
  (interactive)
  (insert-char last-input-event 1))

(define-minor-mode literal-insert-mode
    "Fait en sorte qu'emacs produise des caractères correspondant au clavier du système d'exploitation,
 en ignorant la key-translation-map"
  :keymap (let ((new-map (make-sparse-keymap))
                (english-chars "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:\"ZXCVBNM<>#"))
            (mapc (lambda (char)
                    (define-key new-map (string char)
                      'literal-insert))
                  english-chars)
            new-map))

Answer 3

Pas sûr, d'où sabof a obtenu 150 milliards. J'ai exécuté ce code (grâce à Yuri Khan, pris sur EmacsWiki):

(loop
 for from across "йцукенгшщзхъфывапролджэячсмитьбюЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖ\ЭЯЧСМИТЬБЮ№"
 for to   across "qwertyuiop[]asdfghjkl;'zxcvbnm,.QWERTYUIOP{}ASDFGHJKL:\"ZXCVBNM<>#"
 do
 (eval `(define-key key-translation-map (kbd ,(concat "C-" (string from))) (kbd ,(concat     "C-" (string to)))))
 (eval `(define-key key-translation-map (kbd ,(concat "M-" (string from))) (kbd ,(concat     "M-" (string to))))))

Il n'y a que 128 combinaisons. Malheureusement, les combinaisons avec des lettres uniques comme C-x b ne fonctionnent pas. J'essaie toujours de trouver une meilleure solution.

Answer 4

J'utilise le snippet suivant pour le clavier cyrillique et il fonctionne bien pour moi :

(defun reverse-input-method (input-method)
  "Build the reverse mapping of single letters from INPUT-METHOD."
  (interactive
   (list (read-input-method-name "Utiliser la méthode de saisie (par défaut actuelle) : ")))
  (if (and input-method (symbolp input-method))
      (setq input-method (symbol-name input-method)))
  (let ((current current-input-method)
        (modifiers '(nil (control) (meta) (control meta))))
    (when input-method
      (activate-input-method input-method))
    (when (and current-input-method quail-keyboard-layout)
      (dolist (map (cdr (quail-map)))
        (let* ((to (car map))
               (from (quail-get-translation
                      (cadr map) (char-to-string to) 1)))
          (when (and (characterp from) (characterp to))
            (dolist (mod modifiers)
              (define-key local-function-key-map
                (vector (append mod (list from)))
                (vector (append mod (list to)))))))))
    (when input-method
      (activate-input-method current))))

(reverse-input-method 'russian-computer)

Excepté :

Le seul problème que je connaisse est que le recalcul des formules OrgTable ne fonctionne pas en disposition russe car elle est assignée à C-c-* et * change de position.

source

Answer 5

Si vous souhaitez continuer à utiliser la disposition russe dans Emacs (plutôt que d'utiliser les méthodes de saisie d'Emacs), la seule manière que je connaisse pour le moment est d'ajouter des liaisons de la forme :

(define-key function-key-map [?\M-ф] [?\M-a])

Cela indiquera à Emacs que, dans le cas où M-ф n'est pas lié, il devrait essayer de rechercher M-a à la place. Malheureusement, vous aurez besoin de beaucoup de ces liaisons. Si quelqu'un rédige un correctif/package qui peut fournir automatiquement toutes ces liaisons, je serais heureux de l'inclure dans Emacs.