anchor.diff:    (remove sheet (sheet-children (sheet-parent sheet))))
   
   (defmethod sheet-enabled-children ((sheet sheet))
  -  (loop for child in (sheet-children sheet)
  -       if (sheet-enabled-p child)
  -	  collect child))
  +  (delete-if-not #'sheet-enabled-p (copy-list (sheet-children sheet))))
   
   (defmethod sheet-ancestor-p ((sheet sheet) (putative-ancestor sheet))
  -  (loop for s = (sheet-parent sheet) then (sheet-parent s)
  -       until (null s)
  -       if (eq s putative-ancestor)
  -	  return t
  -       finally (return nil)))
  +  (eq sheet putative-ancestor))
   
   (defmethod raise-sheet ((sheet sheet))
  -  (with-slots (children) (sheet-parent sheet)
  -    (setf children (cons sheet (remove sheet children))))
  +  (setf (sheet-children sheet) (cons sheet (remove sheet (sheet-children sheet))))
     sheet)
   
   (defmethod bury-sheet ((sheet sheet))
  -  (with-slots (children) (sheet-parent sheet)
  -    (setf children (nconc (remove sheet children) (list sheet))))
  +  (setf (sheet-children sheet) (nconc (remove sheet (sheet-children sheet)) (list sheet)))
     sheet)
   
  -(define-condition sheet-ordering-underspecified (error)
  -  (
  -   ))
  +(define-condition sheet-ordering-underspecified (error) ())
   
   (defmethod reorder-sheets ((sheet sheet) new-ordering)
  -  (with-slots (children) sheet
  -    (if (set-difference children new-ordering)
  -	(error 'sheet-ordering-underspecified))
  -    (if (set-difference new-ordering children)
  -	(error 'sheet-is-not-child))
  -    (setf children new-ordering))
  +  (when (set-difference (sheet-children sheet) new-ordering)
  +    (error 'sheet-ordering-underspecified))
  +  (when (set-difference new-ordering (sheet-children sheet))
  +    (error 'sheet-is-not-child))
  +  (setf (sheet-children sheet) new-ordering)
     sheet)
   
   (defmethod sheet-viewable-p ((sheet sheet))
  -  (and (sheet-enabled-p sheet)
  -       (or (null (sheet-parent sheet))
  -	   (sheet-viewable-p (sheet-parent sheet)))))
  +  (and (sheet-parent sheet)
  +       (sheet-viewable-p (sheet-parent sheet))
  +       (sheet-enabled-p sheet)))
   
   (defmethod sheet-occluding-sheets ((sheet sheet) (child sheet))
  -  (let ((childs-region (sheet-region child))
  -	(results nil))
  -    (do ((children (sheet-children sheet) (cdr children)))
  -	((or (null children)
  -	     (eq (first children) child)))
  -      (if (and (sheet-enabled-p (first children))
  -	       (region-intersects-region-p childs-region (sheet-region (first children))))
  -	  (push (first children) results)))
  -    results))
  -
  -;;; SHEET mixin classes
  -
  -(defclass sheet-parent-mixin ()
  -  ((parent :initform nil
  -	   :reader sheet-parent)
  -   ))
  -
  -(defmethod set-sheets-parent ((child sheet-parent-mixin) (parent sheet))
  -  (setf (slot-value child 'parent) parent))
  -
  -(defclass sheet-leaf-mixin ()
  -  (
  -   ))
  -
  -(defmethod sheet-adopt-child ((sheet sheet-leaf-mixin) (child sheet))
  -  (error "Leaf sheet attempting to adopt a child"))
  -
  -(defclass sheet-single-child-mixin ()
  -  ((children :initform nil
  -	     :reader sheet-children)
  -   ))
  -
  -(defmethod sheet-adopt-child ((sheet sheet-single-child-mixin) (child sheet))
  -  (if (sheet-parent child)
  -      (error 'sheet-already-has-parent))
  -  (if (sheet-children sheet)
  -      (error "Single Child Sheet attempting to adopt a second child"))
  -  (set-sheets-parent child sheet)
  -  (with-slots (children) sheet
  -    (setf children (list child)))
  -  child)
  -
  -(defclass sheet-multiple-child-mixin ()
  -  ((children :initform nil
  -	     :reader sheet-children)
  -   ))
  -
  -(defmethod sheet-adopt-child ((sheet sheet-multiple-child-mixin) (child sheet))
  -  (if (sheet-parent child)
  -      (error 'sheet-already-has-parent))
  -  (set-sheets-parent child sheet)
  -  (with-slots (children) sheet
  -    (setf children (append children (list child))))
  -  child)
  -
  -;;; SHEET geometry functions
  +  (labels ((fun (l)
  +		(cond ((eq (car l) child) '())
  +		      ((region-intersects-region-p
  +			(sheet-region (car l)) (sheet-region child))
  +		       (cons (car l) (fun (cdr l))))
  +		      (t (fun (cdr l))))))
  +    (fun (sheet-children sheet))))
  +
  +(defmethod sheet-transformation ((sheet sheet))
  +  (error "Attempting to get the TRANSFORMATION of a SHEET that doesn't contain one"))
  +
  +(defmethod (setf sheet-transformation) (transformation (sheet sheet))
  +  (declare (ignore transformation))
  +  (error "Attempting to set the TRANSFORMATION of a SHEET that doesn't contain one"))
   
   (defmethod map-sheet-position-to-parent ((sheet sheet) x y)
  -  (transform-position (sheet-transformation sheet) x y))
  +  (declare (ignore x y))
  +  (error "Sheet has no parent"))
   
   (defmethod map-sheet-position-to-child ((sheet sheet) x y)
  -  (transform-position (invert-transformation (sheet-transformation sheet)) x y))
  +  (declare (ignore x y))
  +  (error "Sheet has no parent"))
   
   (defmethod map-sheet-rectangle*-to-parent ((sheet sheet) x1 y1 x2 y2)
  -  (transform-rectangle* (sheet-transformation sheet) x1 y1 x2 y2))
  +  (declare (ignore x1 y1 x2 y2))
  +  (error "Sheet has no parent"))
   
   (defmethod map-sheet-rectangle*-to-child ((sheet sheet) x1 y1 x2 y2)
  -  (transform-rectangle* (invert-transformation (sheet-transformation sheet)) x1 y1 x2 y2))
  +  (declare (ignore x1 y1 x2 y2))
  +  (error "Sheet has no parent"))
   
   (defmethod child-containing-position ((sheet sheet) x y)
     (loop for child in (sheet-children sheet)
         do (multiple-value-bind (tx ty) (map-sheet-position-to-child child x y)
  -	   (if (and (sheet-enabled-p child)
  -		    (region-contains-position-p (sheet-region child) tx ty))
  -	       (return child)))))
  +	    (if (and (sheet-enabled-p child)
  +		     (region-contains-position-p (sheet-region child) tx ty))
  +		(return child)))))
   
   (defmethod children-overlapping-region ((sheet sheet) (region region))
     (loop for child in (sheet-children sheet)
         if (and (sheet-enabled-p child)
  -	      (region-intersects-region-p region (transform-region (sheet-transformation child) (sheet-region child))))
  +	      (region-intersects-region-p 
  +	       region 
  +	       (transform-region (sheet-transformation child)
  +				 (sheet-region child))))
         collect child))
   
   (defmethod children-overlapping-rectangle* ((sheet sheet) x1 y1 x2 y2)
  -  (loop with region = (make-rectangle* x1 y1 x2 y2)
  -      for child in (sheet-children sheet)
  -      if (and (sheet-enabled-p child)
  -	      (region-intersects-region-p region (transform-region (sheet-transformation child) (sheet-region child))))
  -      collect child))
  +  (children-overlapping-region sheet (make-rectangle* x1 y1 x2 y2)))
   
   (defmethod sheet-delta-transformation ((sheet sheet) (ancestor (eql nil)))
  -  (if (sheet-parent sheet)
  -      (compose-transformations (sheet-transformation sheet)
  -			       (sheet-delta-transformation
  -				(sheet-parent sheet) ancestor))
  -      (sheet-transformation sheet)))
  +  (cond ((sheet-parent sheet)
  +	 (compose-transformations (sheet-transformation sheet)
  +				  (sheet-delta-transformation
  +				   (sheet-parent sheet) ancestor)))
  +	(t (sheet-transformation sheet))))
     
   (define-condition sheet-is-not-ancestor (error) ())
   
  
positive.code:   (queue-repaint sheet region))
  
  (defmethod repaint-sheet ((sheet mute-repaint-mixin) region)
    (declare (ignore region))
    (values))
  
negative.code: (defmethod sheet-children ((sheet sheet))
    nil)
  
  (defmethod sheet-adopt-child ((sheet sheet) (child sheet))
    (error "SHEET attempting to adopt a child"))
  
  (define-condition sheet-is-not-child (error) ())
  
  (defmethod sheet-disown-child ((sheet sheet) (child sheet) &key (errorp t))
    (cond
     ((eq (sheet-parent child) sheet)
      (set-sheets-parent child nil)
      (setf (sheet-children sheet) (remove child (sheet-children sheet))))
     (errorp
      (error 'sheet-is-not-child)))
    child)
  