lisp/textmodes/picture.el

   1 ;;; picture.el --- "Picture mode" -- editing using quarter-plane screen model
   2
   3 ;; Copyright (C) 1985, 1994, 2001-2012 Free Software Foundation, Inc.
   4
   5 ;; Author: K. Shane Hartman
   6 ;; Maintainer: FSF
   7 ;; Keywords: convenience wp
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; This code provides the picture-mode commands documented in the Emacs
  27 ;; manual.  The screen is treated as a semi-infinite quarter-plane with
  28 ;; support for rectangle operations and `etch-a-sketch' character
  29 ;; insertion in any of eight directions.
  30
  31 ;;; Code:
  32
  33 (defgroup picture nil
  34   "Editing text-based pictures (\"ASCII art\")."
  35   :prefix "picture-"
  36   :group 'wp)
  37
  38 (defcustom picture-rectangle-ctl ?+
  39   "Character `picture-draw-rectangle' uses for top left corners."
  40   :type 'character
  41   :group 'picture)
  42 (defcustom picture-rectangle-ctr ?+
  43   "Character `picture-draw-rectangle' uses for top right corners."
  44   :type 'character
  45   :group 'picture)
  46 (defcustom picture-rectangle-cbr ?+
  47   "Character `picture-draw-rectangle' uses for bottom right corners."
  48   :type 'character
  49   :group 'picture)
  50 (defcustom picture-rectangle-cbl ?+
  51   "Character `picture-draw-rectangle' uses for bottom left corners."
  52   :type 'character
  53   :group 'picture)
  54 (defcustom picture-rectangle-v   ?|
  55   "Character `picture-draw-rectangle' uses for vertical lines."
  56   :type 'character
  57   :group 'picture)
  58 (defcustom picture-rectangle-h   ?-
  59   "Character `picture-draw-rectangle' uses for horizontal lines."
  60   :type 'character
  61   :group 'picture)
  62
  63
  64 ;; Picture Movement Commands
  65
  66 (defvar picture-desired-column 0
  67   "Desired current column for Picture mode.
  68 When a cursor is on a wide-column character (e.g. Chinese,
  69 Japanese, Korean), this may may be different from `current-column'.")
  70
  71
  72 (defun picture-update-desired-column (adjust-to-current)
  73   "Maybe update `picture-desired-column'.
  74 If the value of `picture-desired-column' is more than one column
  75 from `current-column', or if the argument ADJUST-TO-CURRENT is
  76 non-nil, set it to the current column.  Return `current-column'."
  77   (let ((current-column (current-column)))
  78     (if (or adjust-to-current
  79             (< picture-desired-column (1- current-column))
  80             (> picture-desired-column (1+ current-column)))
  81         (setq picture-desired-column current-column))
  82     current-column))
  83
  84 (defun picture-beginning-of-line (&optional arg)
  85   "Position point at the beginning of the line.
  86 With ARG not nil, move forward ARG - 1 lines first.
  87 If scan reaches end of buffer, stop there without error."
  88   (interactive "^P")
  89   (if arg (forward-line (1- (prefix-numeric-value arg))))
  90   (beginning-of-line)
  91   (setq picture-desired-column 0))
  92
  93 (defun picture-end-of-line (&optional arg)
  94   "Position point after last non-blank character on current line.
  95 With ARG not nil, move forward ARG - 1 lines first.
  96 If scan reaches end of buffer, stop there without error."
  97   (interactive "^P")
  98   (if arg (forward-line (1- (prefix-numeric-value arg))))
  99   (beginning-of-line)
 100   (skip-chars-backward " \t" (prog1 (point) (end-of-line)))
 101   (setq picture-desired-column (current-column)))
 102
 103 (defun picture-forward-column (arg &optional interactive)
 104   "Move cursor right, making whitespace if necessary.
 105 With argument, move that many columns."
 106   (interactive "^p\nd")
 107   (let (deactivate-mark)
 108     (picture-update-desired-column interactive)
 109     (setq picture-desired-column (max 0 (+ picture-desired-column arg)))
 110     (let ((current-column (move-to-column picture-desired-column t)))
 111       (if (and (> current-column picture-desired-column)
 112                (< arg 0))
 113           ;; It seems that we have just tried to move to the right
 114           ;; column of a multi-column character.
 115           (forward-char -1)))))
 116
 117 (defun picture-backward-column (arg &optional interactive)
 118   "Move cursor left, making whitespace if necessary.
 119 With argument, move that many columns."
 120   (interactive "^p\nd")
 121   (picture-update-desired-column interactive)
 122   (picture-forward-column (- arg)))
 123
 124 (defun picture-move-down (arg)
 125   "Move vertically down, making whitespace if necessary.
 126 With argument, move that many lines."
 127   (interactive "^p")
 128   (let (deactivate-mark)
 129     (picture-update-desired-column nil)
 130     (picture-newline arg)
 131     (let ((current-column (move-to-column picture-desired-column t)))
 132       (if (> current-column picture-desired-column)
 133           (forward-char -1)))))
 134
 135 (defvar picture-vertical-step 0
 136   "Amount to move vertically after text character in Picture mode.")
 137
 138 (defvar picture-horizontal-step 1
 139   "Amount to move horizontally after text character in Picture mode.")
 140
 141 (defun picture-move-up (arg)
 142   "Move vertically up, making whitespace if necessary.
 143 With argument, move that many lines."
 144   (interactive "^p")
 145   (picture-update-desired-column nil)
 146   (picture-move-down (- arg)))
 147
 148 (defun picture-movement-right ()
 149   "Move right after self-inserting character in Picture mode."
 150   (interactive)
 151   (picture-set-motion 0 1))
 152
 153 (defun picture-movement-left ()
 154   "Move left after self-inserting character in Picture mode."
 155   (interactive)
 156   (picture-set-motion 0 -1))
 157
 158 (defun picture-movement-up ()
 159   "Move up after self-inserting character in Picture mode."
 160   (interactive)
 161   (picture-set-motion -1 0))
 162
 163 (defun picture-movement-down ()
 164   "Move down after self-inserting character in Picture mode."
 165   (interactive)
 166   (picture-set-motion 1 0))
 167
 168 (defun picture-movement-nw (&optional arg)
 169   "Move up and left after self-inserting character in Picture mode.
 170 With prefix argument, move up and two-column left."
 171   (interactive "P")
 172   (picture-set-motion -1 (if arg -2 -1)))
 173
 174 (defun picture-movement-ne (&optional arg)
 175   "Move up and right after self-inserting character in Picture mode.
 176 With prefix argument, move up and two-column right."
 177   (interactive "P")
 178   (picture-set-motion -1 (if arg 2 1)))
 179
 180 (defun picture-movement-sw (&optional arg)
 181   "Move down and left after self-inserting character in Picture mode.
 182 With prefix argument, move down and two-column left."
 183   (interactive "P")
 184   (picture-set-motion 1 (if arg -2 -1)))
 185
 186 (defun picture-movement-se (&optional arg)
 187   "Move down and right after self-inserting character in Picture mode.
 188 With prefix argument, move down and two-column right."
 189   (interactive "P")
 190   (picture-set-motion 1 (if arg 2 1)))
 191
 192 (defun picture-set-motion (vert horiz)
 193   "Set VERTICAL and HORIZONTAL increments for movement in Picture mode.
 194 The mode line is updated to reflect the current direction."
 195   (setq picture-vertical-step vert
 196         picture-horizontal-step horiz)
 197   (setq mode-name
 198         (format "Picture:%s"
 199                 (nth (+ 2 (% horiz 3) (* 5 (1+ (% vert 2))))
 200                      '(wnw nw up ne ene Left left none right Right
 201                            wsw sw down se ese))))
 202   (force-mode-line-update)
 203   (message ""))
 204
 205 (defun picture-move ()
 206   "Move in direction of `picture-vertical-step' and `picture-horizontal-step'."
 207   (if (/= picture-vertical-step 0)
 208       (picture-move-down picture-vertical-step))
 209   (if (/= picture-horizontal-step 0)
 210       (picture-forward-column picture-horizontal-step)))
 211
 212 (defun picture-motion (arg)
 213   "Move point in direction of current picture motion in Picture mode.
 214 With ARG do it that many times.  Useful for delineating rectangles in
 215 conjunction with diagonal picture motion.
 216 Use \"\\[command-apropos] picture-movement\" to see commands which control motion."
 217   (interactive "^p")
 218   (picture-move-down (* arg picture-vertical-step))
 219   (picture-forward-column (* arg picture-horizontal-step)))
 220
 221 (defun picture-motion-reverse (arg)
 222   "Move point in direction opposite of current picture motion in Picture mode.
 223 With ARG do it that many times.  Useful for delineating rectangles in
 224 conjunction with diagonal picture motion.
 225 Use \"\\[command-apropos] picture-movement\" to see commands which control motion."
 226   (interactive "^p")
 227   (picture-motion (- arg)))
 228
 229 (defun picture-mouse-set-point (event)
 230   "Move point to the position of EVENT, making whitespace if necessary."
 231   (interactive "e")
 232   (let ((position (event-start event)))
 233     (unless (posn-area position) ; Ignore EVENT unless in text area
 234       (let* ((window (posn-window position))
 235              (frame  (if (framep window) window (window-frame window)))
 236              (pair   (posn-x-y position))
 237              (start-pos (window-start window))
 238              (start-pair (posn-x-y (posn-at-point start-pos)))
 239              (dx (- (car pair) (car start-pair)))
 240              (dy (- (cdr pair) (cdr start-pair)))
 241              (char-ht (frame-char-height frame))
 242              (spacing (when (display-graphic-p frame)
 243                         (or (with-current-buffer (window-buffer window)
 244                               line-spacing)
 245                             (frame-parameter frame 'line-spacing)))))
 246         (cond ((floatp spacing)
 247                (setq spacing (truncate (* spacing char-ht))))
 248               ((null spacing)
 249                (setq spacing 0)))
 250         (goto-char start-pos)
 251         (picture-move-down      (/ dy (+ char-ht spacing)))
 252         (picture-forward-column (/ dx (frame-char-width frame)))))))
 253
 254 \f
 255 ;; Picture insertion and deletion.
 256
 257 (defun picture-insert (ch arg)
 258   (let* ((width (char-width ch))
 259          ;; We must be sure that the succeeding insertion won't delete
 260          ;; the just inserted character.
 261          (picture-horizontal-step
 262           (if (and (= picture-vertical-step 0)
 263                    (> width 1)
 264                    (< (abs picture-horizontal-step) 2))
 265               (* picture-horizontal-step 2)
 266             picture-horizontal-step)))
 267     (while (> arg 0)
 268       (setq arg (1- arg))
 269       (if (/= picture-desired-column (current-column))
 270           (move-to-column picture-desired-column t))
 271       (let ((col (+ picture-desired-column width)))
 272         (or (eolp)
 273             (let ((pos (point)))
 274               (move-to-column col t)
 275               (delete-region pos (point)))))
 276       (insert ch)
 277       (forward-char -1)
 278       (picture-move))))
 279
 280 (defun picture-self-insert (arg)
 281   "Insert this character in place of character previously at the cursor.
 282 The cursor then moves in the direction you previously specified
 283 with the commands `picture-movement-right', `picture-movement-up', etc.
 284 Use \"\\[command-apropos] picture-movement\" to see those commands."
 285   (interactive "p")
 286   (picture-update-desired-column (not (eq this-command last-command)))
 287   (picture-insert last-command-event arg)) ; Always a character in this case.
 288
 289 (defun picture-clear-column (arg)
 290   "Clear out ARG columns after point without moving."
 291   (interactive "p")
 292   (let* ((original-col (current-column))
 293          (target-col (max 0 (+ original-col arg)))
 294          pos)
 295     (move-to-column target-col t)
 296     (setq pos (point))
 297     (move-to-column original-col)
 298     (delete-region pos (point))
 299     (save-excursion
 300      (indent-to (max target-col original-col))))
 301   (setq picture-desired-column (current-column)))
 302
 303 (defun picture-backward-clear-column (arg)
 304   "Clear out ARG columns before point, moving back over them."
 305   (interactive "p")
 306   (picture-clear-column (- arg)))
 307
 308 (defun picture-clear-line (arg)
 309   "Clear out rest of line; if at end of line, advance to next line.
 310 Cleared-out line text goes into the kill ring, as do newlines that are
 311 advanced over.  With argument, clear out (and save in kill ring) that
 312 many lines."
 313   (interactive "P")
 314   (if arg
 315       (progn
 316        (setq arg (prefix-numeric-value arg))
 317        (kill-line arg)
 318        (newline (if (> arg 0) arg (- arg))))
 319     (if (looking-at "[ \t]*$")
 320         (kill-ring-save (point) (progn (forward-line 1) (point)))
 321       (kill-region (point) (progn (end-of-line) (point))))))
 322
 323 (defun picture-newline (arg)
 324   "Move to the beginning of the following line.
 325 With argument, moves that many lines (up, if negative argument);
 326 always moves to the beginning of a line."
 327   (interactive "^p")
 328   (let ((start (point))
 329         (lines-left (forward-line arg)))
 330     (if (and (eobp)
 331              (> (point) start))
 332         (newline))
 333     (if (> lines-left 0)
 334         (newline lines-left))))
 335
 336 (defun picture-open-line (arg)
 337   "Insert an empty line after the current line.
 338 With positive argument insert that many lines."
 339   (interactive "p")
 340   (save-excursion
 341    (end-of-line)
 342    (open-line arg)))
 343
 344 (defun picture-duplicate-line ()
 345   "Insert a duplicate of the current line, below it."
 346   (interactive)
 347   (save-excursion
 348    (let ((contents
 349           (buffer-substring
 350            (progn (beginning-of-line) (point))
 351            (progn (picture-newline 1) (point)))))
 352      (forward-line -1)
 353      (insert contents))))
 354
 355 ;; Like replace-match, but overwrites.
 356 (defun picture-replace-match (newtext fixedcase literal)
 357   (let (ocolumn change pos)
 358     (goto-char (setq pos (match-end 0)))
 359     (setq ocolumn (current-column))
 360     ;; Make the replacement and undo it, to see how it changes the length.
 361     (let ((buffer-undo-list nil)
 362           list1)
 363       (replace-match newtext fixedcase literal)
 364       (setq change (- (current-column) ocolumn))
 365       (setq list1 buffer-undo-list)
 366       (while list1
 367         (setq list1 (primitive-undo 1 list1))))
 368     (goto-char pos)
 369     (if (> change 0)
 370         (delete-region (point)
 371                        (progn
 372                          (move-to-column (+ change (current-column)) t)
 373                          (point))))
 374     (replace-match newtext fixedcase literal)
 375     (if (< change 0)
 376         (insert-char ?\s (- change)))))
 377 \f
 378 ;; Picture Tabs
 379
 380 (defcustom picture-tab-chars "!-~"
 381   "A character set which controls behavior of commands.
 382 \\[picture-set-tab-stops] and \\[picture-tab-search].
 383 The syntax for this variable is like the syntax used inside of `[...]'
 384 in a regular expression--but without the `[' and the `]'.
 385 It is NOT a regular expression, any regexp special characters will be quoted.
 386 It defines a set of \"interesting characters\" to look for when setting
 387 \(or searching for) tab stops, initially \"!-~\" (all printing characters).
 388 For example, suppose that you are editing a table which is formatted thus:
 389 | foo           | bar + baz | 23  *
 390 | bubbles       | and + etc | 97  *
 391 and that `picture-tab-chars' is \"|+*\".  Then invoking
 392 \\[picture-set-tab-stops] on either of the previous lines would result
 393 in the following tab stops
 394                 :     :     :     :
 395 Another example - \"A-Za-z0-9\" would produce the tab stops
 396   :               :     :     :
 397
 398 Note that if you want the character `-' to be in the set, it must be
 399 included in a range or else appear in a context where it cannot be
 400 taken for indicating a range (e.g. \"-A-Z\" declares the set to be the
 401 letters `A' through `Z' and the character `-').  If you want the
 402 character `\\' in the set it must be preceded by itself: \"\\\\\".
 403
 404 The command \\[picture-tab-search] is defined to move beneath (or to) a
 405 character belonging to this set independent of the tab stops list."
 406   :type 'string
 407   :group 'picture)
 408
 409 (defun picture-set-tab-stops (&optional arg)
 410   "Set value of `tab-stop-list' according to context of this line.
 411 This controls the behavior of \\[picture-tab].  A tab stop is set at
 412 every column occupied by an \"interesting character\" that is preceded
 413 by whitespace.  Interesting characters are defined by the variable
 414 `picture-tab-chars', see its documentation for an example of usage.
 415 With ARG, just (re)set `tab-stop-list' to its default value.  The tab
 416 stops computed are displayed in the minibuffer with `:' at each stop."
 417   (interactive "P")
 418   (save-excursion
 419     (let (tabs)
 420       (if arg
 421           (setq tabs (default-value 'tab-stop-list))
 422         (let ((regexp (concat "[ \t]+[" (regexp-quote picture-tab-chars) "]")))
 423           (beginning-of-line)
 424           (let ((bol (point)))
 425             (end-of-line)
 426             (while (re-search-backward regexp bol t)
 427               (skip-chars-forward " \t")
 428               (setq tabs (cons (current-column) tabs)))
 429             (if (null tabs)
 430                 (error "No characters in set %s on this line"
 431                        (regexp-quote picture-tab-chars))))))
 432       (setq tab-stop-list tabs)
 433       (let ((blurb (make-string (1+ (nth (1- (length tabs)) tabs)) ?\ )))
 434         (while tabs
 435           (aset blurb (car tabs) ?:)
 436           (setq tabs (cdr tabs)))
 437         (message blurb)))))
 438
 439 (defun picture-tab-search (&optional arg)
 440   "Move to column beneath next interesting char in previous line.
 441 With ARG move to column occupied by next interesting character in this
 442 line.  The character must be preceded by whitespace.
 443 \"interesting characters\" are defined by variable `picture-tab-chars'.
 444 If no such character is found, move to beginning of line."
 445   (interactive "^P")
 446   (let ((target (current-column)))
 447     (save-excursion
 448       (if (and (not arg)
 449                (progn
 450                  (beginning-of-line)
 451                  (skip-chars-backward
 452                   (concat "^" (regexp-quote picture-tab-chars))
 453                   (point-min))
 454                  (not (bobp))))
 455           (move-to-column target))
 456       (if (re-search-forward
 457            (concat "[ \t]+[" (regexp-quote picture-tab-chars) "]")
 458            (line-end-position)
 459            'move)
 460           (setq target (1- (current-column)))
 461         (setq target nil)))
 462     (if target
 463         (move-to-column target t)
 464       (beginning-of-line))))
 465
 466 (defun picture-tab (&optional arg)
 467   "Tab transparently (just move point) to next tab stop.
 468 With prefix arg, overwrite the traversed text with spaces.  The tab stop
 469 list can be changed by \\[picture-set-tab-stops] and \\[edit-tab-stops].
 470 See also documentation for variable `picture-tab-chars'."
 471   (interactive "^P")
 472   (let* ((opoint (point)))
 473     (move-to-tab-stop)
 474     (if arg
 475         (let (indent-tabs-mode
 476               (column (current-column)))
 477           (delete-region opoint (point))
 478           (indent-to column)))))
 479 \f
 480 ;; Picture Rectangles
 481
 482 (defvar picture-killed-rectangle nil
 483   "Rectangle killed or copied by \\[picture-clear-rectangle] in Picture mode.
 484 The contents can be retrieved by \\[picture-yank-rectangle]")
 485
 486 (defun picture-clear-rectangle (start end &optional killp)
 487   "Clear and save rectangle delineated by point and mark.
 488 The rectangle is saved for yanking by \\[picture-yank-rectangle] and replaced
 489 with whitespace.  The previously saved rectangle, if any, is lost.  With
 490 prefix argument, the rectangle is actually killed, shifting remaining text."
 491   (interactive "r\nP")
 492   (setq picture-killed-rectangle (picture-snarf-rectangle start end killp)))
 493
 494 (defun picture-clear-rectangle-to-register (start end register &optional killp)
 495   "Clear rectangle delineated by point and mark into REGISTER.
 496 The rectangle is saved in REGISTER and replaced with whitespace.  With
 497 prefix argument, the rectangle is actually killed, shifting remaining text."
 498   (interactive "r\ncRectangle to register: \nP")
 499   (set-register register (picture-snarf-rectangle start end killp)))
 500
 501 (defun picture-snarf-rectangle (start end &optional killp)
 502   (let ((column (current-column))
 503         (indent-tabs-mode nil))
 504     (prog1 (save-excursion
 505              (if killp
 506                  (delete-extract-rectangle start end)
 507                (prog1 (extract-rectangle start end)
 508                       (clear-rectangle start end))))
 509            (move-to-column column t))))
 510
 511 (defun picture-yank-rectangle (&optional insertp)
 512   "Overlay rectangle saved by \\[picture-clear-rectangle]
 513 The rectangle is positioned with upper left corner at point, overwriting
 514 existing text.  With prefix argument, the rectangle is inserted instead,
 515 shifting existing text.  Leaves mark at one corner of rectangle and
 516 point at the other (diagonally opposed) corner."
 517   (interactive "P")
 518   (if (not (consp picture-killed-rectangle))
 519       (error "No rectangle saved")
 520     (picture-insert-rectangle picture-killed-rectangle insertp)))
 521
 522 (defun picture-yank-at-click (click arg)
 523   "Insert the last killed rectangle at the position clicked on.
 524 Also move point to one end of the text thus inserted (normally the end).
 525 Prefix arguments are interpreted as with \\[yank].
 526 If `mouse-yank-at-point' is non-nil, insert at point
 527 regardless of where you click."
 528   (interactive "e\nP")
 529   (or mouse-yank-at-point (mouse-set-point click))
 530   (picture-yank-rectangle arg))
 531
 532 (defun picture-yank-rectangle-from-register (register &optional insertp)
 533   "Overlay rectangle saved in REGISTER.
 534 The rectangle is positioned with upper left corner at point, overwriting
 535 existing text.  With prefix argument, the rectangle is
 536 inserted instead, shifting existing text.  Leaves mark at one corner
 537 of rectangle and point at the other (diagonally opposed) corner."
 538   (interactive "cRectangle from register: \nP")
 539   (let ((rectangle (get-register register)))
 540     (if (not (consp rectangle))
 541         (error "Register %c does not contain a rectangle" register)
 542       (picture-insert-rectangle rectangle insertp))))
 543
 544 (defun picture-insert-rectangle (rectangle &optional insertp)
 545   "Overlay RECTANGLE with upper left corner at point.
 546 Optional argument INSERTP, if non-nil causes RECTANGLE to be inserted.
 547 Leaves the region surrounding the rectangle."
 548   (let ((indent-tabs-mode nil))
 549     (if (not insertp)
 550         (save-excursion
 551           (delete-rectangle (point)
 552                             (progn
 553                               (picture-forward-column (length (car rectangle)))
 554                               (picture-move-down (1- (length rectangle)))
 555                               (point)))))
 556     (push-mark)
 557     (insert-rectangle rectangle)))
 558
 559 (defun picture-current-line ()
 560   "Return the vertical position of point.  Top line is 1."
 561   (+ (count-lines (point-min) (point))
 562      (if (= (current-column) 0) 1 0)))
 563
 564 (defun picture-draw-rectangle (start end)
 565   "Draw a rectangle around region."
 566   (interactive "*r")                    ; start will be less than end
 567   (let* ((sl     (picture-current-line))
 568          (sc     (current-column))
 569          (pvs    picture-vertical-step)
 570          (phs    picture-horizontal-step)
 571          (c1     (progn (goto-char start) (current-column)))
 572          (r1     (picture-current-line))
 573          (c2     (progn (goto-char end) (current-column)))
 574          (r2     (picture-current-line))
 575          (right  (max c1 c2))
 576          (left   (min c1 c2))
 577          (top    (min r1 r2))
 578          (bottom (max r1 r2)))
 579     (goto-char (point-min))
 580     (forward-line (1- top))
 581     (move-to-column left t)
 582     (picture-update-desired-column t)
 583
 584     (picture-movement-right)
 585     (picture-insert picture-rectangle-ctl 1)
 586     (picture-insert picture-rectangle-h (- right picture-desired-column))
 587
 588     (picture-movement-down)
 589     (picture-insert picture-rectangle-ctr 1)
 590     (picture-insert picture-rectangle-v (- bottom (picture-current-line)))
 591
 592     (picture-movement-left)
 593     (picture-insert picture-rectangle-cbr 1)
 594     (picture-insert picture-rectangle-h (- picture-desired-column left))
 595
 596     (picture-movement-up)
 597     (picture-insert picture-rectangle-cbl 1)
 598     (picture-insert picture-rectangle-v (- (picture-current-line) top))
 599
 600     (picture-set-motion pvs phs)
 601     (goto-char (point-min))
 602     (forward-line (1- sl))
 603     (move-to-column sc t)))
 604
 605 \f
 606 ;; Picture Keymap, entry and exit points.
 607
 608 (defalias 'picture-delete-char 'delete-char)
 609
 610 (defvar picture-mode-map
 611   (let ((map (make-keymap)))
 612     (define-key map [remap self-insert-command] 'picture-self-insert)
 613     (define-key map [remap self-insert-command] 'picture-self-insert)
 614     (define-key map [remap completion-separator-self-insert-command]
 615       'picture-self-insert)
 616     (define-key map [remap completion-separator-self-insert-autofilling]
 617       'picture-self-insert)
 618     (define-key map [remap forward-char] 'picture-forward-column)
 619     (define-key map [remap backward-char] 'picture-backward-column)
 620     (define-key map [remap delete-char] 'picture-clear-column)
 621     ;; There are two possibilities for what is normally on DEL.
 622     (define-key map [remap backward-delete-char-untabify]
 623       'picture-backward-clear-column)
 624     (define-key map [remap delete-backward-char] 'picture-backward-clear-column)
 625     (define-key map [remap kill-line] 'picture-clear-line)
 626     (define-key map [remap open-line] 'picture-open-line)
 627     (define-key map [remap newline] 'picture-newline)
 628     (define-key map [remap newline-and-indent] 'picture-duplicate-line)
 629     (define-key map [remap next-line] 'picture-move-down)
 630     (define-key map [remap previous-line] 'picture-move-up)
 631     (define-key map [remap move-beginning-of-line] 'picture-beginning-of-line)
 632     (define-key map [remap move-end-of-line] 'picture-end-of-line)
 633     (define-key map [remap mouse-set-point] 'picture-mouse-set-point)
 634     (define-key map "\C-c\C-d" 'picture-delete-char)
 635     (define-key map "\e\t" 'picture-toggle-tab-state)
 636     (define-key map "\t" 'picture-tab)
 637     (define-key map "\e\t" 'picture-tab-search)
 638     (define-key map "\C-c\t" 'picture-set-tab-stops)
 639     (define-key map "\C-c\C-k" 'picture-clear-rectangle)
 640     (define-key map "\C-c\C-w" 'picture-clear-rectangle-to-register)
 641     (define-key map "\C-c\C-y" 'picture-yank-rectangle)
 642     (define-key map "\C-c\C-x" 'picture-yank-rectangle-from-register)
 643     (define-key map "\C-c\C-r" 'picture-draw-rectangle)
 644     (define-key map "\C-c\C-c" 'picture-mode-exit)
 645     (define-key map "\C-c\C-f" 'picture-motion)
 646     (define-key map "\C-c\C-b" 'picture-motion-reverse)
 647     (define-key map "\C-c<" 'picture-movement-left)
 648     (define-key map "\C-c>" 'picture-movement-right)
 649     (define-key map "\C-c^" 'picture-movement-up)
 650     (define-key map "\C-c." 'picture-movement-down)
 651     (define-key map "\C-c`" 'picture-movement-nw)
 652     (define-key map "\C-c'" 'picture-movement-ne)
 653     (define-key map "\C-c/" 'picture-movement-sw)
 654     (define-key map "\C-c\\" 'picture-movement-se)
 655     (define-key map [(control ?c) left]  'picture-movement-left)
 656     (define-key map [(control ?c) right] 'picture-movement-right)
 657     (define-key map [(control ?c) up]    'picture-movement-up)
 658     (define-key map [(control ?c) down]  'picture-movement-down)
 659     (define-key map [(control ?c) home]  'picture-movement-nw)
 660     (define-key map [(control ?c) prior] 'picture-movement-ne)
 661     (define-key map [(control ?c) end]   'picture-movement-sw)
 662     (define-key map [(control ?c) next]  'picture-movement-se)
 663     map)
 664   "Keymap used in `picture-mode'.")
 665
 666 (defcustom picture-mode-hook nil
 667   "If non-nil, its value is called on entry to Picture mode.
 668 Picture mode is invoked by the command \\[picture-mode]."
 669   :type 'hook
 670   :group 'picture)
 671
 672 (defvar picture-mode-old-local-map)
 673 (defvar picture-mode-old-mode-name)
 674 (defvar picture-mode-old-major-mode)
 675 (defvar picture-mode-old-truncate-lines)
 676
 677 ;;;###autoload
 678 (defun picture-mode ()
 679   "Switch to Picture mode, in which a quarter-plane screen model is used.
 680 \\<picture-mode-map>
 681 Printing characters replace instead of inserting themselves with motion
 682 afterwards settable by these commands:
 683
 684  Move left after insertion:            \\[picture-movement-left]
 685  Move right after insertion:           \\[picture-movement-right]
 686  Move up after insertion:              \\[picture-movement-up]
 687  Move down after insertion:            \\[picture-movement-down]
 688
 689  Move northwest (nw) after insertion:  \\[picture-movement-nw]
 690  Move northeast (ne) after insertion:  \\[picture-movement-ne]
 691  Move southwest (sw) after insertion:  \\[picture-movement-sw]
 692  Move southeast (se) after insertion:  \\[picture-movement-se]
 693
 694  Move westnorthwest (wnw) after insertion:  C-u \\[picture-movement-nw]
 695  Move eastnortheast (ene) after insertion:  C-u \\[picture-movement-ne]
 696  Move westsouthwest (wsw) after insertion:  C-u \\[picture-movement-sw]
 697  Move eastsoutheast (ese) after insertion:  C-u \\[picture-movement-se]
 698
 699 The current direction is displayed in the mode line.  The initial
 700 direction is right.  Whitespace is inserted and tabs are changed to
 701 spaces when required by movement.  You can move around in the buffer
 702 with these commands:
 703
 704  Move vertically to SAME column in previous line: \\[picture-move-down]
 705  Move vertically to SAME column in next line:     \\[picture-move-up]
 706  Move to column following last
 707   non-whitespace character:                       \\[picture-end-of-line]
 708  Move right, inserting spaces if required:        \\[picture-forward-column]
 709  Move left changing tabs to spaces if required:   \\[picture-backward-column]
 710  Move in direction of current picture motion:     \\[picture-motion]
 711  Move opposite to current picture motion:         \\[picture-motion-reverse]
 712  Move to beginning of next line:                  \\[next-line]
 713
 714 You can edit tabular text with these commands:
 715
 716  Move to column beneath (or at) next interesting
 717   character (see variable `picture-tab-chars'):   \\[picture-tab-search]
 718  Move to next stop in tab stop list:              \\[picture-tab]
 719  Set tab stops according to context of this line: \\[picture-set-tab-stops]
 720    (With ARG, resets tab stops to default value.)
 721  Change the tab stop list:                        \\[edit-tab-stops]
 722
 723 You can manipulate text with these commands:
 724  Clear ARG columns after point without moving:    \\[picture-clear-column]
 725  Delete char at point:                            \\[picture-delete-char]
 726  Clear ARG columns backward:                      \\[picture-backward-clear-column]
 727  Clear ARG lines, advancing over them:            \\[picture-clear-line]
 728   (the cleared text is saved in the kill ring)
 729  Open blank line(s) beneath current line:         \\[picture-open-line]
 730
 731 You can manipulate rectangles with these commands:
 732   Clear a rectangle and save it:                  \\[picture-clear-rectangle]
 733   Clear a rectangle, saving in a named register:  \\[picture-clear-rectangle-to-register]
 734   Insert currently saved rectangle at point:      \\[picture-yank-rectangle]
 735   Insert rectangle from named register:           \\[picture-yank-rectangle-from-register]
 736   Draw a rectangular box around mark and point:   \\[picture-draw-rectangle]
 737   Copies a rectangle to a register:               \\[copy-rectangle-to-register]
 738   Undo effects of rectangle overlay commands:     \\[undo]
 739
 740 You can return to the previous mode with \\[picture-mode-exit], which
 741 also strips trailing whitespace from every line.  Stripping is suppressed
 742 by supplying an argument.
 743
 744 Entry to this mode calls the value of `picture-mode-hook' if non-nil.
 745
 746 Note that Picture mode commands will work outside of Picture mode, but
 747 they are not by default assigned to keys."
 748   (interactive)
 749   (if (eq major-mode 'picture-mode)
 750       (error "You are already editing a picture")
 751     (set (make-local-variable 'picture-mode-old-local-map) (current-local-map))
 752     (use-local-map picture-mode-map)
 753     (set (make-local-variable 'picture-mode-old-mode-name) mode-name)
 754     (set (make-local-variable 'picture-mode-old-major-mode) major-mode)
 755     (setq major-mode 'picture-mode)
 756     (set (make-local-variable 'picture-killed-rectangle) nil)
 757     (set (make-local-variable 'tab-stop-list) (default-value 'tab-stop-list))
 758     (set (make-local-variable 'picture-tab-chars)
 759          (default-value 'picture-tab-chars))
 760     (make-local-variable 'picture-vertical-step)
 761     (make-local-variable 'picture-horizontal-step)
 762     (set (make-local-variable 'picture-mode-old-truncate-lines) truncate-lines)
 763     (setq truncate-lines t)
 764     (picture-set-motion 0 1)
 765
 766     ;; edit-picture-hook is what we used to run, picture-mode-hook is in doc.
 767     (run-hooks 'edit-picture-hook 'picture-mode-hook)
 768     (message "Type %s in this buffer to return it to %s mode."
 769              (substitute-command-keys "\\[picture-mode-exit]")
 770              picture-mode-old-mode-name)))
 771
 772 ;;;###autoload
 773 (defalias 'edit-picture 'picture-mode)
 774
 775 (defun picture-mode-exit (&optional nostrip)
 776   "Undo `picture-mode' and return to previous major mode.
 777 With no argument, strip whitespace from end of every line in Picture buffer;
 778   otherwise, just return to previous mode.
 779 Runs `picture-mode-exit-hook' at the end."
 780   (interactive "P")
 781   (if (not (eq major-mode 'picture-mode))
 782       (error "You aren't editing a Picture")
 783     (if (not nostrip) (delete-trailing-whitespace))
 784     (setq mode-name picture-mode-old-mode-name)
 785     (use-local-map picture-mode-old-local-map)
 786     (setq major-mode picture-mode-old-major-mode)
 787     (kill-local-variable 'tab-stop-list)
 788     (setq truncate-lines picture-mode-old-truncate-lines)
 789     (force-mode-line-update)
 790     (run-hooks 'picture-mode-exit-hook)))
 791
 792 (provide 'picture)
 793
 794 ;;; picture.el ends here