anchor.diff:            stream object object-type view :rescan nil))
          (values object object-type)))))
   
  -(defun display-minibuffer (frame pane)
  -  (declare (ignore frame))
  -  (if (message pane)
  -      (if (> (get-universal-time)
  -             (+ *minimum-message-time* (message-time pane)))
  -          (setf (message pane) nil)
  -          (replay-output-record (message pane) pane))
  -      ;; Even if there isn't a message, someone else might still have
  -      ;; scribbled in the pane. We shouldn't disappoint them.
  -      (replay (stream-output-history pane) pane)))
  -
   (defgeneric invoke-with-minibuffer-stream (minibuffer continuation))
   
   (defmethod invoke-with-minibuffer-stream ((minibuffer minibuffer-pane) continuation)
  +  (window-clear minibuffer)
     (setf (message minibuffer)
  -        (with-output-to-output-record (minibuffer)
  +        (with-new-output-record (minibuffer)
             (setf (message-time minibuffer) (get-universal-time))
  -          (funcall continuation minibuffer))))
  +          (filling-output (minibuffer :fill-width (bounding-rectangle-width minibuffer))
  +            (funcall continuation minibuffer)))))
   
   (defmethod invoke-with-minibuffer-stream ((minibuffer pointer-documentation-pane) continuation)
     (clim-extensions:with-output-to-pointer-documentation (stream (pane-frame minibuffer))
  
positive.code:   (apply #'prompt-for-accept pane type view args)
    ;; but we need to turn some of ACCEPT-1 off.
    (apply #'accept-1-for-minibuffer pane type args))
  
  ;;; simpler version of McCLIM's internal operators of the same names:
  ;;; HANDLE-EMPTY-INPUT to make default processing work, EMPTY-INPUT-P
  
negative.code: current message was set."))
    (:default-initargs
     :scroll-bars nil
     :display-function 'display-minibuffer
     :display-time :command-loop
     :incremental-redisplay t))
  
  (defmethod handle-repaint ((pane minibuffer-pane) region)
    (when (and (message pane)
               (> (get-universal-time)
                  (+ *minimum-message-time* (message-time pane))))
      (window-clear pane)
      (setf (message pane) nil))
    (call-next-method))
  
  (defmethod (setf message) :after (new-value (pane minibuffer-pane))
    (change-space-requirements pane))
  
  (defmethod pane-needs-redisplay ((pane minibuffer-pane))
    ;; Always call the display function, never clear the window. This
    ;; allows us to time-out the message in the minibuffer.
    (values t nil))
  
  (defun display-minibuffer (frame pane)
    (declare (ignore frame))
    (handle-repaint pane +everywhere+))
  
  (defmethod stream-accept :around ((pane minibuffer-pane) type &rest args)
    (declare (ignore args))
    (when (message pane)
      (setf (message pane) nil))
    (window-clear pane)
    ;; FIXME: this isn't the friendliest way of indicating a parse
    ;; error: there's no feedback, unlike emacs' quite nice "[no
    ;; match]".
    (unwind-protect
         (loop
          (handler-case
              (with-input-focus (pane)
                (return (call-next-method)))
            (parse-error () nil)))
      (window-clear pane)))
  
  (defmethod stream-accept ((pane minibuffer-pane) type &rest args
                            &key (view (stream-default-view pane))
  