Subversion-Projekte lars-tiefland.php_share

<?php

// $Header: /cvsroot/html2ps/box.table.php,v 1.59 2007/04/01 12:11:24 Konstantin Exp $

class CellSpan {

  var $row;

  var $column;

  var $size;

}

/**

 * It is assumed that every row contains at least one cell

 */

class TableBox extends GenericContainerBox {

  var $cwc;

  var $_cached_min_widths;

  function TableBox() {

    $this->GenericContainerBox();

    // List of column width constraints

    $this->cwc = array();

    $this->_cached_min_widths = null;

  }

  function readCSS(&$state) {

    parent::readCSS($state);

    $this->_readCSS($state,

                    array(CSS_BORDER_COLLAPSE,

                          CSS_TABLE_LAYOUT));

    $this->_readCSSLengths($state,

                           array(CSS_HTML2PS_CELLPADDING,

                                 CSS_HTML2PS_CELLSPACING));

  }

  function &cell($r, $c) {

    return $this->content[$r]->content[$c];

  }

  function rows_count() {

    return count($this->content);

  }

  // NOTE: assumes that rows are already normalized!

  function cols_count() {

    return count($this->content[0]->content);

  }

  // FIXME: just a stub

  function append_line(&$e) {}

  function &create(&$root, &$pipeline) {

    $box =& new TableBox();

    $box->readCSS($pipeline->get_current_css_state());

    // This row should not inherit any table specific properties!

    // 'overflow' for example

    //

    $css_state =& $pipeline->get_current_css_state();

    $css_state->pushDefaultState();

    $row =& new TableRowBox($root);

    $row->readCSS($css_state);

    $box->add_child($row);

    $css_state->popState();

    // Setup cellspacing / cellpadding values

    if ($box->get_css_property(CSS_BORDER_COLLAPSE) == BORDER_COLLAPSE) {

      $handler =& CSS::get_handler(CSS_PADDING);

      $box->setCSSProperty(CSS_PADDING, $handler->default_value());

    };

    // Set text-align to 'left'; all browsers I've ever seen prevent inheriting of

    // 'text-align' property by the tables.

    // Say, in the following example the text inside the table cell will be aligned left,

    // instead of inheriting 'center' value.

    //

    // <div style="text-align: center; background-color: green;">

    // <table width="100" bgcolor="red">

    // <tr><td>TEST

    // </table>

    // </div>

    $handler =& CSS::get_handler(CSS_TEXT_ALIGN);

    $handler->css('left', $pipeline);

    // Parse table contents

    $child = $root->first_child();

    $col_index = 0;

    while ($child) {

      if ($child->node_type() === XML_ELEMENT_NODE) {

        if ($child->tagname() === 'colgroup') {

          // COLGROUP tags do not generate boxes; they contain information on the columns

          //

          $col_index = $box->parse_colgroup_tag($child, $col_index);

        } else {

          $child_box =& create_pdf_box($child, $pipeline);

          $box->add_child($child_box);

        };

      };

      $child = $child->next_sibling();

    };

    $box->normalize($pipeline);

    $box->normalize_cwc();

    $box->normalize_rhc();

    $box->normalize_parent();

    return $box;

  }

  // Parse the data in COL node;

  // currently only 'width' attribute is parsed

  //

  // @param $root reference to a COL dom node

  // @param $index index of column corresponding to this node

  function parse_col(&$root, $index) {

    if ($root->has_attribute('width')) {

      // The value if 'width' attrubute is "multi-length";

      // it means that it could be:

      // 1. absolute value (10)

      // 2. percentage value (10%)

      // 3. relative value (3* or just *)

      //

      // TODO: support for relative values

      $value = $root->get_attribute('width');

      if (is_percentage($value)) {

        $this->cwc[$index] = new WCFraction(((int)$value) / 100);

      } else {

        $this->cwc[$index] = new WCConstant(px2pt((int)$value));

      };

    };

  }

  // Traverse the COLGROUP node and save the column-specific information

  //

  // @param $root COLGROUP node

  // @param $start_index index of the first column in this column group

  // @return index of column after the last processed

  //

  function parse_colgroup_tag(&$root, $start_index) {

    $index = $start_index;

    // COLGROUP may contain zero or more COLs

    //

    $child = $root->first_child();

    while ($child) {

      if ($child->tagname() === 'col') {

        $this->parse_col($child, $index);

        $index ++;

      };

      $child = $child->next_sibling();

    };

    return $index;

  }

  function normalize_parent() {

    for ($i=0; $i<count($this->content); $i++) {

      $this->content[$i]->parent =& $this;

      for ($j=0; $j<count($this->content[$i]->content); $j++) {

        $this->content[$i]->content[$j]->parent =& $this;

        // Set the column number for the cell to further reference

        $this->content[$i]->content[$j]->column = $j;

        // Set the column number for the cell to further reference

        $this->content[$i]->content[$j]->row    = $i;

      }

    }

  }

  // Normalize row height constraints

  //

  // no return value

  //

  function normalize_rhc() {

    // Initialize the constraint array with the empty constraints

    $this->rhc = array();

    for ($i=0, $size = count($this->content); $i < $size; $i++) {

      $this->rhc[$i] = new HCConstraint(null, null, null);

    };

    // Scan all cells

    for ($i=0, $num_rows = count($this->content); $i < $num_rows; $i++) {

      $row =& $this->content[$i];

      for ($j=0, $num_cells = count($row->content); $j < $num_cells; $j++) {

        $cell = $row->content[$j];

        // Ignore cells with rowspans

        if ($cell->rowspan > 1) { continue; }

        // Put current cell width constraint as a columns with constraint

        $this->rhc[$i] = merge_height_constraint($this->rhc[$i], $cell->get_height_constraint());

        // Now reset the cell width constraint; cell width should be affected by ceolumn constraint only

        $hc = new HCConstraint(null, null, null);

        $cell->put_height_constraint($hc);

      };

    };

  }

  // Normalize column width constraints

  // Note that cwc array may be partially prefilled by a GOLGROUP/COL-generated constraints!

  //

  function normalize_cwc() {

    // Note we've called 'normalize' method prior to 'normalize_cwc',

    // so we already have all rows of equal length

    //

    for ($i=0, $num_cols = count($this->content[0]->content); $i < $num_cols; $i++) {

      // Check if there's already COL-generated constraint for this column

      //

      if (!isset($this->cwc[$i])) {

        $this->cwc[$i] = new WCNone;

      };

    }

    // For each column (we should have table already normalized - so lengths of all rows are equal)

    for ($i=0, $num_cols = count($this->content[0]->content); $i < $num_cols; $i++) {

      // For each row

      for ($j=0, $num_rows = count($this->content); $j < $num_rows; $j++) {

        $cell =& $this->content[$j]->content[$i];

        // Ignore cells with colspans

        if ($cell->colspan > 1) { continue; }

        // Put current cell width constraint as a columns with constraint

        $this->cwc[$i] = merge_width_constraint($this->cwc[$i], $cell->get_css_property(CSS_WIDTH));

        // Now reset the cell width constraint; cell width should be affected by ceolumn constraint only

        $cell->setCSSProperty(CSS_WIDTH, new WCNone);

      }

    }

    // Now fix the overconstrained columns; first of all, sum of all percentage-constrained

    // columns should be less or equal than 100%. If sum is greater, the last column

    // percentage is reduced in order to get 100% as a result.

    $rest = 1;

    for ($i=0, $num_cols = count($this->content[0]->content); $i < $num_cols; $i++) {

      // Get current CWC

      $wc =& $this->cwc[$i];

      if ($wc->isFraction()) {

        $wc->fraction = min($rest, $wc->fraction);

        $rest -= $wc->fraction;

      };

    };

    /**

     * Now, let's process cells spanninig several columns.

     */

    /**

     * Let's check if there's any colspanning cells filling the whole table width and

     * containing non-100% percentage constraint

     */

    // For each row

    for ($j=0; $j<count($this->content); $j++) {

      /**

       * Check if the first cell in this row satisfies the above condition

       */

      $cell =& $this->content[$j]->content[0];

      /**

       * Note that there should be '>='; '==' is not enough, as sometimes cell is declared to span

       * more columns than there are in the table

       */

      $cell_wc = $cell->get_css_property(CSS_WIDTH);

      if (!$cell->is_fake() &&

          $cell_wc->isFraction() &&

          $cell->colspan >= count($this->content[$j])) {

        /**

         * Clear the constraint; anyway, it should be replaced with 100% in this case, as

         * this cell is the only cell in the row

         */

        $wc = new WCNone;

        $cell->setCSSProperty(CSS_WIDTH, $wc);

      };

    };

  }

  /**

   * Normalize table by adding fake cells for colspans and rowspans

   * Also, if there is any empty rows (without cells), add at least one fake cell

   */

  function normalize(&$pipeline) {

    /**

     * Fix empty rows by adding a fake cell

     */

    for ($i=0; $i<count($this->content); $i++) {

      $row =& $this->content[$i];

      if (count($row->content) == 0) {

        $this->content[$i]->add_fake_cell_before(0, $pipeline);

      };

    };

    /**

     * first, normalize colspans

     */

    for ($i=0; $i<count($this->content); $i++) {

      $this->content[$i]->normalize($pipeline);

    };

    /**

     * second, normalize rowspans

     *

     * We should scan table column-by-column searching for row-spanned cells;

     * consider the following example:

     *

     * <table>

     * <tr>

     * <td>A1</td>

     * <td rowspan="3">B1</td>

     * <td>C1</td>

     * </tr>

     *

     * <tr>

     * <td rowspan="2">A2</td>

     * <td>C2</td>

     * </tr>

     *

     * <tr>

     * <td>C3</td>

     * </tr>

     * </table>

     */

    $i_col = 0;

    do {

      $flag = false;

      for ($i_row=0; $i_row<count($this->content); $i_row++) {

        $row =& $this->content[$i_row];

        if ($i_col < count($row->content)) {

          $flag = true;

          // Check if this rowspan runs off the last row

          $row->content[$i_col]->rowspan = min($row->content[$i_col]->rowspan,

                                               count($this->content) - $i_row);

          if ($row->content[$i_col]->rowspan > 1) {

            // Note that min($i_row + $row->content[$i_col]->rowspan, count($this->content)) is

            // required, as we cannot be sure that table actually contains the number

            // of rows used in rowspan

            //

            for ($k=$i_row+1; $k<min($i_row + $row->content[$i_col]->rowspan, count($this->content)); $k++) {

              // Note that if rowspanned cell have a colspan, we should insert SEVERAL fake cells!

              //

              for ($cs = 0; $cs < $row->content[$i_col]->colspan; $cs++) {

                $this->content[$k]->add_fake_cell_before($i_col, $pipeline);

              };

            };

          };

        };

      };

      $i_col ++;

    } while ($flag);

    // third, make all rows equal in length by padding with fake-cells

    $length = 0;

    for ($i=0; $i<count($this->content); $i++) {

      $length = max($length, count($this->content[$i]->content));

    }

    for ($i=0; $i<count($this->content); $i++) {

      $row =& $this->content[$i];

      while ($length > count($row->content)) {

        $row->append_fake_cell($pipeline);

      }

    }

  }

  // Overrides default 'add_child' in GenericFormattedBox

  function add_child(&$item) {

    // Check if we're trying to add table cell to current table directly, without any table-rows

    if ($item->isCell()) {

      // Add cell to the last row

      $last_row =& $this->content[count($this->content)-1];

      $last_row->add_child($item);

    } elseif ($item->isTableRow()) {

      // If previous row is empty, remove it (get rid of automatically generated table row in constructor)

      if (count($this->content) > 0) {

        if (count($this->content[count($this->content)-1]->content) == 0) {

          array_pop($this->content);

        }

      };

      // Just add passed row

      $this->content[] =& $item;

    } elseif ($item->isTableSection()) {

      // Add table section rows to current table, then drop section box

      for ($i=0, $size = count($item->content); $i < $size; $i++) {

        $this->add_child($item->content[$i]);

      }

    };

  }

  // Table-specific functions

  // PREDICATES

  function is_constrained_column($index) {

    return !is_a($this->get_cwc($index),"wcnone");

  }

  // ROWSPANS

  function table_have_rowspan($x,$y) {

    return $this->content[$y]->content[$x]->rowspan;

  }

  function table_fit_rowspans($heights) {

    $spans = $this->get_rowspans();

    // Scan all cells spanning several rows

    foreach ($spans as $span) {

      $cell =& $this->content[$span->row]->content[$span->column];

      // now check if cell height is less than sum of spanned rows heights

      $row_heights = array_slice($heights, $span->row, $span->size);

      // Vertical-align current cell

      // calculate (approximate) row baseline

      $baseline = $this->content[$span->row]->get_row_baseline();

      // apply vertical-align

      $vertical_align = $cell->get_css_property(CSS_VERTICAL_ALIGN);

      $va_fun = CSSVerticalAlign::value2pdf($vertical_align);

      $va_fun->apply_cell($cell, array_sum($row_heights), $baseline);

      if (array_sum($row_heights) > $cell->get_full_height()) {

        // Make cell fill all available vertical space

        $cell->put_full_height(array_sum($row_heights));

      };

    }

  }

  function get_rowspans() {

    $spans = array();

    for ($i=0; $i<count($this->content); $i++) {

      $spans = array_merge($spans, $this->content[$i]->get_rowspans($i));

    };

    return $spans;

  }

  // ROW-RELATED

  /**

   * Calculate set of row heights

   *

   * At the moment (*), we have a sum of total content heights of percentage constraned rows in

   * $ch variable, and a "free" (e.g. table height - sum of all non-percentage constrained heights) height

   * in the $h variable. Obviously, percentage-constrained rows should be expanded to fill the free space

   *

   * On the other size, there should be a maximal value to expand them to; for example, if sum of

   * percentage constraints is 33%, then all these rows should fill only 1/3 of the table height,

   * whatever the content height of other rows is. In this case, other (non-constrained) rows

   * should be expanded to fill space left.

   *

   * In the latter case, if there's no non-constrained rows, the additional space should be filled by

   * "plain" rows without any constraints

   *

   * @param $minheight the minimal allowed height of the row; as we'll need to expand rows later

   * and rows containing totally empty cells will have zero height

   * @return array of row heights in media points

   */

  function _row_heights($minheight) {

    $heights = array();

    $cheights = array();

    $height = $this->get_height();

    // Calculate "content" and "constrained" heights of table rows

    for ($i=0; $i<count($this->content); $i++) {

      $heights[] = max($minheight, $this->content[$i]->row_height());

      // Apply row height constraint

      // we need to specify box which parent will serve as a base for height calculation;

      $hc = $this->get_rhc($i);

      $cheights[] = $hc->apply($heights[$i], $this->content[$i], null);

    };

    // Collapse "constrained" heights of percentage-constrained rows, if they're

    // taking more that available space

    $flags = $this->get_non_percentage_constrained_height_flags();

    $h = $height;

    $ch = 0;

    for ($i=0; $i<count($heights); $i++) {

      if ($flags[$i]) { $h -= $cheights[$i]; } else { $ch += $cheights[$i]; };

    };

    // (*) see note in the function description

    if ($ch > 0) {

      $scale = $h / $ch;

      if ($scale < 1) {

        for ($i=0; $i<count($heights); $i++) {

          if (!$flags[$i]) { $cheights[$i] *= $scale; };

        };

      };

    };

    // Expand non-constrained rows, if there's free space still

    $flags = $this->get_non_constrained_height_flags();

    $h = $height;

    $ch = 0;

    for ($i=0; $i<count($cheights); $i++) {

      if (!$flags[$i]) { $h -= $cheights[$i]; } else { $ch += $cheights[$i]; };

    };

    // (*) see note in the function description

    if ($ch > 0) {

      $scale = $h / $ch;

      if ($scale < 1) {

        for ($i=0; $i<count($heights); $i++) {

          if ($flags[$i]) { $cheights[$i] *= $scale; };

        };

      };

    };

    // Expand percentage-constrained rows, if there's free space still

    $flags = $this->get_non_percentage_constrained_height_flags();

    $h = $height;

    $ch = 0;

    for ($i=0; $i<count($cheights); $i++) {

      if ($flags[$i]) { $h -= $cheights[$i]; } else { $ch += $cheights[$i]; };

    };

    // (*) see note in the function description

    if ($ch > 0) {

      $scale = $h / $ch;

      if ($scale < 1) {

        for ($i=0; $i<count($heights); $i++) {

          if (!$flags[$i]) { $cheights[$i] *= $scale; };

        };

      };

    };

    // Get the actual row height

    for ($i=0; $i<count($heights); $i++) {

      $heights[$i] = max($heights[$i], $cheights[$i]);

    };

    return $heights;

  }

  function table_resize_rows(&$heights) {

    $row_top = $this->get_top();

    $size = count($heights);

    for ($i=0; $i<$size; $i++) {

      $this->content[$i]->table_resize_row($heights[$i], $row_top);

      $row_top -= $heights[$i];

    }

    // Set table height to sum of row heights

    $this->put_height(array_sum($heights));

  }

  //   // Calculate given table row height

  //   //

  //   // @param  $index zero-based row index

  //   // @return value of row height (in media points)

  //   //

  //   function table_row_height($index) {

  //     // Select row

  //     $row =& $this->content[$index];

  //     // Calculate height of each cell contained in this row

  //     $height = 0;

  //     for ($i=0; $i<count($row->content); $i++) {

  //       if ($this->table_have_rowspan($i, $index) <= 1) {

  //         $height = max($height, $row->content[$i]->get_full_height());

  //       }

  //     }

  //     return $height;

  //   }

  //   function get_row_baseline($index) {

  //     // Get current row

  //     $row =& $this->content[$index];

  //     // Calculate maximal baseline for each cell contained

  //     $baseline = 0;

  //     for ($i = 0; $i < count($row->content); $i++) {

  //       // Cell baseline is the baseline of its first line box inside this cell

  //       if (count($row->content[$i]->content) > 0) {

  //         $baseline = max($baseline, $row->content[$i]->content[0]->baseline);

  //       };

  //     };

  //     return $baseline;

  //   }

  // Width constraints

  function get_cwc($col) {

    return $this->cwc[$col];

  }

  // Get height constraint for the given row

  //

  // @param $row number of row (zero-based)

  //

  // @return HCConstraint object

  //

  function get_rhc($row) {

    return $this->rhc[$row];

  }

  // Width calculation

  //

  // Note that if table have no width constraint AND some columns are percentage constrained,

  // then the width of the table can be determined based on the minimal column width;

  // e.g. if some column have minimal width of 10px and 10% width constraint,

  // then table will have minimal width of 100px. If there's several percentage-constrained columns,

  // then we choose from the generated values the maximal one

  //

  // Of course, all of the above can be applied ONLY to table without width constraint;

  // of theres any w.c. applied to the table, it will have greater than column constraints

  //

  // We must take constrained table width into account; if there's a width constraint,

  // then we must choose the maximal value between the constrained width and sum of minimal

  // columns widths - so, expanding the constrained width in case it is not enough to fit

  // the table contents

  //

  // @param $context referene to a flow context object

  // @return minimal box width (including the padding/margin/border width! NOT content width)

  //

  function get_min_width(&$context) {

    $widths = $this->get_table_columns_min_widths($context);

    $maxw = $this->get_table_columns_max_widths($context);

    // Expand some columns to fit colspanning cells

    $widths = $this->_table_apply_colspans($widths, $context, 'get_min_width', $widths, $maxw);

    $width = array_sum($widths);

    $base_width = $width;

    $wc = $this->get_css_property(CSS_WIDTH);

    if (!$wc->isNull()) {

      // Check if constrained table width should be expanded to fit the table contents

      //

      $width = max($width, $wc->apply(0, $this->parent->get_available_width($context)));

    } else {

      // Now check if there's any percentage column width constraints (note that

      // if we've get here, than the table width is not constrained). Calculate

      // the table width basing on these values and select the maximal value

      //

      for ($i=0; $i<$this->cols_count(); $i++) {

        $cwc = $this->get_cwc($i);

        $width = max($width,

                     min($cwc->apply_inverse($widths[$i], $base_width),

                         $this->parent->get_available_width($context) - $this->_get_hor_extra()));

      };

    };

    return $width + $this->_get_hor_extra();

  }

  function get_min_width_natural(&$context) {

    return $this->get_min_width($context);

  }

  function get_max_width(&$context) {

    $wc = $this->get_css_property(CSS_WIDTH);

    if ($wc->isConstant()) {

      return $wc->apply(0, $this->parent->get_available_width($context));

    } else {

      $widths = $this->get_table_columns_max_widths($context);

      $minwc = $this->get_table_columns_min_widths($context);

      $widths = $this->_table_apply_colspans($widths, $context, 'get_max_width', $minwc, $widths);

      $width = array_sum($widths);

      $base_width = $width;

      // Now check if there's any percentage column width constraints (note that

      // if we've get here, than the table width is not constrained). Calculate

      // the table width based on these values and select the maximal value

      //

      for ($i=0; $i<$this->cols_count(); $i++) {

        $cwc = $this->get_cwc($i);

        $width = max($width,

                     min($cwc->apply_inverse($widths[$i], $base_width),

                         $this->parent->get_available_width($context) - $this->_get_hor_extra()));

      };

      return $width + $this->_get_hor_extra();

    }

  }

  function get_max_width_natural(&$context) {

    return $this->get_max_width($context);

  }

  function get_width() {

    $wc  = $this->get_css_property(CSS_WIDTH);

    $pwc = $this->parent->get_css_property(CSS_WIDTH);

    if (!$this->parent->isCell() ||

        !$pwc->isNull() ||

        !$wc->isFraction()) {

      $width = $wc->apply($this->width, $this->parent->width);

    } else {

      $width = $this->width;

    };

    // Note that table 'padding' property for is handled differently

    // by different browsers; for example, IE 6 ignores it completely,

    // while FF 1.5 subtracts horizontal padding value from constrained

    // table width. We emulate FF behavior here

    return $width -

      $this->get_padding_left() -

      $this->get_padding_right();

  }

  function table_column_widths(&$context) {

    $table_layout = $this->get_css_property(CSS_TABLE_LAYOUT);

    switch ($table_layout) {

    case TABLE_LAYOUT_FIXED:

//       require_once(HTML2PS_DIR.'strategy.table.layout.fixed.php');

//       $strategy =& new StrategyTableLayoutFixed();

//       break;

    case TABLE_LAYOUT_AUTO:

    default:

      require_once(HTML2PS_DIR.'strategy.table.layout.auto.php');

      $strategy =& new StrategyTableLayoutAuto();

      break;

    };

    return $strategy->apply($this, $context);

  }

  // Extend some columns widths (if needed) to fit colspanned cell contents

  //

  function _table_apply_colspans($widths, &$context, $width_fun, $minwc, $maxwc) {

    $colspans = $this->get_colspans();

    foreach ($colspans as $colspan) {

      $cell = $this->content[$colspan->row]->content[$colspan->column];

      // apply colspans to the corresponsing colspanned-cell dimension

      //

      $cell_width = $cell->$width_fun($context);

      // Apply cell constraint width, if any AND if table width is constrained

      // if table width is not constrained, we should not do this, as current value

      // of $table->get_width is maximal width (parent width), not the actual

      // width of the table

      $wc = $this->get_css_property(CSS_WIDTH);

      if (!$wc->isNull()) {

        $cell_wc = $cell->get_css_property(CSS_WIDTH);

        $cell_width = $cell_wc->apply($cell_width, $this->get_width());

        // On the other side, constrained with cannot be less than cell minimal width

        $cell_width = max($cell_width, $cell->get_min_width($context));

      };

      // now select the pre-calculated widths of columns covered by this cell

      // select the list of resizable columns covered by this cell

      $spanned_widths = array();

      $spanned_resizable = array();

      for ($i=$colspan->column; $i < $colspan->column+$colspan->size; $i++) {

        $spanned_widths[] = $widths[$i];

        $spanned_resizable[] = ($minwc[$i] != $maxwc[$i]);

      }

      // Sometimes we may encounter the colspan over the empty columns (I mean ALL columns are empty); in this case

      // we need to make these columns reizable in order to fit colspanned cell contents

      //

      if (array_sum($spanned_widths) == 0) {

        for ($i=0; $i<count($spanned_widths); $i++) {

          $spanned_widths[$i] = EPSILON;

          $spanned_resizable[$i] = true;

        };

      };

      // The same problem may arise when all colspanned columns are not resizable; in this case we'll force all

      // of them to be resized

      $any_resizable = false;

      for ($i=0; $i<count($spanned_widths); $i++) {

        $any_resizable |= $spanned_resizable[$i];

      };

      if (!$any_resizable) {

        for ($i=0; $i<count($spanned_widths); $i++) {

          $spanned_resizable[$i] = true;

        };

      }

      // Expand resizable columns

      //

      $spanned_widths = expand_to_with_flags($cell_width,$spanned_widths,$spanned_resizable);

      // Store modified widths

      array_splice($widths, $colspan->column, $colspan->size, $spanned_widths);

    };

    return $widths;

  }

  function get_table_columns_max_widths(&$context) {

    $widths = array();

    for ($i=0; $i<count($this->content[0]->content); $i++) {

      $widths[] = 0;

    };

    for ($i=0; $i<count($this->content); $i++) {

      // Calculate column widths for a current row

      $roww = $this->content[$i]->get_table_columns_max_widths($context);

      for ($j=0; $j<count($roww); $j++) {

        //        $widths[$j] = max($roww[$j], isset($widths[$j]) ? $widths[$j] : 0);

        $widths[$j] = max($roww[$j], $widths[$j]);

      }

    }

    // Use column width constraints - column should not be wider its constrained width

    for ($i=0; $i<count($widths); $i++) {

      $cwc = $this->get_cwc($i);

      // Newertheless, percentage constraints should not be applied IF table

      // does not have constrained width

      //

      if (!is_a($cwc,"wcfraction")) {

        $widths[$i] = $cwc->apply($widths[$i], $this->get_width());

      };

    }

    // TODO: colspans

    return $widths;

  }

  /**

   * Optimization: calculated widths are cached

   */

  function get_table_columns_min_widths(&$context) {

    if (!is_null($this->_cached_min_widths)) {

      return $this->_cached_min_widths;

    };

    $widths = array();

    for ($i=0; $i<count($this->content[0]->content); $i++) {

      $widths[] = 0;

    };

    $content_size = count($this->content);

    for ($i=0; $i<$content_size; $i++) {

      // Calculate column widths for a current row

      $roww = $this->content[$i]->get_table_columns_min_widths($context);

      $row_size = count($roww);

      for ($j=0; $j<$row_size; $j++) {

        $widths[$j] = max($roww[$j], $widths[$j]);

      }

    }

    $this->_cached_min_widths = $widths;

    return $widths;

  }

  function get_colspans() {

    $colspans = array();

    for ($i=0; $i<count($this->content); $i++) {

      $colspans = array_merge($colspans, $this->content[$i]->get_colspans($i));

    };

    return $colspans;

  }

  function check_constrained_colspan($col) {

    for ($i=0; $i<$this->rows_count(); $i++) {

      $cell =& $this->cell($i, $col);

      $cell_wc = $cell->get_css_property(CSS_WIDTH);

      if ($cell->colspan > 1 &&

          !$cell_wc->isNull()) {

        return true;

      };

    };

    return false;

  }

  // Tries to change minimal constrained width so that columns will fit into the given

  // table width

  //

  // Note that every width constraint have its own priority; first, the unconstrained columns are collapsed,

  // then - percentage constrained and after all - columns having fixed width

  //

  // @param $width table width

  // @param $minw array of unconstrained minimal widths

  // @param $minwc array of constrained minimal widths

  // @return list of normalized minimal constrained widths

  //

  function normalize_min_widths($width, $minw, $minwc) {

    // Check if sum of constrained widths is too big

    // Note that we compare sum of constrained width with the MAXIMAL value of table width and

    // sum of uncostrained minimal width; it will prevent from unneeded collapsing of table cells

    // if table content will expand its width anyway

    //

    $twidth = max($width, array_sum($minw));

    // compare with sum of minimal constrained widths

    //

    if (array_sum($minwc) > $twidth) {

      $delta = array_sum($minwc) - $twidth;

      // Calculate the amount of difference between minimal and constrained minimal width for each columns

      $diff = array();

      for ($i=0; $i<count($minw); $i++) {

        // Do no modify width of columns taking part in constrained colspans

        if (!$this->check_constrained_colspan($i)) {

          $diff[$i] = $minwc[$i] - $minw[$i];

        } else {

          $diff[$i] = 0;

        };

      }

      // If no difference is found, we can collapse no columns

      // otherwise scale some columns...

      $cwdelta = array_sum($diff);

      if ($cwdelta > 0) {

        for ($i=0; $i<count($minw); $i++) {

          //          $minwc[$i] = max(0,- ($minwc[$i] - $minw[$i]) / $cwdelta * $delta + $minwc[$i]);

          $minwc[$i] = max(0, -$diff[$i] / $cwdelta * $delta + $minwc[$i]);

        }

      }

    }

    return $minwc;

  }

  function table_have_colspan($x, $y) {

    return $this->content[$y]->content[$x]->colspan;

  }

  // Flow-control

  function reflow(&$parent, &$context) {

    if ($this->get_css_property(CSS_FLOAT) === FLOAT_NONE) {

      $status = $this->reflow_static_normal($parent, $context);

    } else {

      $status = $this->reflow_static_float($parent, $context);

    }

    return $status;

  }

  function reflow_absolute(&$context) {

    GenericFormattedBox::reflow($parent, $context);

    // Calculate margin values if they have been set as a percentage

    $this->_calc_percentage_margins($parent);

    // Calculate width value if it had been set as a percentage

    $this->_calc_percentage_width($parent, $context);

    $wc = $this->get_css_property(CSS_WIDTH);

    if (!$wc->isNull()) {

      $col_width = $this->get_table_columns_min_widths($context);

      $maxw      = $this->get_table_columns_max_widths($context);

      $col_width = $this->_table_apply_colspans($col_width, $context, 'get_min_width', $col_width, $maxw);

      if (array_sum($col_width) > $this->get_width()) {

        $wc = new WCConstant(array_sum($col_width));

      };

    };

    $position_strategy =& new StrategyPositionAbsolute();

    $position_strategy->apply($this);

    $this->reflow_content($context);

  }

  /**

   * TODO: unlike block elements, table unconstrained width is determined

   * with its content, so it may be smaller than parent available width!

   */

  function reflow_static_normal(&$parent, &$context) {

    GenericFormattedBox::reflow($parent, $context);

    // Calculate margin values if they have been set as a percentage

    $this->_calc_percentage_margins($parent);