xemacs-beta: lisp/emulators/tpu-edt.el comparison

comparison lisp/emulators/tpu-edt.el @ 134:34a5b81f86ba r20-2b1

Import from CVS: tag r20-2b1

author	cvs
date	Mon, 13 Aug 2007 09:30:11 +0200
parents	54cc21c15cbb
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:b27e67717092
+:34a5b81f86ba
 ;; Author: Rob Riepel <riepel@networking.stanford.edu>
 ;; Maintainer: Rob Riepel <riepel@networking.stanford.edu>
 ;; Version: 4.2
 ;; Keywords: emulations
+;; Modified for XEmacs by R. Kevin Oberman <oberman@es.net>
 ;; This file is part of XEmacs.
 ;; XEmacs is free software; you can redistribute it and/or modify it
 ;; under the terms of the GNU General Public License as published by
 ;;    (define-key SS3-map "w" 'tpu-paragraph)                    ; KP7
 ;;    ; Repeat the preceding mappings for X-windows.
 ;;    (cond
 ;;     (window-system
-;;      (global-set-key [kp-7] 'tpu-paragraph)                   ; KP7
+;;      (global-set-key [kp_7] 'tpu-paragraph)                   ; KP7
-;;      (define-key GOLD-map [kp-f1] 'universal-argument)))      ; GOLD-PF1
+;;      (define-key GOLD-map [kp_f1] 'universal-argument)))      ; GOLD-PF1
 ;;    ; Display the TPU-edt version.
 ;;    (tpu-version)
 	 (tpu-unset-match) nil)))
 (defun tpu-show-match-markers nil
 "Show the values of the match markers."
 (interactive)
+(setq zmacs-region-stays t)
 (if (markerp tpu-match-beginning-mark)
 (let ((beg (marker-position tpu-match-beginning-mark)))
 	(message "(%s, %s) in %s -- current %s in %s"
 		 (if beg (1- beg) nil)
 		 (marker-position tpu-match-end-mark)
 "The set of user-defined markers (breadcrumbs), as a plist.")
 (defun tpu-drop-breadcrumb (num)
 "Drops a breadcrumb that can be returned to later with goto-breadcrumb."
 (interactive "p")
+(setq zmacs-region-stays t)
 (put tpu-breadcrumb-plist num (list (current-buffer) (point)))
 (message "Mark %d set." num))
 (defun tpu-goto-breadcrumb (num)
 "Returns to a breadcrumb set with drop-breadcrumb."
 (interactive "p")
+(setq zmacs-region-stays t)
 (cond ((get tpu-breadcrumb-plist num)
 	 (switch-to-buffer (car (get tpu-breadcrumb-plist num)))
 	 (goto-char (tpu-cadr (get tpu-breadcrumb-plist num)))
 	 (message "mark %d found." num))
 	(t
 	 (fill-paragraph num))))
 (defun tpu-version nil
 "Print the TPU-edt version number."
 (interactive)
+(setq zmacs-region-stays t)
 (message
 "TPU-edt version %s by Rob Riepel (riepel@networking.stanford.edu)"
 tpu-version))
 (defun tpu-reset-screen-size (height width)
 "Sets the screen size."
 (interactive "nnew screen height: \nnnew screen width: ")
+(setq zmacs-region-stays t)
 (set-screen-height height)
 (set-screen-width width))
 (defun tpu-toggle-newline-and-indent nil
 "Toggle between 'newline and indent' and 'simple newline'."
 (interactive)
+(setq zmacs-region-stays t)
 (cond (tpu-newline-and-indent-p
 (setq tpu-newline-and-indent-string "")
 (setq tpu-newline-and-indent-p nil)
 (tpu-local-set-key "\C-m" 'newline))
 (t
 (if (tpu-mark) (tpu-unselect t)))
 (defun tpu-toggle-overwrite-mode nil
 "Switches in and out of overwrite mode"
 (interactive)
+(setq zmacs-region-stays t)
 (cond (overwrite-mode
 	 (tpu-local-set-key "\177" tpu-saved-delete-func)
 	 (overwrite-mode 0))
 	(t
 	 (setq tpu-saved-delete-func (local-key-binding "\177"))
 (defun tpu-special-insert (num)
 "Insert a character or control code according to
 its ASCII decimal value."
 (interactive "P")
+(setq zmacs-region-stays t)
 (if overwrite-mode (delete-char 1))
 (insert (if num num 0)))
 (defun tpu-quoted-insert (num)
 "Read next input character and insert it.
 This is useful for inserting control characters."
 (interactive "*p")
+(setq zmacs-region-stays t)
 (let ((char (read-char)) )
 (if overwrite-mode (delete-char num))
 (insert-char char num)))
 ;;;  TPU line-mode commands
 ;;;
 (defun tpu-include (file)
 "TPU-like include file"
 (interactive "fInclude file: ")
+(setq zmacs-region-stays t)
 (save-excursion
 (insert-file file)
 (message "")))
 (defun tpu-get (file)
 "TPU-like get file"
 (interactive "FFile to get: ")
+(setq zmacs-region-stays t)
 (find-file file))
 (defun tpu-what-line nil
 "Tells what line the point is on,
 and the total number of lines in the buffer."
 (interactive)
+(setq zmacs-region-stays t)
 (if (eobp)
 (message "You are at the End of Buffer.  The last line is %d."
 	       (count-lines 1 (point-max)))
 (message "Line %d of %d"
 	     (count-lines 1 (1+ (point)))
 (defvar tpu-help-p "p")                         ; tpu-help "p" symbol
 (defun tpu-help nil
 "Display TPU-edt help."
 (interactive)
+(setq zmacs-region-stays t)
 ;; Save current window configuration
 (save-window-excursion
 ;; Create and fill help buffer if necessary
 (if (not (get-buffer "*TPU-edt Help*"))
 	(progn (generate-new-buffer "*TPU-edt Help*")
 ;;;  Auto-insert
 ;;;
 (defun tpu-insert-escape nil
 "Inserts an escape character, and so becomes the escape-key alias."
 (interactive)
+(setq zmacs-region-stays t)
 (insert "\e"))
 (defun tpu-insert-formfeed nil
 "Inserts a formfeed character."
 (interactive)
+(setq zmacs-region-stays t)
 (insert "\C-L"))
 ;;;
 ;;;  Define key
 (defvar tpu-saved-control-r nil "Saved value of Control-r.")
 (defun tpu-end-define-macro-key (key)
 "Ends the current macro definition"
 (interactive "kPress the key you want to use to do what was just learned: ")
+(setq zmacs-region-stays t)
 (end-kbd-macro nil)
 (global-set-key key last-kbd-macro)
 (global-set-key "\C-r" tpu-saved-control-r))
 (defun tpu-define-macro-key nil
 "Bind a set of keystrokes to a single key, or key combination."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-saved-control-r (global-key-binding "\C-r"))
 (global-set-key "\C-r" 'tpu-end-define-macro-key)
 (start-kbd-macro nil))
 (save-buffers-kill-emacs t)))
 (defun tpu-write-current-buffers nil
 "Save all modified buffers without exiting."
 (interactive)
+(setq zmacs-region-stays t)
 (save-some-buffers t))
 (defun tpu-next-buffer nil
 "Go to next buffer in ring."
 (interactive)
 buffer-list)))
 (defun tpu-next-window nil
 "Move to the next window."
 (interactive)
+(setq zmacs-region-stays t)
 (if (one-window-p) (message "There is only one window on screen.")
 (other-window 1)))
 (defun tpu-previous-window nil
 "Move to the previous window."
 (interactive)
+(setq zmacs-region-stays t)
 (if (one-window-p) (message "There is only one window on screen.")
 (select-window (previous-window))))
 ;;;
 ;;;  Search
 ;;;
 (defun tpu-toggle-regexp nil
 "Switches in and out of regular expression search and replace mode."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-regexp-p (not tpu-regexp-p))
 (tpu-set-search)
 (and (interactive-p)
 (message "Regular expression search and substitute %sabled."
 		(if tpu-regexp-p "en" "dis"))))
 (defun tpu-search nil
 "Search for a string or regular expression.
 The search is performed in the current direction."
 (interactive)
+(setq zmacs-region-stays t)
 (tpu-set-search)
 (tpu-search-internal ""))
 (defun tpu-search-forward nil
 "Search for a string or regular expression.
 The search is begins in the forward direction."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-searching-forward t)
 (tpu-set-search t)
 (tpu-search-internal ""))
 (defun tpu-search-reverse nil
 "Search for a string or regular expression.
 The search is begins in the reverse direction."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-searching-forward nil)
 (tpu-set-search t)
 (tpu-search-internal ""))
 (defun tpu-search-again nil
 "Search for the same string or regular expression as last time.
 The search is performed in the current direction."
 (interactive)
+(setq zmacs-region-stays t)
 (tpu-search-internal tpu-search-last-string))
 ;;  tpu-set-search defines the search functions used by the TPU-edt internal
 ;;  search function.  It should be called whenever the direction changes, or
 ;;  the regular expression mode is turned on or off.  It can also be called
 (defun tpu-toggle-search-direction nil
 "Toggle the TPU-edt search direction.
 Used for reversing a search in progress."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-searching-forward (not tpu-searching-forward))
 (tpu-set-search t)
 (and (interactive-p)
 (message "Searching %sward."
 		(if tpu-searching-forward "for" "back"))))
 (defun tpu-search-forward-exit nil
 "Set search direction forward and exit minibuffer."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-searching-forward t)
 (tpu-set-search t)
 (exit-minibuffer))
 (defun tpu-search-backward-exit nil
 "Set search direction backward and exit minibuffer."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-searching-forward nil)
 (tpu-set-search t)
 (exit-minibuffer))
 ;;;  Delete / Cut
 ;;;
 (defun tpu-toggle-rectangle nil
 "Toggle rectangular mode for remove and insert."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-rectangular-p (not tpu-rectangular-p))
 (setq tpu-rectangle-string (if tpu-rectangular-p " Rect" ""))
 (tpu-update-mode-line)
 (and (interactive-p)
 (message "Rectangular cut and paste %sabled."
 (defun tpu-store-text nil
 "Copy the selected region to the cut buffer without deleting it.
 The text is saved for the tpu-paste command."
 (interactive)
+(setq zmacs-region-stays t)
 (cond ((tpu-mark)
 	 (cond (tpu-rectangular-p
 		(save-excursion
 		  (tpu-arrange-rectangle)
 		  (setq picture-killed-rectangle
 (defun tpu-delete-current-line (num)
 "Delete one or specified number of lines after point.
 This includes the newline character at the end of each line.
 They are saved for the TPU-edt undelete-lines command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (forward-line num)
 (if (not (eq (preceding-char) ?\n))
 (insert "\n"))
 (setq tpu-last-deleted-lines
 (defun tpu-delete-to-eol (num)
 "Delete text up to end of line.
 With argument, delete up to to Nth line-end past point.
 They are saved for the TPU-edt undelete-lines command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (forward-char 1)
 (end-of-line num)
 (setq tpu-last-deleted-lines
 (buffer-substring beg (point)))
 (defun tpu-delete-to-bol (num)
 "Delete text back to beginning of line.
 With argument, delete up to to Nth line-end past point.
 They are saved for the TPU-edt undelete-lines command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (tpu-next-beginning-of-line num)
 (setq tpu-last-deleted-lines
 (buffer-substring (point) beg))
 (delete-region (point) beg)))
 (defun tpu-delete-current-word (num)
 "Delete one or specified number of words after point.
 They are saved for the TPU-edt undelete-words command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (tpu-forward-to-word num)
 (setq tpu-last-deleted-words
 (buffer-substring beg (point)))
 (delete-region beg (point))))
 (defun tpu-delete-previous-word (num)
 "Delete one or specified number of words before point.
 They are saved for the TPU-edt undelete-words command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (tpu-backward-to-word num)
 (setq tpu-last-deleted-words
 (buffer-substring (point) beg))
 (delete-region beg (point))))
 (defun tpu-delete-current-char (num)
 "Delete one or specified number of characters after point.  The last
 character deleted is saved for the TPU-edt undelete-char command."
 (interactive "p")
+(setq zmacs-region-stays t)
 (while (and (> num 0) (not (eobp)))
 (setq tpu-last-deleted-char (char-after (point)))
 (cond (overwrite-mode
 	   (picture-clear-column 1)
 	   (forward-char 1))
 ;;;
 (defun tpu-paste (num)
 "Insert the last region or rectangle of killed text.
 With argument reinserts the text that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (while (> num 0)
 (cond (tpu-rectangular-p
 	   (let ((beg (point)))
 	     (save-excursion
 	       (picture-yank-rectangle (not overwrite-mode))
 (defun tpu-undelete-lines (num)
 "Insert lines deleted by last TPU-edt line-deletion command.
 With argument reinserts lines that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (while (> num 0)
 (insert tpu-last-deleted-lines)
 (setq num (1- num)))
 (goto-char beg)))
 (defun tpu-undelete-words (num)
 "Insert words deleted by last TPU-edt word-deletion command.
 With argument reinserts words that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (while (> num 0)
 (insert tpu-last-deleted-words)
 (setq num (1- num)))
 (goto-char beg)))
 (defun tpu-undelete-char (num)
 "Insert character deleted by last TPU-edt character-deletion command.
 With argument reinserts the character that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (while (> num 0)
 (if overwrite-mode (prog1 (forward-char -1) (delete-char 1)))
 (insert tpu-last-deleted-char)
 (forward-char -1)
 (setq num (1- num))))
 (defun tpu-add-at-bol (text)
 "Add text to the beginning of each line in a region,
 or each line in the entire buffer if no region is selected."
 (interactive
 (list (tpu-string-prompt "String to add: " 'tpu-add-at-bol-hist)))
+(setq zmacs-region-stays t)
 (if (string= "" text) (error "No string specified."))
 (cond ((tpu-mark)
 	 (save-excursion
 	   (if (> (point) (tpu-mark)) (exchange-point-and-mark))
 	   (while (and (< (point) (tpu-mark)) (re-search-forward "^" (tpu-mark) t))
 (defun tpu-add-at-eol (text)
 "Add text to the end of each line in a region,
 or each line of the entire buffer if no region is selected."
 (interactive
 (list (tpu-string-prompt "String to add: " 'tpu-add-at-eol-hist)))
+(set zmacs-region-stays t)
 (if (string= "" text) (error "No string specified."))
 (cond ((tpu-mark)
 	 (save-excursion
 	   (if (> (point) (tpu-mark)) (exchange-point-and-mark))
 	   (while (< (point) (tpu-mark))
 	     (end-of-line) (insert text) (forward-line))))))
 (defun tpu-trim-line-ends nil
 "Removes trailing whitespace from every line in the buffer."
 (interactive)
+(setq zmacs-region-stays t)
 (picture-clean))
 ;;;
 ;;;  Movement by character
 ;;;
 (defun tpu-char (num)
 "Move to the next character in the current direction.
 A repeat count means move that many characters."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (tpu-forward-char num) (tpu-backward-char num)))
 (defun tpu-forward-char (num)
 "Move right ARG characters (left if ARG is negative)."
 (interactive "p")
+(setq zmacs-region-stays t)
 (forward-char num))
 (defun tpu-backward-char (num)
 "Move left ARG characters (right if ARG is negative)."
 (interactive "p")
+(setq zmacs-region-stays t)
 (backward-char num))
 ;;;
 ;;;  Movement by word
 (defun tpu-word (num)
 "Move to the beginning of the next word in the current direction.
 A repeat count means move that many words."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (tpu-forward-to-word num) (tpu-backward-to-word num)))
 (defun tpu-forward-to-word (num)
 "Move forward until encountering the beginning of a word.
 With argument, do this that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (while (and (> num 0) (not (eobp)))
 (let* ((beg (point))
 	   (end (prog2 (end-of-line) (point) (goto-char beg))))
 (cond ((eolp)
 	     (forward-char 1))
 (defun tpu-backward-to-word (num)
 "Move backward until encountering the beginning of a word.
 With argument, do this that many times."
 (interactive "p")
+(setq zmacs-region-stays t)
 (while (and (> num 0) (not (bobp)))
 (let* ((beg (point))
 	   (end (prog2 (beginning-of-line) (point) (goto-char beg))))
 (cond ((bolp)
 	     ( forward-char -1))
 (setq num (1- num))))
 (defun tpu-add-word-separators (separators)
 "Add new word separators for TPU-edt word commands."
 (interactive "sSeparators: ")
+(setq zmacs-region-stays t)
 (let* ((n 0) (length (length separators)))
 (while (< n length)
 (let ((char (aref separators n))
 	    (ss (substring separators n (1+ n))))
 	(cond ((not (memq char tpu-word-separator-list))
 	(setq n (1+ n))))))
 (defun tpu-reset-word-separators nil
 "Reset word separators to default value."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-word-separator-list nil)
 (setq tpu-skip-chars "^ \t"))
 (defun tpu-set-word-separators (separators)
 "Set new word separators for TPU-edt word commands."
 (interactive "sSeparators: ")
+(setq zmacs-region-stays t)
 (tpu-reset-word-separators)
 (tpu-add-word-separators separators))
 ;;;
 ;;;
 (defun tpu-next-line (num)
 "Move to next line.
 Prefix argument serves as a repeat count."
 (interactive "p")
+(setq zmacs-region-stays t)
 (next-line-internal num)
 (setq this-command 'next-line))
 (defun tpu-previous-line (num)
 "Move to previous line.
 Prefix argument serves as a repeat count."
 (interactive "p")
+(setq zmacs-region-stays t)
 (next-line-internal (- num))
 (setq this-command 'previous-line))
 (defun tpu-next-beginning-of-line (num)
 "Move to beginning of line; if at beginning, move to beginning of next line.
 Accepts a prefix argument for the number of lines to move."
 (interactive "p")
+(setq zmacs-region-stays t)
 (backward-char 1)
 (forward-line (- 1 num)))
 (defun tpu-end-of-line (num)
 "Move to the next end of line in the current direction.
 A repeat count means move that many lines."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (tpu-next-end-of-line num) (tpu-previous-end-of-line num)))
 (defun tpu-next-end-of-line (num)
 "Move to end of line; if at end, move to end of next line.
 Accepts a prefix argument for the number of lines to move."
 (interactive "p")
+(setq zmacs-region-stays t)
 (forward-char 1)
 (end-of-line num))
 (defun tpu-previous-end-of-line (num)
 "Move EOL upward.
 Accepts a prefix argument for the number of lines to move."
 (interactive "p")
+(setq zmacs-region-stays t)
 (end-of-line (- 1 num)))
 (defun tpu-current-end-of-line nil
 "Move point to end of current line."
 (interactive)
+(setq zmacs-region-stays t)
 (let ((beg (point)))
 (end-of-line)
 (if (= beg (point)) (message "You are already at the end of a line."))))
 (defun tpu-line (num)
 "Move to the beginning of the next line in the current direction.
 A repeat count means move that many lines."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (tpu-forward-line num) (tpu-backward-line num)))
 (defun tpu-forward-line (num)
 "Move to beginning of next line.
 Prefix argument serves as a repeat count."
 (interactive "p")
+(setq zmacs-region-stays t)
 (forward-line num))
 (defun tpu-backward-line (num)
 "Move to beginning of previous line.
 Prefix argument serves as repeat count."
 (interactive "p")
+(setq zmacs-region-stays t)
 (or (bolp) (>= 0 num) (setq num (- num 1)))
 (forward-line (- num)))
 ;;;
 ;;;
 (defun tpu-paragraph (num)
 "Move to the next paragraph in the current direction.
 A repeat count means move that many paragraphs."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance
 (tpu-next-paragraph num) (tpu-previous-paragraph num)))
 (defun tpu-next-paragraph (num)
 "Move to beginning of the next paragraph.
 Accepts a prefix argument for the number of paragraphs."
 (interactive "p")
+(setq zmacs-region-stays t)
 (beginning-of-line)
 (while (and (not (eobp)) (> num 0))
 (if (re-search-forward "^[ \t]*$" nil t)
 	(if (re-search-forward "[^ \t\n]" nil t)
 	    (goto-char (match-beginning 0))
 (defun tpu-previous-paragraph (num)
 "Move to beginning of previous paragraph.
 Accepts a prefix argument for the number of paragraphs."
 (interactive "p")
+(setq zmacs-region-stays t)
 (end-of-line)
 (while (and (not (bobp)) (> num 0))
 (if (not (and (re-search-backward "^[ \t]*$" nil t)
 		  (re-search-backward "[^ \t\n]" nil t)
 		  (re-search-backward "^[ \t]*$" nil t)
 ;;;
 (defun tpu-page (num)
 "Move to the next page in the current direction.
 A repeat count means move that many pages."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (forward-page num) (backward-page num))
 (if (eobp) (recenter -1)))
 ;;;
 ;;;
 (defun tpu-scroll-window (num)
 "Scroll the display to the next section in the current direction.
 A repeat count means scroll that many sections."
 (interactive "p")
+(setq zmacs-region-stays t)
 (if tpu-advance (tpu-scroll-window-up num) (tpu-scroll-window-down num)))
 (defun tpu-scroll-window-down (num)
 "Scroll the display down to the next section.
 A repeat count means scroll that many sections."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let* ((beg (tpu-current-line))
 	 (height (1- (window-height)))
 	 (lines (* num (/ (* height tpu-percent-scroll) 100))))
 (next-line-internal (- lines))
 (if (> lines beg) (recenter 0))))
 (defun tpu-scroll-window-up (num)
 "Scroll the display up to the next section.
 A repeat count means scroll that many sections."
 (interactive "p")
+(setq zmacs-region-stays t)
 (let* ((beg (tpu-current-line))
 	 (height (1- (window-height)))
 	 (lines (* num (/ (* height tpu-percent-scroll) 100))))
 (next-line-internal lines)
 (if (>= (+ lines beg) height) (recenter -1))))
 (defun tpu-pan-right (num)
 "Pan right tpu-pan-columns (16 by default).
 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
 (interactive "p")
+(setq zmacs-region-stays t)
 (scroll-left (* tpu-pan-columns num)))
 (defun tpu-pan-left (num)
 "Pan left tpu-pan-columns (16 by default).
 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
 (interactive "p")
+(setq zmacs-region-stays t)
 (scroll-right (* tpu-pan-columns num)))
 (defun tpu-move-to-beginning nil
 "Move cursor to the beginning of buffer, but don't set the mark."
 (interactive)
+(setq zmacs-region-stays t)
 (goto-char (point-min)))
 (defun tpu-move-to-end nil
 "Move cursor to the end of buffer, but don't set the mark."
 (interactive)
+(setq zmacs-region-stays t)
 (goto-char (point-max))
 (recenter -1))
 (defun tpu-goto-percent (perc)
 "Move point to ARG percentage of the buffer."
 (interactive "NGoto-percentage: ")
+(setq zmacs-region-stays t)
 (if (or (> perc 100) (< perc 0))
 (error "Percentage %d out of range 0 < percent < 100" perc)
 (goto-char (/ (* (point-max) perc) 100))))
 (defun tpu-beginning-of-window nil
 "Move cursor to top of window."
 (interactive)
+(setq zmacs-region-stays t)
 (move-to-window-line 0))
 (defun tpu-end-of-window nil
 "Move cursor to bottom of window."
 (interactive)
+(setq zmacs-region-stays t)
 (move-to-window-line -1))
 (defun tpu-line-to-bottom-of-window nil
 "Move the current line to the bottom of the window."
 (interactive)
+(setq zmacs-region-stays t)
 (recenter -1))
 (defun tpu-line-to-top-of-window nil
 "Move the current line to the top of the window."
 (interactive)
+(setq zmacs-region-stays t)
 (recenter 0))
 ;;;
 ;;;  Direction
 ;;;
 (defun tpu-advance-direction nil
 "Set TPU Advance mode so keypad commands move forward."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-direction-string " Advance")
 (setq tpu-advance t)
 (setq tpu-reverse nil)
 (tpu-set-search)
 (tpu-update-mode-line))
 (defun tpu-backup-direction nil
 "Set TPU Backup mode so keypad commands move backward."
 (interactive)
+(setq zmacs-region-stays t)
 (setq tpu-direction-string " Reverse")
 (setq tpu-advance nil)
 (setq tpu-reverse t)
 (tpu-set-search)
 (tpu-update-mode-line))
 (define-key repeat-complex-command-map "\eOA" 'previous-complex-command)
 (define-key repeat-complex-command-map "\eOB" 'next-complex-command)))
 ;;;
-;;;  Minibuffer map additions to make KP-enter = RET
+;;;  Minibuffer map additions to make KP_enter = RET
 ;;;
 (define-key minibuffer-local-map "\eOM" 'exit-minibuffer)
 (define-key minibuffer-local-ns-map "\eOM" 'exit-minibuffer)
 (define-key minibuffer-local-completion-map "\eOM" 'exit-minibuffer)
 (define-key minibuffer-local-must-match-map "\eOM" 'minibuffer-complete-and-exit)
 	     (setq tpu-control-keys tpu-style))))))
 (defun tpu-toggle-control-keys nil
 "Toggles control key bindings between TPU-edt and Emacs."
 (interactive)
+(setq zmacs-region-stays t)
 (tpu-reset-control-keys (not tpu-control-keys))
 (and (interactive-p)
 (message "Control keys function with %s bindings."
 		(if tpu-control-keys "TPU-edt" "Emacs"))))
 ;;;  Emacs version 19 minibuffer history support
 ;;;
 (defun tpu-next-history-element (n)
 "Insert the next element of the minibuffer history into the minibuffer."
 (interactive "p")
+(setq zmacs-region-stays t)
 (next-history-element n)
 (goto-char (point-max)))
 (defun tpu-previous-history-element (n)
 "Insert the previous element of the minibuffer history into the minibuffer."
 (interactive "p")
+(setq zmacs-region-stays t)
 (previous-history-element n)
 (goto-char (point-max)))
 (defun tpu-arrow-history nil
 "Modify minibuffer maps to use arrows for history recall."
 (interactive)
+(setq zmacs-region-stays t)
 (let ((loc (where-is-internal 'tpu-previous-line)) (cur nil))
 (while (setq cur (car loc))
 (define-key read-expression-map cur 'tpu-previous-history-element)
 (define-key minibuffer-local-map cur 'tpu-previous-history-element)
 (define-key minibuffer-local-ns-map cur 'tpu-previous-history-element)
 (defun tpu-load-xkeys (file)
 "Load the TPU-edt X-windows key definitions FILE.
 If FILE is nil, try to load a default file.  The default file names are
 `~/.tpu-lucid-keys' for Lucid emacs, and `~/.tpu-keys' for Emacs."
 (interactive "fX key definition file: ")
+(setq zmacs-region-stays t)
 (cond (file
 	 (setq file (expand-file-name file)))
 	(tpu-xkeys-file
 	 (setq file (expand-file-name tpu-xkeys-file)))
 	(tpu-lucid-emacs19-p
 		  (sit-for 120)))))))
 (defun tpu-copy-keyfile (oldname newname)
 "Copy the TPU-edt X key definitions file to the new default name."
 (interactive "fOld name: \nFNew name: ")
+(setq zmacs-region-stays t)
 (if (not (get-buffer "*TPU-Notice*")) (generate-new-buffer "*TPU-Notice*"))
 (set-buffer "*TPU-Notice*")
 (erase-buffer)
 (insert "
 NOTICE --

Mercurial > hg > xemacs-beta

comparison lisp/emulators/tpu-edt.el @ 134:34a5b81f86ba r20-2b1