-;;; rect.el --- rectangle functions for GNU Emacs.
+;;; rect.el --- rectangle functions for GNU Emacs
-;; Copyright (C) 1985, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1999-2011 Free Software Foundation, Inc.
-;; Maintainer: Didier Verna <verna@inf.enst.fr>
+;; Maintainer: Didier Verna <didier@xemacs.org>
;; Keywords: internal
+;; Package: emacs
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
-;; This package provides the operations on rectangles that are ocumented
+;; 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
-;; <verna@inf.enst.fr> 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.
+;; ### NOTE: this file was almost completely rewritten by Didier Verna
+;; <didier@xemacs.org> in July 1999.
+;;; 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)
+;;;###autoload (define-key ctl-x-r-map "N" 'rectangle-number-lines)
;;; Code:
-;;;###autoload
-(defun move-to-column-force (column &optional flag)
- "Move point to column COLUMN rigidly in the current line.
-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."
- (let ((col (move-to-column column (or flag t))))
- (if (> col column)
- (let (pos)
- (delete-char -1)
- (insert-char ? (- column (current-column)))
- (setq pos (point))
- (indent-to col)
- (goto-char pos)))
- column))
-
-;; 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 appart in
-;; `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
(while (< (point) endlinepos)
(let (startpos begextra endextra)
(if coerce-tabs
- (move-to-column-force startcol)
+ (move-to-column startcol t)
(move-to-column startcol))
(setq begextra (- (current-column) startcol))
(setq startpos (point))
(if coerce-tabs
- (move-to-column-force endcol)
+ (move-to-column endcol t)
(move-to-column endcol))
;; If we overshot, move back one character
;; so that endextra will be positive.
(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
+rectangle, plus ARGS extra arguments. Point is at the beginning of line when
the function is called."
(let (startcol startpt endcol endpt)
(save-excursion
))
(defun delete-rectangle-line (startcol endcol fill)
- (let ((pt (line-end-position)))
- (when (= (move-to-column-force startcol (or fill 'coerce)) startcol)
- (if (and (not fill) (<= pt endcol))
- (delete-region (point) pt)
- ;; else
- (setq pt (point))
- (move-to-column-force endcol)
- (delete-region pt (point))))
- ))
+ (when (= (move-to-column startcol (if fill t 'coerce)) startcol)
+ (delete-region (point)
+ (progn (move-to-column endcol 'coerce)
+ (point)))))
(defun delete-extract-rectangle-line (startcol endcol lines fill)
(let ((pt (point-at-eol)))
- (if (< (move-to-column-force startcol (or fill 'coerce)) startcol)
+ (if (< (move-to-column startcol (if fill t 'coerce)) startcol)
(setcdr lines (cons (spaces-string (- endcol startcol))
(cdr lines)))
;; else
(setq pt (point))
- (move-to-column-force endcol)
- (setcdr lines (cons (buffer-substring pt (point)) (cdr lines)))
- (delete-region pt (point)))
+ (move-to-column endcol t)
+ (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)
- (let ((val ""))
- (while (> n 8)
- (setq val (concat " " val)
- n (- n 8)))
- (concat val (aref spaces-strings n)))))
-
+ (make-string n ?\s)))
+
;;;###autoload
(defun delete-rectangle (start end &optional fill)
- "Delete (don't save) text in rectangle with corners at point and mark (START
-and END when called from a program). The same range of columns is deleted in
-each line starting with the line where the region begins and ending with the
-line where the region ends.
-
-With a prefix (or a FILL) argument, also fill lines where nothing has to be
-deleted."
- (interactive "r\nP")
+ "Delete (don't save) text in the region-rectangle.
+The same range of columns is deleted in each line starting with the
+line where the region begins and ending with the line where the region
+ends.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, also fill lines where nothing has
+to be deleted."
+ (interactive "*r\nP")
(apply-on-rectangle 'delete-rectangle-line start end fill))
;;;###autoload
(defun delete-extract-rectangle (start end &optional fill)
- "Delete the contents of the rectangle with corners at START and END, and
-return it as a list of strings, one for each line of the rectangle.
+ "Delete the contents of the rectangle with corners at START and END.
+Return it as a list of strings, one for each line of the rectangle.
+When called from a program the rectangle's corners are START and END.
With an optional FILL argument, also fill lines where nothing has to be
deleted."
(let ((lines (list nil)))
;;;###autoload
(defun extract-rectangle (start end)
- "Return the contents of the rectangle with corners at START and END,
-as a list of strings, one for each line of the rectangle."
+ "Return the contents of the rectangle with corners at START and END.
+Return it as a list of strings, one for each line of the rectangle."
(let ((lines (list nil)))
(apply-on-rectangle 'extract-rectangle-line start end lines)
(nreverse (cdr lines))))
(defvar killed-rectangle nil
- "Rectangle for yank-rectangle to insert.")
+ "Rectangle for `yank-rectangle' to insert.")
;;;###autoload
(defun kill-rectangle (start end &optional fill)
- "Delete the rectangle with corners at point and mark (START and END when
-called from a program) and save it as the last killed one. You might prefer to
-use `delete-extract-rectangle' from a program.
+ "Delete the region-rectangle and save it as the last killed one.
+
+When called from a program the rectangle's corners are START and END.
+You might prefer to use `delete-extract-rectangle' from a program.
With a prefix (or a FILL) argument, also fill lines where nothing has to be
-deleted."
+deleted.
+
+If the buffer is read-only, Emacs will beep and refrain from deleting
+the rectangle, but put it in the kill ring anyway. This means that
+you can use this command to copy text from a read-only buffer.
+\(If the variable `kill-read-only-ok' is non-nil, then this won't
+even beep.)"
(interactive "r\nP")
- (when buffer-read-only
- (setq killed-rectangle (extract-rectangle start end))
- (barf-if-buffer-read-only))
- (setq killed-rectangle (delete-extract-rectangle start end fill)))
+ (condition-case nil
+ (setq killed-rectangle (delete-extract-rectangle start end fill))
+ ((buffer-read-only text-read-only)
+ (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 yank-rectangle ()
"Yank the last killed rectangle with upper left corner at point."
- (interactive)
+ (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.
(progn
(forward-line 1)
(or (bolp) (insert ?\n))
- (move-to-column-force insertcolumn)))
+ (move-to-column insertcolumn t)))
(setq first nil)
- (insert (car lines))
+ (insert-for-yank (car lines))
(setq lines (cdr lines)))))
;;;###autoload
(defun open-rectangle (start end &optional fill)
- "Blank out rectangle with corners at point and mark (START and END when
-called from a program), shifting text right. The text previously in the region
-is not overwritten by the blanks, but instead winds up to the right of the
-rectangle.
+ "Blank out the region-rectangle, shifting text right.
-With a prefix (or a FILL) argument, fill with blanks even if there is no text
-on the right side of the rectangle."
- (interactive "r\nP")
+The text previously in the region is not overwritten by the blanks,
+but instead winds up to the right of the rectangle.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, fill with blanks even if there is
+no text on the right side of the rectangle."
+ (interactive "*r\nP")
(apply-on-rectangle 'open-rectangle-line start end fill)
(goto-char start))
(defun open-rectangle-line (startcol endcol fill)
- (let (spaces)
- (when (= (move-to-column-force startcol (or fill 'coerce)) startcol)
- (unless (and (not fill)
- (= (point) (point-at-eol)))
- (indent-to endcol)))
- ))
+ (when (= (move-to-column startcol (if fill t 'coerce)) startcol)
+ (unless (and (not fill)
+ (= (point) (point-at-eol)))
+ (indent-to endcol))))
-(defun delete-whitespace-rectangle-line (startcol endcol fill)
- (when (= (move-to-column-force startcol (or fill 'coerce)) startcol)
+(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))))
- ))
+ (delete-region (point) (progn (skip-syntax-forward " ") (point))))))
+
+;;;###autoload
+(defalias 'close-rectangle 'delete-whitespace-rectangle) ;; Old name
-;;;###autoload (defalias 'close-rectangle 'delete-whitespace-rectangle) ;; Old name
;;;###autoload
(defun delete-whitespace-rectangle (start end &optional fill)
"Delete all whitespace following a specified column in each line.
at which whitespace deletion should begin. On each line in the
rectangle, all continuous whitespace starting at that column is deleted.
+When called from a program the rectangle's corners are START and END.
With a prefix (or a FILL) argument, also fill too short lines."
- (interactive "r\nP")
+ (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)
+ (if delete
+ (delete-rectangle-line startcol endcol nil))
+ (insert string))
;;;###autoload
(defun string-rectangle (start end string)
- "Insert STRING on each line of the rectangle with corners at point and mark
-(START and END when called from a program), shifting text right. The left edge
-of the rectangle specifies the column for insertion. This command does not
-delete or overwrite any existing text."
- (interactive "r\nsString rectangle: ")
- (apply-on-rectangle 'string-rectangle-line start end string))
-
-(defun string-rectangle-line (startcol endcol string)
- (move-to-column-force startcol)
- (insert string))
+ "Replace rectangle contents with STRING on each line.
+The length of STRING need not be the same as the rectangle width.
+
+Called from a program, takes three args; START, END and STRING."
+ (interactive
+ (progn (barf-if-buffer-read-only)
+ (list
+ (region-beginning)
+ (region-end)
+ (read-string (format "String rectangle (default %s): "
+ (or (car string-rectangle-history) ""))
+ nil 'string-rectangle-history
+ (car string-rectangle-history)))))
+ (apply-on-rectangle 'string-rectangle-line start end string t))
+
+;;;###autoload
+(defalias 'replace-rectangle 'string-rectangle)
+
+;;;###autoload
+(defun string-insert-rectangle (start end string)
+ "Insert STRING on each line of region-rectangle, shifting text right.
+
+When called from a program, the rectangle's corners are START and END.
+The left edge of the rectangle specifies the column for insertion.
+This command does not delete or overwrite any existing text."
+ (interactive
+ (progn (barf-if-buffer-read-only)
+ (list
+ (region-beginning)
+ (region-end)
+ (read-string (format "String insert rectangle (default %s): "
+ (or (car string-rectangle-history) ""))
+ nil 'string-rectangle-history
+ (car string-rectangle-history)))))
+ (apply-on-rectangle 'string-rectangle-line start end string nil))
;;;###autoload
(defun clear-rectangle (start end &optional fill)
- "Blank out the rectangle with corners at point and mark (START and END when
-called from a program). The text previously in the region is overwritten with
-blanks.
+ "Blank out the region-rectangle.
+The text previously in the region is overwritten with blanks.
+When called from a program the rectangle's corners are START and END.
With a prefix (or a FILL) argument, also fill with blanks the parts of the
rectangle which were empty."
- (interactive "r\nP")
+ (interactive "*r\nP")
(apply-on-rectangle 'clear-rectangle-line start end fill))
(defun clear-rectangle-line (startcol endcol fill)
- (let ((pt (point-at-eol))
- spaces)
- (when (= (move-to-column-force startcol (or fill 'coerce)) startcol)
+ (let ((pt (point-at-eol)))
+ (when (= (move-to-column startcol (if fill t 'coerce)) startcol)
(if (and (not fill)
(<= (save-excursion (goto-char pt) (current-column)) endcol))
(delete-region (point) pt)
;; else
(setq pt (point))
- (move-to-column-force endcol)
- (setq spaces (- (point) pt))
+ (move-to-column endcol t)
+ (setq endcol (current-column))
(delete-region pt (point))
- (indent-to (+ (current-column) spaces))))
- ))
+ (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)))
(provide 'rect)