lisp/textmodes/picture.el

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