anchor.diff:  	 (visible-region (pane-viewport-region stream))
   	 (old-children (if (slot-boundp record 'old-children)
   			   (old-children record)
  -			   nil)))
  +			   nil))
  +	 (old-bounds (old-bounds record)))
       (unless (or (null visible-region)
   		(region-intersects-region-p visible-region record)
   		(and old-children
  -		     (region-intersects-region-p visible-region old-children)))
  +		     (region-intersects-region-p visible-region old-bounds)))
         (return-from compute-difference-set (values nil nil nil nil nil)))
       ;; XXX This means that compute-difference-set can't be called repeatedly on
       ;; the same tree; ugh. On the other hand, if we don't clear explicit-moves,
  
positive.code: (defgeneric find-child-output-record (record use-old-elements record-type
  				      &rest initargs
  				      &key unique-id unique-id-test))
  
  (defgeneric find-equal-display-record (root use-old-elements record))
  
  (defmethod find-equal-display-record ((root standard-updating-output-record)
  				      use-old-elements
  				      record)
    (cond ((eq (output-record-dirty root) :clean)
  	 nil)
  	(use-old-elements
  	 (when (slot-boundp root 'old-children)
  	   (find-equal-display-record (old-children root)
  				      use-old-elements
  				      record)))
  	(t (find-equal-display-record (sub-record root)
  				      use-old-elements
  				      record))))
  
  (defmethod find-equal-display-record ((root compound-output-record)
  				      use-old-elements
  				      record)
    (when (region-intersects-region-p root record)
      (flet ((mapper (r)
  	     (let ((result (find-equal-display-record r
  						      use-old-elements
  						      record)))
  	       (when result
  		 (return-from find-equal-display-record result)))))
        (declare (dynamic-extent #'mapper))
        (map-over-output-records-overlapping-region #'mapper root record)))
    nil)
  
  
  (defmethod find-equal-display-record ((root displayed-output-record)
  				      use-old-elements
  				      record)
    (declare (ignore use-old-elements))
    (if (output-record-equal root record)
        root
        nil))
  
  (defgeneric map-over-displayed-output-records
      (function root use-old-elements clean clip-region)
  
negative.code: updating-output-parent above this one in the tree.")
     ;; Results of (setf output-record-position) while updating
     (explicit-moves :accessor explicit-moves)
     (old-bounds :accessor old-bounds
  	       :initform (make-bounding-rectangle 0.0d0 0.0d0 0.0d0 0.0d0)
  	       :documentation "Holds the old bounds of an updating output
   record if that can no longer be determined from the old-children.")
     ;; on-screen state?
     ))
  
  