-;;; rect.el --- rectangle functions for GNU Emacs
+;;; rect.el --- rectangle functions for GNU Emacs -*- lexical-binding:t -*-
-;; Copyright (C) 1985, 1999, 2000, 2001, 2002, 2003, 2004
-;; 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1999-2013 Free Software Foundation, Inc.
;; Maintainer: Didier Verna <didier@xemacs.org>
;; Keywords: internal
+;; Package: emacs
;; This file is part of GNU Emacs.
;; This package provides the operations on rectangles that are documented
;; in the Emacs manual.
-;; ### NOTE: this file has been almost completely rewritten by Didier Verna
-;; <didier@xemacs.org> in July 1999. The purpose of this rewrite is to be less
-;; intrusive and fill lines with whitespaces only when needed. A few functions
-;; are untouched though, as noted above their definition.
-
-;;; Global key bindings
-
-;;;###autoload (define-key ctl-x-r-map "c" 'clear-rectangle)
-;;;###autoload (define-key ctl-x-r-map "k" 'kill-rectangle)
-;;;###autoload (define-key ctl-x-r-map "d" 'delete-rectangle)
-;;;###autoload (define-key ctl-x-r-map "y" 'yank-rectangle)
-;;;###autoload (define-key ctl-x-r-map "o" 'open-rectangle)
-;;;###autoload (define-key ctl-x-r-map "t" 'string-rectangle)
+;; ### NOTE: this file was almost completely rewritten by Didier Verna
+;; <didier@xemacs.org> in July 1999.
;;; Code:
-;;;###autoload
-(defun move-to-column-force (column &optional flag)
- "If COLUMN is within a multi-column character, replace it by spaces and tab.
-As for `move-to-column', passing anything but nil or t in FLAG will move to
-the desired column only if the line is long enough."
- (move-to-column column (or flag t)))
-
-;;;###autoload
-(make-obsolete 'move-to-column-force 'move-to-column "21.2")
-
-;; not used any more --dv
-;; extract-rectangle-line stores lines into this list
-;; to accumulate them for extract-rectangle and delete-extract-rectangle.
-(defvar operate-on-rectangle-lines)
-
-;; ### NOTE: this function is untouched, but not used anymore apart from
-;; `delete-whitespace-rectangle'. `apply-on-rectangle' is used instead. --dv
+;; FIXME: this function should be replaced by `apply-on-rectangle'
(defun operate-on-rectangle (function start end coerce-tabs)
"Call FUNCTION for each line of rectangle with corners at START, END.
If COERCE-TABS is non-nil, convert multi-column characters
(forward-line 1)))
(- endcol startcol)))
-;; The replacement for `operate-on-rectangle' -- dv
(defun apply-on-rectangle (function start end &rest args)
"Call FUNCTION for each line of rectangle with corners at START, END.
FUNCTION is called with two arguments: the start and end columns of the
rectangle, plus ARGS extra arguments. Point is at the beginning of line when
-the function is called."
- (let (startcol startpt endcol endpt)
+the function is called.
+The final point after the last operation will be returned."
+ (let (startcol startpt endcol endpt final-point)
(save-excursion
(goto-char start)
(setq startcol (current-column))
(goto-char startpt)
(while (< (point) endpt)
(apply function startcol endcol args)
+ (setq final-point (point))
(forward-line 1)))
- ))
+ final-point))
(defun delete-rectangle-line (startcol endcol fill)
(when (= (move-to-column startcol (if fill t 'coerce)) startcol)
(setcdr lines (cons (filter-buffer-substring pt (point) t) (cdr lines))))
))
-;; ### NOTE: this is actually the only function that needs to do complicated
-;; stuff like what's happening in `operate-on-rectangle', because the buffer
-;; might be read-only. --dv
+;; This is actually the only function that needs to do complicated
+;; stuff like what's happening in `operate-on-rectangle', because the
+;; buffer might be read-only.
(defun extract-rectangle-line (startcol endcol lines)
(let (start end begextra endextra line)
(move-to-column startcol)
(defconst spaces-strings
'["" " " " " " " " " " " " " " " " "])
-;; this one is untouched --dv
(defun spaces-string (n)
"Return a string with N spaces."
(if (<= n 8) (aref spaces-strings n)
(condition-case nil
(setq killed-rectangle (delete-extract-rectangle start end fill))
((buffer-read-only text-read-only)
+ (setq deactivate-mark t)
(setq killed-rectangle (extract-rectangle start end))
(if kill-read-only-ok
(progn (message "Read only text copied to kill ring") nil)
(barf-if-buffer-read-only)
(signal 'text-read-only (list (current-buffer)))))))
-;; this one is untouched --dv
+;;;###autoload
+(defun copy-rectangle-as-kill (start end)
+ "Copy the region-rectangle and save it as the last killed one."
+ (interactive "r")
+ (setq killed-rectangle (extract-rectangle start end))
+ (setq deactivate-mark t)
+ (if (called-interactively-p 'interactive)
+ (indicate-copied-region (length (car killed-rectangle)))))
+
;;;###autoload
(defun yank-rectangle ()
"Yank the last killed rectangle with upper left corner at point."
(interactive "*")
(insert-rectangle killed-rectangle))
-;; this one is untoutched --dv
;;;###autoload
(defun insert-rectangle (rectangle)
"Insert text of RECTANGLE with upper left corner at point.
(= (point) (point-at-eol)))
(indent-to endcol))))
-(defun delete-whitespace-rectangle-line (startcol endcol fill)
+(defun delete-whitespace-rectangle-line (startcol _endcol fill)
(when (= (move-to-column startcol (if fill t 'coerce)) startcol)
(unless (= (point) (point-at-eol))
(delete-region (point) (progn (skip-syntax-forward " ") (point))))))
(interactive "*r\nP")
(apply-on-rectangle 'delete-whitespace-rectangle-line start end fill))
-;; not used any more --dv
-;; string-rectangle uses this variable to pass the string
-;; to string-rectangle-line.
-(defvar string-rectangle-string)
(defvar string-rectangle-history nil)
(defun string-rectangle-line (startcol endcol string delete)
(move-to-column startcol t)
(or (car string-rectangle-history) ""))
nil 'string-rectangle-history
(car string-rectangle-history)))))
- (apply-on-rectangle 'string-rectangle-line start end string t))
+ (goto-char
+ (apply-on-rectangle 'string-rectangle-line start end string t)))
;;;###autoload
(defalias 'replace-rectangle 'string-rectangle)
(delete-region pt (point))
(indent-to endcol)))))
+;; Line numbers for `rectangle-number-line-callback'.
+(defvar rectangle-number-line-counter)
+
+(defun rectangle-number-line-callback (start _end format-string)
+ (move-to-column start t)
+ (insert (format format-string rectangle-number-line-counter))
+ (setq rectangle-number-line-counter
+ (1+ rectangle-number-line-counter)))
+
+(defun rectange--default-line-number-format (start end start-at)
+ (concat "%"
+ (int-to-string (length (int-to-string (+ (count-lines start end)
+ start-at))))
+ "d "))
+
+;;;###autoload
+(defun rectangle-number-lines (start end start-at &optional format)
+ "Insert numbers in front of the region-rectangle.
+
+START-AT, if non-nil, should be a number from which to begin
+counting. FORMAT, if non-nil, should be a format string to pass
+to `format' along with the line count. When called interactively
+with a prefix argument, prompt for START-AT and FORMAT."
+ (interactive
+ (if current-prefix-arg
+ (let* ((start (region-beginning))
+ (end (region-end))
+ (start-at (read-number "Number to count from: " 1)))
+ (list start end start-at
+ (read-string "Format string: "
+ (rectange--default-line-number-format
+ start end start-at))))
+ (list (region-beginning) (region-end) 1 nil)))
+ (unless format
+ (setq format (rectange--default-line-number-format start end start-at)))
+ (let ((rectangle-number-line-counter start-at))
+ (apply-on-rectangle 'rectangle-number-line-callback
+ start end format)))
+
+;;; New rectangle integration with kill-ring.
+
+;; FIXME: known problems with the new rectangle support:
+;; - lots of commands handle the region without paying attention to its
+;; rectangular shape.
+
+(add-hook 'deactivate-mark-hook
+ (lambda () (rectangle-mark-mode -1)))
+
+(add-function :around redisplay-highlight-region-function
+ #'rectangle--highlight-for-redisplay)
+(add-function :around redisplay-unhighlight-region-function
+ #'rectangle--unhighlight-for-redisplay)
+(add-function :around region-extract-function
+ #'rectangle--extract-region)
+
+(defvar rectangle-mark-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map [?\C-o] 'open-rectangle)
+ (define-key map [?\C-t] 'string-rectangle)
+ ;; (define-key map [remap open-line] 'open-rectangle)
+ ;; (define-key map [remap transpose-chars] 'string-rectangle)
+ map)
+ "Keymap used while marking a rectangular region.")
+
+;;;###autoload
+(define-minor-mode rectangle-mark-mode
+ "Toggle the region as rectangular.
+Activates the region if needed. Only lasts until the region is deactivated."
+ nil nil nil
+ (when rectangle-mark-mode
+ (unless (region-active-p) (push-mark-command t))))
+
+(defun rectangle--extract-region (orig &optional delete)
+ (if (not rectangle-mark-mode)
+ (funcall orig delete)
+ (let* ((strs (funcall (if delete
+ #'delete-extract-rectangle
+ #'extract-rectangle)
+ (region-beginning) (region-end)))
+ (str (mapconcat #'identity strs "\n")))
+ (when (eq last-command 'kill-region)
+ ;; Try to prevent kill-region from appending this to some
+ ;; earlier element.
+ (setq last-command 'kill-region-dont-append))
+ (when strs
+ (put-text-property 0 (length str) 'yank-handler
+ `(rectangle--insert-for-yank ,strs t)
+ str)
+ str))))
+
+(defun rectangle--insert-for-yank (strs)
+ (push (point) buffer-undo-list)
+ (let ((undo-at-start buffer-undo-list))
+ (insert-rectangle strs)
+ (setq yank-undo-function
+ (lambda (_start _end)
+ (undo-start)
+ (setcar undo-at-start nil) ;Turn it into a boundary.
+ (while (not (eq pending-undo-list (cdr undo-at-start)))
+ (undo-more 1))))))
+
+(defun rectangle--highlight-for-redisplay (orig start end window rol)
+ (cond
+ ((not rectangle-mark-mode)
+ (funcall orig start end window rol))
+ ((and (eq 'rectangle (car-safe rol))
+ (eq (nth 1 rol) (buffer-chars-modified-tick))
+ (eq start (nth 2 rol))
+ (eq end (nth 3 rol)))
+ rol)
+ (t
+ (save-excursion
+ (let* ((nrol nil)
+ (old (if (eq 'rectangle (car-safe rol))
+ (nthcdr 4 rol)
+ (funcall redisplay-unhighlight-region-function rol)
+ nil))
+ (ptcol (progn (goto-char start) (current-column)))
+ (markcol (progn (goto-char end) (current-column)))
+ (leftcol (min ptcol markcol))
+ (rightcol (max ptcol markcol)))
+ (goto-char start)
+ (while (< (point) end)
+ (let* ((mleft (move-to-column leftcol))
+ (left (point))
+ (mright (move-to-column rightcol))
+ (right (point))
+ (ol
+ (if (not old)
+ (let ((ol (make-overlay left right)))
+ (overlay-put ol 'window window)
+ (overlay-put ol 'face 'region)
+ ol)
+ (let ((ol (pop old)))
+ (move-overlay ol left right (current-buffer))
+ ol))))
+ ;; `move-to-column' may stop before the column (if bumping into
+ ;; EOL) or overshoot it a little, when column is in the middle
+ ;; of a char.
+ (cond
+ ((< mleft leftcol) ;`leftcol' is past EOL.
+ (overlay-put ol 'before-string
+ (spaces-string (- leftcol mleft)))
+ (setq mright (max mright leftcol)))
+ ((and (> mleft leftcol) ;`leftcol' is in the middle of a char.
+ (eq (char-before left) ?\t))
+ (setq left (1- left))
+ (move-overlay ol left right)
+ (goto-char left)
+ (overlay-put ol 'before-string
+ (spaces-string (- leftcol (current-column)))))
+ ((overlay-get ol 'before-string)
+ (overlay-put ol 'before-string nil)))
+ (cond
+ ((< mright rightcol) ;`rightcol' is past EOL.
+ (let ((str (make-string (- rightcol mright) ?\s)))
+ (put-text-property 0 (length str) 'face 'region str)
+ ;; If cursor happens to be here, draw it *before* rather than
+ ;; after this highlighted pseudo-text.
+ (put-text-property 0 1 'cursor t str)
+ (overlay-put ol 'after-string str)))
+ ((and (> mright rightcol) ;`rightcol' is in the middle of a char.
+ (eq (char-before right) ?\t))
+ (setq right (1- right))
+ (move-overlay ol left right)
+ (if (= rightcol leftcol)
+ (overlay-put ol 'after-string nil)
+ (goto-char right)
+ (let ((str (make-string
+ (- rightcol (max leftcol (current-column))) ?\s)))
+ (put-text-property 0 (length str) 'face 'region str)
+ (when (= left right)
+ ;; If cursor happens to be here, draw it *before* rather
+ ;; than after this highlighted pseudo-text.
+ (put-text-property 0 1 'cursor 1 str))
+ (overlay-put ol 'after-string str))))
+ ((overlay-get ol 'after-string)
+ (overlay-put ol 'after-string nil)))
+ (when (= leftcol rightcol)
+ ;; Make zero-width rectangles visible!
+ (overlay-put ol 'after-string
+ (concat (propertize " "
+ 'face '(region (:height 0.2)))
+ (overlay-get ol 'after-string))))
+ (push ol nrol))
+ (forward-line 1))
+ (mapc #'delete-overlay old)
+ `(rectangle ,(buffer-chars-modified-tick) ,start ,end ,@nrol))))))
+
+(defun rectangle--unhighlight-for-redisplay (orig rol)
+ (if (not (eq 'rectangle (car-safe rol)))
+ (funcall orig rol)
+ (mapc #'delete-overlay (nthcdr 4 rol))
+ (setcar (cdr rol) nil)))
+
(provide 'rect)
-;; arch-tag: 178847b3-1f50-4b03-83de-a6e911cc1d16
;;; rect.el ends here
HCoop / bpt / emacs.git / blobdiff