Emacs: jak szarpać ostatni szarpany tekst niezależnie od kolejnych zabójstw?

Nie używaj pierścienia zabijania; zamiast tego umieść tekst w rejestrze. C-x r s a aby zapisać tekst regionu do (powiedzmy) rejestru "a"; następnie C-x r i a Aby wstawić go gdzie indziej.

Możesz użyć M-x delete-region zamiast tego zabić tekst, ewentualnie powiązać go z kluczem, jeśli chcesz go często używać.

1. Jeśli chcesz wielokrotnie szargać ten sam tekst, użyj selekcja wtórna zamiast regionu lub zabitego tekstu.

   To, czego brakuje w vanilla Emacs, to Wiązanie klucza, które ma za zadanie wyrwać drugorzędną selekcję. Używam do tego C-M-y (patrz biblioteka second-sel.el).

2. Aby uzyskać bezpośredni dostęp do wszystkich zabójstw w pierścieniu zabijania, użyj M-y z Browse Kill Ring lub z sople. W obu przypadkach, M-y na najwyższym poziomie daje dostęp do wszystkich wpisów w pierścieniu zabijania.

   I jeśli korzystasz z biblioteki second-sel.el następnie, oprócz pierścienia zabijania, masz dostęp do pierścienia swoich poprzednich selekcji wtórnych.

   A jeśli używasz library second-sel.el i Icicles wtedy M-y yanks wpis z pierścienia, z którego ostatnio Szarpałeś (kill ring lub secondary-selection ring).

   I jeśli używasz biblioteki browse-kill-ring+.el wtedy przeglądarka kill-ring daje dostęp do alternatywnego pierścienia (który domyślnie jest pierścieniem drugorzędnych selekcji, jeśli używasz biblioteki second-sel.el).

[7]}próbuję się włamać wzdłuż linii korzystania z trybu minor. Nazwijmy to delete-mode. Po przejściu w tryb delete, Zabij polecenia (kill-line, kill-paragraph, kill-word, ...) zmieni ich zachowanie tak, że kill-region część ich poleceń zostanie zastąpiona delete-region, a nowy materiał nie zostanie dodany do pierścienia zabijania. W tym trybie pierścień śmierci pozostanie stały. Po ponownym przejściu z tego trybu zachowanie powraca do normy.

Poniżej znajduje się niekompletny kod próbuję zaimplementować to, co napisałem powyżej. Działa poprawnie przy przełączaniu do trybu delete, ale ma problem z przełączeniem z powrotem(wyłączenie trybu minor). Każda pomoc w naprawieniu tego będzie mile widziana.

(defvar delete-mode nil)

(defun delete-mode ()
    "delete minor-mode"
    (interactive)
    (setq delete-mode (not delete-mode))
    (if delete-mode
        (defalias 'kill-region 'delete-region)
        (defalias 'kill-region 'original-kill-region)
    )
)

(if (not (assq 'delete-mode minor-mode-alist))
    (setq minor-mode-alist
        (cons '(delete-mode "Delete mode on") minor-mode-alist)
    )
    (defalias 'original-kill-region 'kill-region)
)

Postaram się bardziej używać delete-region, ale lepiej znam polecenia kill. Sztuczka, która nie wymaga programowania lub planowania z góry jest użycie M-W po szczególnie irytującym ciągu M-y. to stawia bardziej dostępną kopię ostatniego yank w pierścieniu zabijania.

A Better Yank-Pop Implementation

Definiuje to lepszą implementację yank-pop, która próbuje naprawić rosnący problem yank-pop.

Nadpisuje tylko funkcję "current-kill". Ze względu na modułową konstrukcję yank, yank-pop oraz zmienne i funkcje pierścienia śmierci w Emacsie, okazuje się, że nadrzędne "current-kill" jest wszystkim, co jest konieczne, aby uzyskać pożądane zachowanie.

Pożądanym zachowaniem jest to, że (1) zabicie Czegoś wciąż stawia go przed kill ring, ale teraz (2) yanking lub Yank-popping coś również umieszcza go z przodu kill ring (3) zachowujemy zdolność yank-pop do nadawania wyglądu poruszania się przez kill ring poprzez zwiększenie zmiennej globalnej i użycie jej do zastąpienia ostatniego Yank-pop ' pop ' uped elementu z powrotem tam, gdzie był. Oznacza to również, że (4) elementy, które są przejściowo szarpane (tj. elementy umieszczone przez polecenia yank lub yank-pop, gdzie następne polecenie jest yank-pop) ostatecznie zostają tam, gdzie są w kill ring.

;; Example:
;; (setq kill-ring '("a" "b" "c" "d" "e"))
;;
;; keystroke        kill ring contents              value of kill-ring-yank-index
;; C-y              ("a" "b" "c" "d" "e")           0
;; M-y              ("b" "a" "c" "d" "e")           1
;; M-y              ("c" "a" "b" "d" "e")           2
;; M-y              ("d" "a" "b" "c" "e")           3

;; C-y              ("d" "a" "b" "c" "e")           0
;; M-y              ("a" "d" "b" "c" "e")           1

;; M-d              ("x" "a" "d" "b" "c" "e")
;; etc.

Kod:

;; ----------------------------------------------------------------
;; helper functions

(defun list-insert-before (l n x)
  (if (<= n 0) (cons x l)
    (cons (car l) (list-insert-before (cdr l) (- n 1) x))))

(defun list-prepend-nth (l n)
  (if (<= n 0) l
    (let* ((lx (list-prepend-nth (cdr l) (- n 1))))
      (cons (car lx) (cons (car l) (cdr lx))))))

(defun list-insert-car-at (l n)
  (list-insert-before (cdr l) n (car l)))


;; ----------------------------------------------------------------
;; overriding current-kill

(defvar kill-ring-yank-index 0
  "Index into kill-ring of last yank-pop. The item yank-popped
  will be at the head of the kill ring, but if the next command
  is also yank-pop, it will be returned here first before this
  variable is incremented.")

(defun current-kill (n)
  "Replaces standard 'current-kill' function. This version tries
to fix the increasing yank-pop problem.

TODO:
- respect second argument of original function
- deal with 'interprogram-{cut,paste}-function'
"
  (if (eq 0 n) ;; looks like we're doing a yank; reset
               ;; kill-ring-yank-index to 0 to indicate that the
               ;; current head of the list is useful to the user
      (progn (setq kill-ring-yank-index 0)
             (car kill-ring))

    ;; otherwise put the head of kill-ring back where we had
    ;; previously found it, and fetch the next element
    (setq kill-ring
        (list-insert-car-at kill-ring kill-ring-yank-index))
    (setq kill-ring-yank-index (+ kill-ring-yank-index n))
    (when (>= kill-ring-yank-index (- (length kill-ring) 1))
      (setq kill-ring-yank-index (- (length kill-ring) 1))
      (message "Reached end of kill-ring"))
    (when (< kill-ring-yank-index 0)
      (setq kill-ring-yank-index 0)
      (message "Reached beginning of kill-ring"))
    (setq kill-ring (list-prepend-nth kill-ring kill-ring-yank-index))
    (car kill-ring)))

;; ----------------------------------------------------------------
;; new key binding

;; Here's an auxiliary function and key binding that makes it easy to
;; go back and forth in the kill-ring while we're yank-popping
(defun yank-pop-back () "" (interactive "*")
       (yank-pop -1))

(global-set-key "\C-\M-y" 'yank-pop-back)

Używam

M - x-kill-ring

Z klawiszami 'M-y'. Istnieje również wsparcie helm.

Https://www.emacswiki.org/emacs/BrowseKillRing

Oferuje więcej rozwiązań.