lisp/textmodes/picture.el

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