anchor.diff:     (min-height :initarg :min-height :reader cell-min-height))
     (:default-initargs
      :align-x :left :align-y :baseline :min-width 0 :min-height 0))
  -
  -;;; If this were a primary method it wouldn't override the default
  -;;; behavior for the parent being a compound-output-record because of
  -;;; the order of the argument list.
  -(defmethod recompute-extent-for-changed-child :around
  -    (record (changed-child standard-cell-output-record)
  -     old-min-x old-min-y old-max-x old-max-y)
  -  (unless *table-suppress-update*
  -    (call-next-method))
  -  record)
  -
  -(defun table-cell-allowed-as-child-of (record)
  -  "Internal. A predicate which decides whether 'record' can take a
  -table cell as argument."
  -  ;; We allow a cell output record here if any ancestor is a
  -  ;; table-row, column or list-item. Note: This is probably not 100%
  -  ;; correct, as I have no idea what happens when you nest graphs and
  -  ;; tables ...
  -  (or (row-output-record-p record)
  -      (column-output-record-p record)
  -      (item-list-output-record-p record)
  -      (and (output-record-parent record)
  -           (table-cell-allowed-as-child-of (output-record-parent record)))))
  -
  -(defun assert-table-cell-allowed (record)
  -  "Internal. Assert that the a table cell is allowed here and if not
  -   barf."
  -  (unless (table-cell-allowed-as-child-of record)
  -    (error "Sorry ~S not within ~S, ~S or ~S."
  -           'formatting-cell
  -           'formatting-row
  -           'formatting-column
  -           'formatting-item-list)))
   
   (defgeneric invoke-formatting-cell (stream cont
                                       &key align-x align-y min-width min-height record-type
  
positive.code:   (unless (slot-boundp table 'multiple-columns-x-spacing)
      (setf (slot-value table 'multiple-columns-x-spacing)
            (slot-value table 'x-spacing))))
  
  (locally
      (declare #+sbcl (sb-ext:muffle-conditions style-warning))
  
negative.code:   ()
    (:documentation "The class representing one-dimensional blocks of cells."))
  
  (defmethod replay-output-record ((bl block-output-record-mixn) stream
                                   &optional region (x-offset 0) (y-offset 0))
    (when (null region)
      (setq region (or (pane-viewport-region stream) +everywhere+)))
    (with-drawing-options (stream :clipping-region region)
      (let (other-records)
        (map-over-output-records-overlapping-region
         #'(lambda (record)
             (if (cell-output-record-p record)
                 (replay-output-record record stream region x-offset y-offset)
                 (push record other-records)))
         bl region x-offset y-offset)
        (mapc #'(lambda (record)
                  (replay-output-record record stream region x-offset y-offset))
              (nreverse other-records)))))
  
  (defgeneric map-over-block-cells (function block)
    (:documentation "Applies the FUNCTION to all cells in the BLOCK."))
  
  (defmethod map-over-block-cells (function (block block-output-record-mixn))
    ;; ### we need to do better -- yeah! how?
    (labels ((foo (row-record)
               (map-over-output-records
                (lambda (record)
  