emacs आसान दोहराने के लिए ईएमएसीएस में कुंजी बाइंडिंग कैसे लिखूँ?




elisp (4)

यही है वह जो मेरे द्वारा उपयोग किया जाता है। मुझे यह पसंद है क्योंकि आपको दोहराई गई कुंजी निर्दिष्ट करने की आवश्यकता नहीं है।

(require 'repeat)
(defun make-repeatable-command (cmd)
  "Returns a new command that is a repeatable version of CMD.
The new command is named CMD-repeat.  CMD should be a quoted
command.

This allows you to bind the command to a compound keystroke and
repeat it with just the final key.  For example:

  (global-set-key (kbd \"C-c a\") (make-repeatable-command 'foo))

will create a new command called foo-repeat.  Typing C-c a will
just invoke foo.  Typing C-c a a a will invoke foo three times,
and so on."
  (fset (intern (concat (symbol-name cmd) "-repeat"))
        `(lambda ,(help-function-arglist cmd) ;; arg list
           ,(format "A repeatable version of `%s'." (symbol-name cmd)) ;; doc string
           ,(interactive-form cmd) ;; interactive form
           ;; see also repeat-message-function
           (setq last-repeatable-command ',cmd)
           (repeat nil)))
  (intern (concat (symbol-name cmd) "-repeat")))

मान लीजिए कि मैं एक निश्चित फ़ंक्शन की कुंजी को निम्नानुसार बाँधता हूं:

(global-set-key (kbd "C-c =") 'function-foo)

अब, मैं कुंजी बाध्यकारी के रूप में काम करना चाहता हूं:
पहली बार Cc = को दबाए जाने के बाद, यदि मैं फ़ंक्शन-फ़ू को दोहराता हूं, तो मुझे Cc फिर से दबाए जाने की आवश्यकता नहीं है, लेकिन बस दबाकर = दोहराएं। उसके बाद, मैं फ़ंक्शन- foo को पर्याप्त समय के लिए कॉल करने के बाद, मैं बस = (या स्पष्ट रूप से Cg दबाकर) को छोड़ने के लिए कुंजी को दबा सकता हूं

यह कैसे करना है?


यह वह चीज़ हो सकती है जिसे आप चाहते हैं:

(defun function-foo ()
  (interactive)
  (do-your-thing)
  (set-temporary-overlay-map
    (let ((map (make-sparse-keymap)))
      (define-key map (kbd "=") 'function-foo)
      map)))

आप चाहते हैं कि आपका function-foo set-temporary-overlay-map का उपयोग set-temporary-overlay-map


जो जूलोनन ने सुझाव दिया है, इसके अलावा, जो set-temporary-overlay-map का उपयोग करता है, यहां एक विकल्प है जो मैं काफी कुछ का उपयोग करता हूं। यह मानक पुस्तकालय repeat.el का उपयोग करता है

;; This function builds a repeatable version of its argument COMMAND.
(defun repeat-command (command)
  "Repeat COMMAND."
 (interactive)
 (let ((repeat-previous-repeated-command  command)
       (last-repeatable-command           'repeat))
   (repeat nil)))

अलग repeatable आदेश को परिभाषित करने के लिए उस का उपयोग करें उदाहरण के लिए,

(defun backward-char-repeat ()
  "Like `backward-char', but repeatable even on a prefix key."
  (interactive)
  (repeat-command 'backward-char))

उसके बाद इस तरह के आदेश को एक दोहराए जाने वाले प्रत्यय के साथ बाँध लें, उदाहरण के लिए, Cc = ( Cc = = = = ... के लिए)

अधिक जानकारी के लिए इस एसओ पोस्ट देखें।







elisp