anchor.diff:  
   (def-grecording draw-text (string point-x point-y start end
   			   align-x align-y toward-x toward-y transform-glyphs)
  -  ;; XXX transformation!!!
  +  ;; FIXME!!! transformation
    (let* ((width (stream-string-width stream string
                                       :start start :end end
                                       :text-style text-style))
  
positive.code:                      y1 (- tp ,border)
                       x2 (+ rt ,border)
                       y2 (+ bt ,border))))))
         (defmethod ,method-name :around ((stream output-recording-stream) ,@args)
  	 (with-sheet-medium (medium stream)
  	   (when (stream-recording-p stream)
  
negative.code:   (setf (stream-current-output-record stream) (stream-output-history stream)))
  
  (defmethod stream-add-output-record ((stream output-recording-stream) record)
    (add-output-record record (stream-current-output-record stream)))
  
  (defmethod stream-replay ((stream output-recording-stream) &optional region)
    (replay (stream-output-history stream) stream region))
  
  (defmacro with-output-recording-options ((stream &key (record t) (draw t)) &body body)
    (declare (type symbol stream))
    (when (eq stream 't)
      (setq stream *standard-output*))
    (let ((continuation-name (gensym)))
      `(let ((,continuation-name #'(lambda (,stream) ,@body)))
         (invoke-with-output-recording-options ,stream
                                               ,continuation-name
                                               ,record
                                               ,draw))))
  
  (defmethod invoke-with-output-recording-options
    ((stream output-recording-stream) continuation record draw)
    "Calls CONTINUATION on STREAM enabling or disabling recording and drawing
  according to the flags RECORD and DRAW."
    (with-slots (recording-p drawing-p) stream
                (let ((old-record recording-p)
                      (old-draw drawing-p))
                  (unwind-protect
                      (progn
                        (setq recording-p record
                              drawing-p draw)
                        (funcall continuation stream))
                    (setq recording-p old-record
                          drawing-p old-draw)))))
  
  (defmacro with-new-output-record ((stream
                                     &optional
                                     (record-type ''standard-sequence-output-record)
                                     (record nil record-supplied-p)
                                     &rest initargs)
                                    &body body)
    "Creates a new output record of type RECORD-TYPE and then captures
  the output of BODY into the new output record, and inserts the new
  record into the current \"open\" output record assotiated with STREAM.
      If RECORD is supplied, it is the name of a variable that will be
  lexically bound to the new output record inside the body. INITARGS are
  CLOS initargs that are passed to MAKE-INSTANCE when the new output
  record is created.
      It returns the created output record.
      The STREAM argument is a symbol that is bound to an output
  recording stream. If it is T, *STANDARD-OUTPUT* is used."
    (declare (type symbol stream record))
    (when (eq stream 't)
      (setq stream '*standard-output*))
    (unless record-supplied-p
      (setq record (gensym)))
    `(invoke-with-new-output-record
      ,stream
      #'(lambda (,stream ,record)
          ,(unless record-supplied-p `(declare (ignore ,record)))
          ,@body)
      ,record-type
      ,@initargs))
  
  (defmethod invoke-with-new-output-record ((stream output-recording-stream)
                                            continuation record-type
                                            &rest initargs
                                            &key parent)
    (unless parent
      (setq parent (stream-current-output-record stream)))
    (let ((new-record (apply #'make-instance record-type :parent parent initargs))
          (old-record (stream-current-output-record stream)))
      (unwind-protect
          (progn
            (setf (stream-current-output-record stream) new-record)
            (funcall continuation stream new-record))
        (setf (stream-current-output-record stream) old-record)
        (stream-add-output-record stream new-record))
      new-record))
  
  (defmethod scroll-vertical :around ((stream output-recording-stream) dy)
    (declare (ignore dy))
  