anchor.diff:    (if (eq (orientation gadget) :vertical)
         (make-space-requirement :min-width 6 :width 6 :max-width 6
                                 :min-height 1 :height 1)
  -    (make-space-requirement :min-height 6 :height 6 :max-height 6
  -                            :min-width 1 :width 1)))
  +      (make-space-requirement :min-height 6 :height 6 :max-height 6
  +                              :min-width 1 :width 1)))
   
   (defmethod handle-event ((gadget clim-extensions:box-adjuster-gadget)
                            (event pointer-button-press-event))
  -  (setf (slot-value gadget 'drag-from)
  -        (if (eq (orientation gadget) :vertical)
  -            (pointer-event-native-graft-x event)
  -          (pointer-event-native-graft-y event))))
  +  (with-slots (drag-from left-peer right-peer left-sr right-sr) gadget
  +    (setf drag-from (if (eq (orientation gadget) :vertical)
  +                        (pointer-event-native-graft-x event)
  +                        (pointer-event-native-graft-y event))
  +          (values left-peer right-peer)
  +          (do ((current (box-layout-mixin-clients (sheet-parent gadget)) (rest current)))
  +              ((or (null (third current))
  +                   (eq gadget (box-client-pane (second current))))
  +               (values (box-client-pane (first current))
  +                       (box-client-pane (third current)))))
  +          left-sr  (compose-space left-peer)
  +          right-sr (compose-space right-peer))))
   
   (defmethod handle-event ((gadget clim-extensions:box-adjuster-gadget)
                            (event pointer-button-release-event))
  
positive.code:           (values (space-requirement-width sr)
                    (space-requirement-max-width sr)
                    (space-requirement-min-width sr))
          (values (space-requirement-height sr)
                  (space-requirement-max-height sr)
                  (space-requirement-min-height sr)))
      (let ((new-major (max major-min (min major-max (+ major delta)))))
        (if (eq orientation :vertical)
            (change-space-requirements pane :width new-major)
          (change-space-requirements pane :height new-major))
        (- new-major major))))
  
  (defmethod handle-event ((gadget clim-extensions:box-adjuster-gadget)
                           (event pointer-motion-event)
                           &aux (orientation (orientation gadget)))
    (with-slots (drag-from) gadget
      (let ((major-pos (if (eq orientation :vertical)
                            (pointer-event-native-graft-x event)
                          (pointer-event-native-graft-y event))))
        (when drag-from
          (let ((delta (- major-pos drag-from))
                (parent (sheet-parent gadget)))
            (when (typep parent 'box-layout-mixin)
              (multiple-value-bind (left-client right-client)
                  (do ((current (box-layout-mixin-clients parent) (rest current)))
                      ((or (null (third current))
                           (eq gadget (box-client-pane (second current))))
                       (values (first current)
                               (third current))))
                (let* ((left  (box-client-pane left-client))
                       (right (box-client-pane right-client))
                       (left-sr  (compose-space left))
                       (right-sr (compose-space right)))
                  (changing-space-requirements (:resize-frame nil)
                    (adjust-space-requirement left  left-sr  orientation delta)
                    (adjust-space-requirement right right-sr orientation (- delta)))))))
          (setf drag-from major-pos)))))
  
negative.code: 
  (defclass clim-extensions::box-adjuster-gadget
                 (standard-gadget 3d-border-mixin orientation-from-parent-mixin)
    ((drag-from :initform nil)
     (left-sr)
     (left-peer)
     (right-sr)
     (right-peer))
    (:default-initargs :background *3d-inner-color*))
  
  (defmethod compose-space ((gadget clim-extensions:box-adjuster-gadget)
  