Jak przełączać skrzynki pocztowe w regionie w emacs

Question

Jak przełączać wielkość liter w literach (zamienić wielkie litery na małe i wielkie litery) na tekst regionu w Emacs?

Dostępne są wymienione polecenia konwersji, ale nic do przełączenia.

Przykład:

prosze Przegubowe MY literę

powinny stać się:

ZNAJDUJE Przegubowe mój list CASE

Answer 1

Napisałem to dla ciebie; nie miał dokładnych testów, ale wydaje się, że robi to, czego szukasz.

Logika za nim polega na zapętleniu każdego znaku w tekście. Jeśli postać jest równa literą w tekście, dołącz ją do łańcucha powrotu w teczce. Jeśli nie, dołącz ją w dół. Na końcu usuń region i wstaw ciąg powrotny.

Natychmiast działa na stronie tekstu, ale uważam, aby nie używać go w dużych tekstach (powinno być nadal w porządku).

(defun toggle-case() 
    (interactive) 
    (when (region-active-p) 
    (let ((i 0) 
     (return-string "") 
     (input (buffer-substring-no-properties (region-beginning) (region-end)))) 
     (while (< i (- (region-end) (region-beginning))) 
    (let ((current-char (substring input i (+ i 1)))) 
     (if (string= (substring input i (+ i 1)) (downcase (substring input i (+ i 1)))) 
      (setq return-string 
      (concat return-string (upcase (substring input i (+ i 1))))) 
     (setq return-string 
      (concat return-string (downcase (substring input i (+ i 1))))))) 
    (setq i (+ i 1))) 
     (delete-region (region-beginning) (region-end)) 
     (insert return-string)))) 

Answer 2

Jeśli myśli się przypadek, to ta funkcja działa ładnie: http://ergoemacs.org/emacs/modernization_upcase-word.html

(defun toggle-letter-case() 
    "Toggle the letter case of current word or text selection. 
    Toggles between: “all lower”, “Init Caps”, “ALL CAPS”." 
    (interactive) 
    (let (p1 p2 (deactivate-mark nil) (case-fold-search nil)) 
    (if (region-active-p) 
     (setq p1 (region-beginning) p2 (region-end)) 
     (let ((bds (bounds-of-thing-at-point 'word))) 
     (setq p1 (car bds) p2 (cdr bds)))) 
    (when (not (eq last-command this-command)) 
     (save-excursion 
     (goto-char p1) 
     (cond 
     ((looking-at "[[:lower:]][[:lower:]]") (put this-command 'state "all lower")) 
     ((looking-at "[[:upper:]][[:upper:]]") (put this-command 'state "all caps")) 
     ((looking-at "[[:upper:]][[:lower:]]") (put this-command 'state "init caps")) 
     ((looking-at "[[:lower:]]") (put this-command 'state "all lower")) 
     ((looking-at "[[:upper:]]") (put this-command 'state "all caps")) 
     (t (put this-command 'state "all lower"))))) 
    (cond 
    ((string= "all lower" (get this-command 'state)) 
     (upcase-initials-region p1 p2) (put this-command 'state "init caps")) 
    ((string= "init caps" (get this-command 'state)) 
     (upcase-region p1 p2) (put this-command 'state "all caps")) 
    ((string= "all caps" (get this-command 'state)) 
     (downcase-region p1 p2) (put this-command 'state "all lower"))) 
    )) 

Answer 3

Polecenia upcase-region, downcase-region i capitalize-region nie są przełączane i są prawdopodobnie poleceniami "konwersji", o których wspomniałeś. Oto polecenie, które przełącza się między nimi.

(defvar cycle-region-capitalization-last 'upper) 
(defun cycle-region-capitalization (&optional msgp) 
    "Cycle the region text among uppercase, lowercase and capitalized (title case)." 
    (interactive "p") 
    (setq cycle-region-capitalization-last 
     (case cycle-region-capitalization-last 
      (upper (call-interactively #'downcase-region) 'lower) 
      (lower (call-interactively #'capitalize-region) 'title) 
      (title (call-interactively #'upcase-region)  'upper))) 
    (when msgp (message "Region is now %scase" cycle-region-capitalization-last))) 

Answer 4

Lubiłem techniki drugiej odpowiedzieć za porównywania this-command i last-command, więc już włączył ją do mojego starego funkcji. Oto wynik:

(defun upcase-word-toggle() 
    (interactive) 
    (let ((bounds (bounds-of-thing-at-point 'symbol)) 
     beg end 
     regionp) 
    (if (eq this-command last-command) 
     (setq regionp (get this-command 'regionp)) 
     (put this-command 'regionp nil)) 
    (cond 
     ((or (region-active-p) regionp) 
     (setq beg (region-beginning) 
      end (region-end)) 
     (put this-command 'regionp t)) 
     (bounds 
     (setq beg (car bounds) 
      end (cdr bounds))) 
     (t 
     (setq beg (point) 
      end (1+ beg)))) 
    (save-excursion 
     (goto-char (1- beg)) 
     (and (re-search-forward "[A-Za-z]" end t) 
      (funcall (if (char-upcasep (char-after)) 
         'downcase-region 
         'upcase-region) 
        beg end))))) 

(defun char-upcasep (letter) 
    (eq letter (upcase letter))) 

(global-set-key (kbd "C->") 'upcase-word-toggle) 

Answer 5

Można to zrobić z podstawieniem regexp:

M-x replace-regexp RET 
\([[:upper:]]+\)?\([[:lower:]]+\)? RET 
\,(concat (downcase (or \1 "")) (upcase (or \2 ""))) RET 

To do ciebie, aby powiązać klucz do tego.