anchor.diff:        (match-output-records state :cursor-x cx :cursor-y cy))))
   
   (define-protocol-class updating-output-record (output-record))
  -
  -(defgeneric output-record-dirty (record))
  -
  -(defmethod output-record-dirty ((record output-record))
  -  t)
   
   (defclass updating-output-record-mixin (updating-output-map-mixin
   					standard-sequence-output-record)
  
positive.code:     (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"
  
negative.code: 					  erases)))
  			      old-children
  			      visible-region))
      (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 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
        (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")
  