Déplacer la ligne / la région de haut en bas dans emacs

Une ligne peut être déplacée en utilisant des lignes de transposition liées à Cx Ct . Je ne sais pas pour les régions.

J’ai trouvé cet extrait élisp qui fait ce que vous voulez, sauf que vous devez modifier les liaisons.

 (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) 

Mise à jour: Installez le package move-text de Marmalade ou MELPA pour obtenir le code suivant.

Voici ce que j’utilise, qui fonctionne à la fois sur les régions et les lignes individuelles:

 (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 [MS-up] 'move-text-up) (global-set-key [MS-down] 'move-text-down) 

Vous devriez essayer drag-stuff !

Il fonctionne exactement comme éclipse Alt + Up / Down pour les lignes simples, ainsi que pour les lignes de régions sélectionnées!

En plus de cela, il vous permet de déplacer des mots avec Alt + Gauche / Droite
C’est exactement ce que vous cherchez! Et il est même disponible dans les pensions ELPA !

D’autres solutions n’ont jamais fonctionné pour moi. Certains d’entre eux étaient en buggy (lignes de transposition en changeant leur ordre, wtf?) Et certains déplaçaient exactement la région sélectionnée, laissant des parties non sélectionnées des lignes sur leurs positions. Mais drag-stuff fonctionnent exactement comme dans éclipse!

Et encore plus! Vous pouvez essayer de sélectionner une région et utiliser Alt + Gauche / Droite ! Cela transposera la région sélectionnée d’un caractère à gauche ou à droite. Incroyable!

Pour l’activer globalement, lancez simplement ceci:

 (drag-stuff-global-mode) 

J’ai écrit quelques fonctions interactives pour déplacer des lignes vers le haut / bas:

 ;; 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) 

Les raccourcis sont de type IntelliJ IDEA, mais vous pouvez utiliser tout ce que vous voulez. Je devrais probablement mettre en œuvre certaines fonctions qui fonctionnent également dans les régions.

Il y a une entrée dans le wiki emacs juste pour cela:

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

Pour les régions en mouvement:

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

Voici mon extrait pour déplacer la ligne en cours ou les lignes couvertes par la région active. Il respecte la position du curseur et la région en surbrillance. Et cela ne brisera pas les lignes lorsque la région ne commence / ne finit pas aux limites de la ligne. (Il est inspiré par l’éclipse; j’ai trouvé l’éclipse plus pratique que les «lignes de transposition».)

 ;; 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))) 

Il n’y a pas de intégré. Vous pouvez utiliser des lignes de transposition (Cx Ct) mais vous ne pouvez pas l’utiliser à plusieurs resockets. Regardez les fonctions sur http://www.schuerig.de/michael/blog/index.php/2009/01/16/line-movement-for-emacs/ .

Il devrait être facile d’adapter cela aux régions également.

La fonction de transpose-paragraph pourrait vous aider.

Vous pouvez également consulter la section Transposition du manuel d’Emacs. Essentiellement:

 Ct Transpose two characters (transpose-chars). Mt Transpose two words (transpose-words). CMt Transpose two balanced expressions (transpose-sexps). Cx Ct Transpose two lines (transpose-lines). 

J’utilise le package smart-shift (en Melpa) pour cela. Par défaut, il relie CC pour déplacer une ligne ou une région. Il se déplace horizontalement d’une quantité spécifique au mode majeur (par exemple, c-basic-offset ou python-indent-offset). Fonctionne également sur les régions.

 ;; binds CC  (when (require 'smart-shift nil 'noerror) (global-smart-shift-mode 1))