Emacs 确定键盘布局

Emacs是否有办法检测当前的键盘布局

我经常用英语和德语写文本，切换（Win OS）键盘布局。但是，有些函数（例如C-Y）应该始终处于相同的物理键，无论我当前键入的是哪种语言

---

谢谢

考虑使用

M-x设置输入法

和

M-x切换输入法

。切换绑定到

C-\

，设置绑定到

C-x RET C-\

。我推荐这种装订方式：

（全局设置键[？\H-\]'设置输入法）

如果您不是问如何输入不同的语言，而是问如何在操作系统中使用不同的语言时使多个命令工作，请尝试绑定它们。它在俄罗斯符号上效果很好。一个漆黑的夜晚，我甚至写了

(setq russian-symbols '(
                         (?й . ?q)
                         (?ц . ?w)
                         (?у . ?e)
                         (?к . ?r)
                         (?е . ?t)
                         (?н . ?y)
                         (?г . ?u)
                         (?ш . ?i)
                         (?щ . ?o)
                         (?з . ?p)
                         (?х . ?\[)
                         (?ъ . ?\])
                         (?ф . ?a)
                         (?ы . ?s)
                         (?в . ?d)
                         (?а . ?f)
                         (?п . ?g)
                         (?р . ?h)
                         (?о . ?j)
                         (?л . ?k)
                         (?д . ?l)
                         (?ж . ?\;)
                         (?э . ?')
                         (?я . ?z)
                         (?ч . ?x)
                         (?с . ?c)
                         (?м . ?v)
                         (?и . ?b)
                         (?т . ?n)
                         (?ь . ?m)
                         (?б . ?,)
                         (?ю . ?.)

                         (?Й . ?Q)
                         (?Ц . ?W)
                         (?У . ?E)
                         (?К . ?R)
                         (?Е . ?T)
                         (?Н . ?Y)
                         (?Г . ?U)
                         (?Ш . ?I)
                         (?Щ . ?O)
                         (?З . ?P)
                         (?Х . ?{)
                         (?Ъ . ?})
                         (?Ф . ?A)
                         (?Ы . ?S)
                         (?В . ?D)
                         (?А . ?F)
                         (?П . ?G)
                         (?Р . ?H)
                         (?О . ?J)
                         (?Л . ?K)
                         (?Д . ?L)
                         (?Ж . ?:)
                         (?Э . ?\")
                         (?Я . ?Z)
                         (?Ч . ?X)
                         (?С . ?C)
                         (?М . ?V)
                         (?И . ?B)
                         (?Т . ?N)
                         (?Ь . ?M)
                         (?Б . ?<)
                         (?Ю . ?>)

                         (?Ё . ?~)
                         (?ё . ?`)
                         ))

(setq russian-symbols-full (append russian-symbols
                             '((?. . ?/)
                             (?, . ??)
                             (?\" . ?@)
                             (?№ . ?#)
                             (?\; . ?$)
                             (?: . ?^)
                             (?\? . ?&))))
(defun cm-ru-to-en-string(string)
  (apply 'concat (mapcar (lambda (arg) (setq arg (format "%c" (or (cdr (assoc arg russian-symbols-full)) arg)))) string)))

(defun cm-en-to-ru-string(string)
  (apply 'concat (mapcar (lambda (arg) (setq arg (format "%c" (or (car (rassoc arg russian-symbols-full)) arg)))) string)))

(defun cm-ru-to-en-region()
  (interactive)
  (let ((text (buffer-substring-no-properties (mark) (point))))
    (delete-region (mark) (point))
    (insert (cm-ru-to-en-string text))))

(defun cm-en-to-tu-region()
  (interactive)
  (let ((text (buffer-substring-no-properties (mark) (point))))
    (delete-region (mark) (point))
    (insert (cm-en-to-ru-string text))))

;; DO NOT USE vvv SINCE YOU WILL NOT BE ABLE TO INPUT THROUGH C-\

;; (let ((symbols russian-symbols))
;;   (while symbols
;;     (global-set-key (vector (car (car symbols))) (vector (cdr (car symbols))))
;;     (setq symbols (cdr symbols))))

;; DO NOT USE ^^^ SINCE YOU WILL NOT BE ABLE TO INPUT THROUGH C-\

;; (- ?\C-ы ?ы) ;;russian C-
;; (- ?\C-s ?s) ;;english C-
;; (- ?\M-ы ?ы) ;;russian M-
;; (- ?\M-s ?s) ;;english M-


(setq russian-symbols-map1
  (append 
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\C-ы ?ы) (car arg)) (+ (- ?\C-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\M-ы ?ы) (car arg)) (+ (- ?\M-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\C-\M-ы ?ы) (car arg)) (+ (- ?\C-\M-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\H-ы ?ы) (car arg)) (+ (- ?\H-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\H-\C-ы ?ы) (car arg)) (+ (- ?\H-\C-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\H-\M-ы ?ы) (car arg)) (+ (- ?\H-\M-s ?s) (cdr arg))))) russian-symbols)
    (mapcar (lambda (arg) (setq arg (cons (+ (- ?\H-\C-\M-ы ?ы) (car arg)) (+ (- ?\H-\C-\M-s ?s) (cdr arg))))) russian-symbols)))

(setq russian-symbols-map2
  (append
    russian-symbols-map1
    russian-symbols)) ; We must not start with russian letters, but if it is element in a sequence - in should be fine.

(setq symbols2 russian-symbols-map1)    ; One-key sequence command.
(let ((symbols2 russian-symbols-map1))
    (while symbols2
      (if
        (and (symbolp (lookup-key global-map
                        (vector
                          (cdr (car symbols2))
                          )))
          (lookup-key global-map
            (vector
              (cdr (car symbols2))
              )))
        (global-set-key
          (vector
            (car (car symbols2))
            )
          (lookup-key global-map
            (vector
              (cdr (car symbols2))
              ))))
      (setq symbols2 (cdr symbols2))))



(let ((symbols1 russian-symbols-map2) (symbols2 russian-symbols-map1)) ; Two keys sequence
  (while symbols1
    (while symbols2
      (if
        (and (symbolp (lookup-key global-map
                        (vector
                          (cdr (car symbols2))
                          (cdr (car symbols1))
                          )))
          (lookup-key global-map
            (vector
              (cdr (car symbols2))
              (cdr (car symbols1))
              )))
        (global-set-key
          (vector
            (car (car symbols2))
            (car (car symbols1))
            )
          (lookup-key global-map
            (vector
              (cdr (car symbols2))
              (cdr (car symbols1))
              ))))
      (setq symbols2 (cdr symbols2)))
    (setq symbols2 russian-symbols-map1)
    (setq symbols1 (cdr symbols1))))

(provide 'shamanizm) ;russian emacs-users should lol reading this

（setq俄语符号'(
（l q）
（цw）
（？？？e）
（？κ？r）
（？t.）
（±y.）
（？Γ？u）
（？ï？i）
（？？？o）
（？з？p）
(?х . ?\[)
(?ъ . ?\])
（？ф。？a）
（？s）
（？）
（？а？f）
（？П？g）
（？？？h）
（？）
（？-k）
（？？l）
(?ж . ?\;)
(?э . ?')
（？？？z）
（？ч？x）
（？c.？c）
（？М。？v）
（？b）
（？τ？n）
（？m）
(?б . ?,)
(?ю . ?.)
（？Й？Q）
（？？W.）
（？У？E）
（？k.？R）
（？？？T）
（？-h.？Y）
（？Γ。？U）
（？？？I）
（？O）
（？3.？P）
(?Х . ?{)
(?Ъ . ?})
（？Ф？A）
（？ê？S）
（？b.？D）
（？А？F）
（？П？G）
（？П。？H）
（？o.？J）
（？K.）
（？Б。？L）
(?Ж . ?:)
(?Э . ?\")
（？Я？Z）
（？Ч？X）
（？С？C）
（？М？V）
（？？？B）
（？t.？N）
（？？M）
(?Б . ?)
(?Ё . ?~)
(?ё . ?`)
))
（setq俄语符号完整（附加俄语符号）
'((?. . ?/)
(?, . ??)
(?\" . ?@)
(?№ . ?#)
(?\; . ?$)
(?: . ?^)
(?\? . ?&))))
（将cm ru定义为en字符串（字符串）
（应用'concat（mapcar（lambda（arg）（setq arg（格式“%c”（或（cdr（assoc arg俄语符号完整））arg））字符串）））
（将cm en改为ru字符串（字符串）
（应用'concat（mapcar（lambda（arg）（setq arg（格式“%c”（或（car（rassoc arg俄语符号完整））arg））字符串）））
（定义cm-ru-to-en-区域（）
（互动）
（let（（文本（缓冲区子字符串无属性（标记）（点）））
（删除区域（标记）（点））
（插入（cm ru到en字符串文本）））
（定义cm-en-to-tu区域（）
（互动）
（let（（文本（缓冲区子字符串无属性（标记）（点）））
（删除区域（标记）（点））
（插入（cm-en到ru字符串文本）））
；不要使用vvv，因为您将无法通过C进行输入-\
（让（（俄罗斯符号））
而
；；；（全局设置键（向量（汽车符号）））（向量（cdr（汽车符号）））
（setq符号（cdr符号）））
；不要使用^^^，因为您将无法通过C进行输入-\
俄语-
；（？\C-s？s）；英语C-
俄语-
；（？\M-s？s）；英语M-
（setq俄语符号-map1）
（附加）
（mapcar（lambda（arg）（setq arg（cons（+-C-s-s）（cdr arg‘）；）俄语符号）
（mapcar（lambda（arg）（setq arg（cons）（+（\M-ы）（car arg））（+（（\M-s-s）（cdr arg）（）））俄罗斯符号）
（mapcar（lambda（arg）（setq arg（cons（+（-C-\M-ы）（car arg））（++（-C-\M-s-s）（cdr argыы）俄语符号）
（mapcar（lambda（arg）（setq arg（cons（+-H-H-s）（car arg））（+（-H-s-s）（cdr arg）（））俄罗斯符号）
（mapcar（lambda（arg）（setq arg（cons（+-）\H-\C-ы（car arg））（+（（-\H-\C-s-s）（cdr argы）俄语符号）
（mapcar（lambda（arg）（setq arg（cons（+-）\H-\M-ы（car arg））（++-\H-\M-s-s）（cdr argыы）俄语符号）
（mapcar（lambda（arg）（setq arg（cons（+-）\H-\C-\M-ы（car arg））（+（-\H-\C-\M-s-s）（cdr argыы）俄语符号）））
（setq俄语符号-map2）
（附加）
俄语符号-map1
俄文符号）；我们不能以俄文字母开头，但如果它是序列中的元素，in应该可以。
（setq symbols2俄语-symbols-map1）；一键顺序命令。
（let（（symbols2俄语符号-map1））
（而符号2
（如果
（和）symbolp（查找键全局映射
（向量