Fix paste-forward behavior at end of buffer.

[plomvi.el] / plomvi.el

diff --git a/plomvi.el b/plomvi.el
index 34524fd35b0359fa5043df3a120e31005b2b7b0d..bda484d7a1ac73ce63163fff32f1ae6adbe41e0a 100644 (file)
--- a/plomvi.el
+++ b/plomvi.el
@@ -31,15 +31,17 @@
 
 ;;; 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 "<f1>") '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"))
 
 
 
@@ -126,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."
@@ -149,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."
@@ -177,24 +198,9 @@ Note that this ignores killed rectangles."
    ((and (boundp 'rectangle-mark-mode) (eq t rectangle-mark-mode))
     (copy-rectangle-as-kill (region-beginning) (region-end)))
    ((use-region-p)
-    (let* ((start-start-pos (region-beginning))
-           (start-end-pos (region-end))
-           (region-start (progn
-                           (goto-char start-start-pos)
-                           (beginning-of-line)
-                           (point)))
-           (region-end (progn
-                         (goto-char start-end-pos)
-                         (end-of-line)
-                         (+ 1 (point)))))
-      (copy-region-as-kill region-start region-end)
-      (goto-char region-start)))
+    (plomvi-affect-lines-of-region 'copy-region-as-kill))
    (t
-    (let ((keep-pos (point))
-          (region-start (progn (beginning-of-line) (point)))
-          (region-end (progn (end-of-line) (+ 1 (point)))))
-      (copy-region-as-kill region-start region-end)
-      (goto-char keep-pos)))))
+    (copy-region-as-kill (line-beginning-position) (+ 1 (line-end-position))))))
 
 (defun plomvi-copy-region()
   "Copy marked region."
@@ -278,7 +284,7 @@ text editing.")
 (define-key plomvi-mode-editable-map (kbd "P") 'plomvi-paste-backward)
 (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)
@@ -330,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")