   (loop for item in lst
         maximizing (length item)))
 
-(defun* lusty-display-completion-list (entries match)
-  (when (endp entries)
-    (lusty-print-no-entries)
-    (return-from lusty-display-completion-list))
-
+(defun lusty-truncate-entries (entries)
   (let* ((max-possibly-displayable-entries
           (* (- (frame-height) 3)
              (/ (window-width)
                 (1+ (length lusty-column-separator)))))
-         (cut-off (nthcdr max-possibly-displayable-entries entries))
-         (truncate-p (consp cut-off)))
+         (cut-off-point (nthcdr max-possibly-displayable-entries entries))
+         (truncate-p (consp cut-off-point)))
 
     (when truncate-p
-      (setf (cdr cut-off) nil))
-
-    (setq entries
-          (mapcar
-           (cond ((endp (cdr entries))
-                  (lambda (e) (propertize e 'face lusty-match-face)))
-                 (match
-                  (lambda (e)
-                    (if (eq match e)
-                        (propertize e 'face lusty-match-face)
-                      (lusty-propertize-path e))))
-                 (t
-                  'lusty-propertize-path))
-           entries))
-
-    (loop for column-count downfrom (lusty-column-count-upperbound entries)
-          ;; FIXME this is calculated one too many times in the degenerate
-          ;; case.
-          for columns = (lusty-columnize entries column-count)
-          for widths = (mapcar 'lusty-longest-length columns)
-          for full-width = (+ (reduce '+ widths)
-                              (* (length lusty-column-separator)
-                                 (1- column-count)))
-          until (or (<= column-count 1)
-                    (< full-width (window-width)))
-          finally
-          (when (<= column-count 1)
-            (setq columns (list entries)
-                  widths (list 0)))
-          (lusty-print-columns columns widths))
-
-    (when truncate-p
-      (lusty-print-truncated))))
+      ;; Trim down the entries
+      (setf (cdr cut-off-point) nil))
+
+    (values entries truncate-p)))
+
+(defun* lusty-display-entries (entries truncated-p)
+  (when (endp entries)
+    (lusty-print-no-entries)
+    (return-from lusty-display-entries))
+
+  ; STEVE clean up this
+  (setq entries
+        (loop with len = (length entries)
+              with highlighted-index = (mod lusty--highlighted-index len)
+              for e in entries
+              for i from 0
+              when (= i highlighted-index)
+              collect (propertize e 'face lusty-match-face)
+              else
+              collect (lusty-propertize-path e)))
+
+  (loop for column-count downfrom (lusty-column-count-upperbound entries)
+        ;; FIXME this is calculated one too many times in the degenerate
+        ;; case.
+        for columns = (lusty-columnize entries column-count)
+        for widths = (mapcar 'lusty-longest-length columns)
+        for full-width = (+ (reduce '+ widths)
+                            (* (length lusty-column-separator)
+                               (1- column-count)))
+        until (or (<= column-count 1)
+                  (< full-width (window-width)))
+        finally
+        (when (<= column-count 1)
+          (setq columns (list entries)
+                widths (list 0)))
+        (lusty-print-columns columns widths))
+
+  (when truncated-p
+    (lusty-print-truncated)))
   
 (defun lusty-print-no-entries ()
   (insert lusty-no-entries-string)

    ;;     remember to add back the '/'
    ;;     update the minibuffer contents
    ;;   
    (setq lusty--previous-contents (minibuffer-contents-no-properties))
    (lusty-update-completion-buffer)))

;; Cribbed with modification from tail-select-lowest-window.


(defun lusty-update-completion-buffer (&optional tab-pressed-p)
  (assert (minibufferp))
  (multiple-value-bind (matches openable-p)
      (ecase lusty--active-mode
        (:file-explorer (lusty-file-explorer-matches))
        (:buffer-explorer (lusty-buffer-explorer-completions)))

    (if (and openable-p tab-pressed-p)
        ;; STEVE ^^ this is not right anymore
        ;;       tab should select highlighted entry
        ;;       - recurse if directory, open if file
        ;;       enter should use current file-portion
        ;;       - recurse if directory, open if file, create if names nothing
        ;;         - unless file portion is empty
        ;;
        ;; The user pressed TAB (or some other completion key) and we're
        ;; fully completable -- go ahead and choose it.
        (progn
          (lusty-set-minibuffer-text (car matches))
          (minibuffer-complete-and-exit))
      ;;
      ;; Update the completion window.
      (let ((lusty-buffer (get-buffer-create lusty-buffer-name)))
        (with-current-buffer lusty-buffer
          (setq buffer-read-only t)
          (multiple-value-bind (truncated-matches truncated-p)
              (lusty-truncate-entries matches)
            (let ((buffer-read-only nil))
              (erase-buffer)
              (lusty-display-entries truncated-matches truncated-p)
              (goto-char (point-min))))

          ;; If only our completions window is open,
          (when (one-window-p t)
            ;; Restore original window configuration before fitting the
            ;; window so the minibuffer won't grow and look silly.
            (set-window-configuration lusty--initial-window-config))
          (fit-window-to-buffer (display-buffer lusty-buffer)
                                ; TODO vvv do smarter
                                (- (frame-height) 3))
          (set-buffer-modified-p nil))))))

(defun lusty-buffer-explorer-completions ()
