anchor.diff:  (defun spacing-p (pane)
     (typep pane 'spacing-pane))
   
  -(defmethod parse-contents ((pane spacing-pane) contents)
  -  (cond ((and (consp contents)
  -              (null (cdr contents))
  -              (panep (car contents)))
  -         (list (make-instance 'plain-content :pane (car contents))))
  -        (t
  -         (error "Bogus ~S option: ~S. A ~S needs exactly one child not more, not less."
  -                :contents
  -                'spacing-pane))))
  -
  -(defmethod initialize-instance :after ((spacing spacing-pane) &key thickness &allow-other-keys)
  +(defmethod initialize-instance :after ((spacing spacing-pane) &key thickness contents &allow-other-keys)
     (with-slots (user-width user-min-width user-max-width
                  user-height user-min-height user-max-height)
         spacing
       (setf user-width  (max (or thickness 0) (or user-width 0)))
       (setf user-height (max (or thickness 0) (or user-height 0)))
  -    ;; hmm
  -    ))
  +    ;;
  +    (unless (and (listp contents)
  +                 (= (length contents) 1)
  +                 (panep (first contents)))
  +      (error "The ~S option to ~S has bad format, it should be a list of exactly one pane.~%~
  +              Its current value: ~S."
  +             :contents spacing contents))
  +    (sheet-adopt-child spacing (first contents))))
   
   (defmethod compose-space ((spacing spacing-pane))
  -  (with-slots (contents) spacing
  -    (compose-space (content-pane (first contents)))))
  -
  -(defmethod compose-space ((spacing spacing-pane))
  -  (with-slots (contents
  -               user-width user-min-width user-max-width
  -               user-height user-min-height user-max-height) spacing
  -    (let ((sr (compose-space (content-pane (first contents)))))
  -      (make-space-requirement
  -       :width           (+ (or user-width 0) (space-requirement-width sr))
  -       :height          (+ (or user-height 0) (space-requirement-height sr))
  -       :min-width       (min (+ (or user-width 0) (space-requirement-width sr))
  -                             (+ (space-requirement-min-width sr) (or user-min-width 0)))
  -       :min-height      (min (+ (or user-height 0) (space-requirement-height sr))
  -                             (+ (space-requirement-min-height sr) (or user-min-height 0)))
  -       :max-width       (max (+ (or user-width 0) (space-requirement-width sr))
  -                             (+ (space-requirement-max-width sr) (or user-max-width 0)))
  -       :max-height      (max (+ (or user-height 0) (space-requirement-height sr))
  -                             (+ (space-requirement-max-height sr) (or user-max-height 0))) ))))
  +  (compose-space (first (sheet-children spacing))))
   
   (defmethod allocate-space ((spacing spacing-pane) width height)
  -  (with-slots (contents user-width user-height) spacing
  -    (allocate-space (content-pane (first contents))
  +  (with-slots (user-width user-height) spacing
  +    (let ((child (first (sheet-children spacing))))
  +      (layout-child child (pane-align-x spacing) (pane-align-y spacing)
  +                    (/ user-width 2) (/ user-height 2)
                       (- width user-width)
  -                    (- height user-height))
  -    (move-and-resize-sheet (content-pane (first contents))
  -                           (/ user-width 2) (/ user-height 2)
  -                           (- width user-width)
  -                           (- height user-height))))
  +                    (- height user-height)))))
   
   ;;; OUTLINED-PANE
   
  
positive.code:         (declare (ignorable iright itop ileft ibottom))
          (multiple-value-bind (tx ty)
              (values (ecase (pane-align-x pane)
                        (:left (+ x1 m0 (if (slot-value pane 'contents)
                                            (+ a m0 m0 d)
                                          0)))
                        (:right (- x2 m0 (if (slot-value pane 'contents)
                                             (+ a m0 m0 d)
                                           0)
                                   tw))
  
negative.code:                `(locally
                    ,@(walk body))))))
  
  ;;;; Layout Utilities
  
  (defun layout-child (child align-x align-y x y width height)
    "Allocates space to a child of a pane. 
     x, y, width, height designate the area of available space.
     align-x, align-y name the desired child alignment.
     If the child does not have enough strechability to cover all of the
     given area, it is aligned within that area according to the given
     options."
    (let* ((sr           (compose-space child))
           ;; The child's dimension is clamped within its min/max space requirement
           (child-width  (clamp width  (space-requirement-min-width sr)  (space-requirement-max-width sr)))
           (child-height (clamp height (space-requirement-min-height sr) (space-requirement-max-height sr)))
           ;; Align the child within the available area
           (child-x      (ecase align-x
                           ((:left)   x)
                           ((:center) (+ x (/ (- width child-width) 2)))
                           ((:right)  (+ x (- width child-width)))))
           (child-y      (ecase align-y
                           ((:top)    y)
                           ((:center) (+ y (/ (- height child-height) 2)))
                           ((:bottom) (+ y (- height child-height))))))
      ;; Actually layout the child
      (move-sheet child child-x child-y)
      (allocate-space child child-width child-height)))
  
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  
  ;; All panes allow for user specified space requirement options, so we
  ;; define a mixin class to hold the corresponding slots:
  