anchor.diff:  					  erases)))
   			      old-children
   			      visible-region))
  -    ;(break)
  +    (when check-overlapping
  +      (setf erase-overlapping (nconc erases draws))
  +      (setf move-overlapping moves)
  +      (setf erases nil)
  +      (setf moves nil)
  +      (setf draws nil))
       ;; Visit this record's updating-output children and merge in the
       ;; difference set. We need to visit all updating-output records, not just
       ;; ones in the visible region, because they might have old records that
       ;; lie in the visible region and that need to be erased.
  -    (map-over-child-updating-output #'(lambda (r)
  -					(multiple-value-bind (e m d)
  -					    (compute-difference-set r)
  -					  (setf erases (nconc e erases))
  -					  (setf moves (nconc m moves))
  -					  (setf draws (nconc d draws))))
  -				    (sub-record record)
  -				    nil)
  -    ;; Finally, look for updating-output children that were not visited. They
  -    ;; may have display records equal to ones we already have; otherwise their
  -    ;; records need to be erased.
  +    (map-over-child-updating-output
  +     #'(lambda (r)
  +	 (multiple-value-bind (e m d e-o m-o)
  +	     (compute-difference-set r check-overlapping)
  +	   (setf erases (nconc e erases))
  +	   (setf moves (nconc m moves))
  +	   (setf draws (nconc d draws))
  +	   (setf erase-overlapping (nconc e-o erase-overlapping))
  +	   (setf move-overlapping (nconc m-o move-overlapping))))
  +     (sub-record record)
  +     nil)
  +    ;; Look for updating-output children that were not visited. Their
  +    ;; display records need to be erased.
       (when old-children
  -      (map-over-child-updating-output
  -       #'(lambda (r)
  -	   (when (eq (output-record-dirty r) :updating)
  -	     (map-over-displayed-output-records
  -	      #'(lambda (dr)		;All of them
  -		  (multiple-value-bind (draws2 found)
  -		      (delete-1 dr draws :test #'output-record-equal)
  -		    (if found
  -			(setq draws draws2)
  -			(push (list dr (copy-bounding-rectange dr)) erases))))
  -	      r
  -	      t
  -	      t
  -	      visible-region)))
  -       old-children
  -       visible-region))
  -    (values erases moves draws nil nil)))
  +      (flet ((erase-obsolete (dr)		;All of them
  +	       (let ((erase-chunk (list dr (copy-bounding-rectange dr))))
  +		 (if check-overlapping
  +		     (push erase-chunk erase-overlapping)
  +		     (push erase-chunk erases)))))
  +	(declare (dynamic-extent #'erase-obsolete))
  +	(map-over-child-updating-output
  +	 #'(lambda (r)
  +	     (when (eq (output-record-dirty r) :updating)
  +	       (map-over-obsolete-display #'erase-obsolete
  +					  (sub-record r)
  +					  visible-region)))
  +	 old-children
  +	 visible-region)))
  +    ;; Traverse all the display records for this updating output node and do
  +    ;; the notes...
  +    (flet ((note-got (r)
  +	     (note-output-record-got-sheet r stream))
  +	   (note-lost (r)
  +	     (note-output-record-lost-sheet r stream)))
  +      (declare (dynamic-extent #'note-got #'note-lost))
  +      (map-over-child-display #'note-got (sub-record record) nil)
  +      (when old-children
  +	(map-over-child-display #'note-lost old-children nil)
  +	(map-over-child-updating-output
  +	 #'(lambda (r)
  +	     (when (eq (output-record-dirty r) :updating)
  +	       (map-over-obsolete-display #'note-lost
  +					  (sub-record r)
  +					  nil)))
  +	 old-children
  +	 nil)))
  +    (values erases moves draws erase-overlapping move-overlapping)))
   
   (defparameter *enable-updating-output* t
     "Switch to turn on incremental redisplay")
  
positive.code:     (record bounding-rectangle (stream updating-output-stream-mixin))
    (declare (ignore bounding-rectangle))
    (note-output-record-lost-sheet record stream))
  
  (defun clear-moved-record (stream new-bounding old-bounding)
    (with-bounding-rectangle* (x1 y1 x2 y2)
  
negative.code:     (when (region-intersects-region-p record clip-rectangle)
        (call-next-method))))
  
  ;;; Variation on a theme. Refactor, refactor...
  
  (defgeneric map-over-obsolete-display (function record clip-rectangle)
    (:method (function (record displayed-output-record) clip-rectangle)
      (declare (ignore clip-rectangle))
      (funcall function record))
    (:method (function (record compound-output-record) clip-rectangle)
      (flet ((mapper (r)
  	     (map-over-obsolete-display function r clip-rectangle)))
        (declare (dynamic-extent #'mapper))
        (map-over-output-records #'mapper record)))
    (:method (function (record standard-updating-output-record) clip-rectangle)
      (when (eq (output-record-dirty record) :updating)
        (map-over-obsolete-display function (sub-record record) clip-rectangle)))
    (:method (function record clip-rectangle)
      (declare (ignore function record clip-rectangle))
      nil)
    (:method :around (function record (clip-rectangle bounding-rectangle))
      (declare (ignore function))
      (when (region-intersects-region-p record clip-rectangle)
        (call-next-method))))
  
  (defun find-existing-record (display-record root visible-region)
    "Returns a display record that is output-record-equal to display-record
    within visible-region and not under an updating-output record"
  