| blob | c5959d193d79dcbd47373e5dc625900a1dfa2b54 |
1 ;;; tpu-edt.el --- Emacs emulating TPU emulating EDT
3 ;; Copyright (C) 1993-1995, 2000-2015 Free Software Foundation, Inc.
5 ;; Author: Rob Riepel <riepel@networking.stanford.edu>
6 ;; Maintainer: Rob Riepel <riepel@networking.stanford.edu>
7 ;; Version: 4.5
8 ;; Keywords: emulations
9 ;; Obsolete-since: 24.5
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation, either version 3 of the License, or
16 ;; (at your option) any later version.
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
26 ;; TPU-edt is based on tpu.el by Jeff Kowalski and Bob Covey.
28 ;;; Commentary:
30 ;; %% TPU-edt -- Emacs emulating TPU emulating EDT
32 ;; %% Contents
34 ;; % Introduction
35 ;; % Differences Between TPU-edt and DEC TPU/edt
36 ;; % Starting TPU-edt
37 ;; % Customizing TPU-edt using the Emacs Initialization File
38 ;; % Regular Expressions in TPU-edt
41 ;; %% Introduction
43 ;; TPU-edt emulates the popular DEC VMS editor EDT (actually, it emulates
44 ;; DEC TPU's EDT emulation, hence the name TPU-edt). TPU-edt features the
45 ;; following TPU/edt functionality:
47 ;; . EDT keypad
48 ;; . On-line help
49 ;; . Repeat counts
50 ;; . Scroll margins
51 ;; . Learn sequences
52 ;; . Free cursor mode
53 ;; . Rectangular cut and paste
54 ;; . Multiple windows and buffers
55 ;; . TPU line-mode REPLACE command
56 ;; . Wild card search and substitution
57 ;; . Configurable through an initialization file
58 ;; . History recall of search strings, file names, and commands
60 ;; Please note that TPU-edt does NOT emulate TPU. It emulates TPU's EDT
61 ;; emulation. Very few TPU line-mode commands are supported.
63 ;; TPU-edt, like its VMS cousin, works on VT-series terminals with DEC
64 ;; style keyboards. VT terminal emulators, including xterm with the
65 ;; appropriate key translations, work just fine too.
67 ;; TPU-edt works with X-windows. This is accomplished through a TPU-edt
68 ;; X key map. The tpu-mapper command creates this map and stores it in a
69 ;; file. See the tpu-mapper command help for more information, or just
70 ;; run it and follow the directions.
73 ;; %% Differences Between TPU-edt and DEC TPU/edt
75 ;; In some cases, Emacs doesn't support text highlighting, so selected
76 ;; regions are not shown in inverse video. Emacs uses the concept of "the
77 ;; mark". The mark is set at one end of a selected region; the cursor is
78 ;; at the other. In cases where the selected region cannot be shown in
79 ;; inverse video an at sign (@) appears in the mode line when mark is set.
80 ;; The native Emacs command ^X^X (Control-X twice) exchanges the cursor
81 ;; with the mark; this provides a handy way to find the location of the
82 ;; mark.
84 ;; In TPU the cursor can be either bound or free. Bound means the cursor
85 ;; cannot wander outside the text of the file being edited. Free means
86 ;; the arrow keys can move the cursor past the ends of lines. Free is the
87 ;; default mode in TPU; bound is the only mode in EDT. Bound is the only
88 ;; mode in the base version of TPU-edt; optional extensions add an
89 ;; approximation of free mode, see the commentary in tpu-extras.el for
90 ;; details.
92 ;; Like TPU, Emacs uses multiple buffers. Some buffers are used to hold
93 ;; files you are editing; other "internal" buffers are used for Emacs's own
94 ;; purposes (like showing you help). Here are some commands for dealing
95 ;; with buffers.
97 ;; Gold-B moves to next buffer, including internal buffers
98 ;; Gold-N moves to next buffer containing a file
99 ;; Gold-M brings up a buffer menu (like TPU "show buffers")
101 ;; Emacs is very fond of throwing up new windows. Dealing with all these
102 ;; windows can be a little confusing at first, so here are a few commands
103 ;; to that may help:
105 ;; Gold-Next_Scr moves to the next window on the screen
106 ;; Gold-Prev_Scr moves to the previous window on the screen
107 ;; Gold-TAB also moves to the next window on the screen
109 ;; Control-x 1 deletes all but the current window
110 ;; Control-x 0 deletes the current window
112 ;; Note that the buffers associated with deleted windows still exist!
114 ;; Like TPU, TPU-edt has a "command" function, invoked with Gold-KP7 or
115 ;; Do. Most of the commands available are Emacs commands. Some TPU
116 ;; commands are available, they are: replace, exit, quit, include, and
117 ;; Get (unfortunately, "get" is an internal Emacs function, so we are
118 ;; stuck with "Get" - to make life easier, Get is available as Gold-g).
120 ;; TPU-edt supports the recall of commands, file names, and search
121 ;; strings. The history of strings recalled differs slightly from
122 ;; TPU/edt, but it is still very convenient.
124 ;; Help is available! The traditional help keys (Help and PF2) display
125 ;; a small help file showing the default keypad layout, control key
126 ;; functions, and Gold key functions. Pressing any key inside of help
127 ;; splits the screen and prints a description of the function of the
128 ;; pressed key. Gold-PF2 invokes the native Emacs help, with its
129 ;; zillions of options.
131 ;; Thanks to Emacs, TPU-edt has some extensions that may make your life
132 ;; easier, or at least more interesting. For example, Gold-r toggles
133 ;; TPU-edt rectangular mode. In rectangular mode, Remove and Insert work
134 ;; on rectangles. Likewise, Gold-* toggles TPU-edt regular expression
135 ;; mode. In regular expression mode Find, Find Next, and the line-mode
136 ;; replace command work with regular expressions. [A regular expression
137 ;; is a pattern that denotes a set of strings; like VMS wildcards.]
139 ;; Emacs also gives TPU-edt the undo and occur functions. Undo does
140 ;; what it says; it undoes the last change. Multiple undos in a row
141 ;; undo multiple changes. For your convenience, undo is available on
142 ;; Gold-u. Occur shows all the lines containing a specific string in
143 ;; another window. Moving to that window, and typing ^C^C (Control-C
144 ;; twice) on a particular line moves you back to the original window
145 ;; at that line. Occur is on Gold-o.
147 ;; Finally, as you edit, remember that all the power of Emacs is at
148 ;; your disposal. It really is a fantastic tool. You may even want to
149 ;; take some time and read the Emacs tutorial; perhaps not to learn the
150 ;; native Emacs key bindings, but to get a feel for all the things
151 ;; Emacs can do for you. The Emacs tutorial is available from the
152 ;; Emacs help function: "Gold-PF2 t"
155 ;; %% Starting TPU-edt
157 ;; All you have to do to start TPU-edt, is turn it on. This can be
158 ;; done from the command line when running Emacs.
160 ;; prompt> emacs -f tpu-edt
162 ;; If you've already started Emacs, turn on TPU-edt using the tpu-edt
163 ;; command. First press `M-x' (that's usually `ESC' followed by `x')
164 ;; and type `tpu-edt' followed by a carriage return.
166 ;; If you like TPU-edt and want to use it all the time, you can start
167 ;; TPU-edt using the Emacs initialization file, .emacs. Simply add
168 ;; the following line to your init file:
170 ;; (tpu-edt)
172 ;; That's all you need to do to start TPU-edt.
175 ;; %% Customizing TPU-edt using the Emacs Initialization File
177 ;; The following is a sample Emacs initialization file. It shows how to
178 ;; invoke TPU-edt, and how to customize it.
180 ;; ; .emacs - a sample Emacs initialization file
182 ;; ; Turn on TPU-edt
183 ;; (tpu-edt)
185 ;; ; Set scroll margins 10% (top) and 15% (bottom).
186 ;; (tpu-set-scroll-margins "10%" "15%")
188 ;; ; Load the vtxxx terminal control functions.
189 ;; (load "vt-control" t)
191 ;; ; TPU-edt treats words like EDT; here's how to add word separators.
192 ;; ; Note that backslash (\) and double quote (") are quoted with '\'.
193 ;; (tpu-add-word-separators "]\\[-_,.\"=+()'/*#:!&;$")
195 ;; ; Emacs is happy to save files without a final newline; other Unix
196 ;; ; programs hate that! Here we make sure that files end with newlines.
197 ;; (setq require-final-newline t)
199 ;; ; Emacs uses Control-s and Control-q. Problems can occur when using
200 ;; ; Emacs on terminals that use these codes for flow control (Xon/Xoff
201 ;; ; flow control). These lines disable Emacs's use of these characters.
202 ;; (global-unset-key "\C-s")
203 ;; (global-unset-key "\C-q")
205 ;; ; The Emacs universal-argument function is very useful.
206 ;; ; This line maps universal-argument to Gold-PF1.
207 ;; (define-key tpu-gold-map [kp_f1] 'universal-argument) ; Gold-PF1
209 ;; ; Make KP7 move by paragraphs, instead of pages.
210 ;; (define-key tpu-global-map [kf_7] 'tpu-paragraph) ; KP7
212 ;; ; Repeat the preceding mappings for X-windows.
213 ;; (cond
214 ;; (window-system
215 ;; (define-key tpu-global-map [kp_7] 'tpu-paragraph) ; KP7
216 ;; (define-key tpu-gold-map [kp_f1] 'universal-argument))) ; GOLD-PF1
218 ;; ; Display the TPU-edt version.
219 ;; (tpu-version)
222 ;; %% Regular Expressions in TPU-edt
224 ;; Gold-* toggles TPU-edt regular expression mode. In regular expression
225 ;; mode, find, find next, replace, and substitute accept Emacs regular
226 ;; expressions. A complete list of Emacs regular expressions can be found
227 ;; using the Emacs "info" command (it's somewhat like the VMS help
228 ;; command). Try the following sequence of commands:
230 ;; DO info <enter info mode>
231 ;; m emacs <select the "emacs" topic>
232 ;; m regexs <select the "regular expression" topic>
234 ;; Type "q" to quit out of info mode.
236 ;; There is a problem in regular expression mode when searching for empty
237 ;; strings, like beginning-of-line (^) and end-of-line ($). When searching
238 ;; for these strings, find-next may find the current string, instead of the
239 ;; next one. This can cause global replace and substitute commands to loop
240 ;; forever in the same location. For this reason, commands like
242 ;; replace "^" "> " <add "> " to beginning of line>
243 ;; replace "$" "00711" <add "00711" to end of line>
245 ;; may not work properly.
247 ;; Commands like those above are very useful for adding text to the
248 ;; beginning or end of lines. They might work on a line-by-line basis, but
249 ;; go into an infinite loop if the "all" response is specified. If the
250 ;; goal is to add a string to the beginning or end of a particular set of
251 ;; lines TPU-edt provides functions to do this.
253 ;; Gold-^ Add a string at BOL in region or buffer
254 ;; Gold-$ Add a string at EOL in region or buffer
256 ;; There is also a TPU-edt interface to the native Emacs string replacement
257 ;; commands. Gold-/ invokes this command. It accepts regular expressions
258 ;; if TPU-edt is in regular expression mode. Given a repeat count, it will
259 ;; perform the replacement without prompting for confirmation.
261 ;; This command replaces empty strings correctly, however, it has its
262 ;; drawbacks. As a native Emacs command, it has a different interface
263 ;; than the emulated TPU commands. Also, it works only in the forward
264 ;; direction, regardless of the current TPU-edt direction.
266 ;;; Todo/Bugs:
268 ;; We shouldn't use vt100 ESC sequences since it is uselessly fighting
269 ;; against function-key-map. Better use real key names.
271 ;;; Code:
273 ;; we use picture-mode functions
277 "Emacs emulating TPU emulating EDT."
282 ;;;
283 ;;; Version Information
284 ;;;
288 ;;;
289 ;;; User Configurable Variables
290 ;;;
292 "Non-nil means `tpu-spell-check' uses `ispell-region' for spell checking.
293 Otherwise, use `spell-region'."
300 "If non-nil, TPU-edt kills modified buffers without asking."
305 "Percentage of the screen to scroll for next/previous screen commands."
310 "Number of columns the tpu-pan functions scroll left or right."
315 ;;;
316 ;;; Global Keymaps
317 ;;;
322 ;; Previously we used escape sequences here. We now instead presume
323 ;; that term/*.el does its job to map the escape sequence to the right
324 ;; key-symbol.
327 (define-key map [down] 'tpu-move-to-end) ; down-arrow
328 (define-key map [right] 'end-of-line) ; right-arrow
329 (define-key map [left] 'beginning-of-line) ; left-arrow
331 ;; (define-key map [find] nil) ; Find
332 ;; (define-key map [insert] nil) ; Insert Here
333 (define-key map [delete] 'tpu-store-text) ; Remove
334 (define-key map [select] 'tpu-unselect) ; Select
335 (define-key map [prior] 'tpu-previous-window) ; Prev Screen
336 (define-key map [next] 'tpu-next-window) ; Next Screen
338 ;; (define-key map [f1] nil) ; F1
339 ;; (define-key map [f2] nil) ; F2
340 ;; (define-key map [f3] nil) ; F3
341 ;; (define-key map [f4] nil) ; F4
342 ;; (define-key map [f5] nil) ; F5
343 ;; (define-key map [f6] nil) ; F6
344 ;; (define-key map [f7] nil) ; F7
345 ;; (define-key map [f8] nil) ; F8
346 ;; (define-key map [f9] nil) ; F9
347 ;; (define-key map [f10] nil) ; F10
348 ;; (define-key map [f11] nil) ; F11
349 ;; (define-key map [f12] nil) ; F12
350 ;; (define-key map [f13] nil) ; F13
351 ;; (define-key map [f14] nil) ; F14
352 (define-key map [help] 'describe-bindings) ; HELP
353 ;; (define-key map [menu] nil) ; DO
354 (define-key map [f17] 'tpu-drop-breadcrumb) ; F17
355 ;; (define-key map [f18] nil) ; F18
356 ;; (define-key map [f19] nil) ; F19
357 ;; (define-key map [f20] nil) ; F20
359 (define-key map [kp-f1] 'keyboard-quit) ; PF1
360 (define-key map [kp-f2] 'help-for-help) ; PF2
361 (define-key map [kp-f3] 'tpu-search) ; PF3
362 (define-key map [kp-f4] 'tpu-undelete-lines) ; PF4
363 (define-key map [kp-0] 'open-line) ; KP0
364 (define-key map [kp-1] 'tpu-change-case) ; KP1
365 (define-key map [kp-2] 'tpu-delete-to-eol) ; KP2
366 (define-key map [kp-3] 'tpu-special-insert) ; KP3
367 (define-key map [kp-4] 'tpu-move-to-end) ; KP4
368 (define-key map [kp-5] 'tpu-move-to-beginning) ; KP5
369 (define-key map [kp-6] 'tpu-paste) ; KP6
370 (define-key map [kp-7] 'execute-extended-command) ; KP7
371 (define-key map [kp-8] 'tpu-fill) ; KP8
372 (define-key map [kp-9] 'tpu-replace) ; KP9
373 (define-key map [kp-subtract] 'tpu-undelete-words) ; KP-
374 (define-key map [kp-separator] 'tpu-undelete-char) ; KP,
375 (define-key map [kp-decimal] 'tpu-unselect) ; KP.
376 (define-key map [kp-enter] 'tpu-substitute) ; KPenter
378 ;;
379 (define-key map "\C-A" 'tpu-toggle-overwrite-mode) ; ^A
380 ;; (define-key map "\C-B" nil) ; ^B
381 ;; (define-key map "\C-C" nil) ; ^C
382 ;; (define-key map "\C-D" nil) ; ^D
383 ;; (define-key map "\C-E" nil) ; ^E
384 (define-key map "\C-F" 'set-visited-file-name) ; ^F
385 (define-key map "\C-g" 'keyboard-quit) ; safety first
386 (define-key map "\C-h" 'delete-other-windows) ; BS
387 (define-key map "\C-i" 'other-window) ; TAB
388 ;; (define-key map "\C-J" nil) ; ^J
389 (define-key map "\C-K" 'tpu-define-macro-key) ; ^K
390 (define-key map "\C-l" 'downcase-region) ; ^L
391 ;; (define-key map "\C-M" nil) ; ^M
392 ;; (define-key map "\C-N" nil) ; ^N
393 ;; (define-key map "\C-O" nil) ; ^O
394 ;; (define-key map "\C-P" nil) ; ^P
395 ;; (define-key map "\C-Q" nil) ; ^Q
396 ;; (define-key map "\C-R" nil) ; ^R
397 ;; (define-key map "\C-S" nil) ; ^S
398 (define-key map "\C-T" 'tpu-toggle-control-keys) ; ^T
399 (define-key map "\C-u" 'upcase-region) ; ^U
400 ;; (define-key map "\C-V" nil) ; ^V
401 (define-key map "\C-w" 'tpu-write-current-buffers) ; ^W
402 ;; (define-key map "\C-X" nil) ; ^X
403 ;; (define-key map "\C-Y" nil) ; ^Y
404 ;; (define-key map "\C-Z" nil) ; ^Z
405 (define-key map " " 'undo) ; SPC
406 ;; (define-key map "!" nil) ; !
407 ;; (define-key map "#" nil) ; #
408 (define-key map "$" 'tpu-add-at-eol) ; $
409 (define-key map "%" 'tpu-goto-percent) ; %
410 ;; (define-key map "&" nil) ; &
411 ;; (define-key map "(" nil) ; (
412 ;; (define-key map ")" nil) ; )
413 (define-key map "*" 'tpu-toggle-regexp) ; *
414 ;; (define-key map "+" nil) ; +
415 (define-key map "," 'tpu-goto-breadcrumb) ; ,
416 (define-key map "-" 'negative-argument) ; -
417 (define-key map "." 'tpu-drop-breadcrumb) ; .
418 (define-key map "/" 'tpu-emacs-replace) ; /
419 (define-key map "0" 'digit-argument) ; 0
420 (define-key map "1" 'digit-argument) ; 1
421 (define-key map "2" 'digit-argument) ; 2
422 (define-key map "3" 'digit-argument) ; 3
423 (define-key map "4" 'digit-argument) ; 4
424 (define-key map "5" 'digit-argument) ; 5
425 (define-key map "6" 'digit-argument) ; 6
426 (define-key map "7" 'digit-argument) ; 7
427 (define-key map "8" 'digit-argument) ; 8
428 (define-key map "9" 'digit-argument) ; 9
429 ;; (define-key map ":" nil) ; :
430 (define-key map ";" 'tpu-trim-line-ends) ; ;
431 ;; (define-key map "<" nil) ; <
432 ;; (define-key map "=" nil) ; =
433 ;; (define-key map ">" nil) ; >
434 (define-key map "?" 'tpu-spell-check) ; ?
435 ;; (define-key map "A" 'tpu-toggle-newline-and-indent) ; A
436 ;; (define-key map "B" 'tpu-next-buffer) ; B
437 ;; (define-key map "C" 'repeat-complex-command) ; C
438 ;; (define-key map "D" 'shell-command) ; D
439 ;; (define-key map "E" 'tpu-exit) ; E
440 ;; (define-key map "F" 'tpu-cursor-free-mode) ; F
441 ;; (define-key map "G" 'tpu-get) ; G
442 ;; (define-key map "H" nil) ; H
443 ;; (define-key map "I" 'tpu-include) ; I
444 ;; (define-key map "K" 'tpu-kill-buffer) ; K
445 (define-key map "L" 'tpu-what-line) ; L
446 ;; (define-key map "M" 'buffer-menu) ; M
447 ;; (define-key map "N" 'tpu-next-file-buffer) ; N
448 ;; (define-key map "O" 'occur) ; O
449 (define-key map "P" 'lpr-buffer) ; P
450 ;; (define-key map "Q" 'tpu-quit) ; Q
451 ;; (define-key map "R" 'tpu-toggle-rectangle) ; R
452 ;; (define-key map "S" 'replace) ; S
453 ;; (define-key map "T" 'tpu-line-to-top-of-window) ; T
454 ;; (define-key map "U" 'undo) ; U
455 ;; (define-key map "V" 'tpu-version) ; V
456 ;; (define-key map "W" 'save-buffer) ; W
457 ;; (define-key map "X" 'tpu-save-all-buffers-kill-emacs) ; X
458 ;; (define-key map "Y" 'copy-region-as-kill) ; Y
459 ;; (define-key map "Z" 'suspend-emacs) ; Z
460 (define-key map "[" 'blink-matching-open) ; [
462 (define-key map "]" 'blink-matching-open) ; ]
463 (define-key map "^" 'tpu-add-at-bol) ; ^
464 (define-key map "_" 'split-window-below) ; -
465 (define-key map "`" 'what-line) ; `
466 (define-key map "a" 'tpu-toggle-newline-and-indent) ; a
467 (define-key map "b" 'tpu-next-buffer) ; b
468 (define-key map "c" 'repeat-complex-command) ; c
469 (define-key map "d" 'shell-command) ; d
470 (define-key map "e" 'tpu-exit) ; e
471 (define-key map "f" 'tpu-cursor-free-mode) ; f
472 (define-key map "g" 'tpu-get) ; g
473 ;; (define-key map "h" nil) ; h
474 (define-key map "i" 'tpu-include) ; i
475 (define-key map "k" 'tpu-kill-buffer) ; k
476 (define-key map "l" 'goto-line) ; l
477 (define-key map "m" 'buffer-menu) ; m
478 (define-key map "n" 'tpu-next-file-buffer) ; n
479 (define-key map "o" 'occur) ; o
480 (define-key map "p" 'lpr-region) ; p
481 (define-key map "q" 'tpu-quit) ; q
482 (define-key map "r" 'tpu-toggle-rectangle) ; r
483 (define-key map "s" 'replace) ; s
484 (define-key map "t" 'tpu-line-to-top-of-window) ; t
485 (define-key map "u" 'undo) ; u
486 (define-key map "v" 'tpu-version) ; v
487 (define-key map "w" 'save-buffer) ; w
488 (define-key map "x" 'tpu-save-all-buffers-kill-emacs) ; x
489 (define-key map "y" 'copy-region-as-kill) ; y
490 (define-key map "z" 'suspend-emacs) ; z
491 ;; (define-key map "{" nil) ; {
492 (define-key map "|" 'split-window-right) ; |
493 ;; (define-key map "}" nil) ; }
494 (define-key map "~" 'exchange-point-and-mark) ; ~
496 map)
497 "Maps the function keys on the VT100 keyboard preceded by PF1.
498 GOLD is the ASCII 7-bit escape sequence <ESC>OP.")
500 (defvar tpu-global-map
501 (let ((map (make-sparse-keymap)))
503 ;; Previously defined in CSI-map. We now presume that term/*.el does
504 ;; its job to map the escape sequence to the right key-symbol.
505 (define-key map [find] 'tpu-search) ; Find
506 (define-key map [insert] 'tpu-paste) ; Insert Here
507 (define-key map [delete] 'tpu-cut) ; Remove
508 (define-key map [select] 'tpu-select) ; Select
509 (define-key map [prior] 'tpu-scroll-window-down) ; Prev Screen
510 (define-key map [next] 'tpu-scroll-window-up) ; Next Screen
512 ;; (define-key map [f1] nil) ; F1
513 ;; (define-key map [f2] nil) ; F2
514 ;; (define-key map [f3] nil) ; F3
515 ;; (define-key map [f4] nil) ; F4
516 ;; (define-key map [f5] nil) ; F5
517 ;; (define-key map [f6] nil) ; F6
518 ;; (define-key map [f7] nil) ; F7
519 ;; (define-key map [f8] nil) ; F8
520 ;; (define-key map [f9] nil) ; F9
521 (define-key map [f10] 'tpu-exit) ; F10
522 (define-key map [f11] 'tpu-insert-escape) ; F11 (ESC)
523 (define-key map [f12] 'tpu-next-beginning-of-line) ; F12 (BS)
524 (define-key map [f13] 'tpu-delete-previous-word) ; F13 (LF)
525 (define-key map [f14] 'tpu-toggle-overwrite-mode) ; F14
526 (define-key map [help] 'tpu-help) ; HELP
527 (define-key map [menu] 'execute-extended-command) ; DO
528 (define-key map [f17] 'tpu-goto-breadcrumb) ; F17
529 ;; (define-key map [f18] nil) ; F18
530 ;; (define-key map [f19] nil) ; F19
531 ;; (define-key map [f20] nil) ; F20
534 ;; Previously defined in SS3-map. We now presume that term/*.el does
535 ;; its job to map the escape sequence to the right key-symbol.
536 (define-key map [kp-f1] tpu-gold-map) ; GOLD map
537 ;;
540 (define-key map [right] 'tpu-forward-char) ; right
541 (define-key map [left] 'tpu-backward-char) ; left
543 (define-key map [kp-f2] 'tpu-help) ; PF2
544 (define-key map [kp-f3] 'tpu-search-again) ; PF3
545 (define-key map [kp-f4] 'tpu-delete-current-line) ; PF4
546 (define-key map [kp-0] 'tpu-line) ; KP0
547 (define-key map [kp-1] 'tpu-word) ; KP1
548 (define-key map [kp-2] 'tpu-end-of-line) ; KP2
549 (define-key map [kp-3] 'tpu-char) ; KP3
550 (define-key map [kp-4] 'tpu-advance-direction) ; KP4
551 (define-key map [kp-5] 'tpu-backup-direction) ; KP5
552 (define-key map [kp-6] 'tpu-cut) ; KP6
553 (define-key map [kp-7] 'tpu-page) ; KP7
554 (define-key map [kp-8] 'tpu-scroll-window) ; KP8
555 (define-key map [kp-9] 'tpu-append-region) ; KP9
556 (define-key map [kp-subtract] 'tpu-delete-current-word) ; KP-
557 (define-key map [kp-separator] 'tpu-delete-current-char) ; KP,
558 (define-key map [kp-decimal] 'tpu-select) ; KP.
559 (define-key map [kp-enter] 'newline) ; KPenter
561 map)
562 "TPU-edt global keymap.")
565 ;;;
566 ;;; Global Variables
567 ;;;
568 (defvar tpu-last-replaced-text ""
569 "Last text deleted by a TPU-edt replace command.")
570 (defvar tpu-last-deleted-region ""
571 "Last text deleted by a TPU-edt remove command.")
572 (defvar tpu-last-deleted-lines ""
573 "Last text deleted by a TPU-edt line-delete command.")
574 (defvar tpu-last-deleted-words ""
575 "Last text deleted by a TPU-edt word-delete command.")
576 (defvar tpu-last-deleted-char ""
577 "Last character deleted by a TPU-edt character-delete command.")
579 (defvar tpu-searching-forward t
580 "If non-nil, TPU-edt is searching in the forward direction.")
581 (defvar tpu-search-last-string ""
582 "Last text searched for by the TPU-edt search commands.")
583 (defvar tpu-search-overlay (make-overlay 1 1)
584 "Search highlight overlay.")
585 (overlay-put tpu-search-overlay 'face 'bold)
587 (defvar tpu-replace-overlay (make-overlay 1 1)
588 "Replace highlight overlay.")
589 (overlay-put tpu-replace-overlay 'face 'highlight)
591 (defvar tpu-regexp-p nil
592 "If non-nil, TPU-edt uses regexp search and replace routines.")
593 (defvar tpu-rectangular-p nil
594 "If non-nil, TPU-edt removes and inserts rectangles.")
595 (defvar tpu-advance t
596 "True when TPU-edt is operating in the forward direction.")
597 (defvar tpu-reverse nil
598 "True when TPU-edt is operating in the backward direction.")
599 (defvar tpu-control-keys nil
600 "If non-nil, control keys are set to perform TPU functions.")
601 (defvar tpu-xkeys-file nil
602 "File containing TPU-edt X key map.")
604 (defvar tpu-rectangle-string nil
605 "Mode line string to identify rectangular mode.")
606 (defvar tpu-direction-string nil
607 "Mode line string to identify current direction.")
609 (defvar tpu-add-at-bol-hist nil
610 "History variable for tpu-edt-add-at-bol function.")
611 (defvar tpu-add-at-eol-hist nil
612 "History variable for tpu-edt-add-at-eol function.")
613 (defvar tpu-regexp-prompt-hist nil
614 "History variable for search and replace functions.")
617 ;;;
618 ;;; Buffer Local Variables
619 ;;;
620 (defvar tpu-newline-and-indent-p nil
621 "If non-nil, Return produces a newline and indents.")
622 (make-variable-buffer-local 'tpu-newline-and-indent-p)
624 (defvar tpu-newline-and-indent-string nil
625 "Mode line string to identify AutoIndent mode.")
626 (make-variable-buffer-local 'tpu-newline-and-indent-string)
628 (defvar tpu-saved-delete-func nil
629 "Saved value of the delete key.")
630 (make-variable-buffer-local 'tpu-saved-delete-func)
632 (defvar tpu-buffer-local-map nil
633 "TPU-edt buffer local key map.")
634 (make-variable-buffer-local 'tpu-buffer-local-map)
637 ;;;
638 ;;; Mode Line - Modify the mode line to show the following
639 ;;;
640 ;;; o Mark state.
641 ;;; o Direction of motion.
642 ;;; o Active rectangle mode.
643 ;;; o Active auto indent mode.
644 ;;;
645 (defvar tpu-original-mm-alist minor-mode-alist)
647 (defvar tpu-mark-flag "")
648 (make-variable-buffer-local 'tpu-mark-flag)
650 (defun tpu-set-mode-line (for-tpu)
651 "Set ``minor-mode-alist'' for TPU-edt, or reset it to default Emacs."
652 (let ((entries '((tpu-newline-and-indent-p tpu-newline-and-indent-string)
653 (tpu-rectangular-p tpu-rectangle-string)
654 (tpu-direction-string tpu-direction-string)
655 (tpu-mark-flag tpu-mark-flag))))
656 (dolist (entry entries)
657 (if for-tpu
658 (add-to-list 'minor-mode-alist entry)
659 (setq minor-mode-alist (remove entry minor-mode-alist))))))
661 (defun tpu-update-mode-line nil
662 "Make sure mode-line in the current buffer reflects all changes."
663 (setq tpu-mark-flag (if transient-mark-mode "" (if (tpu-mark) " @" " ")))
664 (force-mode-line-update))
666 (cond ((featurep 'xemacs)
667 (add-hook 'zmacs-deactivate-region-hook 'tpu-update-mode-line)
668 (add-hook 'zmacs-activate-region-hook 'tpu-update-mode-line))
669 (t
670 (add-hook 'activate-mark-hook 'tpu-update-mode-line)
671 (add-hook 'deactivate-mark-hook 'tpu-update-mode-line)))
674 ;;;
675 ;;; Match Markers -
676 ;;;
677 ;;; Set in: Search
678 ;;;
679 ;;; Used in: Replace, Substitute, Store-Text, Cut/Remove,
680 ;;; Append, and Change-Case
681 ;;;
682 (defvar tpu-match-beginning-mark (make-marker))
683 (defvar tpu-match-end-mark (make-marker))
685 (defun tpu-set-match nil
686 "Set markers at match beginning and end."
687 ;; Add one to beginning mark so it stays with the first character of
688 ;; the string even if characters are added just before the string.
689 (setq tpu-match-beginning-mark (copy-marker (match-beginning 0) t))
690 (setq tpu-match-end-mark (copy-marker (match-end 0))))
692 (defun tpu-unset-match nil
693 "Unset match beginning and end markers."
694 (set-marker tpu-match-beginning-mark nil)
695 (set-marker tpu-match-end-mark nil))
697 (defun tpu-match-beginning nil
698 "Return the location of the last match beginning."
699 (marker-position tpu-match-beginning-mark))
701 (defun tpu-match-end nil
702 "Return the location of the last match end."
703 (marker-position tpu-match-end-mark))
705 (defun tpu-check-match nil
706 "Return t if point is between tpu-match markers.
707 Otherwise sets the tpu-match markers to nil and returns nil."
708 ;; make sure 1- marker is in this buffer
709 ;; 2- point is at or after beginning marker
710 ;; 3- point is before ending marker, or in the case of
711 ;; zero length regions (like bol, or eol) that the
712 ;; beginning, end, and point are equal.
713 (cond ((and
714 (equal (marker-buffer tpu-match-beginning-mark) (current-buffer))
715 (>= (point) (marker-position tpu-match-beginning-mark))
716 (or
717 (< (point) (marker-position tpu-match-end-mark))
718 (and (= (marker-position tpu-match-beginning-mark)
719 (marker-position tpu-match-end-mark))
720 (= (marker-position tpu-match-end-mark) (point))))) t)
721 (t
722 (tpu-unset-match) nil)))
724 (defun tpu-show-match-markers nil
725 "Show the values of the match markers."
726 (interactive)
727 (if (markerp tpu-match-beginning-mark)
728 (message "(%s, %s) in %s -- current %s in %s"
729 (marker-position tpu-match-beginning-mark)
730 (marker-position tpu-match-end-mark)
731 (marker-buffer tpu-match-end-mark)
732 (point) (current-buffer))))
735 ;;;
736 ;;; Utilities
737 ;;;
739 (defun tpu-mark nil
740 "TPU-edt version of the mark function.
741 Return the appropriate value of the mark for the current
742 version of Emacs."
743 (cond ((featurep 'xemacs) (mark (not zmacs-regions)))
744 (t (and mark-active (mark (not transient-mark-mode))))))
746 (defun tpu-set-mark (pos)
747 "TPU-edt version of the `set-mark' function.
748 Sets the mark at POS and activates the region according to the
749 current version of Emacs."
750 (set-mark pos)
751 (when (featurep 'xemacs) (when pos (zmacs-activate-region))))
753 (defun tpu-string-prompt (prompt history-symbol)
754 "Read a string with PROMPT."
755 (read-from-minibuffer prompt nil nil nil history-symbol))
757 (defvar tpu-last-answer nil "Most recent response to tpu-y-or-n-p.")
759 (defun tpu-y-or-n-p (prompt &optional not-yes)
760 "Prompt for a y or n answer with positive default.
761 Optional second argument NOT-YES changes default to negative.
762 Like Emacs `y-or-n-p', but also accepts space as y and DEL as n."
763 (message "%s[%s]" prompt (if not-yes "n" "y"))
764 (let ((doit t))
765 (while doit
766 (setq doit nil)
767 (let ((ans (read-char)))
768 (cond ((or (= ans ?y) (= ans ?Y) (= ans ?\ ))
769 (setq tpu-last-answer t))
770 ((or (= ans ?n) (= ans ?N) (= ans ?\C-?))
771 (setq tpu-last-answer nil))
773 (t
774 (setq doit t) (beep)
775 (message "Please answer y or n. %s[%s]"
776 prompt (if not-yes "n" "y")))))))
777 tpu-last-answer)
779 (defun tpu-local-set-key (key func)
780 "Replace a key in the TPU-edt local key map.
781 Create the key map if necessary."
782 (cond ((not (keymapp tpu-buffer-local-map))
783 (setq tpu-buffer-local-map (if (current-local-map)
784 (copy-keymap (current-local-map))
785 (make-sparse-keymap)))
786 (use-local-map tpu-buffer-local-map)))
787 (local-set-key key func))
789 (defun tpu-current-line ()
790 "Return the vertical position of point in the selected window.
791 Top line is 0. Counts each text line only once, even if it wraps."
792 (or
793 (cdr (nth 6 (posn-at-point)))
794 (if (eq (window-start) (point)) 0
795 (1- (count-screen-lines (window-start) (point) 'count-final-newline)))))
798 ;;;
799 ;;; Breadcrumbs
800 ;;;
801 (defvar tpu-breadcrumb-plist nil
802 "The set of user-defined markers (breadcrumbs), as a plist.")
804 (defun tpu-drop-breadcrumb (num)
805 "Drops a breadcrumb that can be returned to later with goto-breadcrumb."
806 (interactive "p")
807 (put tpu-breadcrumb-plist num (list (current-buffer) (point)))
808 (message "Mark %d set." num))
810 (defun tpu-goto-breadcrumb (num)
811 "Return to a breadcrumb set with drop-breadcrumb."
812 (interactive "p")
813 (cond ((get tpu-breadcrumb-plist num)
814 (switch-to-buffer (car (get tpu-breadcrumb-plist num)))
815 (goto-char (cadr (get tpu-breadcrumb-plist num)))
816 (message "mark %d found." num))
817 (t
818 (message "mark %d not found." num))))
821 ;;;
822 ;;; Miscellaneous
823 ;;;
824 (defun tpu-change-case (num)
825 "Change the case of the character under the cursor or region.
826 Accepts a prefix argument of the number of characters to invert."
827 (interactive "p")
828 (cond ((tpu-mark)
829 (let ((beg (region-beginning)) (end (region-end)))
830 (while (> end beg)
831 (funcall (if (= (downcase (char-after beg)) (char-after beg))
832 'upcase-region 'downcase-region)
833 beg (1+ beg))
834 (setq beg (1+ beg)))
835 (tpu-unselect t)))
836 ((tpu-check-match)
837 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
838 (while (> end beg)
839 (funcall (if (= (downcase (char-after beg)) (char-after beg))
840 'upcase-region 'downcase-region)
841 beg (1+ beg))
842 (setq beg (1+ beg)))
843 (tpu-unset-match)))
844 (t
845 (while (> num 0)
846 (funcall (if (= (downcase (following-char)) (following-char))
847 'upcase-region 'downcase-region)
848 (point) (1+ (point)))
849 (forward-char (if tpu-reverse -1 1))
850 (setq num (1- num))))))
852 (defun tpu-fill (num)
853 "Fill paragraph or marked region.
854 With argument, fill and justify."
855 (interactive "P")
856 (cond ((tpu-mark)
857 (fill-region (point) (tpu-mark) num)
858 (tpu-unselect t))
859 (t
860 (fill-paragraph num))))
862 (defun tpu-version nil
863 "Print the TPU-edt version number."
864 (interactive)
865 (message
866 "TPU-edt version %s by Rob Riepel (riepel@networking.stanford.edu)"
867 tpu-version))
869 (defun tpu-reset-screen-size (height width)
870 "Set the screen size."
872 (set-frame-height (selected-frame) height)
873 (set-frame-width (selected-frame) width))
875 (defun tpu-toggle-newline-and-indent nil
876 "Toggle between 'newline and indent' and 'simple newline'."
877 (interactive)
878 (cond (tpu-newline-and-indent-p
879 (setq tpu-newline-and-indent-string "")
880 (setq tpu-newline-and-indent-p nil)
881 (tpu-local-set-key "\C-m" 'newline))
882 (t
883 (setq tpu-newline-and-indent-string " AutoIndent")
884 (setq tpu-newline-and-indent-p t)
885 (tpu-local-set-key "\C-m" 'newline-and-indent)))
886 (tpu-update-mode-line)
887 (and (called-interactively-p 'interactive)
888 (message "Carriage return inserts a newline%s"
889 (if tpu-newline-and-indent-p " and indents." "."))))
891 (defun tpu-spell-check nil
892 "Check the spelling of the region, or of the entire buffer,
893 if no region is selected."
894 (interactive)
895 (let ((m (tpu-mark)))
896 (apply (if tpu-have-ispell 'ispell-region
897 'spell-region)
898 (if m
899 (if (> m (point)) (list (point) m)
900 (list m (point)))
901 (list (point-min) (point-max))))
902 (if m (tpu-unselect t))))
904 (defun tpu-toggle-overwrite-mode nil
905 "Switch in and out of overwrite mode."
906 (interactive)
907 (cond (overwrite-mode
909 (overwrite-mode 0))
910 (t
913 (overwrite-mode 1))))
915 (defun tpu-special-insert (num)
916 "Insert a character or control code according to its ASCII decimal value."
917 (interactive "P")
918 (if overwrite-mode (delete-char 1))
919 (insert (or num 0)))
921 (defun tpu-quoted-insert (num)
922 "Read next input character and insert it.
923 This is useful for inserting control characters."
924 (interactive "*p")
925 (let ((char (read-char)) )
926 (if overwrite-mode (delete-char num))
927 (insert-char char num)))
930 ;;;
931 ;;; TPU line-mode commands
932 ;;;
933 (defun tpu-include (file)
934 "TPU-like include file."
935 (interactive "fInclude file: ")
936 (insert-file-contents file)
937 (message ""))
939 (defun tpu-get (file)
940 "TPU-like get file."
941 (interactive "FFile to get: ")
942 (find-file file find-file-wildcards))
944 (defun tpu-what-line nil
945 "Tell what line the point is on,
946 and the total number of lines in the buffer."
947 (interactive)
948 (if (eobp)
949 (message "You are at the End of Buffer. The last line is %d."
950 (count-lines 1 (point-max)))
951 (let* ((cur (count-lines 1 (1+ (point))))
952 (max (count-lines 1 (point-max)))
953 (pct (/ (* 100 (+ cur (/ max 200))) max)))
954 (message "You are on line %d out of %d (%d%%)." cur max pct))))
956 (defun tpu-exit nil
957 "Exit the way TPU does, save current buffer and ask about others."
958 (interactive)
959 (if (not (eq (recursion-depth) 0))
960 (exit-recursive-edit)
961 (progn (save-buffer) (save-buffers-kill-emacs))))
963 (defun tpu-quit nil
964 "Quit the way TPU does, ask to make sure changes should be abandoned."
965 (interactive)
966 (let ((list (buffer-list))
967 (working t))
968 (while (and list working)
969 (let ((buffer (car list)))
970 (if (and (buffer-file-name buffer) (buffer-modified-p buffer))
971 (if (tpu-y-or-n-p
972 "Modifications will not be saved, continue quitting? ")
973 (kill-emacs t) (setq working nil)))
974 (setq list (cdr list))))
975 (if working (kill-emacs t))))
978 ;;;
979 ;;; Command and Function Aliases
980 ;;;
981 ;;;###autoload
982 (define-minor-mode tpu-edt-mode
983 "Toggle TPU/edt emulation on or off.
984 With a prefix argument ARG, enable the mode if ARG is positive,
985 and disable it otherwise. If called from Lisp, enable the mode
986 if ARG is omitted or nil."
987 :global t :group 'tpu
988 (if tpu-edt-mode (tpu-edt-on) (tpu-edt-off)))
990 (defalias 'TPU-EDT-MODE 'tpu-edt-mode)
992 ;;;###autoload
993 (defalias 'tpu-edt 'tpu-edt-on)
994 (defalias 'TPU-EDT 'tpu-edt-on)
996 ;; Note: The following functions have no `tpu-' prefix. This is unavoidable.
997 ;; The real TPU/edt editor has interactive commands with these names,
998 ;; so tpu-edt.el users expect things like M-x exit RET and M-x help RET
999 ;; to work. Therefore it really is necessary to define these functions,
1000 ;; even in cases where they redefine existing Emacs functions.
1002 (defalias 'exit 'tpu-exit)
1003 (defalias 'EXIT 'tpu-exit)
1005 (defalias 'Get 'tpu-get)
1006 (defalias 'GET 'tpu-get)
1008 (defalias 'include 'tpu-include)
1009 (defalias 'INCLUDE 'tpu-include)
1011 (defalias 'quit 'tpu-quit)
1012 (defalias 'QUIT 'tpu-quit)
1014 (defalias 'spell 'tpu-spell-check)
1015 (defalias 'SPELL 'tpu-spell-check)
1017 (defalias 'what\ line 'tpu-what-line)
1018 (defalias 'WHAT\ LINE 'tpu-what-line)
1020 (defalias 'replace 'tpu-lm-replace)
1021 (defalias 'REPLACE 'tpu-lm-replace)
1023 (defalias 'help 'tpu-help)
1024 (defalias 'HELP 'tpu-help)
1026 (defalias 'set\ cursor\ free 'tpu-set-cursor-free)
1027 (defalias 'SET\ CURSOR\ FREE 'tpu-set-cursor-free)
1029 (defalias 'set\ cursor\ bound 'tpu-set-cursor-bound)
1030 (defalias 'SET\ CURSOR\ BOUND 'tpu-set-cursor-bound)
1032 (defalias 'set\ scroll\ margins 'tpu-set-scroll-margins)
1033 (defalias 'SET\ SCROLL\ MARGINS 'tpu-set-scroll-margins)
1035 ;; Real TPU error messages end in periods.
1036 ;; Define this to avoid openly flouting Emacs coding standards.
1037 (defalias 'tpu-error 'error)
1040 ;;;
1041 ;;; Help
1042 ;;;
1044 _______________________ _______________________________
1045 | HELP | Do | | | | | |
1046 |KeyDefs| | | | | | |
1047 |_______|_______________| |_______|_______|_______|_______|
1048 _______________________ _______________________________
1049 | Find |Insert |Remove | | Gold | HELP |FndNxt | Del L |
1050 | | |Sto Tex| | key |E-Help | Find |Undel L|
1051 |_______|_______|_______| |_______|_______|_______|_______|
1052 |Select |Pre Scr|Nex Scr| | Page | Sect |Append | Del W |
1053 | Reset |Pre Win|Nex Win| | Do | Fill |Replace|Undel W|
1054 |_______|_______|_______| |_______|_______|_______|_______|
1055 |Move up| |Forward|Reverse|Remove | Del C |
1056 | Top | |Bottom | Top |Insert |Undel C|
1057 _______|_______|_______ |_______|_______|_______|_______|
1058 |Mov Lef|Mov Dow|Mov Rig| | Word | EOL | Char | |
1059 |StaOfLi|Bottom |EndOfLi| |ChngCas|Del EOL|SpecIns| Enter |
1060 |_______|_______|_______| |_______|_______|_______| |
1061 | Line |Select | Subs |
1062 | Open Line | Reset | |
1063 |_______________|_______|_______|
1064 ")
1066 (defvar tpu-help-text "
1067 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1069 Control Characters
1071 ^A toggle insert and overwrite
1072 ^B recall
1073 ^E end of line
1075 ^G Cancel current operation
1076 ^H beginning of line
1077 ^J delete previous word
1079 ^K learn
1080 ^L insert page break
1081 ^R remember (during learn), re-center
1083 ^U delete to beginning of line
1084 ^V quote
1085 ^W refresh
1087 ^Z exit
1088 ^X^X exchange point and mark - useful for checking region boundaries
1090 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1091 Gold-<key> Functions
1093 B Next Buffer - display the next buffer (all buffers)
1094 C Recall - edit and possibly repeat previous commands
1095 E Exit - save current buffer and ask about others
1096 G Get - load a file into a new edit buffer
1098 I Include - include a file in this buffer
1099 K Kill Buffer - abandon edits and delete buffer
1100 M Buffer Menu - display a list of all buffers
1101 N Next File Buffer - display next buffer containing a file
1103 O Occur - show following lines containing REGEXP
1104 Q Quit - exit without saving anything
1105 R Toggle rectangular mode for remove and insert
1106 S Search and substitute - line mode REPLACE command
1108 ^T Toggle control key bindings between TPU and Emacs
1109 U Undo - undo the last edit
1110 W Write - save current buffer
1111 X Exit - save all modified buffers and exit
1113 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1115 More extensive documentation on TPU-edt can be found in the `Commentary'
1116 section of tpu-edt.el. This section can be accessed through the standard
1117 Emacs help facility using the `p' option. Once you exit TPU-edt Help, one
1118 of the following key sequences is sure to get you there.
1120 ^h p if you're not yet using TPU-edt
1121 Gold-PF2 p if you're using TPU-edt
1123 Alternatively, fire up Emacs help from the command prompt, with
1125 M-x help-for-help <CR> p <CR>
1127 Where `M-x' might be any of `Gold-KP7', 'Do', or 'ESC-x'.
1129 When you successfully invoke this part of the Emacs help facility, you
1130 will see a buffer named `*Finder*' listing a number of topics. Look for
1131 tpu-edt under `emulations'.
1133 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1135 *** No more help, use P to view previous screen")
1137 (defvar tpu-help-enter (format "%s" "\eOM")) ; tpu-help enter key symbol
1139 (defvar tpu-help-N "N") ; tpu-help "N" symbol
1140 (defvar tpu-help-n "n") ; tpu-help "n" symbol
1141 (defvar tpu-help-P "P") ; tpu-help "P" symbol
1142 (defvar tpu-help-p "p") ; tpu-help "p" symbol
1144 (defun tpu-help nil
1145 "Display TPU-edt help."
1146 (interactive)
1147 ;; Save current window configuration
1148 (save-window-excursion
1149 ;; Create and fill help buffer if necessary
1150 (if (not (get-buffer "*TPU-edt Help*"))
1151 (progn (generate-new-buffer "*TPU-edt Help*")
1152 (switch-to-buffer "*TPU-edt Help*")
1153 (insert tpu-help-keypad-map)
1154 (insert tpu-help-text)
1155 (setq buffer-read-only t)))
1157 ;; Display the help buffer
1158 (switch-to-buffer "*TPU-edt Help*")
1159 (delete-other-windows)
1160 (tpu-move-to-beginning)
1161 (forward-line 1)
1162 (tpu-line-to-top-of-window)
1164 ;; Prompt for keys to describe, based on screen state (split/not split)
1165 (let ((key nil) (fkey nil) (split nil))
1166 (while (not (equal tpu-help-return fkey))
1167 (if split
1168 (setq key
1169 (read-key-sequence
1170 "Press the key you want help on (RET=exit, ENTER=redisplay, N=next, P=prev): "))
1171 (setq key
1172 (read-key-sequence
1173 "Press the key you want help on (RET to exit, N next screen, P prev screen): ")))
1175 ;; Process the read key
1176 ;;
1177 ;; ENTER - Display just the help window
1178 ;; N or n - Next help or describe-key screen
1179 ;; P or p - Previous help or describe-key screen
1180 ;; RETURN - Exit from TPU-help
1181 ;; default - describe the key
1182 ;;
1183 (setq fkey (format "%s" key))
1184 (cond ((equal tpu-help-enter fkey)
1185 (setq split nil)
1186 (delete-other-windows))
1187 ((or (equal tpu-help-N fkey) (equal tpu-help-n fkey))
1188 (cond (split
1189 (condition-case nil
1190 (scroll-other-window 8)
1191 (error nil)))
1192 (t
1193 (forward-page)
1194 (forward-line 1)
1195 (tpu-line-to-top-of-window))))
1196 ((or (equal tpu-help-P fkey) (equal tpu-help-p fkey))
1197 (cond (split
1198 (condition-case nil
1199 (scroll-other-window -8)
1200 (error nil)))
1201 (t
1202 (forward-line -1)
1203 (backward-page)
1204 (forward-line 1)
1205 (tpu-line-to-top-of-window))))
1206 ((not (equal tpu-help-return fkey))
1207 (setq split t)
1208 (describe-key key)
1209 ;; If the key is undefined, leave the
1210 ;; message in the mini-buffer for 3 seconds
1211 (if (not (key-binding key)) (sit-for 3))))))))
1214 ;;;
1215 ;;; Auto-insert
1216 ;;;
1217 (defun tpu-insert-escape nil
1218 "Insert an escape character, and so becomes the escape-key alias."
1219 (interactive)
1220 (insert "\e"))
1222 (defun tpu-insert-formfeed nil
1223 "Insert a formfeed character."
1224 (interactive)
1225 (insert "\C-L"))
1228 ;;;
1229 ;;; Define key
1230 ;;;
1231 (defvar tpu-saved-control-r nil "Saved value of Control-r.")
1233 (defun tpu-end-define-macro-key (key)
1234 "End the current macro definition."
1235 (interactive "kPress the key you want to use to do what was just learned: ")
1236 (end-kbd-macro nil)
1237 (global-set-key key last-kbd-macro)
1238 (global-set-key "\C-r" tpu-saved-control-r))
1240 (defun tpu-define-macro-key nil
1241 "Bind a set of keystrokes to a single key, or key combination."
1242 (interactive)
1243 (setq tpu-saved-control-r (global-key-binding "\C-r"))
1244 (global-set-key "\C-r" 'tpu-end-define-macro-key)
1245 (start-kbd-macro nil))
1248 ;;;
1249 ;;; Buffers and Windows
1250 ;;;
1251 (defun tpu-kill-buffer nil
1252 "Kill the current buffer.
1253 If `tpu-kill-buffers-silently' is non-nil,
1254 kill modified buffers without asking."
1255 (interactive)
1256 (if tpu-kill-buffers-silently (set-buffer-modified-p nil))
1257 (kill-buffer (current-buffer)))
1259 (defun tpu-save-all-buffers-kill-emacs nil
1260 "Save all buffers and exit Emacs."
1261 (interactive)
1262 (let ((delete-old-versions t))
1263 (save-buffers-kill-emacs t)))
1265 (defun tpu-write-current-buffers nil
1266 "Save all modified buffers without exiting."
1267 (interactive)
1268 (save-some-buffers t))
1270 (defun tpu-next-buffer nil
1271 "Go to next buffer in ring."
1272 (interactive)
1273 (switch-to-buffer (car (reverse (buffer-list)))))
1275 (defun tpu-next-file-buffer nil
1276 "Go to next buffer in ring that is visiting a file or directory."
1277 (interactive)
1278 (let ((list (tpu-make-file-buffer-list (buffer-list))))
1279 (setq list (delq (current-buffer) list))
1280 (if (not list) (tpu-error "No other buffers."))
1281 (switch-to-buffer (car (reverse list)))))
1283 (defun tpu-make-file-buffer-list (buffer-list)
1284 "Return names from BUFFER-LIST excluding those beginning with a space or star."
1285 (delq nil (mapcar (lambda (b)
1286 (if (or (= (aref (buffer-name b) 0) ?\s)
1287 (= (aref (buffer-name b) 0) ?*)) nil b))
1288 buffer-list)))
1290 (defun tpu-next-window nil
1291 "Move to the next window."
1292 (interactive)
1293 (if (one-window-p) (message "There is only one window on screen.")
1294 (other-window 1)))
1296 (defun tpu-previous-window nil
1297 "Move to the previous window."
1298 (interactive)
1299 (if (one-window-p) (message "There is only one window on screen.")
1300 (select-window (previous-window))))
1303 ;;;
1304 ;;; Search
1305 ;;;
1306 (defun tpu-toggle-regexp nil
1307 "Switch in and out of regular expression search and replace mode."
1308 (interactive)
1309 (setq tpu-regexp-p (not tpu-regexp-p))
1310 (tpu-set-search)
1311 (and (called-interactively-p 'interactive)
1312 (message "Regular expression search and substitute %sabled."
1313 (if tpu-regexp-p "en" "dis"))))
1315 (defun tpu-regexp-prompt (prompt)
1316 "Read a string, adding 'RE' to the prompt if tpu-regexp-p is set."
1317 (let ((re-prompt (concat (if tpu-regexp-p "RE ") prompt)))
1318 (read-from-minibuffer re-prompt nil nil nil 'tpu-regexp-prompt-hist)))
1320 (defun tpu-search-highlight nil
1321 (if (tpu-check-match)
1322 (move-overlay tpu-search-overlay
1323 (tpu-match-beginning) (tpu-match-end) (current-buffer))
1324 (unless (equal (overlay-start tpu-search-overlay)
1325 (overlay-end tpu-search-overlay))
1326 (move-overlay tpu-search-overlay 1 1 (current-buffer)))))
1328 (defun tpu-search nil
1329 "Search for a string or regular expression.
1330 The search is performed in the current direction."
1331 (interactive)
1332 (tpu-set-search)
1333 (tpu-search-internal ""))
1335 (defun tpu-search-forward nil
1336 "Search for a string or regular expression.
1337 The search is begins in the forward direction."
1338 (interactive)
1339 (setq tpu-searching-forward t)
1340 (tpu-set-search t)
1341 (tpu-search-internal ""))
1343 (defun tpu-search-reverse nil
1344 "Search for a string or regular expression.
1345 The search is begins in the reverse direction."
1346 (interactive)
1347 (setq tpu-searching-forward nil)
1348 (tpu-set-search t)
1349 (tpu-search-internal ""))
1351 (defun tpu-search-again nil
1352 "Search for the same string or regular expression as last time.
1353 The search is performed in the current direction."
1354 (interactive)
1355 (tpu-search-internal tpu-search-last-string))
1357 ;; tpu-set-search defines the search functions used by the TPU-edt internal
1358 ;; search function. It should be called whenever the direction changes, or
1359 ;; the regular expression mode is turned on or off. It can also be called
1360 ;; to ensure that the next search will be in the current direction. It is
1361 ;; called from:
1363 ;; tpu-advance tpu-backup
1364 ;; tpu-toggle-regexp tpu-toggle-search-direction (t)
1365 ;; tpu-search tpu-lm-replace
1366 ;; tpu-search-forward (t) tpu-search-reverse (t)
1367 ;; tpu-search-forward-exit (t) tpu-search-backward-exit (t)
1369 (declare-function tpu-emacs-search "tpu-edt")
1370 (declare-function tpu-emacs-rev-search "tpu-edt")
1372 (defun tpu-set-search (&optional arg)
1373 "Set the search functions and set the search direction to the current direction.
1374 If an argument is specified, don't set the search direction."
1375 (if (not arg) (setq tpu-searching-forward tpu-advance))
1376 (cond (tpu-searching-forward
1377 (cond (tpu-regexp-p
1378 (fset 'tpu-emacs-search 're-search-forward)
1379 (fset 'tpu-emacs-rev-search 're-search-backward))
1380 (t
1381 (fset 'tpu-emacs-search 'search-forward)
1382 (fset 'tpu-emacs-rev-search 'search-backward))))
1383 (t
1384 (cond (tpu-regexp-p
1385 (fset 'tpu-emacs-search 're-search-backward)
1386 (fset 'tpu-emacs-rev-search 're-search-forward))
1387 (t
1388 (fset 'tpu-emacs-search 'search-backward)
1389 (fset 'tpu-emacs-rev-search 'search-forward))))))
1391 (defun tpu-search-internal (pat &optional quiet)
1392 "Search for a string or regular expression."
1393 (setq tpu-search-last-string
1394 (if (not (string= "" pat)) pat (tpu-regexp-prompt "Search: ")))
1396 (tpu-unset-match)
1397 (tpu-adjust-search)
1399 (let ((case-fold-search
1400 (and case-fold-search (tpu-check-search-case tpu-search-last-string))))
1402 (cond ((tpu-emacs-search tpu-search-last-string nil t)
1403 (tpu-set-match) (goto-char (tpu-match-beginning)))
1405 (t
1406 (tpu-adjust-search t)
1407 (let ((found nil) (pos nil))
1408 (save-excursion
1409 (let ((tpu-searching-forward (not tpu-searching-forward)))
1410 (tpu-adjust-search)
1411 (setq found (tpu-emacs-rev-search tpu-search-last-string nil t))
1412 (setq pos (match-beginning 0))))
1414 (cond
1415 (found
1416 (cond ((tpu-y-or-n-p
1417 (format "Found in %s direction. Go there? "
1418 (if tpu-searching-forward "reverse" "forward")))
1419 (goto-char pos) (tpu-set-match)
1420 (tpu-toggle-search-direction))))
1422 (t
1423 (if (not quiet)
1424 (message
1426 (if tpu-regexp-p "RE " "") tpu-search-last-string)))))))))
1428 (defalias 'tpu-search-internal-core (symbol-function 'tpu-search-internal))
1430 (defun tpu-check-search-case (string)
1431 "Return t if string contains upper case."
1432 ;; if using regexp, eliminate upper case forms (\B \W \S.)
1433 (if tpu-regexp-p
1434 (let ((pat (copy-sequence string)) (case-fold-search nil) (pos 0))
1439 (aset pat (+ 1 pos) ?.) (aset pat (+ 2 pos) ?.))
1440 (string-equal pat (downcase pat)))
1441 (string-equal string (downcase string))))
1443 (defun tpu-adjust-search (&optional arg)
1444 "For forward searches, move forward a character before searching,
1445 and backward a character after a failed search. Arg means end of search."
1446 (if tpu-searching-forward
1447 (cond (arg (if (not (bobp)) (forward-char -1)))
1448 (t (if (not (eobp)) (forward-char 1))))))
1450 (defun tpu-toggle-search-direction nil
1451 "Toggle the TPU-edt search direction.
1452 Used for reversing a search in progress."
1453 (interactive)
1454 (setq tpu-searching-forward (not tpu-searching-forward))
1455 (tpu-set-search t)
1456 (and (called-interactively-p 'interactive)
1457 (message "Searching %sward."
1458 (if tpu-searching-forward "for" "back"))))
1460 (defun tpu-search-forward-exit nil
1461 "Set search direction forward and exit minibuffer."
1462 (interactive)
1463 (setq tpu-searching-forward t)
1464 (tpu-set-search t)
1465 (exit-minibuffer))
1467 (defun tpu-search-backward-exit nil
1468 "Set search direction backward and exit minibuffer."
1469 (interactive)
1470 (setq tpu-searching-forward nil)
1471 (tpu-set-search t)
1472 (exit-minibuffer))
1475 ;;;
1476 ;;; Select / Unselect
1477 ;;;
1478 (defun tpu-select (&optional quiet)
1479 "Set the mark to define one end of a region."
1480 (interactive "P")
1481 (cond ((tpu-mark)
1482 (tpu-unselect quiet))
1483 (t
1484 (tpu-set-mark (point))
1485 (tpu-update-mode-line)
1486 (if (not quiet) (message "Move the text cursor to select text.")))))
1488 (defun tpu-unselect (&optional quiet)
1489 "Remove the mark to unselect the current region."
1490 (interactive "P")
1491 (deactivate-mark)
1492 (setq mark-ring nil)
1493 (tpu-set-mark nil)
1494 (tpu-update-mode-line)
1495 (if (not quiet) (message "Selection canceled.")))
1498 ;;;
1499 ;;; Delete / Cut
1500 ;;;
1501 (defun tpu-toggle-rectangle nil
1502 "Toggle rectangular mode for remove and insert."
1503 (interactive)
1504 (setq tpu-rectangular-p (not tpu-rectangular-p))
1505 (setq tpu-rectangle-string (if tpu-rectangular-p " Rect" ""))
1506 (tpu-update-mode-line)
1507 (and (called-interactively-p 'interactive)
1508 (message "Rectangular cut and paste %sabled."
1509 (if tpu-rectangular-p "en" "dis"))))
1511 (defun tpu-arrange-rectangle nil
1512 "Adjust point and mark to upper left and lower right corners of a rectangle."
1513 (let ((mc (current-column))
1514 (pc (progn (exchange-point-and-mark) (current-column))))
1516 (cond ((> (point) (tpu-mark)) ; point on lower line
1517 (cond ((> pc mc) ; point @ lower-right
1518 (exchange-point-and-mark)) ; point -> upper-left
1520 (t ; point @ lower-left
1521 (move-to-column mc t) ; point -> lower-right
1522 (exchange-point-and-mark) ; point -> upper-right
1523 (move-to-column pc t)))) ; point -> upper-left
1525 (t ; point on upper line
1526 (cond ((> pc mc) ; point @ upper-right
1527 (move-to-column mc t) ; point -> upper-left
1528 (exchange-point-and-mark) ; point -> lower-left
1529 (move-to-column pc t) ; point -> lower-right
1530 (exchange-point-and-mark))))))) ; point -> upper-left
1532 (defun tpu-cut-text nil
1533 "Delete the selected region.
1534 The text is saved for the tpu-paste command."
1535 (interactive)
1536 (cond ((tpu-mark)
1537 (cond (tpu-rectangular-p
1538 (tpu-arrange-rectangle)
1539 (picture-clear-rectangle (point) (tpu-mark) (not overwrite-mode))
1540 (tpu-unselect t))
1541 (t
1542 (setq tpu-last-deleted-region
1543 (buffer-substring (tpu-mark) (point)))
1544 (delete-region (tpu-mark) (point))
1545 (tpu-unselect t))))
1546 ((tpu-check-match)
1547 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1548 (setq tpu-last-deleted-region (buffer-substring beg end))
1549 (delete-region beg end)
1550 (tpu-unset-match)))
1551 (t
1552 (tpu-error "No selection active."))))
1554 (defun tpu-store-text nil
1555 "Copy the selected region to the cut buffer without deleting it.
1556 The text is saved for the tpu-paste command."
1557 (interactive)
1558 (cond ((tpu-mark)
1559 (cond (tpu-rectangular-p
1560 (save-excursion
1561 (tpu-arrange-rectangle)
1562 (setq picture-killed-rectangle
1563 (extract-rectangle (point) (tpu-mark))))
1564 (tpu-unselect t))
1565 (t
1566 (setq tpu-last-deleted-region
1567 (buffer-substring (tpu-mark) (point)))
1568 (tpu-unselect t))))
1569 ((tpu-check-match)
1570 (setq tpu-last-deleted-region
1571 (buffer-substring (tpu-match-beginning) (tpu-match-end)))
1572 (tpu-unset-match))
1573 (t
1574 (tpu-error "No selection active."))))
1576 (defun tpu-cut (arg)
1577 "Copy selected region to the cut buffer.
1578 In the absence of an argument, delete the selected region too."
1579 (interactive "P")
1580 (if arg (tpu-store-text) (tpu-cut-text)))
1582 (defun tpu-append-region (arg)
1583 "Append selected region to the tpu-cut buffer.
1584 In the absence of an argument, delete the selected region too."
1585 (interactive "P")
1586 (cond ((tpu-mark)
1587 (let ((beg (region-beginning)) (end (region-end)))
1588 (setq tpu-last-deleted-region
1589 (concat tpu-last-deleted-region
1590 (buffer-substring beg end)))
1591 (if (not arg) (delete-region beg end))
1592 (tpu-unselect t)))
1593 ((tpu-check-match)
1594 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1595 (setq tpu-last-deleted-region
1596 (concat tpu-last-deleted-region
1597 (buffer-substring beg end)))
1598 (if (not arg) (delete-region beg end))
1599 (tpu-unset-match)))
1600 (t
1601 (tpu-error "No selection active."))))
1603 (defun tpu-delete-current-line (num)
1604 "Delete one or specified number of lines after point.
1605 This includes the newline character at the end of each line.
1606 They are saved for the TPU-edt undelete-lines command."
1607 (interactive "p")
1608 (let ((beg (point)))
1609 (forward-line num)
1612 (setq tpu-last-deleted-lines
1613 (buffer-substring beg (point)))
1614 (delete-region beg (point))))
1616 (defun tpu-delete-to-eol (num)
1617 "Delete text up to end of line.
1618 With argument, delete up to the Nth line-end past point.
1619 They are saved for the TPU-edt undelete-lines command."
1620 (interactive "p")
1621 (let ((beg (point)))
1622 (forward-char 1)
1623 (end-of-line num)
1624 (setq tpu-last-deleted-lines
1625 (buffer-substring beg (point)))
1626 (delete-region beg (point))))
1628 (defun tpu-delete-to-bol (num)
1629 "Delete text back to beginning of line.
1630 With argument, delete up to the Nth line-end past point.
1631 They are saved for the TPU-edt undelete-lines command."
1632 (interactive "p")
1633 (let ((beg (point)))
1634 (tpu-next-beginning-of-line num)
1635 (setq tpu-last-deleted-lines
1636 (buffer-substring (point) beg))
1637 (delete-region (point) beg)))
1639 (defun tpu-delete-current-word (num)
1640 "Delete one or specified number of words after point.
1641 They are saved for the TPU-edt undelete-words command."
1642 (interactive "p")
1643 (let ((beg (point)))
1644 (tpu-forward-to-word num)
1645 (setq tpu-last-deleted-words
1646 (buffer-substring beg (point)))
1647 (delete-region beg (point))))
1649 (defun tpu-delete-previous-word (num)
1650 "Delete one or specified number of words before point.
1651 They are saved for the TPU-edt undelete-words command."
1652 (interactive "p")
1653 (let ((beg (point)))
1654 (tpu-backward-to-word num)
1655 (setq tpu-last-deleted-words
1656 (buffer-substring (point) beg))
1657 (delete-region beg (point))))
1659 (defun tpu-delete-current-char (num)
1660 "Delete one or specified number of characters after point.
1661 The last character deleted is saved for the TPU-edt undelete-char command."
1662 (interactive "p")
1663 (while (and (> num 0) (not (eobp)))
1664 (setq tpu-last-deleted-char (char-after (point)))
1665 (cond (overwrite-mode
1666 (picture-clear-column 1)
1667 (forward-char 1))
1668 (t
1669 (delete-char 1)))
1670 (setq num (1- num))))
1673 ;;;
1674 ;;; Undelete / Paste
1675 ;;;
1676 (defun tpu-paste (num)
1677 "Insert the last region or rectangle of killed text.
1678 With argument reinserts the text that many times."
1679 (interactive "p")
1680 (while (> num 0)
1681 (cond (tpu-rectangular-p
1682 (let ((beg (point)))
1683 (save-excursion
1684 (picture-yank-rectangle (not overwrite-mode))
1685 (message ""))
1686 (goto-char beg)))
1687 (t
1688 (insert tpu-last-deleted-region)))
1689 (setq num (1- num))))
1691 (defun tpu-undelete-lines (num)
1692 "Insert lines deleted by last TPU-edt line-deletion command.
1693 With argument reinserts lines that many times."
1694 (interactive "p")
1695 (let ((beg (point)))
1696 (while (> num 0)
1697 (insert tpu-last-deleted-lines)
1698 (setq num (1- num)))
1699 (goto-char beg)))
1701 (defun tpu-undelete-words (num)
1702 "Insert words deleted by last TPU-edt word-deletion command.
1703 With argument reinserts words that many times."
1704 (interactive "p")
1705 (let ((beg (point)))
1706 (while (> num 0)
1707 (insert tpu-last-deleted-words)
1708 (setq num (1- num)))
1709 (goto-char beg)))
1711 (defun tpu-undelete-char (num)
1712 "Insert character deleted by last TPU-edt character-deletion command.
1713 With argument reinserts the character that many times."
1714 (interactive "p")
1715 (while (> num 0)
1716 (if overwrite-mode (prog1 (forward-char -1) (delete-char 1)))
1717 (insert tpu-last-deleted-char)
1718 (forward-char -1)
1719 (setq num (1- num))))
1722 ;;;
1723 ;;; Replace and Substitute
1724 ;;;
1725 (defun tpu-replace nil
1726 "Replace the selected region with the contents of the cut buffer."
1727 (interactive)
1728 (cond ((tpu-mark)
1729 (let ((beg (region-beginning)) (end (region-end)))
1730 (setq tpu-last-replaced-text (buffer-substring beg end))
1731 (delete-region beg end)
1732 (insert tpu-last-deleted-region)
1733 (tpu-unselect t)))
1734 ((tpu-check-match)
1735 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1736 (setq tpu-last-replaced-text (buffer-substring beg end))
1737 (replace-match tpu-last-deleted-region
1738 (not case-replace) (not tpu-regexp-p))
1739 (tpu-unset-match)))
1740 (t
1741 (tpu-error "No selection active."))))
1743 (defun tpu-substitute (num)
1744 "Replace the selected region with the contents of the cut buffer,
1745 and repeat most recent search. A numeric argument serves as a repeat count.
1746 A negative argument means replace all occurrences of the search string."
1747 (interactive "p")
1748 (cond ((or (tpu-mark) (tpu-check-match))
1749 (while (and (not (= num 0)) (or (tpu-mark) (tpu-check-match)))
1750 (let ((beg (point)))
1751 (tpu-replace)
1752 (if tpu-searching-forward (forward-char -1) (goto-char beg))
1753 (if (= num 1) (tpu-search-internal tpu-search-last-string)
1754 (tpu-search-internal-core tpu-search-last-string)))
1755 (setq num (1- num))))
1756 (t
1757 (tpu-error "No selection active."))))
1759 (defun tpu-lm-replace (from to)
1760 "Interactively search for OLD-string and substitute NEW-string."
1761 (interactive (list (tpu-regexp-prompt "Old String: ")
1762 (tpu-regexp-prompt "New String: ")))
1764 (let ((doit t) (strings 0))
1766 ;; Can't replace null strings
1767 (if (string= "" from) (tpu-error "No string to replace."))
1769 ;; Find the first occurrence
1770 (tpu-set-search)
1771 (tpu-search-internal from t)
1773 ;; Loop on replace question - yes, no, all, last, or quit.
1774 (while doit
1775 (if (not (tpu-check-match)) (setq doit nil)
1776 (progn
1777 (move-overlay tpu-replace-overlay
1778 (tpu-match-beginning) (tpu-match-end) (current-buffer))
1779 (message "Replace? Type Yes, No, All, Last, or Quit: ")
1780 (let ((ans (read-char)))
1783 (let ((beg (point)))
1784 (replace-match to (not case-replace) (not tpu-regexp-p))
1785 (setq strings (1+ strings))
1786 (if tpu-searching-forward (forward-char -1) (goto-char beg)))
1787 (tpu-search-internal from t))
1789 ((or (= ans ?n) (= ans ?N) (= ans ?\C-?))
1790 (tpu-search-internal from t))
1792 ((or (= ans ?a) (= ans ?A))
1793 (save-excursion
1794 (let ((beg (point)))
1795 (replace-match to (not case-replace) (not tpu-regexp-p))
1796 (setq strings (1+ strings))
1797 (if tpu-searching-forward (forward-char -1) (goto-char beg)))
1798 (tpu-search-internal-core from t)
1799 (while (tpu-check-match)
1800 (let ((beg (point)))
1801 (replace-match to (not case-replace) (not tpu-regexp-p))
1802 (setq strings (1+ strings))
1803 (if tpu-searching-forward (forward-char -1) (goto-char beg)))
1804 (tpu-search-internal-core from t)))
1805 (setq doit nil))
1807 ((or (= ans ?l) (= ans ?L))
1808 (let ((beg (point)))
1809 (replace-match to (not case-replace) (not tpu-regexp-p))
1810 (setq strings (1+ strings))
1811 (if tpu-searching-forward (forward-char -1) (goto-char beg)))
1812 (setq doit nil))
1814 ((or (= ans ?q) (= ans ?Q))
1815 (tpu-unset-match)
1816 (setq doit nil)))))))
1818 (move-overlay tpu-replace-overlay 1 1 (current-buffer))
1819 (message "Replaced %s occurrence%s." strings (if (not (= 1 strings)) "s" ""))))
1821 (defun tpu-emacs-replace (&optional dont-ask)
1822 "A TPU-edt interface to the Emacs replace functions.
1823 If TPU-edt is currently in regular expression mode, the Emacs regular
1824 expression replace functions are used. If an argument is supplied,
1825 replacements are performed without asking. Only works in forward direction."
1826 (interactive "P")
1827 (cond (dont-ask
1828 (setq current-prefix-arg nil)
1829 (call-interactively
1830 (if tpu-regexp-p 'replace-regexp 'replace-string)))
1831 (t
1832 (call-interactively
1833 (if tpu-regexp-p 'query-replace-regexp 'query-replace)))))
1835 (defun tpu-add-at-bol (text)
1836 "Add text to the beginning of each line in a region,
1837 or each line in the entire buffer if no region is selected."
1838 (interactive
1839 (list (tpu-string-prompt "String to add: " 'tpu-add-at-bol-hist)))
1840 (if (string= "" text) (tpu-error "No string specified."))
1841 (cond ((tpu-mark)
1842 (save-excursion
1843 (if (> (point) (tpu-mark)) (exchange-point-and-mark))
1844 (while (and (< (point) (tpu-mark)) (re-search-forward "^" (tpu-mark) t))
1845 (if (< (point) (tpu-mark)) (replace-match text))))
1846 (tpu-unselect t))
1847 (t
1848 (save-excursion
1849 (goto-char (point-min))
1850 (while (and (re-search-forward "^" nil t) (not (eobp)))
1851 (replace-match text))))))
1853 (defun tpu-add-at-eol (text)
1854 "Add text to the end of each line in a region,
1855 or each line of the entire buffer if no region is selected."
1856 (interactive
1857 (list (tpu-string-prompt "String to add: " 'tpu-add-at-eol-hist)))
1858 (if (string= "" text) (tpu-error "No string specified."))
1859 (cond ((tpu-mark)
1860 (save-excursion
1861 (if (> (point) (tpu-mark)) (exchange-point-and-mark))
1862 (while (< (point) (tpu-mark))
1863 (end-of-line)
1864 (if (<= (point) (tpu-mark)) (insert text))
1865 (forward-line)))
1866 (tpu-unselect t))
1867 (t
1868 (save-excursion
1869 (goto-char (point-min))
1870 (while (not (eobp))
1871 (end-of-line) (insert text) (forward-line))))))
1873 (defun tpu-trim-line-ends nil
1874 "Remove trailing whitespace from every line in the buffer."
1875 (interactive)
1876 (save-match-data
1877 (save-excursion
1878 (goto-char (point-min))
1880 (delete-region (match-beginning 0) (match-end 0))))))
1883 ;;;
1884 ;;; Movement by character
1885 ;;;
1886 (defun tpu-char (num)
1887 "Move to the next character in the current direction.
1888 A repeat count means move that many characters."
1889 (interactive "p")
1890 (if tpu-advance (tpu-forward-char num) (tpu-backward-char num)))
1892 (defun tpu-forward-char (num)
1893 "Move right ARG characters (left if ARG is negative)."
1894 (interactive "p")
1895 (forward-char num))
1897 (defun tpu-backward-char (num)
1898 "Move left ARG characters (right if ARG is negative)."
1899 (interactive "p")
1900 (backward-char num))
1903 ;;;
1904 ;;; Movement by word
1905 ;;;
1906 (defvar tpu-word-separator-list '()
1907 "List of additional word separators.")
1909 "Characters to skip when moving by word.
1910 Additional word separators are added to this string.")
1912 (defun tpu-word (num)
1913 "Move to the beginning of the next word in the current direction.
1914 A repeat count means move that many words."
1915 (interactive "p")
1916 (if tpu-advance (tpu-forward-to-word num) (tpu-backward-to-word num)))
1918 (defun tpu-forward-to-word (num)
1919 "Move forward until encountering the beginning of a word.
1920 With argument, do this that many times."
1921 (interactive "p")
1922 (while (and (> num 0) (not (eobp)))
1923 (let* ((beg (point))
1924 (end (prog2 (end-of-line) (point) (goto-char beg))))
1925 (cond ((eolp)
1926 (forward-char 1))
1927 ((memq (char-after (point)) tpu-word-separator-list)
1928 (forward-char 1)
1930 (t
1931 (skip-chars-forward tpu-skip-chars end)
1933 (setq num (1- num))))
1935 (defun tpu-backward-to-word (num)
1936 "Move backward until encountering the beginning of a word.
1937 With argument, do this that many times."
1938 (interactive "p")
1939 (while (and (> num 0) (not (bobp)))
1940 (let* ((beg (point))
1941 (end (prog2 (beginning-of-line) (point) (goto-char beg))))
1942 (cond ((bolp)
1943 ( forward-char -1))
1944 ((memq (char-after (1- (point))) tpu-word-separator-list)
1945 (forward-char -1))
1946 (t
1948 (skip-chars-backward tpu-skip-chars end)
1949 (if (and (not (bolp)) (= ? (char-syntax (char-after (point)))))
1950 (forward-char -1)))))
1951 (setq num (1- num))))
1953 (defun tpu-add-word-separators (separators)
1954 "Add new word separators for TPU-edt word commands."
1955 (interactive "sSeparators: ")
1956 (let* ((n 0) (length (length separators)))
1957 (while (< n length)
1958 (let ((char (aref separators n))
1959 (ss (substring separators n (1+ n))))
1960 (cond ((not (memq char tpu-word-separator-list))
1961 (setq tpu-word-separator-list
1962 (append ss tpu-word-separator-list))
1963 (cond ((= char ?-)
1967 ((= char ?^)
1969 (t
1970 (setq tpu-skip-chars (concat tpu-skip-chars ss))))))
1971 (setq n (1+ n))))))
1973 (defun tpu-reset-word-separators nil
1974 "Reset word separators to default value."
1975 (interactive)
1976 (setq tpu-word-separator-list nil)
1979 (defun tpu-set-word-separators (separators)
1980 "Set new word separators for TPU-edt word commands."
1981 (interactive "sSeparators: ")
1982 (tpu-reset-word-separators)
1983 (tpu-add-word-separators separators))
1986 ;;;
1987 ;;; Movement by line
1988 ;;;
1989 (defun tpu-next-line (num)
1990 "Move to next line.
1991 Prefix argument serves as a repeat count."
1992 (interactive "p")
1993 (line-move num)
1994 (setq this-command 'next-line))
1996 (defun tpu-previous-line (num)
1997 "Move to previous line.
1998 Prefix argument serves as a repeat count."
1999 (interactive "p")
2000 (line-move (- num))
2001 (setq this-command 'previous-line))
2003 (defun tpu-next-beginning-of-line (num)
2004 "Move to beginning of line; if at beginning, move to beginning of next line.
2005 Accepts a prefix argument for the number of lines to move."
2006 (interactive "p")
2007 (backward-char 1)
2008 (forward-visible-line (- 1 num)))
2010 (defun tpu-end-of-line (num)
2011 "Move to the next end of line in the current direction.
2012 A repeat count means move that many lines."
2013 (interactive "p")
2014 (if tpu-advance (tpu-next-end-of-line num) (tpu-previous-end-of-line num)))
2016 (defun tpu-next-end-of-line (num)
2017 "Move to end of line; if at end, move to end of next line.
2018 Accepts a prefix argument for the number of lines to move."
2019 (interactive "p")
2020 (forward-char 1)
2021 (end-of-line num))
2023 (defun tpu-previous-end-of-line (num)
2024 "Move EOL upward.
2025 Accepts a prefix argument for the number of lines to move."
2026 (interactive "p")
2027 (end-of-line (- 1 num)))
2029 (defun tpu-current-end-of-line nil
2030 "Move point to end of current line."
2031 (interactive)
2032 (let ((beg (point)))
2033 (end-of-line)
2034 (if (= beg (point)) (message "You are already at the end of a line."))))
2036 (defun tpu-line (num)
2037 "Move to the beginning of the next line in the current direction.
2038 A repeat count means move that many lines."
2039 (interactive "p")
2040 (if tpu-advance (tpu-forward-line num) (tpu-backward-line num)))
2042 (defun tpu-forward-line (num)
2043 "Move to beginning of next line.
2044 Prefix argument serves as a repeat count."
2045 (interactive "p")
2046 (forward-line num))
2048 (defun tpu-backward-line (num)
2049 "Move to beginning of previous line.
2050 Prefix argument serves as repeat count."
2051 (interactive "p")
2052 (or (bolp) (>= 0 num) (setq num (- num 1)))
2053 (forward-line (- num)))
2056 ;;;
2057 ;;; Movement by paragraph
2058 ;;;
2059 (defun tpu-paragraph (num)
2060 "Move to the next paragraph in the current direction.
2061 A repeat count means move that many paragraphs."
2062 (interactive "p")
2063 (if tpu-advance
2064 (tpu-next-paragraph num) (tpu-previous-paragraph num)))
2066 (defun tpu-next-paragraph (num)
2067 "Move to beginning of the next paragraph.
2068 Accepts a prefix argument for the number of paragraphs."
2069 (interactive "p")
2070 (beginning-of-line)
2071 (while (and (not (eobp)) (> num 0))
2074 (goto-char (match-beginning 0))
2075 (goto-char (point-max))))
2076 (setq num (1- num)))
2077 (beginning-of-line))
2080 (defun tpu-previous-paragraph (num)
2081 "Move to beginning of previous paragraph.
2082 Accepts a prefix argument for the number of paragraphs."
2083 (interactive "p")
2084 (end-of-line)
2085 (while (and (not (bobp)) (> num 0))
2090 (goto-char (match-beginning 0)))))
2091 (goto-char (point-min)))
2092 (setq num (1- num)))
2093 (beginning-of-line))
2096 ;;;
2097 ;;; Movement by page
2098 ;;;
2099 (defun tpu-page (num)
2100 "Move to the next page in the current direction.
2101 A repeat count means move that many pages."
2102 (interactive "p")
2103 (if tpu-advance (forward-page num) (backward-page num))
2104 (if (eobp) (recenter -1)))
2107 ;;;
2108 ;;; Scrolling and movement within the buffer
2109 ;;;
2110 (defun tpu-scroll-window (num)
2111 "Scroll the display to the next section in the current direction.
2112 A repeat count means scroll that many sections."
2113 (interactive "p")
2114 (if tpu-advance (tpu-scroll-window-up num) (tpu-scroll-window-down num)))
2116 (defun tpu-scroll-window-down (num)
2117 "Scroll the display down to the next section.
2118 A repeat count means scroll that many sections."
2119 (interactive "p")
2120 (let* ((beg (tpu-current-line))
2121 (height (1- (window-height)))
2122 (lines (* num (/ (* height tpu-percent-scroll) 100))))
2123 (line-move (- lines))
2124 (if (> lines beg) (recenter 0))))
2126 (defun tpu-scroll-window-up (num)
2127 "Scroll the display up to the next section.
2128 A repeat count means scroll that many sections."
2129 (interactive "p")
2130 (let* ((beg (tpu-current-line))
2131 (height (1- (window-height)))
2132 (lines (* num (/ (* height tpu-percent-scroll) 100))))
2133 (line-move lines)
2134 (if (>= (+ lines beg) height) (recenter -1))))
2136 (defun tpu-pan-right (num)
2137 "Pan right tpu-pan-columns (16 by default).
2138 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
2139 (interactive "p")
2140 (scroll-left (* tpu-pan-columns num)))
2142 (defun tpu-pan-left (num)
2143 "Pan left tpu-pan-columns (16 by default).
2144 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
2145 (interactive "p")
2146 (scroll-right (* tpu-pan-columns num)))
2148 (defun tpu-move-to-beginning nil
2149 "Move cursor to the beginning of buffer, but don't set the mark."
2150 (interactive)
2151 (goto-char (point-min)))
2153 (defun tpu-move-to-end nil
2154 "Move cursor to the end of buffer, but don't set the mark."
2155 (interactive)
2156 (goto-char (point-max))
2157 (recenter -1))
2159 (defun tpu-goto-percent (perc)
2160 "Move point to ARG percentage of the buffer."
2161 (interactive "NGoto-percentage: ")
2162 (if (or (> perc 100) (< perc 0))
2163 (tpu-error "Percentage %d out of range 0 < percent < 100." perc)
2164 (goto-char (/ (* (point-max) perc) 100))))
2166 (defun tpu-beginning-of-window nil
2167 "Move cursor to top of window."
2168 (interactive)
2169 (move-to-window-line 0))
2171 (defun tpu-end-of-window nil
2172 "Move cursor to bottom of window."
2173 (interactive)
2174 (move-to-window-line -1))
2176 (defun tpu-line-to-bottom-of-window nil
2177 "Move the current line to the bottom of the window."
2178 (interactive)
2179 (recenter -1))
2181 (defun tpu-line-to-top-of-window nil
2182 "Move the current line to the top of the window."
2183 (interactive)
2184 (recenter 0))
2187 ;;;
2188 ;;; Direction
2189 ;;;
2190 (defun tpu-advance-direction nil
2191 "Set TPU Advance mode so keypad commands move forward."
2192 (interactive)
2193 (setq tpu-direction-string " Advance")
2194 (setq tpu-advance t)
2195 (setq tpu-reverse nil)
2196 (tpu-set-search)
2197 (tpu-update-mode-line))
2199 (defun tpu-backup-direction nil
2200 "Set TPU Backup mode so keypad commands move backward."
2201 (interactive)
2202 (setq tpu-direction-string " Reverse")
2203 (setq tpu-advance nil)
2204 (setq tpu-reverse t)
2205 (tpu-set-search)
2206 (tpu-update-mode-line))
2208 (defun tpu-toggle-direction nil
2209 "Change the current TPU direction."
2210 (interactive)
2211 (if tpu-advance (tpu-backup-direction) (tpu-advance-direction)))
2214 ;;;
2215 ;;; Minibuffer map additions to make KP_enter = RET
2216 ;;;
2217 ;; Standard Emacs settings under xterm in function-key-map map
2218 ;; "\eOM" to [kp-enter] and [kp-enter] to RET, but since the output of the map
2219 ;; is not fed back into the map, the key stays as kp-enter :-(.
2220 (define-key minibuffer-local-map [kp-enter] 'exit-minibuffer)
2221 ;; These are not necessary because they are inherited.
2222 ;; (define-key minibuffer-local-ns-map [kp-enter] 'exit-minibuffer)
2223 ;; (define-key minibuffer-local-completion-map [kp-enter] 'exit-minibuffer)
2224 (define-key minibuffer-local-must-match-map [kp-enter] 'minibuffer-complete-and-exit)
2227 ;;;
2228 ;;; Minibuffer map additions to set search direction
2229 ;;;
2230 (define-key minibuffer-local-map [kp-4] 'tpu-search-forward-exit) ;KP4
2231 (define-key minibuffer-local-map [kp-5] 'tpu-search-backward-exit) ;KP5
2234 ;;;
2235 ;;; Functions to set, reset, and toggle the control key bindings
2236 ;;;
2238 (defvar tpu-control-keys-map
2239 (let ((map (make-sparse-keymap)))
2241 (define-key map "\C-a" 'tpu-toggle-overwrite-mode) ; ^A
2242 (define-key map "\C-b" 'repeat-complex-command) ; ^B
2243 (define-key map "\C-e" 'tpu-current-end-of-line) ; ^E
2244 (define-key map "\C-h" 'tpu-next-beginning-of-line) ; ^H (BS)
2245 (define-key map "\C-j" 'tpu-delete-previous-word) ; ^J (LF)
2246 (define-key map "\C-k" 'tpu-define-macro-key) ; ^K
2247 (define-key map "\C-l" 'tpu-insert-formfeed) ; ^L (FF)
2248 (define-key map "\C-r" 'recenter) ; ^R
2249 (define-key map "\C-u" 'tpu-delete-to-bol) ; ^U
2250 (define-key map "\C-v" 'tpu-quoted-insert) ; ^V
2251 (define-key map "\C-w" 'redraw-display) ; ^W
2252 (define-key map "\C-z" 'tpu-exit) ; ^Z
2253 map))
2255 (defun tpu-set-control-keys ()
2256 "Set control keys to TPU style functions."
2257 (tpu-reset-control-keys 'tpu))
2259 (defun tpu-reset-control-keys (tpu-style)
2260 "Set control keys to TPU or Emacs style functions."
2261 (let ((parent (keymap-parent tpu-global-map)))
2262 (if tpu-style
2263 (if (eq parent tpu-control-keys-map)
2264 nil ;All done already.
2265 ;; Insert tpu-control-keys-map in the global map.
2266 (set-keymap-parent tpu-control-keys-map parent)
2267 (set-keymap-parent tpu-global-map tpu-control-keys-map))
2268 (if (not (eq parent tpu-control-keys-map))
2269 nil ;All done already.
2270 ;; Remove tpu-control-keys-map from the global map.
2271 (set-keymap-parent tpu-global-map (keymap-parent parent))
2272 (set-keymap-parent tpu-control-keys-map nil)))
2273 (setq tpu-control-keys tpu-style)))
2275 (defun tpu-toggle-control-keys nil
2276 "Toggle control key bindings between TPU-edt and Emacs."
2277 (interactive)
2278 (tpu-reset-control-keys (not tpu-control-keys))
2279 (and (called-interactively-p 'interactive)
2280 (message "Control keys function with %s bindings."
2281 (if tpu-control-keys "TPU-edt" "Emacs"))))
2284 ;;;
2285 ;;; Emacs version 19 minibuffer history support
2286 ;;;
2287 (defun tpu-next-history-element (n)
2288 "Insert the next element of the minibuffer history into the minibuffer."
2289 (interactive "p")
2290 (next-history-element n)
2291 (goto-char (point-max)))
2293 (defun tpu-previous-history-element (n)
2294 "Insert the previous element of the minibuffer history into the minibuffer."
2295 (interactive "p")
2296 (previous-history-element n)
2297 (goto-char (point-max)))
2299 (defun tpu-arrow-history nil
2300 "Modify minibuffer maps to use arrows for history recall."
2301 (interactive)
2302 (dolist (cur (where-is-internal 'tpu-previous-line))
2303 (define-key read-expression-map cur 'tpu-previous-history-element)
2304 (define-key minibuffer-local-map cur 'tpu-previous-history-element)
2305 ;; These are inherited anyway. --Stef
2306 ;; (define-key minibuffer-local-ns-map cur 'tpu-previous-history-element)
2307 ;; (define-key minibuffer-local-completion-map cur 'tpu-previous-history-element)
2308 ;; (define-key minibuffer-local-must-match-map cur 'tpu-previous-history-element)
2309 )
2311 (dolist (cur (where-is-internal 'tpu-next-line))
2312 (define-key read-expression-map cur 'tpu-next-history-element)
2313 (define-key minibuffer-local-map cur 'tpu-next-history-element)
2314 ;; These are inherited anyway. --Stef
2315 ;; (define-key minibuffer-local-ns-map cur 'tpu-next-history-element)
2316 ;; (define-key minibuffer-local-completion-map cur 'tpu-next-history-element)
2317 ;; (define-key minibuffer-local-must-match-map cur 'tpu-next-history-element)
2318 ))
2321 ;;;
2322 ;;; Emacs version 19 X-windows key definition support
2323 ;;;
2324 (defun tpu-load-xkeys (file)
2325 "Load the TPU-edt X-windows key definitions FILE.
2326 If FILE is nil, try to load a default file. The default file names are
2327 `~/.tpu-lucid-keys' for XEmacs, and `~/.tpu-keys' for Emacs."
2328 (interactive "fX key definition file: ")
2329 (cond (file
2330 (setq file (expand-file-name file)))
2331 (tpu-xkeys-file
2332 (setq file (expand-file-name tpu-xkeys-file)))
2333 ((featurep 'xemacs)
2334 (setq file (convert-standard-filename
2335 (expand-file-name "~/.tpu-lucid-keys"))))
2336 (t
2337 (setq file (convert-standard-filename
2338 (expand-file-name "~/.tpu-keys")))
2339 (and (not (file-exists-p file))
2340 (file-exists-p
2341 (convert-standard-filename
2342 (expand-file-name "~/.tpu-gnu-keys")))
2343 (tpu-copy-keyfile
2344 (convert-standard-filename
2345 (expand-file-name "~/.tpu-gnu-keys")) file))))
2346 (cond ((file-readable-p file)
2347 (load-file file))
2348 (t
2349 ;; This used to force the user to build `file'. With the
2350 ;; new code, such a file may not be necessary. In case it
2351 ;; is, issue a message giving a hint as to how to build it.
2352 (message "%s not found: use M-x tpu-mapper to create it"
2353 (abbreviate-file-name file)))))
2355 (defun tpu-copy-keyfile (oldname newname)
2356 "Copy the TPU-edt X key definitions file to the new default name."
2358 (if (not (get-buffer "*TPU-Notice*")) (generate-new-buffer "*TPU-Notice*"))
2359 (set-buffer "*TPU-Notice*")
2360 (erase-buffer)
2361 (insert "
2362 NOTICE --
2364 The default name of the TPU-edt key definition file has changed
2365 from `~/.tpu-gnu-keys' to `~/.tpu-keys'. With your permission,
2366 your key definitions will be copied to the new file. If you'll
2367 never use older versions of Emacs, you can remove the old file.
2368 If the copy fails, you'll be asked if you want to create a new
2369 key definitions file. Do you want to copy your key definition
2370 file now?
2371 ")
2372 (save-window-excursion
2373 (switch-to-buffer-other-window "*TPU-Notice*")
2374 (shrink-window-if-larger-than-buffer)
2375 (goto-char (point-min))
2376 (beep)
2377 (and (tpu-y-or-n-p "Copy key definitions to the new file now? ")
2378 (with-demoted-errors "Sorry, couldn't copy - %s."
2379 (copy-file oldname newname)))
2380 (kill-buffer "*TPU-Notice*")))
2382 (defvar tpu-edt-old-global-values nil)
2384 ;;;
2385 ;;; Start and Stop TPU-edt
2386 ;;;
2387 ;;;###autoload
2388 (defun tpu-edt-on ()
2389 "Turn on TPU/edt emulation."
2390 (interactive)
2391 ;; To clean things up (and avoid cycles in the global map).
2392 (tpu-edt-off)
2393 ;; First, activate tpu-global-map, while protecting the original keymap.
2394 (set-keymap-parent tpu-global-map global-map)
2395 (setq global-map tpu-global-map)
2396 (use-global-map global-map)
2397 ;; Then do the normal TPU setup.
2398 (transient-mark-mode t)
2399 (add-hook 'post-command-hook 'tpu-search-highlight)
2400 (tpu-set-mode-line t)
2401 (tpu-advance-direction)
2402 ;; set page delimiter, display line truncation, and scrolling like TPU
2404 (truncate-lines . t)
2405 (scroll-step . 1)))
2406 (push (cons (car varval) (default-value (car varval)))
2407 tpu-edt-old-global-values)
2408 (set-default (car varval) (cdr varval)))
2409 (tpu-set-control-keys)
2410 (and window-system (tpu-load-xkeys nil))
2411 (tpu-arrow-history)
2412 ;; Then protect tpu-global-map from user modifications.
2413 (let ((map (make-sparse-keymap)))
2414 (set-keymap-parent map global-map)
2415 (setq global-map map)
2416 (use-global-map map))
2417 (setq tpu-edt-mode t))
2419 (defun tpu-edt-off ()
2420 "Turn off TPU/edt emulation. Note that the keypad is left on."
2421 (interactive)
2422 (tpu-reset-control-keys nil)
2423 (remove-hook 'post-command-hook 'tpu-search-highlight)
2424 (tpu-set-mode-line nil)
2425 (while tpu-edt-old-global-values
2426 (let ((varval (pop tpu-edt-old-global-values)))
2427 (set-default (car varval) (cdr varval))))
2428 ;; Remove tpu-global-map from the global map.
2429 (let ((map global-map))
2430 (while map
2431 (let ((parent (keymap-parent map)))
2432 (if (eq tpu-global-map parent)
2433 (set-keymap-parent map (keymap-parent parent))
2434 (setq map parent)))))
2435 ;; Only has an effect if the advice in tpu-extras has been activated.
2436 (condition-case nil
2438 (error nil))
2439 (setq tpu-edt-mode nil))
2441 \f
2442 ;;;### (autoloads nil "tpu-extras" "tpu-extras.el" "cbbb448cff48fab904ac19805aa6f36a")
2443 ;;; Generated autoloads from tpu-extras.el
2445 (autoload 'tpu-cursor-free-mode "tpu-extras" "\
2446 Minor mode to allow the cursor to move freely about the screen.
2447 With a prefix argument ARG, enable the mode if ARG is positive,
2448 and disable it otherwise. If called from Lisp, enable the mode
2449 if ARG is omitted or nil.
2451 \(fn &optional ARG)" t nil)
2453 (autoload 'tpu-set-scroll-margins "tpu-extras" "\
2454 Set scroll margins.
2456 \(fn TOP BOTTOM)" t nil)
2458 (autoload 'tpu-set-cursor-free "tpu-extras" "\
2459 Allow the cursor to move freely about the screen.
2461 \(fn)" t nil)
2463 (autoload 'tpu-set-cursor-bound "tpu-extras" "\
2464 Constrain the cursor to the flow of the text.
2466 \(fn)" t nil)
2468 ;;;***
2469 \f
2470 (provide 'tpu-edt)
2472 ;;; tpu-edt.el ends here