238
|
1 ;; "Picture mode" -- editing using quarter-plane screen model.
|
|
2 ;; Copyright (C) 1985 Free Software Foundation, Inc.
|
|
3 ;; Principal author K. Shane Hartman
|
|
4
|
|
5 ;; This file is part of GNU Emacs.
|
|
6
|
|
7 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
8 ;; it under the terms of the GNU General Public License as published by
|
|
9 ;; the Free Software Foundation; either version 1, or (at your option)
|
|
10 ;; any later version.
|
|
11
|
|
12 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
15 ;; GNU General Public License for more details.
|
|
16
|
|
17 ;; You should have received a copy of the GNU General Public License
|
|
18 ;; along with GNU Emacs; see the file COPYING. If not, write to
|
|
19 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
20
|
|
21
|
|
22 (defun move-to-column-force (column)
|
|
23 "Move to column COLUMN in current line.
|
|
24 Differs from `move-to-column' in that it creates or modifies whitespace
|
|
25 if necessary to attain exactly the specified column."
|
|
26 (move-to-column column)
|
|
27 (let ((col (current-column)))
|
|
28 (if (< col column)
|
|
29 (indent-to column)
|
|
30 (if (and (/= col column)
|
|
31 (= (preceding-char) ?\t))
|
|
32 (let (indent-tabs-mode)
|
|
33 (delete-char -1)
|
|
34 (indent-to col)
|
|
35 (move-to-column column))))))
|
|
36
|
|
37
|
|
38 ;; Picture Movement Commands
|
|
39
|
|
40 (defun picture-end-of-line (&optional arg)
|
|
41 "Position point after last non-blank character on current line.
|
|
42 With ARG not nil, move forward ARG - 1 lines first.
|
|
43 If scan reaches end of buffer, stop there without error."
|
|
44 (interactive "P")
|
|
45 (if arg (forward-line (1- (prefix-numeric-value arg))))
|
|
46 (beginning-of-line)
|
|
47 (skip-chars-backward " \t" (prog1 (point) (end-of-line))))
|
|
48
|
|
49 (defun picture-forward-column (arg)
|
|
50 "Move cursor right, making whitespace if necessary.
|
|
51 With argument, move that many columns."
|
|
52 (interactive "p")
|
|
53 (move-to-column-force (+ (current-column) arg)))
|
|
54
|
|
55 (defun picture-backward-column (arg)
|
|
56 "Move cursor left, making whitespace if necessary.
|
|
57 With argument, move that many columns."
|
|
58 (interactive "p")
|
|
59 (move-to-column-force (- (current-column) arg)))
|
|
60
|
|
61 (defun picture-move-down (arg)
|
|
62 "Move vertically down, making whitespace if necessary.
|
|
63 With argument, move that many lines."
|
|
64 (interactive "p")
|
|
65 (let ((col (current-column)))
|
|
66 (picture-newline arg)
|
|
67 (move-to-column-force col)))
|
|
68
|
|
69 (defconst picture-vertical-step 0
|
|
70 "Amount to move vertically after text character in Picture mode.")
|
|
71
|
|
72 (defconst picture-horizontal-step 1
|
|
73 "Amount to move horizontally after text character in Picture mode.")
|
|
74
|
|
75 (defun picture-move-up (arg)
|
|
76 "Move vertically up, making whitespace if necessary.
|
|
77 With argument, move that many lines."
|
|
78 (interactive "p")
|
|
79 (picture-move-down (- arg)))
|
|
80
|
|
81 (defun picture-movement-right ()
|
|
82 "Move right after self-inserting character in Picture mode."
|
|
83 (interactive)
|
|
84 (picture-set-motion 0 1))
|
|
85
|
|
86 (defun picture-movement-left ()
|
|
87 "Move left after self-inserting character in Picture mode."
|
|
88 (interactive)
|
|
89 (picture-set-motion 0 -1))
|
|
90
|
|
91 (defun picture-movement-up ()
|
|
92 "Move up after self-inserting character in Picture mode."
|
|
93 (interactive)
|
|
94 (picture-set-motion -1 0))
|
|
95
|
|
96 (defun picture-movement-down ()
|
|
97 "Move down after self-inserting character in Picture mode."
|
|
98 (interactive)
|
|
99 (picture-set-motion 1 0))
|
|
100
|
|
101 (defun picture-movement-nw ()
|
|
102 "Move up and left after self-inserting character in Picture mode."
|
|
103 (interactive)
|
|
104 (picture-set-motion -1 -1))
|
|
105
|
|
106 (defun picture-movement-ne ()
|
|
107 "Move up and right after self-inserting character in Picture mode."
|
|
108 (interactive)
|
|
109 (picture-set-motion -1 1))
|
|
110
|
|
111 (defun picture-movement-sw ()
|
|
112 "Move down and left after self-inserting character in Picture mode."
|
|
113 (interactive)
|
|
114 (picture-set-motion 1 -1))
|
|
115
|
|
116 (defun picture-movement-se ()
|
|
117 "Move down and right after self-inserting character in Picture mode."
|
|
118 (interactive)
|
|
119 (picture-set-motion 1 1))
|
|
120
|
|
121 (defun picture-set-motion (vert horiz)
|
|
122 "Set VERTICAL and HORIZONTAL increments for movement in Picture mode.
|
|
123 The mode line is updated to reflect the current direction."
|
|
124 (setq picture-vertical-step vert
|
|
125 picture-horizontal-step horiz)
|
|
126 (setq mode-name
|
|
127 (format "Picture:%s"
|
|
128 (car (nthcdr (+ 1 (% horiz 2) (* 3 (1+ (% vert 2))))
|
|
129 '(nw up ne left none right sw down se)))))
|
|
130 ;; Kludge - force the mode line to be updated. Is there a better
|
|
131 ;; way to this?
|
|
132 (set-buffer-modified-p (buffer-modified-p))
|
|
133 (message ""))
|
|
134
|
|
135 (defun picture-move ()
|
|
136 "Move in direction of `picture-vertical-step' and `picture-horizontal-step'."
|
|
137 (picture-move-down picture-vertical-step)
|
|
138 (picture-forward-column picture-horizontal-step))
|
|
139
|
|
140 (defun picture-motion (arg)
|
|
141 "Move point in direction of current picture motion in Picture mode.
|
|
142 With ARG do it that many times. Useful for delineating rectangles in
|
|
143 conjunction with diagonal picture motion.
|
|
144 Do \\[command-apropos] picture-movement to see commands which control motion."
|
|
145 (interactive "p")
|
|
146 (picture-move-down (* arg picture-vertical-step))
|
|
147 (picture-forward-column (* arg picture-horizontal-step)))
|
|
148
|
|
149 (defun picture-motion-reverse (arg)
|
|
150 "Move point in direction opposite of current picture motion in Picture mode.
|
|
151 With ARG do it that many times. Useful for delineating rectangles in
|
|
152 conjunction with diagonal picture motion.
|
|
153 Do \\[command-apropos] `picture-movement' to see commands which control motion."
|
|
154 (interactive "p")
|
|
155 (picture-motion (- arg)))
|
|
156
|
|
157
|
|
158 ;; Picture insertion and deletion.
|
|
159
|
|
160 (defun picture-self-insert (arg)
|
|
161 "Insert this character in place of character previously at the cursor.
|
|
162 The cursor then moves in the direction you previously specified
|
|
163 with the commands `picture-movement-right', `picture-movement-up', etc.
|
|
164 Do \\[command-apropos] `picture-movement' to see those commands."
|
|
165 (interactive "p")
|
|
166 (while (> arg 0)
|
|
167 (setq arg (1- arg))
|
|
168 (move-to-column-force (1+ (current-column)))
|
|
169 (delete-char -1)
|
|
170 (insert last-input-char)
|
|
171 (forward-char -1)
|
|
172 (picture-move)))
|
|
173
|
|
174 (defun picture-clear-column (arg)
|
|
175 "Clear out ARG columns after point without moving."
|
|
176 (interactive "p")
|
|
177 (let* ((opoint (point))
|
|
178 (original-col (current-column))
|
|
179 (target-col (+ original-col arg)))
|
|
180 (move-to-column-force target-col)
|
|
181 (delete-region opoint (point))
|
|
182 (save-excursion
|
|
183 (indent-to (max target-col original-col)))))
|
|
184
|
|
185 (defun picture-backward-clear-column (arg)
|
|
186 "Clear out ARG columns before point, moving back over them."
|
|
187 (interactive "p")
|
|
188 (picture-clear-column (- arg)))
|
|
189
|
|
190 (defun picture-clear-line (arg)
|
|
191 "Clear out rest of line; if at end of line, advance to next line.
|
|
192 Cleared-out line text goes into the kill ring, as do newlines that are
|
|
193 advanced over. With argument, clear out (and save in kill ring) that
|
|
194 many lines."
|
|
195 (interactive "P")
|
|
196 (if arg
|
|
197 (progn
|
|
198 (setq arg (prefix-numeric-value arg))
|
|
199 (kill-line arg)
|
|
200 (newline (if (> arg 0) arg (- arg))))
|
|
201 (if (looking-at "[ \t]*$")
|
|
202 (kill-ring-save (point) (progn (forward-line 1) (point)))
|
|
203 (kill-region (point) (progn (end-of-line) (point))))))
|
|
204
|
|
205 (defun picture-newline (arg)
|
|
206 "Move to the beginning of the following line.
|
|
207 With argument, moves that many lines (up, if negative argument);
|
|
208 always moves to the beginning of a line."
|
|
209 (interactive "p")
|
|
210 (if (< arg 0)
|
|
211 (forward-line arg)
|
|
212 (while (> arg 0)
|
|
213 (end-of-line)
|
|
214 (if (eobp) (newline) (forward-char 1))
|
|
215 (setq arg (1- arg)))))
|
|
216
|
|
217 (defun picture-open-line (arg)
|
|
218 "Insert an empty line after the current line.
|
|
219 With positive argument insert that many lines."
|
|
220 (interactive "p")
|
|
221 (save-excursion
|
|
222 (end-of-line)
|
|
223 (open-line arg)))
|
|
224
|
|
225 (defun picture-duplicate-line ()
|
|
226 "Insert a duplicate of the current line, below it."
|
|
227 (interactive)
|
|
228 (save-excursion
|
|
229 (let ((contents
|
|
230 (buffer-substring
|
|
231 (progn (beginning-of-line) (point))
|
|
232 (progn (picture-newline 1) (point)))))
|
|
233 (forward-line -1)
|
|
234 (insert contents))))
|
|
235
|
|
236
|
|
237 ;; Picture Tabs
|
|
238
|
|
239 (defvar picture-tab-chars "!-~"
|
|
240 "*A character set which controls behavior of commands
|
|
241 \\[picture-set-tab-stops] and \\[picture-tab-search]. It is NOT a
|
|
242 regular expression, any regexp special characters will be quoted.
|
|
243 It defines a set of \"interesting characters\" to look for when setting
|
|
244 \(or searching for) tab stops, initially \"!-~\" (all printing characters).
|
|
245 For example, suppose that you are editing a table which is formatted thus:
|
|
246 | foo | bar + baz | 23 *
|
|
247 | bubbles | and + etc | 97 *
|
|
248 and that `picture-tab-chars' is \"|+*\". Then invoking
|
|
249 \\[picture-set-tab-stops] on either of the previous lines would result
|
|
250 in the following tab stops
|
|
251 : : : :
|
|
252 Another example - \"A-Za-z0-9\" would produce the tab stops
|
|
253 : : : :
|
|
254
|
|
255 Note that if you want the character `-' to be in the set, it must be
|
|
256 included in a range or else appear in a context where it cannot be
|
|
257 taken for indicating a range (e.g. \"-A-Z\" declares the set to be the
|
|
258 letters `A' through `Z' and the character `-'). If you want the
|
|
259 character `\\' in the set it must be preceded by itself: \"\\\\\".
|
|
260
|
|
261 The command \\[picture-tab-search] is defined to move beneath (or to) a
|
|
262 character belonging to this set independent of the tab stops list.")
|
|
263
|
|
264 (defun picture-set-tab-stops (&optional arg)
|
|
265 "Set value of `tab-stop-list' according to context of this line.
|
|
266 This controls the behavior of \\[picture-tab]. A tab stop is set at
|
|
267 every column occupied by an \"interesting character\" that is preceded
|
|
268 by whitespace. Interesting characters are defined by the variable
|
|
269 `picture-tab-chars', see its documentation for an example of usage.
|
|
270 With ARG, just (re)set `tab-stop-list' to its default value. The tab
|
|
271 stops computed are displayed in the minibuffer with `:' at each stop."
|
|
272 (interactive "P")
|
|
273 (save-excursion
|
|
274 (let (tabs)
|
|
275 (if arg
|
|
276 (setq tabs (default-value 'tab-stop-list))
|
|
277 (let ((regexp (concat "[ \t]+[" (regexp-quote picture-tab-chars) "]")))
|
|
278 (beginning-of-line)
|
|
279 (let ((bol (point)))
|
|
280 (end-of-line)
|
|
281 (while (re-search-backward regexp bol t)
|
|
282 (skip-chars-forward " \t")
|
|
283 (setq tabs (cons (current-column) tabs)))
|
|
284 (if (null tabs)
|
|
285 (error "No characters in set %s on this line."
|
|
286 (regexp-quote picture-tab-chars))))))
|
|
287 (setq tab-stop-list tabs)
|
|
288 (let ((blurb (make-string (1+ (nth (1- (length tabs)) tabs)) ?\ )))
|
|
289 (while tabs
|
|
290 (aset blurb (car tabs) ?:)
|
|
291 (setq tabs (cdr tabs)))
|
|
292 (message blurb)))))
|
|
293
|
|
294 (defun picture-tab-search (&optional arg)
|
|
295 "Move to column beneath next interesting char in previous line.
|
|
296 With ARG move to column occupied by next interesting character in this
|
|
297 line. The character must be preceded by whitespace.
|
|
298 \"interesting characters\" are defined by variable `picture-tab-chars'.
|
|
299 If no such character is found, move to beginning of line."
|
|
300 (interactive "P")
|
|
301 (let ((target (current-column)))
|
|
302 (save-excursion
|
|
303 (if (and (not arg)
|
|
304 (progn
|
|
305 (beginning-of-line)
|
|
306 (skip-chars-backward
|
|
307 (concat "^" (regexp-quote picture-tab-chars))
|
|
308 (point-min))
|
|
309 (not (bobp))))
|
|
310 (move-to-column target))
|
|
311 (if (re-search-forward
|
|
312 (concat "[ \t]+[" (regexp-quote picture-tab-chars) "]")
|
|
313 (save-excursion (end-of-line) (point))
|
|
314 'move)
|
|
315 (setq target (1- (current-column)))
|
|
316 (setq target nil)))
|
|
317 (if target
|
|
318 (move-to-column-force target)
|
|
319 (beginning-of-line))))
|
|
320
|
|
321 (defun picture-tab (&optional arg)
|
|
322 "Tab transparently (just move point) to next tab stop.
|
|
323 With prefix arg, overwrite the traversed text with spaces. The tab stop
|
|
324 list can be changed by \\[picture-set-tab-stops] and \\[edit-tab-stops].
|
|
325 See also documentation for variable `picture-tab-chars'."
|
|
326 (interactive "P")
|
|
327 (let* ((opoint (point)))
|
|
328 (move-to-tab-stop)
|
|
329 (if arg
|
|
330 (let (indent-tabs-mode
|
|
331 (column (current-column)))
|
|
332 (delete-region opoint (point))
|
|
333 (indent-to column)))))
|
|
334
|
|
335 ;; Picture Rectangles
|
|
336
|
|
337 (defconst picture-killed-rectangle nil
|
|
338 "Rectangle killed or copied by \\[picture-clear-rectangle] in Picture mode.
|
|
339 The contents can be retrieved by \\[picture-yank-rectangle]")
|
|
340
|
|
341 (defun picture-clear-rectangle (start end &optional killp)
|
|
342 "Clear and save rectangle delineated by point and mark.
|
|
343 The rectangle is saved for yanking by \\[picture-yank-rectangle] and replaced
|
|
344 with whitespace. The previously saved rectangle, if any, is lost. With
|
|
345 prefix argument, the rectangle is actually killed, shifting remaining text."
|
|
346 (interactive "r\nP")
|
|
347 (setq picture-killed-rectangle (picture-snarf-rectangle start end killp)))
|
|
348
|
|
349 (defun picture-clear-rectangle-to-register (start end register &optional killp)
|
|
350 "Clear rectangle delineated by point and mark into REGISTER.
|
|
351 The rectangle is saved in REGISTER and replaced with whitespace. With
|
|
352 prefix argument, the rectangle is actually killed, shifting remaining text."
|
|
353 (interactive "r\ncRectangle to register: \nP")
|
|
354 (set-register register (picture-snarf-rectangle start end killp)))
|
|
355
|
|
356 (defun picture-snarf-rectangle (start end &optional killp)
|
|
357 (let ((column (current-column))
|
|
358 (indent-tabs-mode nil))
|
|
359 (prog1 (save-excursion
|
|
360 (if killp
|
|
361 (delete-extract-rectangle start end)
|
|
362 (prog1 (extract-rectangle start end)
|
|
363 (clear-rectangle start end))))
|
|
364 (move-to-column-force column))))
|
|
365
|
|
366 (defun picture-yank-rectangle (&optional insertp)
|
|
367 "Overlay rectangle saved by \\[picture-clear-rectangle]
|
|
368 The rectangle is positioned with upper left corner at point, overwriting
|
|
369 existing text. With prefix argument, the rectangle is inserted instead,
|
|
370 shifting existing text. Leaves mark at one corner of rectangle and
|
|
371 point at the other (diagonally opposed) corner."
|
|
372 (interactive "P")
|
|
373 (if (not (consp picture-killed-rectangle))
|
|
374 (error "No rectangle saved.")
|
|
375 (picture-insert-rectangle picture-killed-rectangle insertp)))
|
|
376
|
|
377 (defun picture-yank-rectangle-from-register (register &optional insertp)
|
|
378 "Overlay rectangle saved in REGISTER.
|
|
379 The rectangle is positioned with upper left corner at point, overwriting
|
|
380 existing text. With prefix argument, the rectangle is
|
|
381 inserted instead, shifting existing text. Leaves mark at one corner
|
|
382 of rectangle and point at the other (diagonally opposed) corner."
|
|
383 (interactive "cRectangle from register: \nP")
|
|
384 (let ((rectangle (get-register register)))
|
|
385 (if (not (consp rectangle))
|
|
386 (error "Register %c does not contain a rectangle." register)
|
|
387 (picture-insert-rectangle rectangle insertp))))
|
|
388
|
|
389 (defun picture-insert-rectangle (rectangle &optional insertp)
|
|
390 "Overlay RECTANGLE with upper left corner at point.
|
|
391 Optional argument INSERTP, if non-nil causes RECTANGLE to be inserted.
|
|
392 Leaves the region surrounding the rectangle."
|
|
393 (let ((indent-tabs-mode nil))
|
|
394 (if (not insertp)
|
|
395 (save-excursion
|
|
396 (delete-rectangle (point)
|
|
397 (progn
|
|
398 (picture-forward-column (length (car rectangle)))
|
|
399 (picture-move-down (1- (length rectangle)))
|
|
400 (point)))))
|
|
401 (push-mark)
|
|
402 (insert-rectangle rectangle)))
|
|
403
|
|
404
|
|
405 ;; Picture Keymap, entry and exit points.
|
|
406
|
|
407 (defconst picture-mode-map nil)
|
|
408
|
|
409 (if (not picture-mode-map)
|
|
410 (let ((i ?\ ))
|
|
411 (setq picture-mode-map (make-keymap))
|
|
412 (while (< i ?\177)
|
|
413 (aset picture-mode-map i 'picture-self-insert)
|
|
414 (setq i (1+ i)))
|
|
415 (define-key picture-mode-map "\C-f" 'picture-forward-column)
|
|
416 (define-key picture-mode-map "\C-b" 'picture-backward-column)
|
|
417 (define-key picture-mode-map "\C-d" 'picture-clear-column)
|
|
418 (define-key picture-mode-map "\C-c\C-d" 'delete-char)
|
|
419 (define-key picture-mode-map "\177" 'picture-backward-clear-column)
|
|
420 (define-key picture-mode-map "\C-k" 'picture-clear-line)
|
|
421 (define-key picture-mode-map "\C-o" 'picture-open-line)
|
|
422 (define-key picture-mode-map "\C-m" 'picture-newline)
|
|
423 (define-key picture-mode-map "\C-j" 'picture-duplicate-line)
|
|
424 (define-key picture-mode-map "\C-n" 'picture-move-down)
|
|
425 (define-key picture-mode-map "\C-p" 'picture-move-up)
|
|
426 (define-key picture-mode-map "\C-e" 'picture-end-of-line)
|
|
427 (define-key picture-mode-map "\e\t" 'picture-toggle-tab-state)
|
|
428 (define-key picture-mode-map "\t" 'picture-tab)
|
|
429 (define-key picture-mode-map "\e\t" 'picture-tab-search)
|
|
430 (define-key picture-mode-map "\C-c\t" 'picture-set-tab-stops)
|
|
431 (define-key picture-mode-map "\C-c\C-k" 'picture-clear-rectangle)
|
|
432 (define-key picture-mode-map "\C-c\C-w" 'picture-clear-rectangle-to-register)
|
|
433 (define-key picture-mode-map "\C-c\C-y" 'picture-yank-rectangle)
|
|
434 (define-key picture-mode-map "\C-c\C-x" 'picture-yank-rectangle-from-register)
|
|
435 (define-key picture-mode-map "\C-c\C-c" 'picture-mode-exit)
|
|
436 (define-key picture-mode-map "\C-c\C-f" 'picture-motion)
|
|
437 (define-key picture-mode-map "\C-c\C-b" 'picture-motion-reverse)
|
|
438 (define-key picture-mode-map "\C-c<" 'picture-movement-left)
|
|
439 (define-key picture-mode-map "\C-c>" 'picture-movement-right)
|
|
440 (define-key picture-mode-map "\C-c^" 'picture-movement-up)
|
|
441 (define-key picture-mode-map "\C-c." 'picture-movement-down)
|
|
442 (define-key picture-mode-map "\C-c`" 'picture-movement-nw)
|
|
443 (define-key picture-mode-map "\C-c'" 'picture-movement-ne)
|
|
444 (define-key picture-mode-map "\C-c/" 'picture-movement-sw)
|
|
445 (define-key picture-mode-map "\C-c\\" 'picture-movement-se)))
|
|
446
|
|
447 (defvar edit-picture-hook nil
|
|
448 "If non-nil, it's value is called on entry to Picture mode.
|
|
449 Picture mode is invoked by the command \\[edit-picture].")
|
|
450
|
256
|
451 ;;;###autoload
|
238
|
452 (defun edit-picture ()
|
|
453 "Switch to Picture mode, in which a quarter-plane screen model is used.
|
|
454 Printing characters replace instead of inserting themselves with motion
|
|
455 afterwards settable by these commands:
|
|
456 C-c < Move left after insertion.
|
|
457 C-c > Move right after insertion.
|
|
458 C-c ^ Move up after insertion.
|
|
459 C-c . Move down after insertion.
|
|
460 C-c ` Move northwest (nw) after insertion.
|
|
461 C-c ' Move northeast (ne) after insertion.
|
|
462 C-c / Move southwest (sw) after insertion.
|
|
463 C-c \\ Move southeast (se) after insertion.
|
|
464 The current direction is displayed in the mode line. The initial
|
|
465 direction is right. Whitespace is inserted and tabs are changed to
|
|
466 spaces when required by movement. You can move around in the buffer
|
|
467 with these commands:
|
|
468 C-p Move vertically to SAME column in previous line.
|
|
469 C-n Move vertically to SAME column in next line.
|
|
470 C-e Move to column following last non-whitespace character.
|
|
471 C-f Move right inserting spaces if required.
|
|
472 C-b Move left changing tabs to spaces if required.
|
|
473 C-c C-f Move in direction of current picture motion.
|
|
474 C-c C-b Move in opposite direction of current picture motion.
|
|
475 Return Move to beginning of next line.
|
|
476 You can edit tabular text with these commands:
|
|
477 M-Tab Move to column beneath (or at) next interesting character.
|
|
478 `Indents' relative to a previous line.
|
|
479 Tab Move to next stop in tab stop list.
|
|
480 C-c Tab Set tab stops according to context of this line.
|
|
481 With ARG resets tab stops to default (global) value.
|
|
482 See also documentation of variable picture-tab-chars
|
|
483 which defines \"interesting character\". You can manually
|
|
484 change the tab stop list with command \\[edit-tab-stops].
|
|
485 You can manipulate text with these commands:
|
|
486 C-d Clear (replace) ARG columns after point without moving.
|
|
487 C-c C-d Delete char at point - the command normally assigned to C-d.
|
|
488 Delete Clear (replace) ARG columns before point, moving back over them.
|
|
489 C-k Clear ARG lines, advancing over them. The cleared
|
|
490 text is saved in the kill ring.
|
|
491 C-o Open blank line(s) beneath current line.
|
|
492 You can manipulate rectangles with these commands:
|
|
493 C-c C-k Clear (or kill) a rectangle and save it.
|
|
494 C-c C-w Like C-c C-k except rectangle is saved in named register.
|
|
495 C-c C-y Overlay (or insert) currently saved rectangle at point.
|
|
496 C-c C-x Like C-c C-y except rectangle is taken from named register.
|
|
497 \\[copy-rectangle-to-register] Copies a rectangle to a register.
|
|
498 \\[advertised-undo] Can undo effects of rectangle overlay commands
|
|
499 commands if invoked soon enough.
|
|
500 You can return to the previous mode with:
|
|
501 C-c C-c Which also strips trailing whitespace from every line.
|
|
502 Stripping is suppressed by supplying an argument.
|
|
503
|
|
504 Entry to this mode calls the value of edit-picture-hook if non-nil.
|
|
505
|
|
506 Note that Picture mode commands will work outside of Picture mode, but
|
|
507 they are not defaultly assigned to keys."
|
|
508 (interactive)
|
|
509 (if (eq major-mode 'edit-picture)
|
|
510 (error "You are already editing a Picture.")
|
|
511 (make-local-variable 'picture-mode-old-local-map)
|
|
512 (setq picture-mode-old-local-map (current-local-map))
|
|
513 (use-local-map picture-mode-map)
|
|
514 (make-local-variable 'picture-mode-old-mode-name)
|
|
515 (setq picture-mode-old-mode-name mode-name)
|
|
516 (make-local-variable 'picture-mode-old-major-mode)
|
|
517 (setq picture-mode-old-major-mode major-mode)
|
|
518 (setq major-mode 'edit-picture)
|
|
519 (make-local-variable 'picture-killed-rectangle)
|
|
520 (setq picture-killed-rectangle nil)
|
|
521 (make-local-variable 'tab-stop-list)
|
|
522 (setq tab-stop-list (default-value 'tab-stop-list))
|
|
523 (make-local-variable 'picture-tab-chars)
|
|
524 (setq picture-tab-chars (default-value 'picture-tab-chars))
|
|
525 (make-local-variable 'picture-vertical-step)
|
|
526 (make-local-variable 'picture-horizontal-step)
|
|
527 (picture-set-motion 0 1)
|
|
528 (run-hooks 'edit-picture-hook)
|
|
529 (message
|
|
530 (substitute-command-keys
|
|
531 "Type \\[picture-mode-exit] in this buffer to return it to %s mode.")
|
|
532 picture-mode-old-mode-name)))
|
|
533
|
269
|
534 ;;;###autoload
|
|
535 (fset 'picture-mode 'edit-picture)
|
238
|
536
|
|
537 (defun picture-mode-exit (&optional nostrip)
|
|
538 "Undo edit-picture and return to previous major mode.
|
|
539 With no argument strips whitespace from end of every line in Picture buffer
|
|
540 otherwise just return to previous mode."
|
|
541 (interactive "P")
|
|
542 (if (not (eq major-mode 'edit-picture))
|
|
543 (error "You aren't editing a Picture.")
|
|
544 (if (not nostrip) (picture-clean))
|
|
545 (setq mode-name picture-mode-old-mode-name)
|
|
546 (use-local-map picture-mode-old-local-map)
|
|
547 (setq major-mode picture-mode-old-major-mode)
|
|
548 (kill-local-variable 'tab-stop-list)
|
|
549 ;; Kludge - force the mode line to be updated. Is there a better
|
|
550 ;; way to do this?
|
|
551 (set-buffer-modified-p (buffer-modified-p))))
|
|
552
|
|
553 (defun picture-clean ()
|
|
554 "Eliminate whitespace at ends of lines."
|
|
555 (save-excursion
|
|
556 (goto-char (point-min))
|
|
557 (while (re-search-forward "[ \t][ \t]*$" nil t)
|
|
558 (delete-region (match-beginning 0) (point)))))
|
584
|
559
|
|
560 (provide 'picture)
|
|
561
|