Merge with main repo.

1 files changed, 179 insertions, 51 deletions

diff --git a/dw/table.cc b/dw/table.cc
index d6dbe633..dc112ef8 100644
--- a/dw/table.cc
+++ b/dw/table.cc
@@ -135,12 +135,13 @@ void Table::getExtremesImpl (core::Extremes *extremes)
 
    if (numCols == 0)
       extremes->minWidth = extremes->minWidthIntrinsic = extremes->maxWidth =
-         extremes->maxWidthIntrinsic = boxDiffWidth ();
+         extremes->maxWidthIntrinsic = extremes->adjustmentWidth =
+         boxDiffWidth ();
    else {
       forceCalcColumnExtremes ();
 
       extremes->minWidth = extremes->minWidthIntrinsic = extremes->maxWidth =
-         extremes->maxWidthIntrinsic =
+         extremes->maxWidthIntrinsic = extremes->adjustmentWidth =
          (numCols + 1) * getStyle()->hBorderSpacing + boxDiffWidth ();
       for (int col = 0; col < numCols; col++) {
          extremes->minWidth += colExtremes->getRef(col)->minWidth;
@@ -149,10 +150,11 @@ void Table::getExtremesImpl (core::Extremes *extremes)
          extremes->maxWidth += colExtremes->getRef(col)->maxWidth;
          extremes->maxWidthIntrinsic +=
             colExtremes->getRef(col)->maxWidthIntrinsic;
+         extremes->adjustmentWidth += colExtremes->getRef(col)->adjustmentWidth;
       }
    }
 
-   correctExtremes (extremes);
+   correctExtremes (extremes, true);
 
    // For the order, see similar reasoning for dw::Textblock.
    correctExtremesByOOF (extremes);
@@ -231,14 +233,32 @@ int Table::getAvailWidthOfChild (Widget *child, bool forceValue)
        oofm->dealingWithSizeOfChild (child))
       width = oofm->getAvailWidthOfChild (child, forceValue);
    else {
-      // Unlike other containers, the table widget sometimes narrows
-      // columns to a width less than specified by CSS (see
-      // forceCalcCellSizes). For this reason, the column widths have to
-      // be calculated in all cases.
-      if (forceValue) {
-         calcCellSizes (false);
+      // We do not calculate the column widths at this point, because
+      // this tends to be rather inefficient for tables with many
+      // cells:
+      //
+      // For each of the n cells, some text is added (say, only one word
+      // per cell). Textblock::addText will eventually (via addText0
+      // etc.) call this method, Table::getAvailWidthOfChild. If
+      // calcCellSizes() is called here, this will call
+      // forceCalcCellSizes(), since the last call, sizes have to be
+      // re-calculated (because cells have been added). This will
+      // calculate the extremes for each existing cell, so
+      // Widget::getExtremes is called n * (n + 1) / 2 times. Even if the
+      // extremes are cached (so that getExtremesImpl does not have to be
+      // called in each case), this would make rendering tables with more
+      // than a few hundred cells unacceptably slow.
+      //
+      // Instead, column widths are calculated in Table::sizeRequestImpl.
+      //
+      // An alternative would be incremental resizing for tables; this
+      // approach resembles the behaviour before GROWS.
+
+      // TODO Does it still make sence to return -1 when forceValue is
+      // set?
+      if (forceValue)
          width = calcAvailWidthForDescendant (child);
-      } else
+      else
          width = -1;
    }
 
@@ -259,39 +279,31 @@ int Table::calcAvailWidthForDescendant (Widget *child)
 
    assert (actualChild != NULL);
 
-   // TODO This is inefficient. (Use parentRef?)
-   int width = -1;
-   for (int row = numRows - 1; width == -1 && row >= 0; row--) {
-      for (int col = 0; width == -1 && col < numCols; col++) {
-         int n = row * numCols + col;
-         if (childDefined (n) &&
-             children->get(n)->cell.widget == actualChild) {
-            DBG_OBJ_MSGF ("resize", 1, "calculated from column %d", col);
-            width = (children->get(n)->cell.colspanEff - 1)
-               * getStyle()->hBorderSpacing;
-            for (int i = 0; i < children->get(n)->cell.colspanEff; i++)
-               width += colWidths->get (col + i);
-            width = misc::max (width, 0);
-
-            if (child != actualChild) {
-               // For table cells (direct children: child == actualChild),
-               // CSS 'width' is already regarded in the column calculation.
-               // However, for children of the table cells, CSS 'width' must
-               // be regarded here.
-
-               int corrWidth = width;
-               child->calcFinalWidth (child->getStyle(), -1, this, 0, true,
-                                      &corrWidth);
-
-               // But better not exceed it ... (TODO: Only here?)
-               width = misc::min (width, corrWidth);
-            }
-         }
-      }
+   // ActualChild->parentRef contains the position in the children
+   // array (see addCell()), so the column can be easily determined.
+   int col = actualChild->parentRef % numCols;
+   int colspanEff = children->get(actualChild->parentRef)->cell.colspanEff;
+   DBG_OBJ_MSGF ("resize", 1, "calculated from column %d, colspanEff = %d",
+                 col, colspanEff);
+
+   int width = (colspanEff - 1) * getStyle()->hBorderSpacing;
+   for (int i = 0; i < colspanEff; i++)
+      width += colWidths->get (col + i);
+   width = misc::max (width, 0);
+
+   if (child != actualChild) {
+      // For table cells (direct children: child == actualChild), CSS
+      // 'width' is already regarded in the column calculation.
+      // However, for children of the table cells, CSS 'width' must be
+      // regarded here.
+
+      int corrWidth = width;
+      child->calcFinalWidth (child->getStyle(), -1, this, 0, true, &corrWidth);
+      
+      // But better not exceed it ... (TODO: Only here?)
+      width = misc::min (width, corrWidth);
    }
 
-   assert (width != -1);
-
    DBG_OBJ_MSGF ("resize", 1, "=> %d", width);
    DBG_OBJ_LEAVE ();
    return width;
@@ -563,6 +575,12 @@ void Table::addCell (Widget *widget, int colspan, int rowspan)
    child->cell.rowspan = rowspan;
    children->set (curRow * numCols + curCol, child);
 
+   // The position in the children array is assigned to parentRef,
+   // although incremental resizing is not implemented. Useful, e. g.,
+   // in calcAvailWidthForDescendant(). See also reallocChildren().
+   widget->parentRef = curRow * numCols + curCol;
+   DBG_OBJ_SET_NUM_O (widget, "parentRef", widget->parentRef);
+
    curCol += colspanEff;
 
    widget->parentRef = makeParentRefInFlow (0);
@@ -799,9 +817,35 @@ void Table::reallocChildren (int newNumCols, int newNumRows)
       rowStyle->set (row, NULL);
    // Rest is increased, when needed.
 
+   if (newNumCols > numCols) {
+      // Re-calculate parentRef. See addCell().
+      for (int row = 1; row < newNumRows; row++)
+         for (int col = 0; col < newNumCols; col++) {
+            int n = row * newNumCols + col;
+            Child *child = children->get (n);
+            if (child != NULL && child->type == Child::CELL) {
+               child->cell.widget->parentRef = n;
+               DBG_OBJ_SET_NUM_O (child->cell.widget, "parentRef",
+                                  child->cell.widget->parentRef);
+            }
+         }
+   }
+
    numCols = newNumCols;
    numRows = newNumRows;
 
+   // We initiate the column widths with a random value, to have a
+   // defined available width for the children before the column
+   // widths are actually calculated.
+
+   colWidths->setSize (numCols, 100);
+
+   DBG_IF_RTFL {
+      DBG_OBJ_SET_NUM ("colWidths.size", colWidths->size ());
+      for (int i = 0; i < colWidths->size (); i++)
+         DBG_OBJ_ARRSET_NUM ("colWidths", i, colWidths->get (i));
+   }
+
    DBG_OBJ_SET_NUM ("numCols", numCols);
    DBG_OBJ_SET_NUM ("numRows", numCols);
 }
@@ -826,6 +870,64 @@ void Table::calcCellSizes (bool calcHeights)
 
 void Table::forceCalcCellSizes (bool calcHeights)
 {
+   // Since Table::getAvailWidthOfChild does not calculate the column
+   // widths, and so initially a random value (100) is returned, a
+   // correction is necessary. The old values are temporary preserved
+   // ...
+
+   lout::misc::SimpleVector<int> oldColWidths (8);
+   oldColWidths.setSize (colWidths->size ());
+   colWidths->copyTo (&oldColWidths);
+   
+   actuallyCalcCellSizes (calcHeights);
+
+   // ... and then compared to the new ones. In case of a difference,
+   // the cell is told about this.
+
+   for (int col = 0; col < colWidths->size (); col++) {
+      if (oldColWidths.get (col) != colWidths->get (col)) {
+         for (int row = 0; row < numRows; row++) {
+            int n = row * numCols + col, col2;
+            Child *child = children->get(n);
+            if (child) {
+               Widget *cell;
+               switch (child->type) {
+               case Child::CELL:
+                  cell = child->cell.widget;
+                  break;
+
+               case Child::SPAN_SPACE:
+                  // TODO Are Child::spanSpace::startRow and
+                  // Child::spanSpace::startCol not defined?
+
+                  // Search for actual cell. If not found, this means
+                  // that a cell is spanning multiple columns *and*
+                  // rows; in this case it has been processed before.
+
+                  cell = NULL;
+                  for (col2 = col - 1; col2 >= 0 && cell == NULL; col2--) {
+                     int n2 = row * numCols + col2;
+                     Child *child2 = children->get(n2);
+                     if (child2 != NULL && child2->type == Child::CELL)
+                        cell = child2->cell.widget;
+                  }
+                  break;
+
+               default:
+                  misc::assertNotReached ();
+                  cell = NULL;
+               }
+                  
+               if (cell)
+                  cell->containerSizeChanged ();
+            }
+         }
+      }
+   }
+}
+
+void Table::actuallyCalcCellSizes (bool calcHeights)
+{
    DBG_OBJ_ENTER0 ("resize", 0, "forceCalcCellSizes");
 
    int childHeight;
@@ -835,10 +937,10 @@ void Table::forceCalcCellSizes (bool calcHeights)
    getExtremes (&extremes);
 
    int availWidth = getAvailWidth (true);
-   // When adjust_table_min_width is set, use the minimal (intrinsic)
-   // width for correction.
+   // When adjust_table_min_width is set, use perhaps the adjustment
+   // width for correction. (TODO: Is this necessary?)
    int corrWidth =
-      Table::getAdjustTableMinWidth () ? extremes.minWidthIntrinsic : 0;
+      Table::getAdjustTableMinWidth () ? extremes.adjustmentWidth : 0;
    int totalWidth = misc::max (availWidth, corrWidth)
       - ((numCols + 1) * getStyle()->hBorderSpacing + boxDiffWidth ());
       
@@ -847,13 +949,14 @@ void Table::forceCalcCellSizes (bool calcHeights)
                  availWidth, corrWidth, numCols, getStyle()->hBorderSpacing,
                  boxDiffWidth (), totalWidth);
 
-   colWidths->setSize (numCols, 0);
+   assert (colWidths->size () == numCols); // This is set in addCell.
    cumHeight->setSize (numRows + 1, 0);
    rowSpanCells->setSize (0);
    baseline->setSize (numRows);
 
    misc::SimpleVector<int> *oldColWidths = colWidths;
    colWidths = new misc::SimpleVector <int> (8);
+   colWidths->setSize (numCols);
 
    int minWidth = 0, minWidthIntrinsic = 0, maxWidth = 0;
    for (int col = 0; col < colExtremes->size(); col++) {
@@ -924,8 +1027,6 @@ void Table::forceCalcCellSizes (bool calcHeights)
       } else {
          DBG_OBJ_MSG ("resize", 1, "case 1b: treat percentages specially");
 
-         colWidths->setSize (colExtremes->size(), 0);
-
          // Keep track of the width which is apportioned to the rest
          // of the columns with percentage width (widthPartPer), and
          // the minimal width (intrinsic minimum) which is needed for
@@ -1048,7 +1149,6 @@ void Table::forceCalcCellSizes (bool calcHeights)
          DBG_OBJ_MSG ("resize", 1, "finally setting column widths:");
          DBG_OBJ_MSG_START ();
 
-         colWidths->setSize (colExtremes->size());
          indexNotSpecified = 0;
          for (int col = 0; col < colExtremes->size(); col++)
             if (colWidthSpecified->get (col)) {
@@ -1253,6 +1353,7 @@ void Table::forceCalcColumnExtremes ()
          colExtremes->getRef(col)->minWidthIntrinsic = 0;
          colExtremes->getRef(col)->maxWidth = 0;
          colExtremes->getRef(col)->maxWidthIntrinsic = 0;
+         colExtremes->getRef(col)->adjustmentWidth = 0;
 
          for (int row = 0; row < numRows; row++) {
             DBG_OBJ_MSGF ("resize", 1, "row %d", row);
@@ -1284,6 +1385,10 @@ void Table::forceCalcColumnExtremes ()
                                 colExtremes->getRef(col)->maxWidth,
                                 cellExtremes.maxWidth);
 
+                  colExtremes->getRef(col)->adjustmentWidth =
+                     misc::max (colExtremes->getRef(col)->adjustmentWidth,
+                                cellExtremes.adjustmentWidth);
+
                   core::style::Length childWidth =
                      children->get(n)->cell.widget->getStyle()->width;
                   if (childWidth != core::style::LENGTH_AUTO) {
@@ -1322,9 +1427,10 @@ void Table::forceCalcColumnExtremes ()
          core::Extremes cellExtremes;
          children->get(n)->cell.widget->getExtremes (&cellExtremes);
 
-         calcExtremesSpanMulteCols (col, cs, &cellExtremes, MIN, MAX, NULL);
-         calcExtremesSpanMulteCols (col, cs, &cellExtremes, MIN_INTR, MAX_INTR,
+         calcExtremesSpanMultiCols (col, cs, &cellExtremes, MIN, MAX, NULL);
+         calcExtremesSpanMultiCols (col, cs, &cellExtremes, MIN_INTR, MAX_INTR,
                                     NULL);
+         calcAdjustmentWidthSpanMultiCols (col, cs, &cellExtremes);
 
          core::style::Length childWidth =
             children->get(n)->cell.widget->getStyle()->width;
@@ -1380,7 +1486,7 @@ void Table::forceCalcColumnExtremes ()
    DBG_OBJ_LEAVE ();
 }
 
-void Table::calcExtremesSpanMulteCols (int col, int cs,
+void Table::calcExtremesSpanMultiCols (int col, int cs,
                                        core::Extremes *cellExtremes,
                                        ExtrMod minExtrMod, ExtrMod maxExtrMod,
                                        void *extrData)
@@ -1431,6 +1537,28 @@ void Table::calcExtremesSpanMulteCols (int col, int cs,
    DBG_OBJ_LEAVE ();
 }
 
+void Table::calcAdjustmentWidthSpanMultiCols (int col, int cs,
+                                              core::Extremes *cellExtremes)
+{
+   DBG_OBJ_ENTER ("resize", 0, "calcAdjustmentWidthSpanMultiCols",
+                  "%d, %d, ...", col, cs);
+
+   int sumAdjustmentWidth = 0;
+   for (int j = 0; j < cs; j++)
+      sumAdjustmentWidth +=  colExtremes->getRef(col + j)->adjustmentWidth;
+   
+   if (cellExtremes->adjustmentWidth > sumAdjustmentWidth) {
+      misc::SimpleVector<int> newAdjustmentWidth;
+      apportion2 (cellExtremes->adjustmentWidth, col, col + cs - 1, MIN, MAX,
+                  NULL, &newAdjustmentWidth, 0);
+      for (int j = 0; j < cs; j++)
+         colExtremes->getRef(col + j)->adjustmentWidth =
+            newAdjustmentWidth.get (j);
+   }
+
+   DBG_OBJ_LEAVE ();
+}
+
 /**
  * \brief Actual apportionment function.
  */