anchor.diff:  (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)
  
positive.code: 	 (visible-region (pane-viewport-region stream))
  	 (old-children (if (slot-boundp record 'old-children)
  			   (old-children record)
  			   nil)))
      (unless (or (null visible-region)
  		(region-intersects-region-p visible-region record)
  		(and old-children
  		     (region-intersects-region-p visible-region old-children)))
        (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,
  
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?
     ))
  
  