anchor.diff:  (defgeneric tree-recompute-extent (record))
   
   ;;; 21.3 Incremental Redisplay Protocol.  These generic functions need
  -;;; to be implemented for all the basic displayed-output-records, so they are
  -;;; defined in this file.
  +;;; to be implemented for all the basic displayed-output-records, so
  +;;; they are defined in this file.
   ;;;
  -;;; match-output-records and find-child-output-record, as defined in
  -;;; the CLIM spec, are pretty silly.  How does incremental redisplay know
  -;;; what keyword arguments to supply to find-child-output-record?  Through
  -;;; a gf specialized on the type of the record it needs to match... why
  -;;; not define the search function and the predicate on two records then!
  +;;; MATCH-OUTPUT-RECORDS and FIND-CHILD-OUTPUT-RECORD, as defined in
  +;;; the CLIM spec, are pretty silly.  How does incremental redisplay
  +;;; know what keyword arguments to supply to FIND-CHILD-OUTPUT-RECORD?
  +;;; Through a gf specialized on the type of the record it needs to
  +;;; match... why not define the search function and the predicate on
  +;;; two records then!
   ;;;
  -;;; We'll implement match-output-records and find-child-output-record,
  +;;; We'll implement MATCH-OUTPUT-RECORDS and FIND-CHILD-OUTPUT-RECORD,
   ;;; but we won't actually use them.  Instead, output-record-equal will
   ;;; match two records, and find-child-record-equal will search for the
   ;;; equivalent record.
   
   (defgeneric match-output-records (record &rest args))
   
  -;;; These gf's use :most-specific-last because one of the least
  -;;; specific methods will check the bounding boxes of the records, which
  -;;; should cause an early out most of the time.
  +;;; These gf's use :MOST-SPECIFIC-LAST because one of the least
  +;;; specific methods will check the bounding boxes of the records,
  +;;; which should cause an early out most of the time.
   
   (defgeneric match-output-records-1 (record &key)
     (:method-combination and :most-specific-last))
  
positive.code:     (without-local-recording stream
        (call-next-method))))
  
  #+nil
  (defmethod stream-write-char :around ((stream standard-output-recording-stream) char)
    (when (and (stream-recording-p stream)
               (slot-value stream 'local-record-p))
      (if (or (eql char #\return)
  
          (stream-close-text-output-record stream)
        (let* ((medium (sheet-medium stream))
               (text-style (medium-text-style medium)))
          (stream-add-character-output stream char text-style
                                       (stream-character-width stream char :text-style text-style)
                                       (text-style-height text-style medium)
                                       (text-style-ascent text-style medium)))))
    (without-local-recording stream
                             (call-next-method))))
  
  #+nil
  (defmethod stream-write-string :around ((stream standard-output-recording-stream) string
                                          &optional (start 0) end)
    (when (and (stream-recording-p stream)
               (slot-value stream 'local-record-p))
      (let* ((medium (sheet-medium stream))
             (text-style (medium-text-style medium)))
        (stream-add-string-output stream string start end text-style
                                  (stream-string-width stream string
                                                       :start start :end end
                                                       :text-style text-style)
                                  (text-style-height text-style medium)
                                  (text-style-ascent text-style medium))))
    (without-local-recording stream
                             (call-next-method)))
  
  
  (defmethod stream-finish-output :after ((stream standard-output-recording-stream))
    (stream-close-text-output-record stream))
  
  
negative.code: order they were added."
    (declare (ignore x-offset y-offset))
    (loop with children = (output-record-children record)
  	for i from (1- (length children)) downto 0
  	for child = (aref children i)
  	when (and (multiple-value-bind (min-x min-y max-x max-y)
  		      (output-record-hit-detection-rectangle* child)
  		    (and (<= min-x x max-x) (<= min-y y max-y)))
  		  (output-record-refined-position-test child x y))
  	  do (apply function child function-args)))
  
  (defmethod map-over-output-records-overlapping-region
      (function (record standard-sequence-output-record) region
  