X-Git-Url: https://plomlompom.com/repos/?p=plomvi.el;a=blobdiff_plain;f=plomvi.el;h=bda484d7a1ac73ce63163fff32f1ae6adbe41e0a;hp=4d1b9e3cfa5db15a21b6abffd7ea06a165e8529e;hb=HEAD;hpb=c789535cda371cde21e6cd02a3394e9b7e6145b1 diff --git a/plomvi.el b/plomvi.el index 4d1b9e3..bda484d 100644 --- a/plomvi.el +++ b/plomvi.el @@ -31,22 +31,20 @@ ;;; Instructions: -;; 1. load this script into your init file: (load ...) +;; 1. load this script at the end of your init file: (load ...) -;; 2. to start plomvi by default, put this into your init file: +;; 2. to start plomvi by default, put this right after: ;; (plomvi-global-mode 1) -;; 3. define some otherwise unused keybinding to simulate what would -;; be a jump back from Insert mode to Normal mode in Vim (but is de -;; facto just a plomvi mode activation), such as this: -;; (global-set-key (kbd "") 'plomvi-activate) +;; 3. if you want to use a different keybinding than "C-c C-c C-c" +;; to simulate the jump back from Insert to Normal mode in Vim (de +;; facto just a plomvi mode activation), put a line such as this +;; before the (load ...) line for plomvi (with "C-c" the desired +;; combo): +;; (defvar plomvi-return-combo (kbd "C-c")) -(defun plomvi-nothing() - "Do nothing. Used to shadow self-insert bindings in `plomvi-mode-editable-map'." - (interactive)) - (defun plomvi-half-scroll() "Scroll down half a screen width." (interactive) @@ -130,21 +128,38 @@ Note that this ignores killed rectangles. (defun plomvi-paste-forward () "Paste last kill rightwards in current line, or (if kill ends in \n) under it. +Doesn't move rightwards before yanking if at end of buffer. + Note that this ignores killed rectangles." (interactive) (if (eq nil (string-match "\n$" (current-kill 0))) (progn - (right-char) + (if (< (point) (point-max)) + (right-char)) (yank)) (end-of-line) - (right-char) + (if (< (point) (point-max)) + (right-char)) (yank) (previous-line))) -(defun plomvi-region-kill() - "Kill marked region." +(defun plomvi-affect-lines-of-region(f) + "Call f on start of first line of region and end of last line of region." + (let* ((start-start-pos (region-beginning)) + (start-end-pos (region-end)) + (region-start (progn + (goto-char start-start-pos) + (line-beginning-position))) + (region-end (progn + (goto-char start-end-pos) + (+ 1 (line-end-position))))) + (funcall f region-start region-end) + (goto-char region-start))) + +(defun plomvi-kill-region-lines() + "Kill lines of marked region." (interactive) - (kill-region (region-beginning) (region-end))) + (plomvi-affect-lines-of-region 'kill-region)) (defun plomvi-x() "If rectangle or region marked, kill those; else, kill char after point." @@ -153,9 +168,11 @@ Note that this ignores killed rectangles." ((and (boundp 'rectangle-mark-mode) (eq t rectangle-mark-mode)) (kill-rectangle (region-beginning) (region-end))) ((use-region-p) - (plomvi-region-kill)) - (t - (delete-char 1)))) + (kill-region (region-beginning) (region-end))) + ((not (= (point) (line-end-position))) + (delete-char 1)) + ((not (= (line-beginning-position) (line-end-position))) + (backward-char) (delete-char 1)))) (defun plomvi-rectangle-mark() "Start marked rectangle, move right one char so a single column is visible." @@ -174,14 +191,16 @@ Note that this ignores killed rectangles." (interactive) (search-backward isearch-string)) - -(defun plomvi-copy-line() - "Copy current line into kill buffer." +(defun plomvi-Y() + "Copy rectangle, or full line, or region in full lines." (interactive) - (let ((keep_pos (point))) ; We sort of cheat: We kill the line, then we - (kill-whole-line) ; paste it back, and return point to its - (plomvi-paste-backward) ; original position. - (goto-char keep_pos))) ; + (cond + ((and (boundp 'rectangle-mark-mode) (eq t rectangle-mark-mode)) + (copy-rectangle-as-kill (region-beginning) (region-end))) + ((use-region-p) + (plomvi-affect-lines-of-region 'copy-region-as-kill)) + (t + (copy-region-as-kill (line-beginning-position) (+ 1 (line-end-position)))))) (defun plomvi-copy-region() "Copy marked region." @@ -193,29 +212,6 @@ Note that this ignores killed rectangles." (interactive "cplomvi-replace-char") (delete-char 1) (insert-char c) (left-char)) -;;; some attempt at a redo feature, not very successful, documented here for -;;; research purposes -; -;(setq plomvi-in-redo nil) ; should be made buffer-local -;(setq plomvi-undo-count 0) ; should be made buffer-local -;(defun plomvi-undo() -; (interactive) -; (undo-only) -; (setq plomvi-in-redo nil) -; (setq plomvi-undo-count (+ plomvi-undo-count 1))) -;(defun plomvi-redo() -; (interactive) -; (if (> plomvi-undo-count 0) -; (progn -; (if (null plomvi-in-redo) -; (progn -; (insert-char ?\s 1) -; (undo) -; (setq plomvi-in-redo t))) -; (progn -; (undo) -; (setq plomvi-undo-count (- plomvi-undo-count 1)))))) - (defun plomvi-no-redo() "Tell user what to do, since implementing vim redo was too much of a hassle." (interactive) @@ -234,12 +230,10 @@ Note that this ignores killed rectangles." (defvar plomvi-mode-basic-map (make-sparse-keymap) "Keymap for `plomvi-mode' on read-only buffers. -In contrast to the keymap `plomvi-editable-mode' for editable buffers, -this not only excludes keybindings for editing text, but also does not -shadow keybindings that are bound to `self-insert-command'. - -Thus, it on the whole shadows much fewer keybindings of other keymaps -that can therefore be used for other purposes.") +In contrast to the keymap `plomvi-editable-mode' for editable +buffers, this excludes keybindings for editing text, which thus +become available to be used for other purposes.") +(suppress-keymap plomvi-mode-basic-map t) (define-key plomvi-mode-basic-map (kbd ":") 'plomvi-prompt) (define-key plomvi-mode-basic-map (kbd "C-w") 'other-window) (define-key plomvi-mode-basic-map (kbd "k") 'previous-line) @@ -275,11 +269,9 @@ that can therefore be used for other purposes.") (defvar plomvi-mode-editable-map (make-sparse-keymap) "Keymap for `plomvi-mode' on editable buffers. -Inherits from `plomvi-mode-basic-map', but adds keybindings for text editing -and shadows keybindings bound to `self-insert-command' to avoid accidentally -typing text outside of what would be Vim's Insert mode.") +Inherits from `plomvi-mode-basic-map', but adds keybindings for +text editing.") (set-keymap-parent plomvi-mode-editable-map plomvi-mode-basic-map) -(define-key plomvi-mode-editable-map [remap self-insert-command] 'plomvi-nothing) (define-key plomvi-mode-editable-map (kbd "i") 'plomvi-deactivate) (define-key plomvi-mode-editable-map (kbd "x") 'plomvi-x) (define-key plomvi-mode-editable-map (kbd "o") 'plomvi-newline-below) @@ -287,14 +279,12 @@ typing text outside of what would be Vim's Insert mode.") (define-key plomvi-mode-editable-map (kbd "r") 'plomvi-replace-char) (define-key plomvi-mode-editable-map (kbd "u") 'undo-only) (define-key plomvi-mode-editable-map (kbd "C-r") 'plomvi-no-redo) -;(define-key plomvi-mode-editable-map (kbd "u") 'plomvi-undo) -;(define-key plomvi-mode-editable-map (kbd "C-r") 'plomvi-redo) (define-key plomvi-mode-editable-map (kbd "I") 'string-insert-rectangle) (define-key plomvi-mode-editable-map (kbd "p") 'plomvi-paste-forward) (define-key plomvi-mode-editable-map (kbd "P") 'plomvi-paste-backward) -(define-key plomvi-mode-editable-map (kbd "Y") 'plomvi-copy-line) +(define-key plomvi-mode-editable-map (kbd "Y") 'plomvi-Y) (define-key plomvi-mode-editable-map (kbd "y") 'plomvi-copy-region) -(define-key plomvi-mode-editable-map (kbd "D") 'plomvi-region-kill) +(define-key plomvi-mode-editable-map (kbd "D") 'plomvi-kill-region-lines) (define-prefix-command 'plomvi-d-map) (define-key plomvi-mode-editable-map (kbd "d") 'plomvi-d-map) (define-key plomvi-d-map (kbd "w") 'kill-word) @@ -320,9 +310,9 @@ or, on editable buffers, `plomvi-mode-editable'. The latter two's values in `minor-mode-map-alist' toggle either `plomvi-mode-basic-map' or `plomvi-mode-editable-map'." (interactive (list (or current-prefix-arg 'toggle))) - (let ((enable (if (eq arg 'toggle) - (not plomvi-mode) - (> (prefix-numeric-value arg) 0 )))) + (let ((enable (if (eq arg 'toggle) ; follow suggestions + (not plomvi-mode) ; from (elisp)Minor + (> (prefix-numeric-value arg) 0 )))) ; Mode Conventions (if enable (unless (minibufferp) (if buffer-read-only @@ -346,3 +336,13 @@ or, on editable buffers, `plomvi-mode-editable'. The latter two's values in plomvi-mode-basic-map)) (add-to-list 'minor-mode-map-alist (cons 'plomvi-mode-editable plomvi-mode-editable-map)) + +(defvar plomvi-callable-mode-map + (let ((map (make-sparse-keymap)) + (return-combo (if (boundp 'plomvi-return-combo) + plomvi-return-combo + (kbd "C-c C-c C-c")))) + (define-key map return-combo 'plomvi-activate) + map)) +(define-minor-mode plomvi-callable-mode "" + :init-value t :keymap "plomvi-callable")