(icomplete-eoinput): Remove.

(icomplete-overlay): New var to replace it.
(icomplete-tidy): Rewrite.
(icomplete-exhibit): Use an overlay.
(icomplete-completions): Use completion-all-sorted-completions.
Obey completion-ignore-case.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 213cfd9b98ae569bb845ebff8ce78c20b462d2f7..9d95e7db89a761ef6fc2d5859583cdfdca0b9892 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,12 @@
 2008-05-22  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+       * icomplete.el (icomplete-eoinput): Remove.
+       (icomplete-overlay): New var to replace it.
+       (icomplete-tidy): Rewrite.
+       (icomplete-exhibit): Use an overlay.
+       (icomplete-completions): Use completion-all-sorted-completions.
+       Obey completion-ignore-case.
+
        * files.el (locate-dominating-file): Accept non-existing argument.
        (project-find-settings-file): Rewrite, using locate-dominating-file.
 

diff --git a/lisp/icomplete.el b/lisp/icomplete.el
index 369342e4d917f5af0aa137976d508ae4ac5e2bb4..cacb7b26f1991918c2e3a3fdd7b77ae13354053a 100644 (file)
--- a/lisp/icomplete.el
+++ b/lisp/icomplete.el
@@ -117,9 +117,9 @@ icompletion is occurring."
 
 ;;;_ + Internal Variables
 ;;;_  = icomplete-eoinput nil
-(defvar icomplete-eoinput nil
-  "Point where minibuffer input ends and completion info begins.")
-(make-variable-buffer-local 'icomplete-eoinput)
+(defvar icomplete-overlay (make-overlay (point-min) (point-min) nil t t)
+  "Overlay used to display the list of completions.")
+
 ;;;_  = icomplete-pre-command-hook
 (defvar icomplete-pre-command-hook nil
   "Incremental-minibuffer-completion pre-command-hook.
@@ -215,15 +215,7 @@ Usually run by inclusion in `minibuffer-setup-hook'."
   "Remove completions display \(if any) prior to new user input.
 Should be run in on the minibuffer `pre-command-hook'.  See `icomplete-mode'
 and `minibuffer-setup-hook'."
-  (when (and icomplete-mode icomplete-eoinput)
-
-    (unless (>= icomplete-eoinput (point-max))
-      (let ((buffer-undo-list t) ; prevent entry
-           deactivate-mark)
-       (delete-region icomplete-eoinput (point-max))))
-
-    ;; Reestablish the safe value.
-    (setq icomplete-eoinput nil)))
+  (delete-overlay icomplete-overlay))
 
 ;;;_ > icomplete-exhibit ()
 (defun icomplete-exhibit ()
@@ -233,9 +225,6 @@ and `minibuffer-setup-hook'."
   (when (and icomplete-mode (icomplete-simple-completing-p))
     (save-excursion
       (goto-char (point-max))
-      ;; Register the end of input, so we know where the extra stuff
-      ;; (match-status info) begins:
-      (setq icomplete-eoinput (point))
                                         ; Insert the match-status information:
       (if (and (> (point-max) (minibuffer-prompt-end))
               buffer-undo-list         ; Wait for some user input.
@@ -250,16 +239,21 @@ and `minibuffer-setup-hook'."
                ;; embarking on computing completions:
                (sit-for icomplete-compute-delay)))
          (let ((text (while-no-input
-                       (list
                         (icomplete-completions
                          (field-string)
                          minibuffer-completion-table
                          minibuffer-completion-predicate
-                         (not minibuffer-completion-confirm)))))
+                         (not minibuffer-completion-confirm))))
                (buffer-undo-list t)
                deactivate-mark)
            ;; Do nothing if while-no-input was aborted.
-           (if (consp text) (insert (car text))))))))
+           (when (stringp text)
+              (move-overlay icomplete-overlay (point) (point) (current-buffer))
+              ;; The current C cursor code doesn't know to use the overlay's
+              ;; marker's stickiness to figure out whether to place the cursor
+              ;; before or after the string, so let's spoon-feed it the pos.
+              (put-text-property 0 1 'cursor t text)
+              (overlay-put icomplete-overlay 'after-string text)))))))
 
 ;;;_ > icomplete-completions (name candidates predicate require-match)
 (defun icomplete-completions (name candidates predicate require-match)
@@ -281,16 +275,16 @@ The displays for unambiguous matches have ` [Matched]' appended
 matches exist.  \(Keybindings for uniquely matched commands
 are exhibited within the square braces.)"
 
-  (let* ((comps (completion-all-completions name candidates predicate
-                                            (length name)))
-         (last (last comps))
-         (base-size (if (consp last) (prog1 (cdr last) (setcdr last nil))))
+  (let* ((comps (completion-all-sorted-completions))
+         (last (if (consp comps) (last comps)))
+         (base-size (cdr last))
          (open-bracket (if require-match "(" "["))
          (close-bracket (if require-match ")" "]")))
     ;; `concat'/`mapconcat' is the slow part.  With the introduction of
     ;; `icomplete-prospects-length', there is no need for `catch'/`throw'.
-    (if (null comps)
+    (if (not (consp comps))
         (format " %sNo matches%s" open-bracket close-bracket)
+      (if last (setcdr last nil))
       (let* ((most-try
               (if (and base-size (> base-size 0))
                   (completion-try-completion
@@ -299,7 +293,8 @@ are exhibited within the square braces.)"
                 ;; the same with `comps'.
                 (completion-try-completion
                  name comps nil (length name))))
-            (most (if (consp most-try) (car most-try) (car comps)))
+            (most (if (consp most-try) (car most-try)
+                     (if most-try (car comps) "")))
              ;; Compare name and most, so we can determine if name is
              ;; a prefix of most, or something else.
             (compare (compare-strings name nil nil
@@ -320,7 +315,7 @@ are exhibited within the square braces.)"
              (prefix-len
               ;; Find the common prefix among `comps'.
              (if (eq t (compare-strings (car comps) nil (length most)
-                                        most nil nil case-fold-search))
+                                        most nil nil completion-ignore-case))
                   ;; Common case.
                  (length most)
                 ;; Else, use try-completion.
@@ -329,7 +324,7 @@ are exhibited within the square braces.)"
                        (length comps-prefix)))))
 
             prospects most-is-exact comp limit)
-       (if (or (eq most-try t) (null (cdr comps)))
+       (if (eq most-try t) ;; (or (null (cdr comps))
            (setq prospects nil)
          (while (and comps (not limit))
            (setq comp
@@ -339,16 +334,17 @@ are exhibited within the square braces.)"
                  ((member comp prospects))
                  (t (setq prospects-len (+ (length comp) 1 prospects-len))
                     (if (< prospects-len icomplete-prospects-length)
-                        (setq prospects (cons comp prospects))
+                        (push comp prospects)
                       (setq limit t))))))
+        ;; Restore the base-size info, since completion-all-sorted-completions
+        ;; is cached.
+        (if last (setcdr last base-size))
        (if prospects
            (concat determ
                    "{"
                    (and most-is-exact ",")
-                   (mapconcat 'identity
-                              (sort prospects (function string-lessp))
-                              ",")
-                   (and comps ",...")
+                   (mapconcat 'identity (nreverse prospects) ",")
+                   (and limit ",...")
                    "}")
          (concat determ
                  " [Matched"