anchor.diff:    (values nx ny))
   
   (defmethod* (setf output-record-position) :around
  -    (nx ny (record basic-output-record))
  +            (nx ny (record basic-output-record))
     (with-bounding-rectangle* (min-x min-y max-x max-y) record
  -    (call-next-method)
  +    (call-next-method)    
       (let ((parent (output-record-parent record)))
         (when (and parent (not (and (typep parent 'compound-output-record)
                                     (slot-value parent 'in-moving-p)))) ; XXX
           (recompute-extent-for-changed-child parent record
  -                                            min-x min-y max-x max-y))))
  -  (values nx ny))
  +                                            min-x min-y max-x max-y)))   
  +    (values nx ny)))
   
   (defmethod* (setf output-record-position)
     :before (nx ny (record compound-output-record))
  
positive.code: 						  ox1 oy1 ox2 oy2)))))))
    record)
  
  ;; There was once an :around method on recompute-extent-for-changed-child here,
  ;; but I've eliminated it. Its function was to notify the parent OR in case
  ;; the bounding rect here changed - I've merged this into the above method.
  ;; --Hefner, 8/7/02
  
  (defmethod tree-recompute-extent ((record compound-output-record))
    (tree-recompute-extent-aux record)
    record)
  
negative.code:     ((record compound-output-record) child)
    (unless (null-bounding-rectangle-p child)
      (with-bounding-rectangle* (old-x1 old-y1 old-x2 old-y2) record
        (cond
          ((null-bounding-rectangle-p record)
           (setf (rectangle-edges* record) (bounding-rectangle* child)))
          ((not (null-bounding-rectangle-p child))
           (assert (not (null-bounding-rectangle-p record))) ; important.
           (with-bounding-rectangle* (x1-child y1-child x2-child y2-child)
               child
             (setf (rectangle-edges* record)
                   (values (min old-x1 x1-child) (min old-y1 y1-child)
                           (max old-x2 x2-child) (max old-y2 y2-child))))))
        (let ((parent (output-record-parent record)))
          (when parent
            (recompute-extent-for-changed-child
             parent record old-x1 old-y1 old-x2 old-y2)))))
    record)
  
  (defmethod %tree-recompute-extent* ((record compound-output-record))
  