anchor.diff:  				      (height nil height-p)
   				      (min-height nil min-height-p)
   				      (max-height nil max-height-p))
  -  (with-slots (sr-width sr-max-width sr-min-width sr-height sr-max-height sr-min-height) pane
  +  (with-slots (sr-width sr-height sr-max-width sr-max-height
  +	       sr-min-width sr-min-height) pane
       (when width-p (setf sr-width width))
       (when min-width-p (setf sr-min-width min-width))
       (when max-width-p (setf sr-max-width max-width))
  
positive.code:   (loop for children in (reverse contents)
  	do (loop for child in (reverse children)
  		 do (sheet-adopt-child table child)))
    (setf (table-pane-number table) (length (first contents))))
  
  (defmacro tabling ((&rest options) &body contents)
    `(if (pane-grid-p (list ,@contents))
         (make-pane 'grid-pane ,@options :contents (list ,@contents))
         (make-pane 'table-pane ,@options :contents (list ,@contents))))
  
  (defmacro change-formated-spaces (spaces space-direction-accessor)
    `(setf (,space-direction-accessor space)
  	 (reduce #'max (mapcar #'(lambda (l)
  				  (reduce #'+ (mapcar #',space-direction-accessor l)))
  			      ,spaces))))
  
  (defun format-children (children number-per-line)
    (let (formated aux)
      (loop for child in children
  	  for i from 1
  	  do (progn (push child aux)
  		    (when (= (mod i number-per-line) 0)
  		      (push (nreverse aux) formated)
  		      (setf aux nil))))
      (nreverse formated)))
  
  
  (defmethod compose-space ((table table-pane))
    (mapc #'compute-and-set-space (sheet-children table))
    (let* ((space (make-space-requirement))
  	 (h-spaces (format-children (mapcar #'pane-space-requirement (sheet-children table))
  				    (table-pane-number table)))
  	 (v-spaces (apply #'mapcar #'list h-spaces)))
      (change-formated-spaces h-spaces space-requirement-width)
      (change-formated-spaces h-spaces space-requirement-min-width)
      (change-formated-spaces h-spaces space-requirement-max-width)
      (change-formated-spaces v-spaces space-requirement-height)
      (change-formated-spaces v-spaces space-requirement-min-height)
      (change-formated-spaces v-spaces space-requirement-max-height)
      space))
  
  (defun find-collums-and-rows-size (table)
    (let* ((number-per-line (table-pane-number table))
           (children-request (mapcar #'pane-space-requirement (sheet-children table)))
           (width-requests (mapcar #'space-requirement-width children-request))
           (height-requests (mapcar #'space-requirement-height children-request))
           (height-requests (format-children height-requests number-per-line))
           (width-requests (apply #'mapcar #'list 
                                  (format-children width-requests number-per-line))))
      (list
       (mapcar #'(lambda (l) (reduce #'max l)) width-requests)
       (mapcar #'(lambda (l) (reduce #'max l)) height-requests))))
  
  (defmethod allocate-space ((table table-pane) width height)
    (set-width-and-height table width height)
    (let ((h-percent (/ width (space-requirement-width (pane-space-requirement table))))
          (v-percent (/ height (space-requirement-height (pane-space-requirement table))))
          (table-cell-sizes (find-collums-and-rows-size table))
          (contents (format-children (sheet-children table) (table-pane-number table)))
  	(x 0)
          (y 0))
      (loop for line-children in contents
            for height in (second table-cell-sizes)
            for new-height = (floor (* h-percent height))
            do (progn (loop for child in line-children
  			  for width in (first table-cell-sizes)
  			  for new-width = (floor (* v-percent width))
  			  do (progn (multiple-value-bind (x1 y1)
  					(bounding-rectangle* (sheet-region child))
  				      (setf (sheet-transformation child)
  					    (make-translation-transformation (- x x1) (- y y1))))
  				    (allocate-space child new-width new-height)
  				    (incf x new-width)))
  		    (setf x 0)
  		    (incf y new-height)))))
  
  ;(defmethod sheet-adopt-child :before ((table table-pane) child)
  ;  (declare (ignore child))
  ;  (when (= (length (sheet-children table)) (table-pane-number table))
  ;    (error "The table can't adopt more childs than specified by the table-number")))
  
  (defmethod sheet-disowned-child :before ((table table-pane) child &key (error-p t))
    (declare (ignore child error-p))
    (error "The table pane can't disown one of its child"))
  
  
  ;; GRID PANE
  
  (defclass grid-pane (table-pane) ()
    (:documentation "Be careful : each cell has its width equal to its height"))
  
  (defun pane-grid-p (contents)
    (let ((spaces (mapcar #'pane-space-requirement (apply #'append contents))))
      (apply #'= (mapcan #'(lambda (pane)
  			    (list (space-requirement-width pane)
  				  (space-requirement-height pane)))
  					       
  			spaces))))
  	    
  
  
  (defmethod allocate-space ((grid grid-pane) width height)
    (set-width-and-height grid width height)
    (let* ((new-height (/ height (/ (length (sheet-children grid)) (table-pane-number grid))))
  	 (new-width (/ width (table-pane-number grid)))
  	 (contents (format-children (sheet-children grid) (table-pane-number grid)))
  	 (x 0)
  	 (y 0))
      (loop for children in contents
  	  do (progn (loop for child in children
  			  do (progn (multiple-value-bind (x1 y1)
  					(bounding-rectangle* (sheet-region child))
  				      (setf (sheet-transformation child)
  					    (make-translation-transformation (- x x1) (- y y1))))
  				    (allocate-space child new-width new-height)
  				    (incf x new-width)))
  		    (setf x 0)
  		    (incf y new-height)))))
  
  
  ;; SPACER PANE
  
  (defclass spacer-pane (composite-pane) ())
  
  (defmacro spacing ((&rest options) &body contents)
    `(make-pane 'spacer-pane ,@options :contents (list ,@contents)))
  
  (defmethod compose-space ((spacer spacer-pane))
    (compute-and-set-space (first (sheet-children spacer)))
    (let ((space (make-space-requirement))
  	(margin-space (pane-space-requirement spacer))
  	(child-space (pane-space-requirement (first (sheet-children spacer)))))
      (setf (space-requirement-width space) 
  	  (+ (space-requirement-width margin-space)
  	     (space-requirement-width child-space))
  	  (space-requirement-min-width space) 
  	  (+ (space-requirement-min-width margin-space)
  	     (space-requirement-min-width child-space))
  	  (space-requirement-max-width space) 
  	  (+ (space-requirement-max-width margin-space)
  	     (space-requirement-max-width child-space))
  	  (space-requirement-height space) 
  	  (+ (space-requirement-height margin-space)
  	     (space-requirement-height child-space))
  	  (space-requirement-min-height space) 
  	  (+ (space-requirement-min-height margin-space)
  	     (space-requirement-min-height child-space))
  	  (space-requirement-max-height space) 
  	  (+ (space-requirement-max-height margin-space)
  	     (space-requirement-max-height child-space))
  	  (pane-space-requirement spacer) space)
      space))
  
  ;;; FIXME: I don't see how this one could possibly work
  (defmethod allocate-space ((spacer spacer-pane) width height)
    (set-width-and-height spacer width height)
    (let* ((h-percent (/ width (space-requirement-width (pane-space-requirement spacer))))
  	 (v-percent (/ height (space-requirement-height (pane-space-requirement spacer))))
  	 (child (first (sheet-children spacer)))
  	 (request (pane-space-requirement child))
  	 (new-width (floor (* h-percent (space-requirement-width request))))
  	 (new-height (floor (* v-percent (space-requirement-height request)))))
      (multiple-value-bind (x1 y1)
  	(bounding-rectangle* (sheet-region child))
        (setf (sheet-transformation child)
  	    (make-translation-transformation (- x1) (- y1))))
      (allocate-space child new-width new-height)))
  
  
  ;;; BORDER-PANE class
  
  (defclass border-pane (single-child-composite-pane)
    ((border-width :initarg :border-width
  		 :initform 1
  		 :reader border-pane-width))
    )
  
  (defmacro bordering ((&rest options
  		      &key background &allow-other-keys) contents)
    `(make-pane 'border-pane ,@options :contents (list ,contents)))
  
  (defmethod compose-space ((bp border-pane))
    (let ((space (make-space-requirement))
  	(request (compute-and-set-space (first (sheet-children bp))))
  	(border-width*2 (* 2 (border-pane-width bp))))
      (setf (space-requirement-width space)
  	  (+ border-width*2 (space-requirement-width request)))
      (setf (space-requirement-max-width space)
  	  (+ border-width*2 (space-requirement-max-width request)))
      (setf (space-requirement-min-width space)
  	  (+ border-width*2 (space-requirement-min-width request)))
      (setf (space-requirement-height space)
  	  (+ border-width*2 (space-requirement-height request)))
      (setf (space-requirement-max-height space)
  	  (+ border-width*2 (space-requirement-max-height request)))
      (setf (space-requirement-min-height space)
  	  (+ border-width*2 (space-requirement-min-height request)))
      (setf (pane-space-requirement bp) space)
      space))
  
  (defmethod allocate-space ((bp border-pane) width height)
    (set-width-and-height bp width height)
    (let ((border-width (border-pane-width bp))
  	(child (first (sheet-children bp))))
      (when child
        (setf (sheet-transformation child)
  	(make-translation-transformation border-width border-width))
        (allocate-space child (- width (* 2 border-width)) (- height (* 2 border-width))))))
  
  ;;; RAISED PANE
  
  (defclass raised-pane (border-pane) ())
  
  (defmacro raising ((&rest options
  		    &key background &allow-other-keys) contents)
    `(make-pane 'raised-pane ,@options :contents (list ,contents)))
  
  (defmethod dispatch-repaint ((raised-pane raised-pane) region)
    (repaint-sheet raised-pane region))
  
negative.code:   (remf options :equalize-height)
    (if equalize-height
        `(make-pane 'hrack-pane ,@options :contents (list ,@contents))
        `(make-pane 'hbox-pane ,@options :contents (list ,@contents))))
  
  (defmethod compose-space ((box hbox-pane))
    (loop with space = (make-space-requirement)
  	for child in (sheet-children box)	
  	for request = (compose-space child)
  	sum (get-size child) into sum-width
  	do (incf (space-requirement-width space)
  		 (space-requirement-width request))
  	   (incf (space-requirement-max-width space)
  