lisp/textmodes/picture.el

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