Emacs में लाइन / क्षेत्र को ऊपर और नीचे ले जाएं

Question 1

चयनित क्षेत्र या रेखा (यदि कोई चयन नहीं है) को ईमैक में ऊपर या नीचे ले जाने का सबसे आसान तरीका क्या है? मैं उसी कार्यक्षमता की तलाश कर रहा हूं जो ग्रहण में है (एम-अप, एम-डाउन के लिए बाध्य है)।

Question 2

सीमा से बंधी ट्रांज़ोज़-लाइनों का उपयोग करके एक रेखा को स्थानांतरित किया जा सकता है C-x C-t। हालांकि क्षेत्रों के बारे में पता नहीं।

मुझे यह सटीक स्निपेट मिला जो आपको वह करना चाहता है, सिवाय इसके कि आपको बाइंडिंग बदलने की जरूरत है।

(defun move-text-internal (arg)
   (cond
    ((and mark-active transient-mark-mode)
     (if (> (point) (mark))
            (exchange-point-and-mark))
     (let ((column (current-column))
              (text (delete-and-extract-region (point) (mark))))
       (forward-line arg)
       (move-to-column column t)
       (set-mark (point))
       (insert text)
       (exchange-point-and-mark)
       (setq deactivate-mark nil)))
    (t
     (beginning-of-line)
     (when (or (> arg 0) (not (bobp)))
       (forward-line)
       (when (or (< arg 0) (not (eobp)))
            (transpose-lines arg))
       (forward-line -1)))))

(defun move-text-down (arg)
   "Move region (transient-mark-mode active) or current line
  arg lines down."
   (interactive "*p")
   (move-text-internal arg))

(defun move-text-up (arg)
   "Move region (transient-mark-mode active) or current line
  arg lines up."
   (interactive "*p")
   (move-text-internal (- arg)))

(global-set-key [\M-\S-up] 'move-text-up)
(global-set-key [\M-\S-down] 'move-text-down)

Question 3

अद्यतन: निम्नलिखित कोड प्राप्त करने के लिए move-textMarmalade या MELPA से पैकेज स्थापित करें ।

यहां मैं उपयोग करता हूं, जो दोनों क्षेत्रों और व्यक्तिगत लाइनों पर काम करता है:

(defun move-text-internal (arg)
  (cond
   ((and mark-active transient-mark-mode)
    (if (> (point) (mark))
        (exchange-point-and-mark))
    (let ((column (current-column))
          (text (delete-and-extract-region (point) (mark))))
      (forward-line arg)
      (move-to-column column t)
      (set-mark (point))
      (insert text)
      (exchange-point-and-mark)
      (setq deactivate-mark nil)))
   (t
    (let ((column (current-column)))
      (beginning-of-line)
      (when (or (> arg 0) (not (bobp)))
        (forward-line)
        (when (or (< arg 0) (not (eobp)))
          (transpose-lines arg)
          (when (and (eval-when-compile
                       '(and (>= emacs-major-version 24)
                             (>= emacs-minor-version 3)))
                     (< arg 0))
            (forward-line -1)))
        (forward-line -1))
      (move-to-column column t)))))

(defun move-text-down (arg)
  "Move region (transient-mark-mode active) or current line
  arg lines down."
  (interactive "*p")
  (move-text-internal arg))

(defun move-text-up (arg)
  "Move region (transient-mark-mode active) or current line
  arg lines up."
  (interactive "*p")
  (move-text-internal (- arg)))


(global-set-key [M-S-up] 'move-text-up)
(global-set-key [M-S-down] 'move-text-down)

Question 4

आपको कोशिश करनी चाहिए drag-stuff!

यह बिल्कुल ग्रहण की तरह काम करता Alt+ Up/ Downचयनित क्षेत्र लाइनों के लिए एकल लाइनों के लिए, साथ ही!

इसके अलावा, यह आपको शब्दों को Alt+ के साथ स्थानांतरित करने की अनुमति देता है Left/ Right
यह वही है जो आप देख रहे हैं! और यह ELPA रेपो से भी उपलब्ध है !

अन्य समाधानों ने कभी मेरे लिए काम नहीं किया। उनमें से कुछ छोटी थीं (अपने आदेश को बदलते हुए लाइनों को ट्रांसफ़ॉर्म करते हुए, wtf?) और उनमें से कुछ बिल्कुल चुने हुए क्षेत्र में जा रही थीं, जो लाइनों के अचयनित भागों को उनके पदों पर छोड़ रही थीं। लेकिन drag-stuffग्रहण की तरह ही काम करता है!

और भी अधिक! आप एक क्षेत्र का चयन करने और Alt+ Left/ का उपयोग करके कोशिश कर सकते हैं Right! यह चयनित क्षेत्र को एक वर्ण द्वारा बाईं या दाईं ओर स्थानांतरित करेगा। गजब का!

इसे विश्व स्तर पर सक्षम करने के लिए बस इसे चलाएं:

(drag-stuff-global-mode)

Question 5

मैंने लाइनों को ऊपर / नीचे ले जाने के लिए कुछ इंटरैक्टिव कार्यों को लिखा है:

;; move line up
(defun move-line-up ()
  (interactive)
  (transpose-lines 1)
  (previous-line 2))

(global-set-key [(control shift up)] 'move-line-up)

;; move line down
(defun move-line-down ()
  (interactive)
  (next-line 1)
  (transpose-lines 1)
  (previous-line 1))

(global-set-key [(control shift down)] 'move-line-down)

कीबाइंडिंग IntelliJ IDEA स्टाइल हैं, लेकिन आप अपनी इच्छानुसार कुछ भी उपयोग कर सकते हैं। मुझे संभवतः कुछ कार्यों को लागू करना चाहिए जो क्षेत्रों पर भी काम करते हैं।

Question 6

यहां वर्तमान रेखा या सक्रिय क्षेत्र द्वारा फैली लाइनों को स्थानांतरित करने के लिए मेरा स्निपेट है। यह कर्सर स्थिति और हाइलाइट किए गए क्षेत्र का सम्मान करता है। और जब क्षेत्र सीमा रेखा (नों) पर शुरू / समाप्त नहीं होता है तो यह रेखाएँ नहीं टूटेंगी। (यह ग्रहण से प्रेरित है; मैंने ग्रहण को 'ट्रांसपोज़-लाइन्स' की तुलना में अधिक सुविधाजनक पाया।)

;; move the line(s) spanned by the active region up/down (line transposing)
;; {{{
(defun move-lines (n)
  (let ((beg) (end) (keep))
    (if mark-active 
        (save-excursion
          (setq keep t)
          (setq beg (region-beginning)
                end (region-end))
          (goto-char beg)
          (setq beg (line-beginning-position))
          (goto-char end)
          (setq end (line-beginning-position 2)))
      (setq beg (line-beginning-position)
            end (line-beginning-position 2)))
    (let ((offset (if (and (mark t) 
                           (and (>= (mark t) beg)
                                (< (mark t) end)))
                      (- (point) (mark t))))
          (rewind (- end (point))))
      (goto-char (if (< n 0) beg end))
      (forward-line n)
      (insert (delete-and-extract-region beg end))
      (backward-char rewind)
      (if offset (set-mark (- (point) offset))))
    (if keep
        (setq mark-active t
              deactivate-mark nil))))

(defun move-lines-up (n)
  "move the line(s) spanned by the active region up by N lines."
  (interactive "*p")
  (move-lines (- (or n 1))))

(defun move-lines-down (n)
  "move the line(s) spanned by the active region down by N lines."
  (interactive "*p")
  (move-lines (or n 1)))

Question 7

इसके लिए सिर्फ emacs wiki में एक प्रविष्टि है:

http://www.emacswiki.org/emacs/MoveLine

बढ़ते क्षेत्रों के लिए:

http://www.emacswiki.org/emacs/MoveRegion

Question 8

कोई बिल्ट-इन नहीं है। आप ट्रांसपोज़-लाइन्स (Cx Ct) का उपयोग कर सकते हैं, लेकिन आप इसे बार-बार उपयोग नहीं कर सकते। Http://www.schuerig.de/michael/blog/index.php/2009/01/16/line-movement-for-emacs/ पर कार्यों को देखें ।

यह कि क्षेत्रों के लिए भी अनुकूलित करना आसान होना चाहिए।

Question 9

transpose-paragraphसमारोह आप मदद कर सकता है।

तुम भी Emacs मैनुअल में पारगमन अनुभाग को देखने के लिए चाहते हो सकता है । अनिवार्य रूप से:

C-t
Transpose two characters (transpose-chars).
M-t
Transpose two words (transpose-words).
C-M-t
Transpose two balanced expressions (transpose-sexps).
C-x C-t
Transpose two lines (transpose-lines).

Question 10

मैं इसके लिए स्मार्ट-शिफ्ट पैकेज (मेलपा में) का उपयोग करता हूं। डिफ़ॉल्ट रूप से यह C-C <arrow>एक पंक्ति या क्षेत्र को स्थानांतरित करने के लिए विद्रोह करता है। यह एक प्रमुख-मोड-विशिष्ट राशि (जैसे सी-बेसिक-ऑफ़सेट या पायथन-इंडेंट-ऑफ़सेट) द्वारा क्षैतिज रूप से चलती है। क्षेत्रों पर भी काम करता है।

;; binds C-C <arrows>
(when (require 'smart-shift nil 'noerror)
  (global-smart-shift-mode 1))