/** * Fit table columns to the given width */ function table_columns_fit(&$table, $width, &$context) { $minw = $table->get_table_columns_min_widths($context); $maxw = $table->get_table_columns_max_widths($context); $minw = $this->use_colspans($table, $minw, $context, 'get_min_width', $minw, $maxw); $maxw = $this->use_colspans($table, $maxw, $context, 'get_max_width', $minw, $maxw); // Store number of columns $columns = count($minw); // Apply column width constraints $minwc = array(); $maxwc = array(); $cellpadding = $table->get_css_property(CSS_HTML2PS_CELLPADDING); $cellspacing = $table->get_css_property(CSS_HTML2PS_CELLSPACING); for ($i = 0; $i < count($minw); $i++) { $cwc = $table->get_cwc($i); // Do not allow constrained max width be less than min width // Do not allow constrained min width be less than min width // $table_width = $table->get_width(); $extra = 2 * $cellpadding->getPoints() + $cellspacing->getPoints(); $extra = 0; $minwc[$i] = max($minw[$i], $cwc->apply($minw[$i] - $extra, $table_width) + $extra); $maxwc[$i] = max($minw[$i], $cwc->apply($maxw[$i] - $extra, $table_width) + $extra); } $minwc = $table->normalize_min_widths($width, $minw, $minwc); $minwc = $table->_table_apply_colspans($minwc, $context, 'get_min_width', $minwc, $maxwc); // We need to normalize widths for the case of colspans width is too big; for example: // <table><tr><td width="100"> // <table><tr><td width="150">TEXT<td>TEXT<tr><td colspan="2" width="200"> // in this case table SHOULD NOT be expanded over the 100px! // // $minwc = $table->normalize_min_widths($width, $minw, $minwc); $maxwc = $table->_table_apply_colspans($maxwc, $context, 'get_max_width', $minwc, $maxwc); // Calculate actual widths $widths = array(); // Calculate widths for all constrained columns for ($i = 0; $i < $columns; $i++) { if ($table->is_constrained_column($i)) { $widths[$i] = $minwc[$i]; } } // Quick fix for overconstrained tables: if table have width attribute AND its value is less than sum // of constrained columns widths plus minimal widths of uncostrained columns, then we'll expand the width of table // to fit all columns // 1. calculate sum of constrained column widths // 2. calculate sum of unconstrained column minimal widths $sum_cw = 0; $sum_ucw = 0; for ($i = 0; $i < $columns; $i++) { if ($table->is_constrained_column($i)) { $sum_cw += $widths[$i]; } else { $sum_ucw += $minwc[$i]; } } // 3. compare these widths with the table width and choose the maximal value $width = max($width, $sum_cw + $sum_ucw); // Second pass - disctribute the rest of the width // Explanation of the stuff below (I've really had problems with this small piece of code, especially // when I was trying to fix "bugs" inside it) // // First of all, no column can be narrower than it minimal width (determined by its content) // Note that constrained columns have their widths distributed above, so we can exclude them for now // (just throw them out and imagine that table does not contain any width-constrained cols) // // Second, the relative widths of columns will have _appoximately_ the same ratio as // their maximal content widths. (In exception of cases where the first rule will take place - // say for the table containing two columns with the VERY long text in the first and one or two words // in the second) // // In general, this approach can be inoptimal in case of _very_ different font sizes // inside the cells, of, say big images; nevertheless, it will give a good approximate // AND still fast enough (unlike fully correct methods involving evaluation of the content height of the cell) // // Thus, we do the following: // - calculate the ratio of current column MAXIMAL ($current_max) width to the sum of MAXIMAL widths of all columns left // (inluding current) second rule applied. Note that we need remember about column spans and select // maxw or maxwc in order. // - then check if the rest of width will be too small for other columns to fit and decrease current columns // width (see MIN function call) // - then check again if our width will be too small for current column to fit (and expand if nesessary) - // MAX function call for ($i = 0; $i < $columns; $i++) { if (!$table->is_constrained_column($i)) { // Get undistributed width (total table width - width of constrained columns) $rest = $width - array_sum($widths); // get max width of column being processed // If width is equal to zero, use max constrained width, as this column could be covered by colspan; // If not, we lose nothing, because all constrained columns are already processed earlier, and no more // columns except these two types can have different constrained and raw widths $current_max = max($maxw[$i], $maxwc[$i]); // Get sum of maximal constrained widths of unplaced columns $sum_max_cw = 0; $sum_min_cw = 0; for ($j = 0; $j < $columns; $j++) { if (!isset($widths[$j])) { $sum_max_cw += max($maxw[$j], $maxwc[$j]); $sum_min_cw += max($minw[$j], $minwc[$j]); } } // If some unplaced columns have maximal (constrained width) greater zero if ($sum_max_cw > 0) { $current_max = min($current_max * $rest / $sum_max_cw, $rest - $sum_min_cw + max($minwc[$i], $minw[$i])); } // Check for minimal width (either unconstrained or constrained) of current column $current_max = max($current_max, $minw[$i] == 0 ? $minwc[$i] : $minw[$i]); // Store calculated width $widths[$i] = $current_max; } } // Process the case of a lone empty table cell (used, for example, for its background color) // as we're using floating point numbers, we cannot use equals sign if (array_sum($widths) < EPSILON) { for ($i = 0; $i < count($widths); $i++) { $widths[$i] = 0.01; } } // now - the last attempt; if total width is less than box width, then we have a situation when either // all columns AND table are width constrained or the HTML similar to the following: // // <table cellpadding="0" width="100%" bgcolor="green"><tbody><tr> // <td colspan="2" bgcolor="yellow"></td> // <td style="width: 100px;" bgcolor="cyan">TEXT // // e.g. empty column (with zero width) and fixed-width column. // $wc = $table->get_css_property(CSS_WIDTH); if (!$wc->isNull()) { if (array_sum($widths) < $width) { // Let's make zero-width columns // non-zero width (so that they columd be expanded) and re-try expanding columns // for ($i = 0; $i < count($widths); $i++) { if ($widths[$i] == 0) { $widths[$i] = EPSILON; } } // Now, if there's at least one non-costrained columns, try expanding them again $flags = $table->get_non_constrained_width_flags(); if (!any_flag_set($flags)) { $flags = $table->get_non_constant_constrained_width_flags(); if (!any_flag_set($flags)) { $flags = $table->get_non_image_constrained_width_flags(); if (!any_flag_set($flags)) { for ($i = 0; $i < count($flags); $i++) { $flags[$i] = true; } } } } $widths = expand_to_with_flags($width, $widths, $flags); } // in case of overconstrained table (e.g. two columns with 20% widths), expand them $widths = expand_to($width, $widths); } $table->put_full_width(array_sum($widths)); // Now we need to sort array by key keeping key-value associations in order for array_slice to work correctly ksort($widths, SORT_NUMERIC); return $widths; }
function reflow_content(&$context) { // Reflow content // Reset current Y value // $this->_current_y = $this->get_top(); // Determine the base table width // if width constraint exists, the actual table width will not be changed anyway // $this->put_width(min($this->get_max_width($context), $this->get_width())); // Calculate widths of table columns $columns = $this->table_column_widths($context); // Collapse table to minimum width (if width is not constrained) $real_width = array_sum($columns); $this->put_width($real_width); // If width is constrained, and is less than calculated, update the width constraint // // if ($this->get_width() < $real_width) { // // $this->put_width_constraint(new WCConstant($real_width)); // }; // Flow cells horizontally in each table row for ($i = 0; $i < count($this->content); $i++) { // Row flow started // Reset current X coordinate to the far left of the table $this->_current_x = $this->get_left(); // Flow each cell in the row $span = 0; for ($j = 0; $j < count($this->content[$i]->content); $j++) { // Skip cells covered by colspans (fake cells, anyway) if ($span == 0) { // Flow current cell // Any colspans here? $span = $this->table_have_colspan($j, $i); // Get sum of width for the current cell (or several cells in colspan) // In most cases, $span == 1 here (just a single cell) $cw = array_sum(array_slice($columns, $j, $span)); // store calculated width of the current cell $cell =& $this->content[$i]->content[$j]; $cell->put_full_width($cw); $cell->setCSSProperty(CSS_WIDTH, new WCConstant($cw - $cell->_get_hor_extra())); // TODO: check for rowspans // Flow cell $this->content[$i]->content[$j]->reflow($this, $context); // Offset current X value by the cell width $this->_current_x += $cw; } // Current cell have been processed or skipped $span = max(0, $span - 1); } // calculate row height and do vertical align // $this->table_fit_row($i); // row height calculation offset current Y coordinate by the row height calculated // $this->_current_y -= $this->table_row_height($i); $this->_current_y -= $this->content[$i]->row_height(); } // Calculate (and possibly adjust height of table rows) $heights = $this->_row_heights(0.1); // adjust row heights to fit cells spanning several rows foreach ($this->get_rowspans() as $rowspan) { // Get height of the cell $cell_height = $this->content[$rowspan->row]->content[$rowspan->column]->get_full_height(); // Get calculated height of the spanned-over rows $cell_row_heights = array_slice($heights, $rowspan->row, $rowspan->size); // Get list of non-constrained columns $flags = array_slice($this->get_non_constrained_flags(), $rowspan->row, $rowspan->size); // Expand row heights (only for non-constrained columns) $new_heights = expand_to_with_flags($cell_height, $cell_row_heights, $flags); // Check if rows could not be expanded // if (array_sum($new_heights) < $cell_height-1) { if (array_sum($new_heights) < $cell_height - EPSILON) { // Get list of non-constant-constrained columns $flags = array_slice($this->get_non_constant_constrained_flags(), $rowspan->row, $rowspan->size); // use non-constant-constrained rows $new_heights = expand_to_with_flags($cell_height, $cell_row_heights, $flags); } // Update the rows heights array_splice($heights, $rowspan->row, $rowspan->size, $new_heights); } // Now expand rows to full table height $table_height = max($this->get_height(), array_sum($heights)); // Get list of non-constrained columns $flags = $this->get_non_constrained_height_flags(); // Expand row heights (only for non-constrained columns) $heights = expand_to_with_flags($table_height, $heights, $flags); // Check if rows could not be expanded if (array_sum($heights) < $table_height - EPSILON) { // Get list of non-constant-constrained columns $flags = $this->get_non_constant_constrained_flags(); // use non-constant-constrained rows $heights = expand_to_with_flags($table_height, $heights, $flags); } // Now we calculated row heights, time to actually resize them $this->table_resize_rows($heights); // Update size of cells spanning several rows $this->table_fit_rowspans($heights); // Expand total table height, if needed $total_height = array_sum($heights); if ($total_height > $this->get_height()) { $hc = new HCConstraint(array($total_height, false), array($total_height, false), array($total_height, false)); $this->put_height_constraint($hc); } }