1 ;;; edt.el --- Enhanced EDT Keypad Mode Emulation for GNU Emacs 19
3 ;; Copyright (C) 1986, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
5 ;; Author: Kevin Gallagher <kgallagh@spd.dsccc.com>
6 ;; Maintainer: Kevin Gallagher <kgallagh@spd.dsccc.com>
8 ;; Keywords: emulations
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to
24 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
30 ;; ====================================================================
32 ;;; Electric Help functions are used for keypad help displays. A few
33 ;;; picture functions are used in rectangular cut and paste commands.
38 ;;;; VARIABLES and CONSTANTS
41 (defconst edt-version "3.0.3" "EDT version number.")
43 (defvar edt-last-deleted-lines ""
44 "Last text deleted by an EDT emulation line delete command.")
46 (defvar edt-last-deleted-words ""
47 "Last text deleted by an EDT emulation word delete command.")
49 (defvar edt-last-deleted-chars ""
50 "Last text deleted by an EDT emulation character delete command.")
52 (defvar edt-last-replaced-key-definition ""
53 "Key definition replaced with edt-define-key or edt-learn command.")
55 (defvar edt-direction-string ""
56 "Current direction of movement.")
58 (defvar edt-select-mode nil
61 (defvar edt-select-mode-text ""
62 "Select mode active text.")
64 (defconst edt-select-mode-string " Select"
65 "String used to indicated select mode is active.")
67 (defconst edt-forward-string " ADVANCE"
68 "Direction string indicating forward movement.")
70 (defconst edt-backward-string " BACKUP"
71 "Direction string indicating backward movement.")
73 (defvar edt-default-map-active nil
74 "Indicates, when true, that default EDT emulation key bindings are active;
75 user-defined custom bindings are active when set to nil.")
77 (defvar edt-user-map-configured nil
78 "Indicates, when true, that user custom EDT emulation key bindings are
79 configured and available for use.")
81 (defvar edt-keep-current-page-delimiter nil
82 "If set to true, when edt-emulation-on is first invoked,
83 modification of the page-delimiter varible to "\f" is suppressed,
84 thereby retaining current Emacs setting.")
86 (defvar edt-use-EDT-control-key-bindings nil
87 "If set to true, EDT control key bindings are defined.
88 When true, many standard Emacs control key bindings are overwritten.
89 If set to nil (the default), EDT control key bindings are not used.
90 Instead, the standard Emacs control key bindings are retained.")
92 (defvar edt-word-entities '(?\t)
93 "*Specifies the list of word entity characters.")
96 ;;; Emacs version identifiers - currently referenced by
98 ;;; o edt-emulation-on o edt-load-xkeys
100 (defconst edt-emacs19-p (not (string-lessp emacs-version "19"))
101 "Non-NIL if we are running Lucid or GNU Emacs version 19.")
103 (defconst edt-lucid-emacs19-p
104 (and edt-emacs19-p (string-match "Lucid" emacs-version))
105 "Non-NIL if we are running Lucid Emacs version 19.")
107 (defconst edt-gnu-emacs19-p (and edt-emacs19-p (not edt-lucid-emacs19-p))
108 "Non-NIL if we are running GNU Emacs version 19.")
110 (defvar edt-xkeys-file nil
111 "File mapping X function keys to LK-201 keyboard function and keypad keys.")
114 ;;;; EDT Emulation Commands
117 ;;; Almost all of EDT's keypad mode commands have equivalent
118 ;;; counterparts in Emacs. Some behave the same way in Emacs as they
119 ;;; do in EDT, but most do not.
121 ;;; The following Emacs functions emulate, where practical, the exact
122 ;;; behavior of the corresponding EDT keypad mode commands. In a few
123 ;;; cases, the emulation is not exact, but it is close enough for most
126 ;;; In a very few cases, we chose to use the superior Emacs way of
127 ;;; handling things. For example, we do not emulate the EDT SUBS
128 ;;; command. Instead, we chose to use the superior Emacs
129 ;;; query-replace function.
135 ;;; Emacs uses the regexp assigned to page-delimiter to determine what
136 ;;; marks a page break. This is normally "^\f", which causes the
137 ;;; edt-page command to ignore form feeds not located at the beginning
138 ;;; of a line. To emulate the EDT PAGE command exactly,
139 ;;; page-delimiter is set to "\f" when EDT emulation is turned on, and
140 ;;; restored to its original value when EDT emulation is turned off.
141 ;;; But this can be overridden if the EDT definition is not desired by
144 ;;; (setq edt-keep-current-page-delimiter t)
146 ;;; in your .emacs file.
148 (defun edt-page-forward (num)
149 "Move forward to just after next page delimiter.
150 Accepts a positive prefix argument for the number of page delimiters to move."
152 (edt-check-prefix num)
154 (error "End of buffer")
158 (edt-line-to-bottom-of-window)
159 (edt-line-to-top-of-window)))))
161 (defun edt-page-backward (num)
162 "Move backward to just after previous page delimiter.
163 Accepts a positive prefix argument for the number of page delimiters to move."
165 (edt-check-prefix num)
167 (error "Beginning of buffer")
170 (edt-line-to-top-of-window))))
172 (defun edt-page (num)
173 "Move in current direction to next page delimiter.
174 Accepts a positive prefix argument for the number of page delimiters to move."
176 (if (equal edt-direction-string edt-forward-string)
177 (edt-page-forward num)
178 (edt-page-backward num)))
183 ;;; EDT defaults a section size to be 16 lines of its one and only
184 ;;; 24-line window. That's two-thirds of the window at a time. The
185 ;;; EDT SECT commands moves the cursor, not the window.
187 ;;; This emulation of EDT's SECT moves the cursor approximately two-thirds
188 ;;; of the current window at a time.
190 (defun edt-sect-forward (num)
191 "Move cursor forward two-thirds of a window.
192 Accepts a positive prefix argument for the number of sections to move."
194 (edt-check-prefix num)
195 (edt-line-forward (* (* (/ (- (window-height) 1) 3) 2) num)))
197 (defun edt-sect-backward (num)
198 "Move cursor backward two-thirds of a window.
199 Accepts a positive prefix argument for the number of sections to move."
201 (edt-check-prefix num)
202 (edt-line-backward (* (* (/ (- (window-height) 1) 3) 2) num)))
204 (defun edt-sect (num)
205 "Move in current direction a full window.
206 Accepts a positive prefix argument for the number windows to move."
208 (if (equal edt-direction-string edt-forward-string)
209 (edt-sect-forward num)
210 (edt-sect-backward num)))
213 ;;; BEGINNING OF LINE
215 ;;; EDT's beginning-of-line command is not affected by current
216 ;;; direction, for some unknown reason.
218 (defun edt-beginning-of-line (num)
219 "Move backward to next beginning of line mark.
220 Accepts a positive prefix argument for the number of BOL marks to move."
222 (edt-check-prefix num)
224 (forward-line (* -1 num))
227 (forward-line (* -1 num)))))
230 ;;; EOL (End of Line)
233 (defun edt-end-of-line-forward (num)
234 "Move forward to next end of line mark.
235 Accepts a positive prefix argument for the number of EOL marks to move."
237 (edt-check-prefix num)
241 (defun edt-end-of-line-backward (num)
242 "Move backward to next end of line mark.
243 Accepts a positive prefix argument for the number of EOL marks to move."
245 (edt-check-prefix num)
246 (end-of-line (1- num)))
248 (defun edt-end-of-line (num)
249 "Move in current direction to next end of line mark.
250 Accepts a positive prefix argument for the number of EOL marks to move."
252 (if (equal edt-direction-string edt-forward-string)
253 (edt-end-of-line-forward num)
254 (edt-end-of-line-backward num)))
259 ;;; This one is a tad messy. To emulate EDT's behavior everywhere in
260 ;;; the file (beginning of file, end of file, beginning of line, end
261 ;;; of line, etc.) it takes a bit of special handling.
263 ;;; The variable edt-word-entities contains a list of characters which
264 ;;; are to be viewed as distinct words where ever they appear in the
265 ;;; buffer. This emulates the EDT line mode command SET ENTITY WORD.
268 (defun edt-one-word-forward ()
269 "Move forward to first character of next word."
272 (error "End of buffer"))
276 (if (memq (following-char) edt-word-entities)
281 (not (eq ?\ (char-syntax (following-char))))
282 (not (memq (following-char) edt-word-entities)))
287 (eq ?\ (char-syntax (following-char)))
288 (not (memq (following-char) edt-word-entities)))
291 (defun edt-one-word-backward ()
292 "Move backward to first character of previous word."
295 (error "Beginning of buffer"))
303 (eq ?\ (char-syntax (following-char)))
304 (not (memq (following-char) edt-word-entities)))
306 (if (not (memq (following-char) edt-word-entities))
310 (not (eq ?\ (char-syntax (preceding-char))))
311 (not (memq (preceding-char) edt-word-entities)))
314 (defun edt-word-forward (num)
315 "Move forward to first character of next word.
316 Accepts a positive prefix argument for the number of words to move."
318 (edt-check-prefix num)
320 (edt-one-word-forward)
321 (setq num (1- num))))
323 (defun edt-word-backward (num)
324 "Move backward to first character of previous word.
325 Accepts a positive prefix argument for the number of words to move."
327 (edt-check-prefix num)
329 (edt-one-word-backward)
330 (setq num (1- num))))
332 (defun edt-word (num)
333 "Move in current direction to first character of next word.
334 Accepts a positive prefix argument for the number of words to move."
336 (if (equal edt-direction-string edt-forward-string)
337 (edt-word-forward num)
338 (edt-word-backward num)))
344 (defun edt-character (num)
345 "Move in current direction to next character.
346 Accepts a positive prefix argument for the number of characters to move."
348 (edt-check-prefix num)
349 (if (equal edt-direction-string edt-forward-string)
351 (backward-char num)))
356 ;;; When direction is set to BACKUP, LINE behaves just like BEGINNING
357 ;;; OF LINE in EDT. So edt-line-backward is not really needed as a
358 ;;; separate function.
360 (defun edt-line-backward (num)
361 "Move backward to next beginning of line mark.
362 Accepts a positive prefix argument for the number of BOL marks to move."
364 (edt-beginning-of-line num))
366 (defun edt-line-forward (num)
367 "Move forward to next beginning of line mark.
368 Accepts a positive prefix argument for the number of BOL marks to move."
370 (edt-check-prefix num)
373 (defun edt-line (num)
374 "Move in current direction to next beginning of line mark.
375 Accepts a positive prefix argument for the number of BOL marks to move."
377 (if (equal edt-direction-string edt-forward-string)
378 (edt-line-forward num)
379 (edt-line-backward num)))
386 "Move cursor to the beginning of buffer."
388 (goto-char (point-min)))
395 "Move cursor to the end of buffer."
397 (goto-char (point-max))
398 (edt-line-to-bottom-of-window))
404 (defun edt-find-forward (&optional find)
405 "Find first occurance of a string in the forward direction and save the string."
408 (set 'search-last-string (read-string "Search forward: ")))
409 (if (search-forward search-last-string)
410 (search-backward search-last-string)))
412 (defun edt-find-backward (&optional find)
413 "Find first occurance of a string in the backward direction and save the string."
416 (set 'search-last-string (read-string "Search backward: ")))
417 (search-backward search-last-string))
420 "Find first occurance of string in current direction and save the string."
422 (set 'search-last-string (read-string "Search: "))
423 (if (equal edt-direction-string edt-forward-string)
425 (edt-find-backward t)))
432 (defun edt-find-next-forward ()
433 "Find next occurance of a string in forward direction."
436 (if (search-forward search-last-string nil t)
437 (search-backward search-last-string)
440 (error "Search failed: \"%s\"." search-last-string))))
442 (defun edt-find-next-backward ()
443 "Find next occurance of a string in backward direction."
445 (if (eq (search-backward search-last-string nil t) nil)
447 (error "Search failed: \"%s\"." search-last-string))))
449 (defun edt-find-next ()
450 "Find next occurance of a string in current direction."
452 (if (equal edt-direction-string edt-forward-string)
453 (edt-find-next-forward)
454 (edt-find-next-backward)))
461 "Append this kill region to last killed region."
463 (edt-check-selection)
465 (kill-region (mark) (point))
466 (message "Selected text APPENDED to kill ring"))
472 (defun edt-delete-line (num)
473 "Delete from cursor up to and including the end of line mark.
474 Accepts a positive prefix argument for the number of lines to delete."
476 (edt-check-prefix num)
479 (if (not (eq (preceding-char) ?\n))
481 (setq edt-last-deleted-lines
482 (buffer-substring beg (point)))
483 (delete-region beg (point))))
489 (defun edt-delete-to-end-of-line (num)
490 "Delete from cursor up to but excluding the end of line mark.
491 Accepts a positive prefix argument for the number of lines to delete."
493 (edt-check-prefix num)
497 (setq edt-last-deleted-lines
498 (buffer-substring beg (point)))
499 (delete-region beg (point))))
505 (defun edt-select-mode (arg)
506 "Turn EDT select mode off if arg is nil; otherwise, turn EDT select mode on.
507 In select mode, selected text is highlighted."
510 (make-local-variable 'edt-select-mode)
511 (setq edt-select-mode 'edt-select-mode-text)
512 (setq rect-start-point (window-point)))
514 (kill-local-variable 'edt-select-mode)))
515 (force-mode-line-update))
518 "Set mark at cursor and start text selection."
520 (set-mark-command nil))
523 "Cancel text selection."
532 "Deletes selected text but copies to kill ring."
534 (edt-check-selection)
535 (kill-region (mark) (point))
536 (message "Selected text CUT to kill ring"))
539 ;;; DELETE TO BEGINNING OF LINE
542 (defun edt-delete-to-beginning-of-line (num)
543 "Delete from cursor to beginning of of line.
544 Accepts a positive prefix argument for the number of lines to delete."
546 (edt-check-prefix num)
548 (edt-beginning-of-line num)
549 (setq edt-last-deleted-lines
550 (buffer-substring (point) beg))
551 (delete-region beg (point))))
557 (defun edt-delete-word (num)
558 "Delete from cursor up to but excluding first character of next word.
559 Accepts a positive prefix argument for the number of words to delete."
561 (edt-check-prefix num)
563 (edt-word-forward num)
564 (setq edt-last-deleted-words (buffer-substring beg (point)))
565 (delete-region beg (point))))
568 ;;; DELETE TO BEGINNING OF WORD
571 (defun edt-delete-to-beginning-of-word (num)
572 "Delete from cursor to beginning of word.
573 Accepts a positive prefix argument for the number of words to delete."
575 (edt-check-prefix num)
577 (edt-word-backward num)
578 (setq edt-last-deleted-words (buffer-substring (point) beg))
579 (delete-region beg (point))))
585 (defun edt-delete-character (num)
586 "Delete character under cursor.
587 Accepts a positive prefix argument for the number of characters to delete."
589 (edt-check-prefix num)
590 (setq edt-last-deleted-chars
591 (buffer-substring (point) (min (point-max) (+ (point) num))))
592 (delete-region (point) (min (point-max) (+ (point) num))))
598 (defun edt-delete-previous-character (num)
599 "Delete character in front of cursor.
600 Accepts a positive prefix argument for the number of characters to delete."
602 (edt-check-prefix num)
603 (setq edt-last-deleted-chars
604 (buffer-substring (max (point-min) (- (point) num)) (point)))
605 (delete-region (max (point-min) (- (point) num)) (point)))
611 (defun edt-undelete-line ()
612 "Undelete previous deleted line(s)."
614 (point-to-register 1)
615 (insert edt-last-deleted-lines)
616 (register-to-point 1))
622 (defun edt-undelete-word ()
623 "Yank words deleted by last EDT word-deletion command."
625 (point-to-register 1)
626 (insert edt-last-deleted-words)
627 (register-to-point 1))
633 (defun edt-undelete-character ()
634 "Yank characters deleted by last EDT character-deletion command."
636 (point-to-register 1)
637 (insert edt-last-deleted-chars)
638 (register-to-point 1))
644 (defun edt-replace ()
645 "Replace marked section with last CUT (killed) text."
647 (exchange-point-and-mark)
649 (exchange-point-and-mark)
650 (delete-region beg (point)))
657 (defun edt-advance ()
658 "Set movement direction forward."
660 (setq edt-direction-string edt-forward-string)
661 (edt-update-mode-line)
662 (if (string-equal " *Minibuf"
663 (substring (buffer-name) 0 (min (length (buffer-name)) 9)))
671 "Set movement direction backward."
673 (setq edt-direction-string edt-backward-string)
674 (edt-update-mode-line)
675 (if (string-equal " *Minibuf"
676 (substring (buffer-name) 0 (min (length (buffer-name)) 9)))
682 ;; This function is based upon Jeff Kowalski's case-flip function in his
685 (defun edt-change-case (num)
686 "Change the case of specified characters.
687 If text selection IS active, then characters between the cursor and mark are
688 changed. If text selection is NOT active, there are two cases. First, if the
689 current direction is ADVANCE, then the prefix number of character(s) under and
690 following cursor are changed. Second, if the current direction is BACKUP, then
691 the prefix number of character(s) before the cursor are changed. Accepts a
692 positive prefix for the number of characters to change, but the prefix is
693 ignored if text selection is active."
695 (edt-check-prefix num)
697 (let ((end (max (mark) (point)))
698 (point-save (point)))
699 (goto-char (min (point) (mark)))
700 (while (not (eq (point) end))
701 (funcall (if (<= ?a (following-char))
702 'upcase-region 'downcase-region)
703 (point) (1+ (point)))
705 (goto-char point-save))
707 (if (string= edt-direction-string edt-backward-string)
710 (funcall (if (<= ?a (following-char))
711 'upcase-region 'downcase-region)
712 (point) (1+ (point)))
714 (setq num (1- num))))))
720 (defun edt-define-key ()
721 "Assign an interactively-callable function to a specified key sequence.
722 The current key definition is saved in edt-last-replaced-key-definition.
723 Use edt-restore-key to restore last replaced key definition."
726 edt-key-definition-string)
727 (setq edt-key-definition-string
728 (read-key-sequence "Press the key to be defined: "))
729 (if (string-equal "\C-m" edt-key-definition-string)
730 (message "Key not defined")
732 (setq edt-function (read-command "Enter command name: "))
733 (if (string-equal "" edt-function)
734 (message "Key not defined")
736 (setq edt-last-replaced-key-definition
737 (lookup-key (current-global-map) edt-key-definition-string))
738 (define-key (current-global-map)
739 edt-key-definition-string edt-function)))))))
745 (defun edt-form-feed-insert (num)
746 "Insert form feed character at cursor position.
747 Accepts a positive prefix argument for the number of form feeds to insert."
749 (edt-check-prefix num)
752 (setq num (1- num))))
758 (defun edt-tab-insert (num)
759 "Insert tab character at cursor position.
760 Accepts a positive prefix argument for the number of tabs to insert."
762 (edt-check-prefix num)
765 (setq num (1- num))))
771 (defun edt-check-prefix (num)
772 "Indicate error if prefix is not positive."
774 (error "Prefix must be positive")))
780 (defun edt-check-selection ()
781 "Indicate error if EDT selection is not active."
782 (if (not edt-select-mode)
783 (error "Selection NOT active")))
786 ;;;; ENHANCEMENTS AND ADDITIONS FOR EDT KEYPAD MODE
790 ;;; Several enhancements and additions to EDT keypad mode commands are
791 ;;; provided here. Some of these have been motivated by similar
792 ;;; TPU/EVE and EVE-Plus commands. Others are new.
794 (defun edt-version nil
795 "Print the EDT version number."
798 "EDT version %s by Kevin Gallagher (kgallagh@spd.dsccc.com)"
805 (defun edt-change-direction ()
806 "Toggle movement direction."
808 (if (equal edt-direction-string edt-forward-string)
816 (defun edt-toggle-select ()
817 "Toggle to start (or cancel) text selection."
827 (defun edt-sentence-forward (num)
828 "Move forward to start of next sentence.
829 Accepts a positive prefix argument for the number of sentences to move."
831 (edt-check-prefix num)
834 (error "End of buffer"))
836 (forward-sentence num)
837 (edt-one-word-forward))))
839 (defun edt-sentence-backward (num)
840 "Move backward to next sentence beginning.
841 Accepts a positive prefix argument for the number of sentences to move."
843 (edt-check-prefix num)
846 (error "End of buffer"))
847 (backward-sentence num)))
849 (defun edt-sentence (num)
850 "Move in current direction to next sentence.
851 Accepts a positive prefix argument for the number of sentences to move."
853 (if (equal edt-direction-string edt-forward-string)
854 (edt-sentence-forward num)
855 (edt-sentence-backward num)))
861 (defun edt-paragraph-forward (num)
862 "Move forward to beginning of paragraph.
863 Accepts a positive prefix argument for the number of paragraphs to move."
865 (edt-check-prefix num)
872 (setq num (1- num))))
874 (defun edt-paragraph-backward (num)
875 "Move backward to beginning of paragraph.
876 Accepts a positive prefix argument for the number of paragraphs to move."
878 (edt-check-prefix num)
882 (if (eolp) (next-line 1))
883 (setq num (1- num))))
885 (defun edt-paragraph (num)
886 "Move in current direction to next paragraph.
887 Accepts a positive prefix argument for the number of paragraph to move."
889 (if (equal edt-direction-string edt-forward-string)
890 (edt-paragraph-forward num)
891 (edt-paragraph-backward num)))
897 (defun edt-restore-key ()
898 "Restore last replaced key definition, which is stored in
899 edt-last-replaced-key-definition."
901 (if edt-last-replaced-key-definition
903 (let (edt-key-definition-string)
904 (set 'edt-key-definition-string
905 (read-key-sequence "Press the key to be restored: "))
906 (if (string-equal "\C-m" edt-key-definition-string)
907 (message "Key not restored")
908 (define-key (current-global-map)
909 edt-key-definition-string edt-last-replaced-key-definition))))
910 (error "No replaced key definition to restore!")))
916 (defun edt-window-top ()
917 "Move the cursor to the top of the window."
919 (let ((start-column (current-column)))
920 (move-to-window-line 0)
921 (move-to-column start-column)))
927 (defun edt-window-bottom ()
928 "Move the cursor to the bottom of the window."
930 (let ((start-column (current-column)))
931 (move-to-window-line (- (window-height) 2))
932 (move-to-column start-column)))
935 ;;; SCROLL WINDOW LINE
938 (defun edt-scroll-window-forward-line ()
939 "Move window forward one line leaving cursor at relative position in window."
943 (defun edt-scroll-window-backward-line ()
944 "Move window backward one line leaving cursor at relative position in window."
948 (defun edt-scroll-line ()
949 "Move window one line in current direction."
951 (if (equal edt-direction-string edt-forward-string)
952 (edt-scroll-window-forward-line)
953 (edt-scroll-window-backward-line)))
958 ;;; Scroll a window (less one line) at a time. Leave cursor in center of
961 (defun edt-scroll-window-forward (num)
962 "Scroll forward one window in buffer, less one line.
963 Accepts a positive prefix argument for the number of windows to move."
965 (edt-check-prefix num)
966 (scroll-up (- (* (window-height) num) 2))
967 (edt-line-forward (/ (- (window-height) 1) 2)))
969 (defun edt-scroll-window-backward (num)
970 "Scroll backward one window in buffer, less one line.
971 Accepts a positive prefix argument for the number of windows to move."
973 (edt-check-prefix num)
974 (scroll-down (- (* (window-height) num) 2))
975 (edt-line-backward (/ (- (window-height) 1) 2)))
977 (defun edt-scroll-window (num)
978 "Scroll one window in buffer, less one line, in current direction.
979 Accepts a positive prefix argument for the number windows to move."
981 (if (equal edt-direction-string edt-forward-string)
982 (edt-scroll-window-forward num)
983 (edt-scroll-window-backward num)))
986 ;;; LINE TO BOTTOM OF WINDOW
989 (defun edt-line-to-bottom-of-window ()
990 "Move the current line to the bottom of the window."
995 ;;; LINE TO TOP OF WINDOW
998 (defun edt-line-to-top-of-window ()
999 "Move the current line to the top of the window."
1004 ;;; LINE TO MIDDLE OF WINDOW
1007 (defun edt-line-to-middle-of-window ()
1008 "Move window so line with cursor is in the middle of the window."
1016 (defun edt-goto-percentage (num)
1017 "Move to specified percentage in buffer from top of buffer."
1018 (interactive "NGoto-percentage: ")
1019 (if (or (> num 100) (< num 0))
1020 (error "Percentage %d out of range 0 < percent < 100" num)
1021 (goto-char (/ (* (point-max) num) 100))))
1027 (defun edt-fill-region ()
1028 "Fill selected text."
1030 (edt-check-selection)
1031 (fill-region (point) (mark)))
1034 ;;; INDENT OR FILL REGION
1037 (defun edt-indent-or-fill-region ()
1038 "Fill region in text modes, indent region in programming language modes."
1040 (if (string= paragraph-start "$\\|\f")
1041 (indent-region (point) (mark) nil)
1042 (fill-region (point) (mark))))
1045 ;;; MARK SECTION WISELY
1048 (defun edt-mark-section-wisely ()
1049 "Mark the section in a manner consistent with the major-mode.
1050 Uses mark-defun for emacs-lisp and lisp,
1051 mark-c-function for C,
1052 mark-fortran-subsystem for fortran,
1053 and mark-paragraph for other modes."
1059 (cond ((or (eq major-mode 'emacs-lisp-mode)
1060 (eq major-mode 'lisp-mode))
1062 (message "Lisp defun selected"))
1063 ((eq major-mode 'c-mode)
1065 (message "C function selected"))
1066 ((eq major-mode 'fortran-mode)
1067 (mark-fortran-subprogram)
1068 (message "Fortran subprogram selected"))
1070 (message "Paragraph selected"))))))
1077 "Copy selected region to kill ring, but don't delete it!"
1079 (edt-check-selection)
1080 (copy-region-as-kill (mark) (point))
1082 (message "Selected text COPIED to kill ring"))
1088 (defun edt-cut-or-copy ()
1089 "Cuts (or copies) selected text to kill ring.
1090 Cuts selected text if buffer-read-only is nil.
1091 Copies selected text if buffer-read-only is t."
1093 (if buffer-read-only
1098 ;;; DELETE ENTIRE LINE
1101 (defun edt-delete-entire-line ()
1102 "Delete entire line regardless of cursor position in the line."
1105 (edt-delete-line 1))
1111 (defun edt-duplicate-line (num)
1112 "Duplicate a line of text.
1113 Accepts a positive prefix argument for the number times to duplicate the line."
1115 (edt-check-prefix num)
1116 (let ((old-column (current-column))
1118 (edt-delete-entire-line)
1122 (setq count (1- count)))
1123 (edt-line-forward num)
1124 (move-to-column old-column)))
1130 (defun edt-duplicate-word()
1131 "Duplicate word (or rest of word) found directly above cursor, if any."
1133 (let ((start (point))
1134 (start-column (current-column)))
1136 (move-to-column start-column)
1137 (if (and (not (equal start (point)))
1140 (if (and (equal ?\t (preceding-char))
1141 (< start-column (current-column)))
1143 (let ((beg (point)))
1144 (edt-one-word-forward)
1145 (setq edt-last-copied-word (buffer-substring beg (point))))
1147 (move-to-column start-column)
1148 (insert edt-last-copied-word))
1150 (if (not (equal start (point)))
1152 (move-to-column start-column)
1153 (error "Nothing to duplicate!")))))
1156 ;;; KEY NOT ASSIGNED
1159 (defun edt-key-not-assigned ()
1160 "Displays message that key has not been assigned to a function."
1162 (error "Key not assigned"))
1165 ;;; TOGGLE CAPITALIZATION OF WORD
1168 (defun edt-toggle-capitalization-of-word ()
1169 "Toggle the capitalization of the current word and move forward to next."
1171 (edt-one-word-forward)
1172 (edt-one-word-backward)
1174 (edt-one-word-backward)
1175 (edt-one-word-forward))
1178 ;;; ELIMINATE ALL TABS
1181 (defun edt-eliminate-all-tabs ()
1182 "Convert all tabs to spaces in the entire buffer."
1184 (untabify (point-min) (point-max))
1185 (message "TABS converted to SPACES"))
1188 ;;; DISPLAY THE TIME
1191 (defun edt-display-the-time ()
1192 "Display the current time."
1194 (set 'time-string (current-time-string))
1195 (message time-string))
1202 "Learn a sequence of key strokes to bind to a key."
1204 (if (eq defining-kbd-macro t)
1206 (start-kbd-macro nil)))
1212 (defun edt-remember ()
1213 "Store the sequence of key strokes started by edt-learn to a key."
1215 (if (eq defining-kbd-macro nil)
1216 (error "Nothing to remember!")
1219 (let (edt-key-definition-string)
1220 (set 'edt-key-definition-string
1221 (read-key-sequence "Enter key for binding: "))
1222 (if (string-equal "\C-m" edt-key-definition-string)
1223 (message "Key sequence not remembered")
1225 (set 'edt-learn-macro-count (+ edt-learn-macro-count 1))
1226 (setq edt-last-replaced-key-definition
1227 (lookup-key (current-global-map)
1228 edt-key-definition-string))
1229 (define-key (current-global-map) edt-key-definition-string
1230 (name-last-kbd-macro
1231 (intern (concat "last-learned-sequence-"
1232 (int-to-string edt-learn-macro-count)))))))))))
1239 "Save current buffer, ask to save other buffers, and then exit Emacs."
1242 (save-buffers-kill-emacs))
1249 "Quit Emacs without saving changes."
1257 (defun edt-split-window ()
1258 "Split current window and place cursor in the new window."
1264 ;;; UPDATE MODE LINE
1267 (defun edt-update-mode-line ()
1268 "Make sure mode-line in the current buffer reflects all changes."
1269 (set-buffer-modified-p (buffer-modified-p))
1276 (defun edt-copy-rectangle ()
1277 "Copy a rectangle of text between mark and cursor to register."
1279 (edt-check-selection)
1280 (copy-rectangle-to-register 3 (region-beginning) (region-end) nil)
1282 (message "Selected rectangle COPIED to register"))
1288 (defun edt-cut-rectangle-overstrike-mode ()
1289 "Cut a rectangle of text between mark and cursor to register, replacing
1290 characters with spaces and moving cursor back to upper left corner."
1292 (edt-check-selection)
1293 (setq edt-rect-start-point (region-beginning))
1294 (picture-clear-rectangle-to-register (region-beginning) (region-end) 3)
1295 (set-window-point (get-buffer-window (window-buffer)) edt-rect-start-point)
1296 (message "Selected rectangle CUT to register"))
1298 (defun edt-cut-rectangle-insert-mode ()
1299 "Cut a rectangle of text between mark and cursor to register, deleting
1300 intermediate text and moving cursor back to upper left corner."
1302 (edt-check-selection)
1303 (setq edt-rect-start-point (region-beginning))
1304 (picture-clear-rectangle-to-register (region-beginning) (region-end) 3 t)
1306 (set-window-point (get-buffer-window (window-buffer)) edt-rect-start-point)
1307 (message "Selected rectangle CUT to register"))
1309 (defun edt-cut-rectangle ()
1310 "Cut a rectangular region of text to register.
1311 If overwrite mode is active, cut text is replace with whitespace."
1314 (edt-cut-rectangle-overstrike-mode)
1315 (edt-cut-rectangle-insert-mode)))
1321 (defun edt-paste-rectangle-overstrike-mode ()
1322 "Paste a rectangular region of text from register, replacing text at cursor."
1324 (picture-yank-rectangle-from-register 3))
1326 (defun edt-paste-rectangle-insert-mode ()
1327 "Paste previously deleted rectangular region, inserting text at cursor."
1329 (picture-yank-rectangle-from-register 3 t))
1331 (defun edt-paste-rectangle ()
1332 "Paste a rectangular region of text.
1333 If overwrite mode is active, existing text is replace with text from register."
1336 (edt-paste-rectangle-overstrike-mode)
1337 (edt-paste-rectangle-insert-mode)))
1343 (defun edt-lowercase ()
1344 "Change specified characters to lower case.
1345 If text selection IS active, then characters between the cursor and
1346 mark are changed. If text selection is NOT active, there are two
1347 situations. If the current direction is ADVANCE, then the word under
1348 the cursor is changed to lower case and the cursor is moved to rest at
1349 the beginning of the next word. If the current direction is BACKUP,
1350 the word prior to the word under the cursor is changed to lower case
1351 and the cursor is left to rest at the beginning of that word."
1355 (downcase-region (mark) (point)))
1357 ;; Move to beginning of current word.
1363 (not (eq ?\ (char-syntax (preceding-char))))
1364 (not (memq (preceding-char) edt-word-entities))
1365 (not (memq (following-char) edt-word-entities)))
1366 (edt-one-word-backward))
1367 (if (equal edt-direction-string edt-backward-string)
1368 (edt-one-word-backward))
1369 (let ((beg (point)))
1370 (edt-one-word-forward)
1371 (downcase-region beg (point)))
1372 (if (equal edt-direction-string edt-backward-string)
1373 (edt-one-word-backward)))))
1379 (defun edt-uppercase ()
1380 "Change specified characters to upper case.
1381 If text selection IS active, then characters between the cursor and
1382 mark are changed. If text selection is NOT active, there are two
1383 situations. If the current direction is ADVANCE, then the word under
1384 the cursor is changed to upper case and the cursor is moved to rest at
1385 the beginning of the next word. If the current direction is BACKUP,
1386 the word prior to the word under the cursor is changed to upper case
1387 and the cursor is left to rest at the beginning of that word."
1391 (upcase-region (mark) (point)))
1393 ;; Move to beginning of current word.
1399 (not (eq ?\ (char-syntax (preceding-char))))
1400 (not (memq (preceding-char) edt-word-entities))
1401 (not (memq (following-char) edt-word-entities)))
1402 (edt-one-word-backward))
1403 (if (equal edt-direction-string edt-backward-string)
1404 (edt-one-word-backward))
1405 (let ((beg (point)))
1406 (edt-one-word-forward)
1407 (upcase-region beg (point)))
1408 (if (equal edt-direction-string edt-backward-string)
1409 (edt-one-word-backward)))))
1413 ;;; INITIALIZATION COMMANDS.
1417 ;;; Emacs version 19 X-windows key definition support
1419 (defvar edt-last-answer nil "Most recent response to edt-y-or-n-p.")
1421 (defun edt-y-or-n-p (prompt &optional not-yes)
1422 "Prompt for a y or n answer with positive default.
1423 Optional second argument NOT-YES changes default to negative.
1424 Like emacs y-or-n-p, also accepts space as y and DEL as n."
1425 (message (format "%s[%s]" prompt (if not-yes "n" "y")))
1429 (let ((ans (read-char)))
1430 (cond ((or (= ans ?y) (= ans ?Y) (= ans ?\ ))
1431 (setq edt-last-answer t))
1432 ((or (= ans ?n) (= ans ?N) (= ans ?\C-?))
1433 (setq edt-last-answer nil))
1434 ((= ans ?\r) (setq edt-last-answer (not not-yes)))
1436 (setq doit t) (beep)
1437 (message (format "Please answer y or n. %s[%s]"
1438 prompt (if not-yes "n" "y"))))))))
1441 (defun edt-load-xkeys (file)
1442 "Load the EDT X-windows key definitions FILE.
1443 If FILE is nil, try to load a default file. The default file names are
1444 ~/.edt-lucid-keys for Lucid emacs, and ~/.edt-gnu-keys for GNU emacs."
1445 (interactive "fX key definition file: ")
1447 (setq file (expand-file-name file)))
1449 (setq file (expand-file-name edt-xkeys-file)))
1451 (setq file (expand-file-name "~/.edt-gnu-keys")))
1452 (edt-lucid-emacs19-p
1453 (setq file (expand-file-name "~/.edt-lucid-keys"))))
1454 (cond ((file-readable-p file)
1457 (switch-to-buffer "*scratch*")
1461 Ack!! You're running the Enhanced EDT Emulation under X-windows
1462 without loading an EDT X key definition file. To create an EDT X
1463 key definition file, run the edt-mapper.el program. But ONLY run
1464 it from an Emacs loaded without any of your own customizations
1465 found in your .emacs file, etc. Some user customization confuse
1466 the edt-mapper function. To do this, you need to invoke Emacs
1469 emacs -q -l edt-mapper.el
1471 The file edt-mapper.el includes these same directions on how to
1472 use it! Perhaps it's laying around here someplace. \n ")
1473 (let ((file "edt-mapper.el")
1476 (search-list (append (list (expand-file-name ".")) load-path)))
1477 (while (and (not found) search-list)
1478 (setq path (concat (car search-list)
1479 (if (string-match "/$" (car search-list)) "" "/")
1481 (if (and (file-exists-p path) (not (file-directory-p path)))
1483 (setq search-list (cdr search-list)))
1486 "Ah yes, there it is, in \n\n %s \n\n" path))
1487 (if (edt-y-or-n-p "Do you want to run it now? ")
1489 (error "EDT Emulation not configured.")))
1491 (insert "Nope, I can't seem to find it. :-(\n\n")
1493 (error "EDT Emulation not configured.")))))))
1496 (defun edt-emulation-on ()
1497 "Turn on EDT Emulation."
1499 ;; If using MS-DOS, need to load edt-pc.el
1500 (if (string-equal system-type "ms-dos")
1501 (setq edt-term "pc")
1502 (setq edt-term (getenv "TERM")))
1503 ;; All DEC VT series terminals are supported by loading edt-vt100.el
1504 (if (string-equal "vt" (substring edt-term 0 (min (length edt-term) 2)))
1505 (setq edt-term "vt100"))
1506 ;; Load EDT terminal specific configuration file.
1507 (let ((term edt-term)
1510 (not (load (concat "edt-" term) t t)))
1511 ;; Strip off last hyphen and what follows, then try again
1512 (if (setq hyphend (string-match "[-_][^-_]+$" term))
1513 (setq term (substring term 0 hyphend))
1515 ;; Override terminal-specific file if running X Windows. X Windows support
1516 ;; is handled differently in edt-load-xkeys
1518 (edt-load-xkeys nil)
1520 (error "Unable to load EDT terminal specific file for %s" edt-term)))
1521 (setq edt-term term))
1522 (setq edt-orig-transient-mark-mode transient-mark-mode)
1523 (add-hook 'activate-mark-hook
1526 (edt-select-mode t))))
1527 (add-hook 'deactivate-mark-hook
1530 (edt-select-mode nil))))
1531 (if (load "edt-user" t t)
1532 (edt-user-emulation-setup)
1533 (edt-default-emulation-setup)))
1535 (defun edt-emulation-off()
1536 "Select original global key bindings, disabling EDT Emulation."
1538 (use-global-map global-map)
1539 (if (not edt-keep-current-page-delimiter)
1540 (setq page-delimiter edt-orig-page-delimiter))
1541 (setq edt-direction-string "")
1542 (setq edt-select-mode-text nil)
1544 (force-mode-line-update t)
1545 (setq transient-mark-mode edt-orig-transient-mark-mode)
1546 (message "Original key bindings restored; EDT Emulation disabled"))
1548 (defun edt-default-emulation-setup (&optional user-setup)
1549 "Setup emulation of DEC's EDT editor."
1550 ;; Setup default EDT global map by copying global map bindings.
1551 ;; This preserves ESC and C-x prefix bindings and other bindings we
1552 ;; wish to retain in EDT emulation mode keymaps. It also permits
1553 ;; customization of these bindings in the EDT global maps without
1554 ;; disturbing the original bindings in global-map.
1555 (fset 'edt-default-ESC-prefix (copy-keymap 'ESC-prefix))
1556 (setq edt-default-global-map (copy-keymap (current-global-map)))
1557 (define-key edt-default-global-map "\e" 'edt-default-ESC-prefix)
1558 (define-prefix-command 'edt-default-gold-map)
1559 (edt-setup-default-bindings)
1560 ;; If terminal has additional function keys, the terminal-specific
1561 ;; initialization file can assign bindings to them via the optional
1562 ;; function edt-setup-extra-default-bindings.
1563 (if (fboundp 'edt-setup-extra-default-bindings)
1564 (edt-setup-extra-default-bindings))
1565 ;; Variable needed by edt-learn.
1566 (setq edt-learn-macro-count 0)
1567 ;; Display EDT text selection active within the mode line
1568 (or (assq 'edt-select-mode minor-mode-alist)
1569 (setq minor-mode-alist
1570 (cons '(edt-select-mode edt-select-mode) minor-mode-alist)))
1571 ;; Display EDT direction of motion within the mode line
1572 (or (assq 'edt-direction-string minor-mode-alist)
1573 (setq minor-mode-alist
1575 '(edt-direction-string edt-direction-string) minor-mode-alist)))
1578 (setq edt-user-map-configured t)
1579 (fset 'edt-emulation-on (symbol-function 'edt-select-user-global-map)))
1581 (fset 'edt-emulation-on (symbol-function 'edt-select-default-global-map))
1582 (edt-select-default-global-map))))
1584 (defun edt-user-emulation-setup ()
1585 "Setup user custom emulation of DEC's EDT editor."
1586 ;; Initialize EDT default bindings.
1587 (edt-default-emulation-setup t)
1588 ;; Setup user EDT global map by copying default EDT global map bindings.
1589 (fset 'edt-user-ESC-prefix (copy-keymap 'edt-default-ESC-prefix))
1590 (setq edt-user-global-map (copy-keymap edt-default-global-map))
1591 (define-key edt-user-global-map "\e" 'edt-user-ESC-prefix)
1592 ;; If terminal has additional function keys, the user's initialization
1593 ;; file can assign bindings to them via the optional
1594 ;; function edt-setup-extra-default-bindings.
1595 (define-prefix-command 'edt-user-gold-map)
1596 (fset 'edt-user-gold-map (copy-keymap 'edt-default-gold-map))
1597 (edt-setup-user-bindings)
1598 (edt-select-user-global-map))
1600 (defun edt-select-default-global-map()
1601 "Select default EDT emulation key bindings."
1603 (transient-mark-mode 1)
1604 (use-global-map edt-default-global-map)
1605 (if (not edt-keep-current-page-delimiter)
1607 (setq edt-orig-page-delimiter page-delimiter)
1608 (setq page-delimiter "\f")))
1609 (setq edt-default-map-active t)
1611 (setq edt-select-mode-text 'edt-select-mode-string)
1613 (message "Default EDT keymap active"))
1615 (defun edt-select-user-global-map()
1616 "Select user EDT emulation custom key bindings."
1618 (if edt-user-map-configured
1620 (transient-mark-mode 1)
1621 (use-global-map edt-user-global-map)
1622 (if (not edt-keep-current-page-delimiter)
1624 (setq edt-orig-page-delimiter page-delimiter)
1625 (setq page-delimiter "\f")))
1626 (setq edt-default-map-active nil)
1628 (setq edt-select-mode-text 'edt-select-mode-string)
1630 (message "User EDT custom keymap active"))
1631 (error "User EDT custom keymap NOT configured!")))
1633 (defun edt-switch-global-maps ()
1634 "Toggle between default EDT keymap and user EDT keymap."
1636 (if edt-default-map-active
1637 (edt-select-user-global-map)
1638 (edt-select-default-global-map)))
1640 ;; There are three key binding functions needed: one for standard keys
1641 ;; (used to bind control keys, primarily), one for Gold sequences of
1642 ;; standard keys, and one for function keys.
1644 (defun edt-bind-gold-key (key gold-binding &optional default)
1645 "Binds commands to a gold key sequence in the EDT Emulator."
1647 (define-key 'edt-default-gold-map key gold-binding)
1648 (define-key 'edt-user-gold-map key gold-binding)))
1650 (defun edt-bind-standard-key (key gold-binding &optional default)
1651 "Bind commands to a gold key sequence in the default EDT keymap."
1653 (define-key edt-default-global-map key gold-binding)
1654 (define-key edt-user-global-map key gold-binding)))
1656 (defun edt-bind-function-key
1657 (function-key binding gold-binding &optional default)
1658 "Binds function keys in the EDT Emulator."
1659 (catch 'edt-key-not-supported
1660 (let ((key-vector (cdr (assoc function-key *EDT-keys*))))
1661 (if (stringp key-vector)
1662 (throw 'edt-key-not-supported t))
1663 (if (not (null key-vector))
1667 (define-key edt-default-global-map key-vector binding)
1668 (define-key 'edt-default-gold-map key-vector gold-binding))
1670 (define-key edt-user-global-map key-vector binding)
1671 (define-key 'edt-user-gold-map key-vector gold-binding))))
1672 (error "%s is not a legal function key name" function-key)))))
1674 (defun edt-setup-default-bindings ()
1675 "Assigns default EDT Emulation keyboard bindings."
1677 ;; Function Key Bindings: Regular and GOLD.
1679 ;; VT100/VT200/VT300 PF1 (GOLD), PF2, PF3, PF4 Keys
1680 (edt-bind-function-key "PF1" 'edt-default-gold-map 'edt-mark-section-wisely t)
1681 (edt-bind-function-key "PF2" 'edt-electric-keypad-help 'describe-function t)
1682 (edt-bind-function-key "PF3" 'edt-find-next 'edt-find t)
1683 (edt-bind-function-key "PF4" 'edt-delete-line 'edt-undelete-line t)
1685 ;; VT100/VT200/VT300 Arrow Keys
1686 (edt-bind-function-key "UP" 'previous-line 'edt-window-top t)
1687 (edt-bind-function-key "DOWN" 'next-line 'edt-window-bottom t)
1688 (edt-bind-function-key "LEFT" 'backward-char 'edt-sentence-backward t)
1689 (edt-bind-function-key "RIGHT" 'forward-char 'edt-sentence-forward t)
1691 ;; VT100/VT200/VT300 Keypad Keys
1692 (edt-bind-function-key "KP0" 'edt-line 'open-line t)
1693 (edt-bind-function-key "KP1" 'edt-word 'edt-change-case t)
1694 (edt-bind-function-key "KP2" 'edt-end-of-line 'edt-delete-to-end-of-line t)
1695 (edt-bind-function-key "KP3" 'edt-character 'quoted-insert t)
1696 (edt-bind-function-key "KP4" 'edt-advance 'edt-bottom t)
1697 (edt-bind-function-key "KP5" 'edt-backup 'edt-top t)
1698 (edt-bind-function-key "KP6" 'edt-cut 'yank t)
1699 (edt-bind-function-key "KP7" 'edt-page 'execute-extended-command t)
1700 (edt-bind-function-key "KP8" 'edt-sect 'edt-fill-region t)
1701 (edt-bind-function-key "KP9" 'edt-append 'edt-replace t)
1702 (edt-bind-function-key "KP-" 'edt-delete-word 'edt-undelete-word t)
1703 (edt-bind-function-key "KP," 'edt-delete-character 'edt-undelete-character t)
1704 (edt-bind-function-key "KPP" 'edt-select 'edt-reset t)
1705 (edt-bind-function-key "KPE" 'other-window 'query-replace t)
1707 ;; VT200/VT300 Function Keys
1708 ;; (F1 through F5, on the VT220, are not programmable, so we skip
1709 ;; making default bindings to those keys.
1710 (edt-bind-function-key "FIND" 'edt-find-next 'edt-find t)
1711 (edt-bind-function-key "INSERT" 'yank 'edt-key-not-assigned t)
1712 (edt-bind-function-key "REMOVE" 'edt-cut 'edt-copy t)
1713 (edt-bind-function-key "SELECT" 'edt-toggle-select 'edt-key-not-assigned t)
1714 (edt-bind-function-key "NEXT" 'edt-sect-forward 'edt-key-not-assigned t)
1715 (edt-bind-function-key "PREVIOUS" 'edt-sect-backward 'edt-key-not-assigned t)
1716 (edt-bind-function-key "F6" 'edt-key-not-assigned 'edt-key-not-assigned t)
1717 (edt-bind-function-key "F7" 'edt-copy-rectangle 'edt-key-not-assigned t)
1718 (edt-bind-function-key "F8"
1719 'edt-cut-rectangle-overstrike-mode 'edt-paste-rectangle-overstrike-mode t)
1720 (edt-bind-function-key "F9"
1721 'edt-cut-rectangle-insert-mode 'edt-paste-rectangle-insert-mode t)
1722 (edt-bind-function-key "F10" 'edt-cut-rectangle 'edt-paste-rectangle t)
1723 ;; Under X, the F11 key can be bound. If using a VT-200 or higher terminal,
1724 ;; the default emacs terminal support causes the VT F11 key to seem as if it
1725 ;; is an ESC key when in emacs.
1726 (edt-bind-function-key "F11"
1727 'edt-key-not-assigned 'edt-key-not-assigned t)
1728 (edt-bind-function-key "F12"
1729 'edt-beginning-of-line 'delete-other-windows t) ;BS
1730 (edt-bind-function-key "F13"
1731 'edt-delete-to-beginning-of-word 'edt-key-not-assigned t) ;LF
1732 (edt-bind-function-key "F14" 'edt-key-not-assigned 'edt-key-not-assigned t)
1733 (edt-bind-function-key "HELP" 'edt-electric-keypad-help 'edt-key-not-assigned t)
1734 (edt-bind-function-key "DO" 'execute-extended-command 'edt-key-not-assigned t)
1735 (edt-bind-function-key "F17" 'edt-key-not-assigned 'edt-key-not-assigned t)
1736 (edt-bind-function-key "F18" 'edt-key-not-assigned 'edt-key-not-assigned t)
1737 (edt-bind-function-key "F19" 'edt-key-not-assigned 'edt-key-not-assigned t)
1738 (edt-bind-function-key "F20" 'edt-key-not-assigned 'edt-key-not-assigned t)
1740 ;; Control key bindings: Regular and GOLD
1742 ;; Standard EDT control key bindings conflict with standard Emacs
1743 ;; control key bindings. Normally, the standard Emacs control key
1744 ;; bindings are left unchanged in the default EDT mode. However, if
1745 ;; the variable edt-use-EDT-control-key-bindings is set to true
1746 ;; before invoking edt-emulation-on for the first time, then the
1747 ;; standard EDT bindings (with some enhancements) as defined here are
1749 (if edt-use-EDT-control-key-bindings
1751 (edt-bind-standard-key "\C-a" 'edt-key-not-assigned t)
1752 (edt-bind-standard-key "\C-b" 'edt-key-not-assigned t)
1753 ;; Leave binding of C-c as original prefix key.
1754 (edt-bind-standard-key "\C-d" 'edt-key-not-assigned t)
1755 (edt-bind-standard-key "\C-e" 'edt-key-not-assigned t)
1756 (edt-bind-standard-key "\C-f" 'edt-key-not-assigned t)
1757 ;; Leave binding of C-g to keyboard-quit
1758 ; (edt-bind-standard-key "\C-g" 'keyboard-quit t)
1759 ;; Standard EDT binding of C-h. To invoke Emacs help, use
1760 ;; GOLD-C-h instead.
1761 (edt-bind-standard-key "\C-h" 'edt-beginning-of-line t)
1762 (edt-bind-standard-key "\C-i" 'edt-tab-insert t)
1763 (edt-bind-standard-key "\C-j" 'edt-delete-to-beginning-of-word t)
1764 (edt-bind-standard-key "\C-k" 'edt-define-key t)
1765 (edt-bind-gold-key "\C-k" 'edt-restore-key t)
1766 (edt-bind-standard-key "\C-l" 'edt-form-feed-insert t)
1767 ;; Leave binding of C-m to newline.
1768 (edt-bind-standard-key "\C-n" 'edt-set-screen-width-80 t)
1769 (edt-bind-standard-key "\C-o" 'edt-key-not-assigned t)
1770 (edt-bind-standard-key "\C-p" 'edt-key-not-assigned t)
1771 (edt-bind-standard-key "\C-q" 'edt-key-not-assigned t)
1772 ;; Leave binding of C-r to isearch-backward.
1773 ;; Leave binding of C-s to isearch-forward.
1774 (edt-bind-standard-key "\C-t" 'edt-display-the-time t)
1775 (edt-bind-standard-key "\C-u" 'edt-delete-to-beginning-of-line t)
1776 (edt-bind-standard-key "\C-v" 'redraw-display t)
1777 (edt-bind-standard-key "\C-w" 'edt-set-screen-width-132 t)
1778 ;; Leave binding of C-x as original prefix key.
1779 (edt-bind-standard-key "\C-y" 'edt-key-not-assigned t)
1780 ; (edt-bind-standard-key "\C-z" 'suspend-emacs t)
1784 ;; GOLD bindings for a few Control keys.
1785 (edt-bind-gold-key "\C-g" 'keyboard-quit t); Just in case.
1786 (edt-bind-gold-key "\C-h" 'help-for-help t)
1787 (edt-bind-gold-key "\C-\\" 'split-window-vertically t)
1789 ;; GOLD bindings for regular keys.
1790 (edt-bind-gold-key "a" 'edt-key-not-assigned t)
1791 (edt-bind-gold-key "A" 'edt-key-not-assigned t)
1792 (edt-bind-gold-key "b" 'buffer-menu t)
1793 (edt-bind-gold-key "B" 'buffer-menu t)
1794 (edt-bind-gold-key "c" 'compile t)
1795 (edt-bind-gold-key "C" 'compile t)
1796 (edt-bind-gold-key "d" 'delete-window t)
1797 (edt-bind-gold-key "D" 'delete-window t)
1798 (edt-bind-gold-key "e" 'edt-exit t)
1799 (edt-bind-gold-key "E" 'edt-exit t)
1800 (edt-bind-gold-key "f" 'find-file t)
1801 (edt-bind-gold-key "F" 'find-file t)
1802 (edt-bind-gold-key "g" 'find-file-other-window t)
1803 (edt-bind-gold-key "G" 'find-file-other-window t)
1804 (edt-bind-gold-key "h" 'edt-electric-keypad-help t)
1805 (edt-bind-gold-key "H" 'edt-electric-keypad-help t)
1806 (edt-bind-gold-key "i" 'insert-file t)
1807 (edt-bind-gold-key "I" 'insert-file t)
1808 (edt-bind-gold-key "j" 'edt-key-not-assigned t)
1809 (edt-bind-gold-key "J" 'edt-key-not-assigned t)
1810 (edt-bind-gold-key "k" 'edt-toggle-capitalization-of-word t)
1811 (edt-bind-gold-key "K" 'edt-toggle-capitalization-of-word t)
1812 (edt-bind-gold-key "l" 'edt-lowercase t)
1813 (edt-bind-gold-key "L" 'edt-lowercase t)
1814 (edt-bind-gold-key "m" 'save-some-buffers t)
1815 (edt-bind-gold-key "M" 'save-some-buffers t)
1816 (edt-bind-gold-key "n" 'next-error t)
1817 (edt-bind-gold-key "N" 'next-error t)
1818 (edt-bind-gold-key "o" 'switch-to-buffer-other-window t)
1819 (edt-bind-gold-key "O" 'switch-to-buffer-other-window t)
1820 (edt-bind-gold-key "p" 'edt-key-not-assigned t)
1821 (edt-bind-gold-key "P" 'edt-key-not-assigned t)
1822 (edt-bind-gold-key "q" 'edt-quit t)
1823 (edt-bind-gold-key "Q" 'edt-quit t)
1824 (edt-bind-gold-key "r" 'revert-file t)
1825 (edt-bind-gold-key "R" 'revert-file t)
1826 (edt-bind-gold-key "s" 'save-buffer t)
1827 (edt-bind-gold-key "S" 'save-buffer t)
1828 (edt-bind-gold-key "t" 'edt-key-not-assigned t)
1829 (edt-bind-gold-key "T" 'edt-key-not-assigned t)
1830 (edt-bind-gold-key "u" 'edt-uppercase t)
1831 (edt-bind-gold-key "U" 'edt-uppercase t)
1832 (edt-bind-gold-key "v" 'find-file-other-window t)
1833 (edt-bind-gold-key "V" 'find-file-other-window t)
1834 (edt-bind-gold-key "w" 'write-file t)
1835 (edt-bind-gold-key "W" 'write-file t)
1836 (edt-bind-gold-key "x" 'edt-key-not-assigned t)
1837 (edt-bind-gold-key "X" 'edt-key-not-assigned t)
1838 (edt-bind-gold-key "y" 'edt-emulation-off t)
1839 (edt-bind-gold-key "Y" 'edt-emulation-off t)
1840 (edt-bind-gold-key "z" 'edt-switch-global-maps t)
1841 (edt-bind-gold-key "Z" 'edt-switch-global-maps t)
1842 (edt-bind-gold-key "1" 'delete-other-windows t)
1843 (edt-bind-gold-key "!" 'edt-key-not-assigned t)
1844 (edt-bind-gold-key "2" 'edt-split-window t)
1845 (edt-bind-gold-key "@" 'edt-key-not-assigned t)
1846 (edt-bind-gold-key "3" 'edt-key-not-assigned t)
1847 (edt-bind-gold-key "#" 'edt-key-not-assigned t)
1848 (edt-bind-gold-key "4" 'edt-key-not-assigned t)
1849 (edt-bind-gold-key "$" 'edt-key-not-assigned t)
1850 (edt-bind-gold-key "5" 'edt-key-not-assigned t)
1851 (edt-bind-gold-key "%" 'edt-goto-percentage t)
1852 (edt-bind-gold-key "6" 'edt-key-not-assigned t)
1853 (edt-bind-gold-key "^" 'edt-key-not-assigned t)
1854 (edt-bind-gold-key "7" 'edt-key-not-assigned t)
1855 (edt-bind-gold-key "&" 'edt-key-not-assigned t)
1856 (edt-bind-gold-key "8" 'edt-key-not-assigned t)
1857 (edt-bind-gold-key "*" 'edt-key-not-assigned t)
1858 (edt-bind-gold-key "9" 'edt-key-not-assigned t)
1859 (edt-bind-gold-key "(" 'edt-key-not-assigned t)
1860 (edt-bind-gold-key "0" 'edt-key-not-assigned t)
1861 (edt-bind-gold-key ")" 'edt-key-not-assigned t)
1862 (edt-bind-gold-key " " 'undo t)
1863 (edt-bind-gold-key "," 'edt-key-not-assigned t)
1864 (edt-bind-gold-key "<" 'edt-key-not-assigned t)
1865 (edt-bind-gold-key "." 'edt-key-not-assigned t)
1866 (edt-bind-gold-key ">" 'edt-key-not-assigned t)
1867 (edt-bind-gold-key "/" 'edt-key-not-assigned t)
1868 (edt-bind-gold-key "?" 'edt-key-not-assigned t)
1869 (edt-bind-gold-key "\\" 'edt-key-not-assigned t)
1870 (edt-bind-gold-key "|" 'edt-key-not-assigned t)
1871 (edt-bind-gold-key ";" 'edt-key-not-assigned t)
1872 (edt-bind-gold-key ":" 'edt-key-not-assigned t)
1873 (edt-bind-gold-key "'" 'edt-key-not-assigned t)
1874 (edt-bind-gold-key "\"" 'edt-key-not-assigned t)
1875 (edt-bind-gold-key "-" 'edt-key-not-assigned t)
1876 (edt-bind-gold-key "_" 'edt-key-not-assigned t)
1877 (edt-bind-gold-key "=" 'goto-line t)
1878 (edt-bind-gold-key "+" 'edt-key-not-assigned t)
1879 (edt-bind-gold-key "[" 'edt-key-not-assigned t)
1880 (edt-bind-gold-key "{" 'edt-key-not-assigned t)
1881 (edt-bind-gold-key "]" 'edt-key-not-assigned t)
1882 (edt-bind-gold-key "}" 'edt-key-not-assigned t)
1883 (edt-bind-gold-key "`" 'what-line t)
1884 (edt-bind-gold-key "~" 'edt-key-not-assigned t)
1888 ;;; DEFAULT EDT KEYPAD HELP
1892 ;;; Upper case commands in the keypad diagram below indicate that the
1893 ;;; emulation should look and feel very much like EDT. Lower case
1894 ;;; commands are enhancements and/or additions to the EDT keypad
1895 ;;; commands or are native Emacs commands.
1898 (defun edt-keypad-help ()
1900 DEFAULT EDT Keypad Active
1902 F7: Copy Rectangle +----------+----------+----------+----------+
1903 F8: Cut Rect Overstrike |Prev Line |Next Line |Bkwd Char |Frwd Char |
1904 G-F8: Paste Rect Overstrike | (UP) | (DOWN) | (LEFT) | (RIGHT) |
1905 F9: Cut Rect Insert |Window Top|Window Bot|Bkwd Sent |Frwd Sent |
1906 G-F9: Paste Rect Insert +----------+----------+----------+----------+
1908 G-F10: Paste Rectangle
1910 F12: Begining of Line +----------+----------+----------+----------+
1911 G-F12: Delete Other Windows | GOLD | HELP | FNDNXT | DEL L |
1912 F13: Delete to Begin of Word | (PF1) | (PF2) | (PF3) | (PF4) |
1913 HELP: Keypad Help |Mark Wisel|Desc Funct| FIND | UND L |
1914 DO: Execute extended command +----------+----------+----------+----------+
1915 | PAGE | SECT | APPEND | DEL W |
1916 C-g: Keyboard Quit | (7) | (8) | (9) | (-) |
1917 G-C-g: Keyboard Quit |Ex Ext Cmd|Fill Regio| REPLACE | UND W |
1918 C-h: Beginning of Line +----------+----------+----------+----------+
1919 G-C-h: Emacs Help | ADVANCE | BACKUP | CUT | DEL C |
1920 C-i: Tab Insert | (4) | (5) | (6) | (,) |
1921 C-j: Delete to Begin of Word | BOTTOM | TOP | Yank | UND C |
1922 C-k: Define Key +----------+----------+----------+----------+
1923 G-C-k: Restore Key | WORD | EOL | CHAR | Next |
1924 C-l: Form Feed Insert | (1) | (2) | (3) | Window |
1925 C-n: Set Screen Width 80 | CHNGCASE | DEL EOL |Quoted Ins| !
1926 C-r: Isearch Backward +---------------------+----------+ (ENTER) |
1927 C-s: Isearch Forward | LINE | SELECT | !
1928 C-t: Display the Time | (0) | (.) | Query |
1929 C-u: Delete to Begin of Line | Open Line | RESET | Replace |
1930 C-v: Redraw Display +---------------------+----------+----------+
1931 C-w: Set Screen Width 132
1932 C-z: Suspend Emacs +----------+----------+----------+
1933 G-C-\\: Split Window | FNDNXT | Yank | CUT |
1934 | (FIND) | (INSERT) | (REMOVE) |
1935 G-b: Buffer Menu | FIND | | COPY |
1936 G-c: Compile +----------+----------+----------+
1937 G-d: Delete Window |SELECT/RES|SECT BACKW|SECT FORWA|
1938 G-e: Exit | (SELECT) |(PREVIOUS)| (NEXT) |
1939 G-f: Find File | | | |
1940 G-g: Find File Other Window +----------+----------+----------+
1943 G-k: Toggle Capitalization Word
1944 G-l: Downcase Region
1945 G-m: Save Some Buffers
1947 G-o: Switch to Next Window
1952 G-v: Find File Other Window
1954 G-y: EDT Emulation OFF
1955 G-z: Switch to User EDT Key Bindings
1956 G-1: Delete Other Windows
1958 G-%: Go to Percentage
1959 G- : Undo (GOLD Spacebar)
1964 (describe-function 'edt-keypad-help))
1966 (defun edt-electric-helpify (fun)
1967 (let ((name "*Help*"))
1968 (if (save-window-excursion
1969 (let* ((p (symbol-function 'print-help-return-message))
1970 (b (get-buffer name))
1971 (m (buffer-modified-p b)))
1972 (and b (not (get-buffer-window b))
1976 (message "%s..." (capitalize (symbol-name fun)))
1980 (set-buffer-modified-p t)))
1981 (fset 'print-help-return-message 'ignore)
1982 (call-interactively fun)
1983 (and (get-buffer name)
1984 (get-buffer-window (get-buffer name))
1986 (not (eq b (get-buffer name)))
1987 (not (buffer-modified-p b)))))
1988 (fset 'print-help-return-message p)
1989 (and b (buffer-name b)
1992 (set-buffer-modified-p m))))))
1993 (with-electric-help 'delete-other-windows name t))))
1995 (defun edt-electric-keypad-help ()
1997 (edt-electric-helpify 'edt-keypad-help))
1999 (defun edt-electric-user-keypad-help ()
2001 (edt-electric-helpify 'edt-user-keypad-help))
2004 ;;; Generic EDT emulation screen width commands.
2006 ;; If modification of terminal attributes is desired when invoking these
2007 ;; commands, then the corresponding terminal specific file will contain a
2008 ;; re-definition of these commands.
2010 (defun edt-set-screen-width-80 ()
2011 "Set screen width to 80 columns."
2013 (set-screen-width 80)
2014 (message "Screen width 80"))
2016 (defun edt-set-screen-width-132 ()
2017 "Set screen width to 132 columns."
2019 (set-screen-width 132)
2020 (message "Screen width 132"))
2024 ;;; edt.el ends here