anchor.diff:  (defmethod frame-standard-output ((frame listener))
     (get-frame-pane frame 'interactor))
   
  -(defun run-listener (&key (system-command-reader nil)
  -                          (new-process nil)
  +(defun run-listener (&key (new-process nil)
                             (width 760)
                             (height 550)
  -                          (process-name "Listener")
  -                          (eval nil))
  +                          (process-name "Listener"))
     (flet ((run ()
              (let ((frame (make-application-frame 
                            'listener
  -                         :width width :height height
  -                         :system-command-reader system-command-reader)))
  -             (run-frame-top-level 
  -              frame :listener-funcall (cond ((null eval) nil)
  -                                            ((functionp eval) eval)
  -                                            (t (lambda () (eval eval))))))))
  +                         :width width :height height)))
  +             (run-frame-top-level frame))))
       (if new-process
           (clim-sys:make-process #'run :name process-name)
           (run))))
  
positive.code: (defun display-wholine (frame pane)
    (invoke-and-center-output pane
      (lambda () (generate-wholine-contents frame pane))
      :horizontally nil :hpad 5))    
  
  ;; This is a toy command history.
  ;; Possibly this should become something integrated with the presentation
  ;; histories, which I have not played with.
  
  (defclass command-history-mixin ()
    ((history :initform nil :accessor history)
     (history-length :initform 25 :initarg :history-length :accessor history-length)))
  
  (defmethod execute-frame-command :after ((frame command-history-mixin) command)
    ;; FIXME: not safe against commands sent from other frames.
    (push command (history frame))  
    (when (> (length (history frame)) (history-length frame))
      (setf (history frame)
            (subseq (history frame) 0 (max (length (history frame))
                                           (history-length frame))))))
  
  (define-command (com-show-command-history :name "Show Command History"
                                            :command-table application-commands
                                            :menu ("Show Command History" :after "Clear Output History"))
      ()
    (formatting-table ()
       (loop for n from 0 by 1
             for command in (history *application-frame*)
             do (formatting-row ()
                  (formatting-cell ()
                     (princ n))
                  (formatting-cell ()
                     (present command 'command))))))
  
  (defparameter *listener-initial-function* nil)
  
  (defun listener-initial-display-function (frame pane)
    (declare (ignore frame pane))
    (when *listener-initial-function*
      (funcall-in-listener
       (lambda ()
         (funcall *listener-initial-function*)
         (fresh-line)))))
  
  ;;; Listener view
  ;;;
  
negative.code:       (apply #'call-next-method stream object type :single-box t args)))
  
  ;;; Listener application frame
  (define-application-frame listener (standard-application-frame)
      ((system-command-reader :accessor system-command-reader
  			    :initarg :system-command-reader
  			    :initform t))
    (:panes (interactor-container
             (make-clim-stream-pane
              :type 'listener-interactor-pane
              :name 'interactor :scroll-bars t))
            (doc :pointer-documentation)
            (wholine (make-pane 'wholine-pane
                       :display-function 'display-wholine :scroll-bars nil
  