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