anchor.diff:        (setf (pane-space-requirement pane)
               (call-next-method))))
   
  -(defmethod change-space-requirements ((pane layout-protocol-mixin)
  -                                      &rest space-req-keys &key resize-frame
  -				      &allow-other-keys)
  -  (declare (ignore resize-frame))
  -  (setf (pane-space-requirement pane) nil)
  -  (note-space-requirements-changed (sheet-parent pane) pane))
  -
  -(defmethod note-space-requirements-changed :before ((sheet layout-protocol-mixin)
  -                                                    (pane layout-protocol-mixin))
  -  )
  -
  -(defmethod note-space-requirements-changed ((pane pane) client)
  -  (declare (ignore client))
  +;;; changing space requirements
  +
  +;; Here is what we do:
  +;;
  +;; change-space-requirements (pane) :=
  +;;   clear space requirements cache
  +;;   call change-space-requirements on parent pane
  +;;   call note-space-requirements-changed
  +;;
  +;; This is splitted into :before, primary and :after method to allow
  +;; for easy overriding of change-space-requirements without needing to
  +;; know the details of the space requirement cache and the
  +;; note-space-requirements-changed notifications.
  +;;
  +;; The calls to change-space-requirements travel all the way up to the
  +;; top-level-sheet-pane which then invokes the layout protocol calling
  +;; layout-frame.
  +;;
  +;; In case this happens within changing-space-requirements layout
  +;; frame is not called but simply recorded and then called when
  +;; changing-space-requirements is left.
  +;;
  +;; No action is taken in note-space-requirements-changed. We leave
  +;; that to the user.
  +
  +(defvar *changing-space-requirements* nil
  +  "Bound to non-NIL while within the execution of CHANGING-SPACE-REQUIREMENTS.")
  +
  +(defvar *changed-space-requirements* nil
  +  "A list of (frame pane resize-frame) tuples recording frames and their panes which
  +   changed during the current execution of CHANGING-SPACE-REQUIREMENTS.
  +   [This is expected to change]")
  +
  +(defmethod change-space-requirements :before ((pane layout-protocol-mixin)
  +                                              &rest space-req-keys
  +                                              &key resize-frame &allow-other-keys)
  +  (declare (ignore resize-frame space-req-keys))
  +  ;; Clear the space requirements cache
     (setf (pane-space-requirement pane) nil)
     (setf (pane-current-width pane) nil)
  -  (setf (pane-current-height pane) nil)
  -  (change-space-requirements pane))
  +  (setf (pane-current-height pane) nil) )
  +
  +(defmethod change-space-requirements ((pane layout-protocol-mixin)
  +                                      &rest space-req-keys
  +                                      &key resize-frame &allow-other-keys)
  +  (declare (ignore resize-frame))
  +  (change-space-requirements (sheet-parent pane) :resize-frame resize-frame))
  +
  +(defmethod change-space-requirements :after ((pane layout-protocol-mixin)
  +                                             &rest space-req-keys
  +                                             &key resize-frame &allow-other-keys)
  +  (declare (ignore resize-frame space-req-keys))
  +  (note-space-requirements-changed (sheet-parent pane) pane))
  +
  +(defmethod note-space-requirements-changed (pane client)
  +  "Just a no-op fallback method."
  +  nil)
  +
  +;;; CHANGING-SPACE-REQUIREMENTS macro
  +
  +(defmacro changing-space-requirements ((&key resize-frame layout) &body body)
  +  `(invoke-while-changing-space-requirements (lambda () ,@body) :resize-frame ,resize-frame :layout layout))
  +
  +(defun invoke-with-changing-space-requirements (continuation &key resize-frame layout)
  +  (cond (*changed-space-requirements*
  +         ;; We are already within changing-space-requirements, so just
  +         ;; call the body. This might however lead to surprising
  +         ;; behavior in case the outer changing-space-requirements has
  +         ;; resize-frame = NIL while the inner has resize-frame = T.
  +         (funcall continuation))
  +        (t
  +         (let ((*changed-space-requirements* nil))
  +           (let ((*changing-space-requirements* t))
  +             (funcall continuation))
  +           ;;
  +           ;; Note: That 'resize-frame' and especially 'layout' are
  +           ;; options to this strongly suggests that the authors of
  +           ;; the clim specification may have meant that
  +           ;; changing-space-requirements records space requirements
  +           ;; of the *application-frame* only.
  +           ;;
  +           ;; We solve this by recording all frames but applying
  +           ;; resize-frame and layout only to *application-frame*.
  +           ;;
  +           (dolist (q *changed-space-requirements*)
  +             (destructuring-bind (frame pane resize-frame-2) q
  +               (cond ((eq frame *application-frame*)
  +                      (when layout
  +                        (setf (frame-current-layout frame) layout))
  +                      (cond (resize-frame
  +                             (layout-frame frame))
  +                            (t
  +                             (layout-frame frame (bounding-rectangle-width pane) (bounding-rectangle-height pane)))))
  +                     (t
  +                      (cond (resize-frame-2
  +                             (layout-frame frame))
  +                            (t
  +                             (layout-frame frame (bounding-rectangle-width pane) (bounding-rectangle-height pane)))))))) ))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   
  
positive.code:            (:line  (* (car x)
                        (stream-line-height pane)))))))
  
  (defvar *changing-space-requirements* nil
    "Bound to non-NIL while within the execution of CHANGING-SPACE-REQUIREMENTS.")
  
  (defvar *changed-space-requirements* nil
    "A list of ?? whose space requirements have changed during the current
     execution of CHANGING-SPACE-REQUIREMENTS.")
  
  (defmacro changing-space-requirements ((&key resize-frame) &body body)
    `(invoke-while-changing-space-requirements (lambda () ,@body) :resize-frame ,resize-frame))
  
  (defun invoke-while-changing-space-requirements (continuation &key resize-frame)
    (let ((*changed-space-requirements* nil))
      (let ((*changing-space-requirements* t))
        (funcall continuation))
      ;; now investiage the list of changed space-requirements ...
      ))
  
  #+nil ; I don't know what this is supposed to achieve
  (defmethod change-space-requirements ((pane composite-pane)
  				      &key resize-frame
  				      (width nil width-p)
  				      (min-width nil min-width-p)
  				      (max-width nil max-width-p)
  				      (height nil height-p)
  				      (min-height nil min-height-p)
  				      (max-height nil max-height-p))
    (declare (ignore width width-p min-width min-width-p max-width max-width-p
  		   height height-p min-height min-height-p max-height max-height-p))
    (if resize-frame
        ;; we didn't find the :resize-frame option in define-application-frame
        (layout-frame (pane-frame pane))
        (note-space-requirements-changed (sheet-parent pane) pane)))
  
  ;;; SINGLE-CHILD-COMPOSITE PANE
  
  (defclass single-child-composite-pane (sheet-single-child-mixin basic-pane) ())
  
negative.code:   (when (sheet-child pane)
      (allocate-space (sheet-child pane) width height)))
  
  ;;;; TOP-LEVEL-SHEET
  
  (defclass top-level-sheet-pane (composite-pane)
    ()
  