anchor.diff:  
            (let ((qvector
                   (mapcar
  -                 (lambda (c &aux p)
  +                 (lambda (c)
                      (cond
                        ((box-client-fillp c)
                         (vector 1 0 0))
  -                     ((setq p (box-client-proportion c))
  -                      (vector 0 p 0))
                        (t
                         (vector 0 0
                                 (abs (- (if (> excess 0)
  -                                          (space-requirement-max-major
  -                                           (xically-content-sr** box c))
  -                                          (space-requirement-min-major
  -                                           (xically-content-sr** box c)))
  -                                      (space-requirement-major
  -                                       (xically-content-sr** box c))))))))
  +                                          (space-requirement-max-major (xically-content-sr*** box c major))
  +                                          (space-requirement-min-major (xically-content-sr*** box c major)))
  +                                      (space-requirement-major (xically-content-sr*** box c major))))))))
                    (box-layout-mixin-clients box))))
              ;;
              (when *dump-allocate-space*
                (format *trace-output* "~&;;   old allotment = ~S.~%" allot)
  +             (format *trace-output* "~&;;   qvector = ~S.~%" qvector)
                (format *trace-output* "~&;;   qvector 0 = ~S.~%" (mapcar #'(lambda (x) (elt x 0)) qvector))
                (format *trace-output* "~&;;   qvector 1 = ~S.~%" (mapcar #'(lambda (x) (elt x 1)) qvector))
                (format *trace-output* "~&;;   qvector 2 = ~S.~%" (mapcar #'(lambda (x) (elt x 2)) qvector)))
  
positive.code:              for major in majors
               for minor in minors
               do
                 #+nil (format *trace-output* "~&;;   child ~S at 0, ~D ~D x ~D~%" child x width height)
                 (when (box-client-pane child)
                   (move-sheet (box-client-pane child)
                               ((lambda (major minor) height width) x 0)
                               ((lambda (major minor) width height) x 0))
                   (allocate-space (box-client-pane child)
                                   width height))
                 (incf x major)
                 (incf x major-spacing)))))))
  
  ;; #+nil
  (defmethod note-sheet-enabled :before ((pane pane))
  
negative.code:            sum (space-requirement-max-major sr) into max-major
             maximize (space-requirement-minor sr) into minor
             maximize (space-requirement-min-minor sr) into min-minor
             maximize (space-requirement-max-minor sr) into max-minor
             finally
               (return
                 (space-requirement+*
  