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




elisp (4)

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

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

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

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

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


एक smartrep.el पैकेज है जो आपको ठीक वही करता है जो आपको चाहिए। प्रलेखन थोड़ा दुर्लभ है लेकिन आप इसे ग्रिब पर पाए जाने वाले कई एएमएसीएस कॉन्फ़िग्स में देखकर इसका उपयोग कैसे किया जा सकता है, यह पकड़ ले सकते हैं। उदाहरण के लिए ( यहां से लिया गया):

(require 'smartrep)
(smartrep-define-key
    global-map "C-q" '(("n" . (scroll-other-window 1))
                       ("p" . (scroll-other-window -1))
                       ("N" . 'scroll-other-window)
                       ("P" . (scroll-other-window '-))
                       ("a" . (beginning-of-buffer-other-window 0))
                       ("e" . (end-of-buffer-other-window 0))))

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

(defun function-foo ()
  (interactive)
  (do-your-thing)
  (set-temporary-overlay-map
    (let ((map (make-sparse-keymap)))
      (define-key map (kbd "=") 'function-foo)
      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