Cómo avanzar y retroceder en el anillo de marca de Emacs

Question

En Emacs, C-u C-SPC "saltará a la marca y establecerá la marca en posición que se quitó del anillo de marca local". ¿Hay alguna manera de ir por el camino opuesto alrededor del anillo de marca? Digamos que ha escrito C-u C-SPC varias veces y quiere volver a una marca que ha visto sin recorrer todo el anillo.

Answer 1

No hace exactamente lo que está pidiendo, pero podría valer la pena buscar un paquete llamado marker-visit.el que le permita navegar por las marcas en el búfer actual en 'orden de posición del búfer' . A partir de ese archivo:

;;; Commentary: 

;; This file provides a simple way to navigate among marks in a 
;; buffer. C-u C-SPC is similar, but takes you haphazardly around the 
;; buffer. Setting bookmarks is a lot of extra work if you just want 
;; to jump around your buffer quickly; plus, you have to come up with 
;; a name for every bookmark. 

;; All the marks you've left while editing a buffer serve as bread 
;; crumb trails of areas in the buffer you've edited. It is 
;; convenient to navigate back and forth among these marks in order. 
;; This file provides two methods to do just that, marker-visit-prev 
;; and marker-visit-next. These two functions will take you, from 
;; point, to the nearest mark in either direction. The function 
;; marker-visit-truncate-mark-ring will truncate the mark ring. 

;; The marks you can visit in a buffer consist of: "the mark" plus the 
;; contents of the mark-ring. 

Ato [S-up] y [S-down] para visitar por marcadores-ant y el marcador de visita al lado respectivamente.

Si realmente desea/necesita navegar en el orden en que su mark-ring tiene actualmente, entonces puede obtener un lugar mirando las funciones pop-to-mark-command y pop-mark e implementando sus propias versiones para rotar el anillo de marca en la dirección opuesta.

Answer 2

¿Has probado browse-kill-ring? Download it from Emacswiki, lo puso en su load-path y luego añadir esto a sus emacs-conf:

(when (require 'browse-kill-ring nil 'noerror) 
    (browse-kill-ring-default-keybindings)) 

Entonces, cuando se pulsa Mi, se le mostrará el anillo de corte, buscarla como texto normal etc . Muy útil. There is also some more practical info on emacs-fu sobre el uso de browse-kill-ring

Answer 3

El manual dice esto:

La variable mark-ring-max especifica el número máximo de entradas para mantener en el histórico de marcas. Si existen muchas entradas y se inserta otra , la más antigua en la lista se descarta. La repetición de `C-u C- 'recorre las posiciones actualmente en el cuadrilátero.

Le sugiero que use eso para contener el tamaño del anillo de marca (a 3 o 4, el mío es actualmente 16). Entonces puedes moverte mucho más rápido usando prefijos.

también:

Si desea volver a la mismo lugar una y otra vez, el anillo de marcas puede no ser lo suficientemente cómodo. Si es , puede registrar la posición en un registro para su posterior recuperación (* nota Guardando Posiciones en Registros: RegPos.).

Answer 4

Aquí es una función para hacerlo:

(defun unpop-to-mark-command() 
    "Unpop off mark ring into the buffer's actual mark. 
Does not set point. Does nothing if mark ring is empty." 
    (interactive) 
    (let ((num-times (if (equal last-command 'pop-to-mark-command) 2 
        (if (equal last-command 'unpop-to-mark-command) 1 
         (error "Previous command was not a (un)pop-to-mark-command"))))) 
    (dotimes (x num-times) 
     (when mark-ring 
     (setq mark-ring (cons (copy-marker (mark-marker)) mark-ring)) 
     (set-marker (mark-marker) (+ 0 (car (last mark-ring))) (current-buffer)) 
     (when (null (mark t)) (ding)) 
     (setq mark-ring (nbutlast mark-ring)) 
     (goto-char (mark t))) 
     (deactivate-mark)))) 

Answer 5

Siguiendo mi comentario a scottfrazer de very handy solution, aquí hay algunos consejos que funciona en conjunción con eso para hacer más fácil a las direcciones alrededor del anillo de marcas a voluntad inversa, sin la necesidad de usar un enlace de clave diferente para cada dirección.

utilizo cua-selection-mode, así que para mí C-SPC está obligado a cua-set-mark, pero he escrito esto como una macro con el fin de asesorar a cualquiera que la función está obligado a C-SPC, y comprobado que funciona con el valor predeterminado set-mark-command.

Para despoblar, simplemente proporcione un argumento de prefijo negativo. p.ej. C--   C-SPC

Una de las cosas buenas de cua-set-mark es que después de una inicial Cu   C-SPC, puede continuar a aparecer marcas sucesivas con sólo C-SPC, y he incluido aquí que el comportamiento: Después de una inicial C--   C-SPC puede seguir un-que hace estallar con sólo C-SPC. Para invertir la dirección nuevamente y llamar al pop-to-mark, simplemente proporcione un argumento positivo una vez más con C-u   C-SPC.

(defmacro my-unpop-to-mark-advice() 
    "Enable reversing direction with un/pop-to-mark." 
    `(defadvice ,(key-binding (kbd "C-SPC")) (around my-unpop-to-mark activate) 
    "Unpop-to-mark with negative arg" 
    (let* ((arg (ad-get-arg 0)) 
      (num (prefix-numeric-value arg))) 
     (cond 
     ;; Enabled repeated un-pops with C-SPC 
     ((eq last-command 'unpop-to-mark-command) 
     (if (and arg (> num 0) (<= num 4)) 
      ad-do-it ;; C-u C-SPC reverses back to normal direction 
      ;; Otherwise continue to un-pop 
      (setq this-command 'unpop-to-mark-command) 
      (unpop-to-mark-command))) 
     ;; Negative argument un-pops: C-- C-SPC 
     ((< num 0) 
     (setq this-command 'unpop-to-mark-command) 
     (unpop-to-mark-command)) 
     (t 
     ad-do-it))))) 
(my-unpop-to-mark-advice) 

Answer 6

Hay dos anillos de marcadores: uno local al búfer en uso y uno global entre todos los búferes.

Por defecto, en Icicles (en carámbano modo menor global):

• C-- C-SPC permite que viaje entre los marcadores locales
• C-- C-x C-SPC le permite tropezar entre los marcadores globales

IOW, con un prefijo negativo arg, C-SPC y C-x C-SPC navegar. Sin él, simplemente hacen lo que hacen normalmente (set-mark-command y pop-global-mark, respectivamente).

obras de navegación, según se indica a continuación:

• ubicaciones están disponibles como candidatas de compleción: el texto es el de la línea del marcador.
• Finalización: puede usar subcadena, expresión regular, prefijo, difusa (varios tipos).
• Puede desplazarse por cualquiera de los candidatos de finalización, o ir a cualquiera de ellos directamente.

Teclas disponibles durante la realización incluyen:

• up, down - ciclo de los candidatos a las *Completions*, sin tener que navegar a sus ubicaciones

• C-up, C-down - ciclo, navegando a cada ubicación a su vez

• C-RET, C-mouse-2 - vaya directamente al candidato actual/seleccionado (p. Ej. en *Completions*)

• RET, mouse-2 - Igual que el anterior (ir a candidato), pero terminar el comando (hecho)

• S-TAB - a propósito-completo (subcadena/regexp)

• TAB - prefijo o difusa completa

Answer 7

a diferencia de las respuestas anteriores, éste sólo hace exactamente lo que se le pedía: el reverso de Cu C-SPC. Lo encuentro el más útil.

(defun unpop-to-mark-command() 
    "Unpop off mark ring. Does nothing if mark ring is empty." 
    (interactive) 
     (when mark-ring 
     (setq mark-ring (cons (copy-marker (mark-marker)) mark-ring)) 
     (set-marker (mark-marker) (car (last mark-ring)) (current-buffer)) 
     (when (null (mark t)) (ding)) 
     (setq mark-ring (nbutlast mark-ring)) 
     (goto-char (marker-position (car (last mark-ring)))))) 

En comparación con la respuesta por scottfrazer, este comando tiene una sutil diferencia de cómo se mueve el cursor y la marca, que refleja con mayor precisión Cu C-SPC, y que no requiere que el comando anterior era un UNPOP/pop-to-mark-command.

Answer 8

Aquí hay una solución que acabo de pasar demasiado tiempo. La diferencia entre esta y las otras soluciones es que funciona en búferes, es decir, funciona en el 'anillo de marca global'. Mi objetivo era emular la navegación histórica similar a Eclipse o IntelliJ. Lo ato a M-izquierda y M-derecha, obviamente puedes elegir diferentes claves para esto.

(defun marker-is-point-p (marker) 
    "test if marker is current point" 
    (and (eq (marker-buffer marker) (current-buffer)) 
     (= (marker-position marker) (point)))) 

(defun push-mark-maybe() 
    "push mark onto `global-mark-ring' if mark head or tail is not current location" 
    (if (not global-mark-ring) (error "global-mark-ring empty") 
    (unless (or (marker-is-point-p (car global-mark-ring)) 
       (marker-is-point-p (car (reverse global-mark-ring)))) 
     (push-mark)))) 


(defun backward-global-mark() 
    "use `pop-global-mark', pushing current point if not on ring." 
    (interactive) 
    (push-mark-maybe) 
    (when (marker-is-point-p (car global-mark-ring)) 
    (call-interactively 'pop-global-mark)) 
    (call-interactively 'pop-global-mark)) 

(defun forward-global-mark() 
    "hack `pop-global-mark' to go in reverse, pushing current point if not on ring." 
    (interactive) 
    (push-mark-maybe) 
    (setq global-mark-ring (nreverse global-mark-ring)) 
    (when (marker-is-point-p (car global-mark-ring)) 
    (call-interactively 'pop-global-mark)) 
    (call-interactively 'pop-global-mark) 
    (setq global-mark-ring (nreverse global-mark-ring))) 

(global-set-key [M-left] (quote backward-global-mark)) 
(global-set-key [M-right] (quote forward-global-mark))