Mercurial > emacs

--- a/lisp/textmodes/ispell.el	Wed Jul 20 14:02:48 1994 +0000
+++ b/lisp/textmodes/ispell.el	Wed Jul 20 18:26:57 1994 +0000
@@ -741,7 +741,6 @@
 	      quietly ispell-quietly))
     (ispell-buffer-local-dict)		; use the correct dictionary
     (let ((cursor-location (point))	; retain cursor location
-	  ispell-keep-choices-win	; override global to force creation
 	  (word (ispell-get-word following))
 	  start end poss replace)
       ;; destructure return word info list.
@@ -778,10 +777,11 @@
 		 (progn
 		   (if ispell-highlight-p ;highlight word
 		       (ispell-highlight-spelling-error start end t))
-		   (setq replace (ispell-command-loop
-				  (car (cdr (cdr poss)))
-				  (car (cdr (cdr (cdr poss))))
-				  (car poss))))
+		   (save-window-excursion
+		     (setq replace (ispell-command-loop
+				    (car (cdr (cdr poss)))
+				    (car (cdr (cdr (cdr poss))))
+				    (car poss)))))
 	       ;; protected
 	       (if ispell-highlight-p	; clear highlight
 		   (ispell-highlight-spelling-error start end)))
@@ -889,214 +889,206 @@
 Global `ispell-pdict-modified-p' becomes a list where the only value
 indicates whether the dictionary has been modified when option `a' or `i' is
 used."
-  (unwind-protect
-      (save-window-excursion
-	(let ((count ?0)
-	      (line 2)
-	      (max-lines (- (window-height) 4)) ; assure 4 context lines.
-	      (choices miss)
-	      (window-min-height (min window-min-height
-				      ispell-choices-win-default-height))
-	      (command-characters '( ?  ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m ))
-	      (skipped 0)
-	      char num result)
-	  (save-excursion
-	    (if ispell-keep-choices-win
+  (let ((count ?0)
+	(line 2)
+	(max-lines (- (window-height) 4)) ; assure 4 context lines.
+	(choices miss)
+	(window-min-height (min window-min-height
+				ispell-choices-win-default-height))
+	(command-characters '( ?  ?i ?a ?A ?r ?R ?? ?x ?X ?q ?l ?u ?m ))
+	(skipped 0)
+	char num result)
+    (save-excursion
+      (set-buffer (get-buffer-create ispell-choices-buffer))
+      (setq mode-line-format "--  %b  --")
+      (erase-buffer)
+      (if guess
+	  (progn
+	    (insert "Affix rules generate and capitalize "
+		    "this word as shown below:\n\t")
+	    (while guess
+	      (if (> (+ 4 (current-column) (length (car guess)))
+		     (window-width))
+		  (progn
+		    (insert "\n\t")
+		    (setq line (1+ line))))
+	      (insert (car guess) "    ")
+	      (setq guess (cdr guess)))
+	    (insert "\nUse option `i' if this is a correct composition"
+		    " from the derivative root.\n")
+	    (setq line (+ line (if choices 3 2)))))
+      (while (and choices
+		  (< (if (> (+ 7 (current-column) (length (car choices))
+			       (if (> count ?~) 3 0))
+			    (window-width))
+			 (progn
+			   (insert "\n")
+			   (setq line (1+ line)))
+		       line)
+		     max-lines))
+	;; not so good if there are over 20 or 30 options, but then, if
+	;; there are that many you don't want to scan them all anyway...
+	(while (memq count command-characters) ; skip command characters.
+	  (setq count (1+ count)
+		skipped (1+ skipped)))
+	(insert "(" count ") " (car choices) "  ")
+	(setq choices (cdr choices)
+	      count (1+ count)))
+      (setq count (- count ?0 skipped)))
+
+    (let ((choices-window (get-buffer-window ispell-choices-buffer)))
+      (if choices-window
+	  (if (not (equal line (window-height choices-window)))
+	      (progn
+		(save-excursion
+		  (let ((cur-point (point)))
+		    (move-to-window-line (- line (window-height choices-window)))
+		    (if (<= (point) cur-point)
+			(set-window-start (selected-window) (point)))))
 		(select-window (previous-window))
-	      (set-buffer (get-buffer-create ispell-choices-buffer))
-	      (setq mode-line-format "--  %b  --"))
-	    (if (equal (get-buffer ispell-choices-buffer) (current-buffer))
-		(erase-buffer)
-	      (error (concat "Bogus, dude! I should be in the *Choices*"
-			     " buffer, but I'm not!")))
-	    (if guess
-		(progn
-		  (insert "Affix rules generate and capitalize "
-			  "this word as shown below:\n\t")
-		  (while guess
-		    (if (> (+ 4 (current-column) (length (car guess)))
-			   (window-width))
-			(progn
-			  (insert "\n\t")
-			  (setq line (1+ line))))
-		    (insert (car guess) "    ")
-		    (setq guess (cdr guess)))
-		  (insert "\nUse option `i' if this is a correct composition"
-			  " from the derivative root.\n")
-		  (setq line (+ line (if choices 3 2)))))
-	    (while (and choices
-			(< (if (> (+ 7 (current-column) (length (car choices))
-				     (if (> count ?~) 3 0))
-				  (window-width))
-			       (progn
-				 (insert "\n")
-				 (setq line (1+ line)))
-			     line)
-			   max-lines))
-	      ;; not so good if there are over 20 or 30 options, but then, if
-	      ;; there are that many you don't want to scan them all anyway...
-	      (while (memq count command-characters) ; skip command characters.
-		(setq count (1+ count)
-		      skipped (1+ skipped)))
-	      (insert "(" count ") " (car choices) "  ")
-	      (setq choices (cdr choices)
-		    count (1+ count)))
-	    (setq count (- count ?0 skipped)))
-
-	  (if ispell-keep-choices-win
-	      (if (> line ispell-keep-choices-win)
-		  (progn
-		    (switch-to-buffer ispell-choices-buffer)
-		    (select-window (next-window))
-		    (save-excursion
-		      (let ((cur-point (point)))
-			(move-to-window-line (- line ispell-keep-choices-win))
-			(if (<= (point) cur-point)
-			    (set-window-start (selected-window) (point)))))
-		    (select-window (previous-window))
-		    (enlarge-window (- line ispell-keep-choices-win))
-		    (goto-char (point-min))))
-	    (ispell-overlay-window (max line
-					ispell-choices-win-default-height)))
-	  (switch-to-buffer ispell-choices-buffer)
-	  (goto-char (point-min))
-	  (select-window (next-window))
-	  (while
-	      (eq
-	       t
-	       (setq
-		result
-		(progn
-		  (undo-boundary)
-		  (message (concat "C-h or ? for more options; SPC to leave "
-				   "unchanged, Character to replace word"))
-		  (let ((inhibit-quit t))
-		    (setq char (if (fboundp 'read-char-exclusive)
-				   (read-char-exclusive)
-				 (read-char))
-			  skipped 0)
-		    (if (or quit-flag (= char ?\C-g)) ; C-g is like typing X
-			(setq char ?X
-			      quit-flag nil)))
-		  ;; Adjust num to array offset skipping command characters.
-		  (let ((com-chars command-characters))
-		    (while com-chars
-		      (if (and (> (car com-chars) ?0) (< (car com-chars) char))
-			  (setq skipped (1+ skipped)))
-		      (setq com-chars (cdr com-chars)))
-		    (setq num (- char ?0 skipped)))
+		(enlarge-window (- line (window-height choices-window))))
+	    (select-window choices-window))
+	(ispell-overlay-window (max line
+				    ispell-choices-win-default-height))
+	(switch-to-buffer ispell-choices-buffer)))
+    (goto-char (point-min))
+    (select-window (next-window))
+    (while
+	(eq
+	 t
+	 (setq
+	  result
+	  (progn
+	    (undo-boundary)
+	    (message (concat "C-h or ? for more options; SPC to leave "
+			     "unchanged, Character to replace word"))
+	    (let ((inhibit-quit t))
+	      (setq char (if (fboundp 'read-char-exclusive)
+			     (read-char-exclusive)
+			   (read-char))
+		    skipped 0)
+	      (if (or quit-flag (= char ?\C-g)) ; C-g is like typing X
+		  (setq char ?X
+			quit-flag nil)))
+	    ;; Adjust num to array offset skipping command characters.
+	    (let ((com-chars command-characters))
+	      (while com-chars
+		(if (and (> (car com-chars) ?0) (< (car com-chars) char))
+		    (setq skipped (1+ skipped)))
+		(setq com-chars (cdr com-chars)))
+	      (setq num (- char ?0 skipped)))

-		  (cond
-		   ((= char ? ) nil)	; accept word this time only
-		   ((= char ?i)		; accept and insert word into pers dict
-		    (process-send-string ispell-process (concat "*" word "\n"))
-		    (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
-		    nil)
-		   ((or (= char ?a) (= char ?A)) ; accept word without insert
-		    (process-send-string ispell-process (concat "@" word "\n"))
-		    (if (null ispell-pdict-modified-p)
-			(setq ispell-pdict-modified-p
-			      (list ispell-pdict-modified-p)))
-		    (if (= char ?A) 0))	; return 0 for ispell-add buffer-local
-		   ((or (= char ?r) (= char ?R)) ; type in replacement
-		    (if (or (= char ?R) ispell-query-replace-choices)
-			(list (read-string "Query-replacement for: " word) t)
-		      (cons (read-string "Replacement for: " word) nil)))
-		   ((or (= char ??) (= char help-char) (= char ?\C-h))
-		    (ispell-help)
-		    t)
-		   ;; Quit and move point back.
-		   ((= char ?x)
-		    (ispell-pdict-save ispell-silently-savep)
-		    (message "Exited spell-checking")
-		    (setq ispell-quit t)
-		    nil)
-		   ;; Quit and preserve point.
-		   ((= char ?X)
-		    (ispell-pdict-save ispell-silently-savep)
-		    (message
-		     (substitute-command-keys
-		      (concat "Spell-checking suspended;"
-			      " use C-u \\[ispell-word] to resume")))
-		    (setq ispell-quit (max (point-min)
-					   (- (point) (length word))))
-		    nil)
-		   ((= char ?q)
-		    (if (y-or-n-p "Really kill Ispell process? ")
-			(progn
-			  (ispell-kill-ispell t) ; terminate process.
-			  (setq ispell-quit (or (not ispell-checking-message)
-						(point))
-				ispell-pdict-modified-p nil))
-		      t))		; continue if they don't quit.
-		   ((= char ?l)
-		    (let ((new-word (read-string
-				     "Lookup string (`*' is wildcard): "
-				     word))
-			  (new-line 2))
-		      (if new-word
+	    (cond
+	     ((= char ? ) nil)		; accept word this time only
+	     ((= char ?i)		; accept and insert word into pers dict
+	      (process-send-string ispell-process (concat "*" word "\n"))
+	      (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
+	      nil)
+	     ((or (= char ?a) (= char ?A)) ; accept word without insert
+	      (process-send-string ispell-process (concat "@" word "\n"))
+	      (if (null ispell-pdict-modified-p)
+		  (setq ispell-pdict-modified-p
+			(list ispell-pdict-modified-p)))
+	      (if (= char ?A) 0))	; return 0 for ispell-add buffer-local
+	     ((or (= char ?r) (= char ?R)) ; type in replacement
+	      (if (or (= char ?R) ispell-query-replace-choices)
+		  (list (read-string "Query-replacement for: " word) t)
+		(cons (read-string "Replacement for: " word) nil)))
+	     ((or (= char ??) (= char help-char) (= char ?\C-h))
+	      (ispell-help)
+	      t)
+	     ;; Quit and move point back.
+	     ((= char ?x)
+	      (ispell-pdict-save ispell-silently-savep)
+	      (message "Exited spell-checking")
+	      (setq ispell-quit t)
+	      nil)
+	     ;; Quit and preserve point.
+	     ((= char ?X)
+	      (ispell-pdict-save ispell-silently-savep)
+	      (message
+	       (substitute-command-keys
+		(concat "Spell-checking suspended;"
+			" use C-u \\[ispell-word] to resume")))
+	      (setq ispell-quit (max (point-min)
+				     (- (point) (length word))))
+	      nil)
+	     ((= char ?q)
+	      (if (y-or-n-p "Really kill Ispell process? ")
+		  (progn
+		    (ispell-kill-ispell t) ; terminate process.
+		    (setq ispell-quit (or (not ispell-checking-message)
+					  (point))
+			  ispell-pdict-modified-p nil))
+		t))			; continue if they don't quit.
+	     ((= char ?l)
+	      (let ((new-word (read-string
+			       "Lookup string (`*' is wildcard): "
+			       word))
+		    (new-line 2))
+		(if new-word
+		    (progn
+		      (save-excursion
+			(set-buffer (get-buffer-create
+				     ispell-choices-buffer))
+			(erase-buffer)
+			(setq count ?0
+			      skipped 0
+			      mode-line-format "--  %b  --"
+			      miss (lookup-words new-word)
+			      choices miss)
+			(while (and choices ; adjust choices window.
+				    (< (if (> (+ 7 (current-column)
+						 (length (car choices))
+						 (if (> count ?~) 3 0))
+					      (window-width))
+					   (progn
+					     (insert "\n")
+					     (setq new-line
+						   (1+ new-line)))
+					 new-line)
+				       max-lines))
+			  (while (memq count command-characters)
+			    (setq count (1+ count)
+				  skipped (1+ skipped)))
+			  (insert "(" count ") " (car choices) "  ")
+			  (setq choices (cdr choices)
+				count (1+ count)))
+			(setq count (- count ?0 skipped)))
+		      (select-window (previous-window))
+		      (if (/= new-line line)
 			  (progn
-			    (save-excursion
-			      (set-buffer (get-buffer-create
-					   ispell-choices-buffer))
-			      (erase-buffer)
-			      (setq count ?0
-				    skipped 0
-				    mode-line-format "--  %b  --"
-				    miss (lookup-words new-word)
-				    choices miss)
-			      (while (and choices ; adjust choices window.
-					  (< (if (> (+ 7 (current-column)
-						       (length (car choices))
-						       (if (> count ?~) 3 0))
-						    (window-width))
-						 (progn
-						   (insert "\n")
-						   (setq new-line
-							 (1+ new-line)))
-					       new-line)
-					     max-lines))
-				(while (memq count command-characters)
-				  (setq count (1+ count)
-					skipped (1+ skipped)))
-				(insert "(" count ") " (car choices) "  ")
-				(setq choices (cdr choices)
-				      count (1+ count)))
-			      (setq count (- count ?0 skipped)))
-			    (select-window (previous-window))
-			    (if (/= new-line line)
-				(progn
-				  (if (> new-line line)
-				      (enlarge-window (- new-line line))
-				    (shrink-window (- line new-line)))
-				  (setq line new-line)))
-			    (select-window (next-window)))))
-		    t)			; reselect from new choices
-		   ((= char ?u)
-		    (process-send-string ispell-process
-					 (concat "*" (downcase word) "\n"))
-		    (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
-		    nil)
-		   ((= char ?m)		; type in what to insert
-		    (process-send-string
-		     ispell-process (concat "*" (read-string "Insert: " word)
-					    "\n"))
-		    (setq ispell-pdict-modified-p '(t))
-		    (cons word nil))
-		   ((and (>= num 0) (< num count))
-		    (if ispell-query-replace-choices ; Query replace flag
-			(list (nth num miss) 'query-replace)
-		      (nth num miss)))
-		   ((= char ?\C-l)
-		    (redraw-display) t)
-		   ((= char ?\C-r)
-		    (save-window-excursion (recursive-edit)) t)
-		   ((= char ?\C-z)
-		    (funcall (key-binding "\C-z"))
-		    t)
-		   (t (ding) t))))))
-	  result))
-    (if (not ispell-keep-choices-win) (bury-buffer ispell-choices-buffer))))
+			    (if (> new-line line)
+				(enlarge-window (- new-line line))
+			      (shrink-window (- line new-line)))
+			    (setq line new-line)))
+		      (select-window (next-window)))))
+	      t)			; reselect from new choices
+	     ((= char ?u)
+	      (process-send-string ispell-process
+				   (concat "*" (downcase word) "\n"))
+	      (setq ispell-pdict-modified-p '(t)) ; dictionary modified!
+	      nil)
+	     ((= char ?m)		; type in what to insert
+	      (process-send-string
+	       ispell-process (concat "*" (read-string "Insert: " word)
+				      "\n"))
+	      (setq ispell-pdict-modified-p '(t))
+	      (cons word nil))
+	     ((and (>= num 0) (< num count))
+	      (if ispell-query-replace-choices ; Query replace flag
+		  (list (nth num miss) 'query-replace)
+		(nth num miss)))
+	     ((= char ?\C-l)
+	      (redraw-display) t)
+	     ((= char ?\C-r)
+	      (save-window-excursion (recursive-edit)) t)
+	     ((= char ?\C-z)
+	      (funcall (key-binding "\C-z"))
+	      t)
+	     (t (ding) t))))))
+    result))
+


 ;;;###autoload
@@ -1313,7 +1305,7 @@
 (defun ispell-overlay-window (height)
   "Create a window covering the top HEIGHT lines of the current window.
 Ensure that the line above point is still visible but otherwise avoid
-scrolling the current window.  Leave the old window selected."
+scrolling the current window.  Leave the new window selected."
   (save-excursion
     (let ((oldot (save-excursion (forward-line -1) (point)))
 	  (top (save-excursion (move-to-window-line height) (point))))
@@ -1541,27 +1533,9 @@
 	(message "Spell checking %s..."
 		 (if (and (= reg-start (point-min)) (= reg-end (point-max)))
 		     (buffer-name) "region"))
-	(sit-for 0)
+;Eliminated to keep ispell-message displaying each piece: (sit-for 0)
 	;; must be top level, not in ispell-command-loop for keeping window.
 	(save-window-excursion
-	  (if ispell-keep-choices-win
-	      (let ((ocb (current-buffer))
-		    (window-min-height ispell-choices-win-default-height))
-		(or (eq ocb (window-buffer (selected-window)))
-		    (error
-		     "current buffer is not visible in selected window: %s"
-		     ocb))
-		;; This keeps the default window size when choices window saved
-		(setq ispell-keep-choices-win
-		      ispell-choices-win-default-height)
-		(ispell-overlay-window ispell-choices-win-default-height)
-		(switch-to-buffer (get-buffer-create ispell-choices-buffer))
-		(setq mode-line-format "--  %b  --")
-		(erase-buffer)
-		(select-window (next-window))
-		(or (eq (current-buffer) ocb)
-		    (error "ispell is confused about current buffer!"))
-		(sit-for 0)))
 	  (goto-char reg-start)
 	  (let ((transient-mark-mode nil))
 	    (while (and (not ispell-quit) (< (point) reg-end))
@@ -1672,10 +1646,18 @@
 					(ispell-highlight-spelling-error
 					 word-start word-end t))
 				    (sit-for 0)	; update screen display
-				    (setq replace (ispell-command-loop
-						   (car (cdr (cdr poss)))
-						   (car (cdr (cdr (cdr poss))))
-						   (car poss))))
+				    (if ispell-keep-choices-win
+					(setq replace
+					      (ispell-command-loop
+					       (car (cdr (cdr poss)))
+					       (car (cdr (cdr (cdr poss))))
+					       (car poss)))
+				      (save-window-excursion
+					(setq replace
+					      (ispell-command-loop
+					       (car (cdr (cdr poss)))
+					       (car (cdr (cdr (cdr poss))))
+					       (car poss))))))
 				;; protected
 				(if ispell-highlight-p
 				    (ispell-highlight-spelling-error
@@ -1815,7 +1797,6 @@
   (interactive "P")
   (let ((cursor-location (point))
 	case-fold-search
-	ispell-keep-choices-win
 	(word (ispell-get-word nil "\\*")) ; force "previous-word" processing.
 	start end possibilities replacement)
     (setq start (car (cdr word))
@@ -1841,8 +1822,9 @@
 	       (progn
 		 (if ispell-highlight-p	; highlight word
 		     (ispell-highlight-spelling-error start end t))
-		 (setq replacement
-		       (ispell-command-loop possibilities nil word)))
+		 (save-window-excursion
+		   (setq replacement
+			 (ispell-command-loop possibilities nil word))))
 	     ;; protected
 	     (if ispell-highlight-p
 		 (ispell-highlight-spelling-error start end))) ; un-highlight