major refactoring and cleaning related to column width handling in scrolltable. Hardcoded margins now removed and most things ought to be possible to define with CSS. fixes #2417

svn changeset:7512/svn branch:6.0

1 files changed, 182 insertions, 153 deletions

diff --git a/src/com/itmill/toolkit/terminal/gwt/client/ui/IScrollTable.java b/src/com/itmill/toolkit/terminal/gwt/client/ui/IScrollTable.java
index 892c330b68..f686f137ae 100644
--- a/src/com/itmill/toolkit/terminal/gwt/client/ui/IScrollTable.java
+++ b/src/com/itmill/toolkit/terminal/gwt/client/ui/IScrollTable.java
@@ -13,6 +13,11 @@ import java.util.List;
 import java.util.Set;
 import java.util.Vector;
 
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.dom.client.NodeList;
+import com.google.gwt.dom.client.TableCellElement;
+import com.google.gwt.dom.client.TableRowElement;
+import com.google.gwt.dom.client.TableSectionElement;
 import com.google.gwt.user.client.Command;
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.DeferredCommand;
@@ -137,10 +142,6 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
      */
     boolean recalcWidths = false;
 
-    int scrollbarWidthReservedInColumn = -1;
-    int scrollbarWidthReserved = -1;
-    boolean relativeWidth = false;
-
     private final ArrayList<Panel> lazyUnregistryBag = new ArrayList<Panel>();
     private String height;
     private String width = "";
@@ -166,10 +167,6 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             return;
         }
 
-        if (uidl.hasAttribute("width")) {
-            relativeWidth = uidl.getStringAttribute("width").endsWith("%");
-        }
-
         // we may have pending cache row fetch, cancel it. See #2136
         rowRequestHandler.cancel();
 
@@ -559,21 +556,18 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         while (headCells.hasNext()) {
             final HeaderCell hCell = (HeaderCell) headCells.next();
             int w = hCell.getWidth();
-            if (w > 0) {
+            if (hCell.isDefinedWidth()) {
                 // server has defined column width explicitly
                 totalExplicitColumnsWidths += w;
             } else {
                 if (hCell.getExpandRatio() > 0) {
                     expandRatioDivider += hCell.getExpandRatio();
-                    w = IScrollTableBody.CELL_EXTRA_WIDTH
-                            + IScrollTableBody.CELL_CONTENT_PADDING;
+                    w = 0;
                 } else {
                     // get and store greater of header width and column width,
                     // and
                     // store it as a minimumn natural col width
-                    final int hw = hCell.getOffsetWidth();
-                    final int cw = tBody.getColWidth(i);
-                    w = (hw > cw ? hw : cw) + IScrollTableBody.CELL_EXTRA_WIDTH;
+                    w = hCell.getNaturalColumnWidth(i);
                 }
                 hCell.setNaturalMinimumColumnWidth(w);
             }
@@ -587,6 +581,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         // fix "natural" width if width not set
         if (width == null || "".equals(width)) {
             int w = total;
+            w += tBody.getCellExtraWidth() * visibleColOrder.length;
             w += getScrollbarWidth();
             setContentWidth(w);
         }
@@ -594,47 +589,23 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         int availW = tBody.getAvailableWidth();
         // Hey IE, are you really sure about this?
         availW = tBody.getAvailableWidth();
+        availW -= tBody.getCellExtraWidth() * visibleColOrder.length;
 
-        // FIXME this may fail if pagelenth does not correlate well with actual
-        // height (via setHeight())
-        boolean verticalScrollbarVisible = (pageLength < totalRows);
-
-        if (verticalScrollbarVisible) {
-            // There will be a vertical scrollbar and its width is not included
-            // in availW
-            availW -= Util.getNativeScrollbarSize();
+        if (!(height != null && !height.equals(""))) {
+            if (pageLength < totalRows) {
+                availW -= Util.getNativeScrollbarSize();
+            }
         }
 
         boolean needsReLayout = false;
 
         if (availW > total) {
             // natural size is smaller than available space
-            int extraSpace = availW - total;
-            int totalWidthR = total - totalExplicitColumnsWidths;
+            final int extraSpace = availW - total;
+            final int totalWidthR = total - totalExplicitColumnsWidths;
             if (totalWidthR > 0) {
                 needsReLayout = true;
-                /*
-                 * If the table has a relative width and there is enough space
-                 * for a scrollbar we reserve this in the last column
-                 */
-                int scrollbarWidth = getScrollbarWidth();
-                scrollbarWidth = Util.getNativeScrollbarSize();
-                if (!verticalScrollbarVisible && relativeWidth
-                        && totalWidthR >= scrollbarWidth) {
-
-                    scrollbarWidthReserved = scrollbarWidth + 1; // 
-                    int columnindex = tHead.getVisibleCellCount() - 1;
-                    widths[columnindex] += scrollbarWidthReserved;
-                    HeaderCell headerCell = tHead.getHeaderCell(columnindex);
-                    if (headerCell.getWidth() == -1) {
-                        totalWidthR += scrollbarWidthReserved;
-                        headerCell.setNaturalMinimumColumnWidth(headerCell
-                                .getNaturalColumnWidth()
-                                + scrollbarWidthReserved);
-                    }
-                    extraSpace -= scrollbarWidthReserved;
-                    scrollbarWidthReservedInColumn = columnindex;
-                }
+
                 if (expandRatioDivider > 0) {
                     // visible columns have some active expand ratios, excess
                     // space is divided according to them
@@ -658,7 +629,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                     i = 0;
                     while (headCells.hasNext()) {
                         HeaderCell hCell = (HeaderCell) headCells.next();
-                        if (hCell.getWidth() == -1) {
+                        if (!hCell.isDefinedWidth()) {
                             int w = widths[i];
                             final int newSpace = extraSpace * w / totalWidthR;
                             w += newSpace;
@@ -997,10 +968,6 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
 
     public class HeaderCell extends Widget {
 
-        private static final int DRAG_WIDGET_WIDTH = 4;
-
-        private static final int MINIMUM_COL_WIDTH = 20;
-
         Element td = DOM.createTD();
 
         Element captionContainer = DOM.createDiv();
@@ -1027,7 +994,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
 
         private int width = -1;
 
-        private int naturalWidth = 0;
+        private int naturalWidth = -1;
 
         private char align = ALIGN_LEFT;
 
@@ -1048,8 +1015,6 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
 
             DOM.setElementProperty(colResizeWidget, "className", CLASSNAME
                     + "-resizer");
-            DOM.setStyleAttribute(colResizeWidget, "width", DRAG_WIDGET_WIDTH
-                    + "px");
             DOM.sinkEvents(colResizeWidget, Event.MOUSEEVENTS);
 
             setText(headerText);
@@ -1089,10 +1054,24 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 DOM.setStyleAttribute(captionContainer, "width", "");
                 setWidth("");
             } else {
-                DOM.setStyleAttribute(captionContainer, "width", (w
-                        - DRAG_WIDGET_WIDTH - 4)
-                        + "px");
-                setWidth(w + "px");
+                captionContainer.getStyle().setPropertyPx("width", w);
+
+                /*
+                 * if we already have tBody, set the header width properly, if
+                 * not defer it. IE will fail with complex float in table header
+                 * unless TD width is not explicitly set.
+                 */
+                if (tBody != null) {
+                    int tdWidth = width + tBody.getCellExtraWidth();
+                    setWidth(tdWidth + "px");
+                } else {
+                    DeferredCommand.addCommand(new Command() {
+                        public void execute() {
+                            int tdWidth = width + tBody.getCellExtraWidth();
+                            setWidth(tdWidth + "px");
+                        }
+                    });
+                }
             }
         }
 
@@ -1307,8 +1286,8 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                     }
 
                     int newWidth = originalWidth + deltaX;
-                    if (newWidth < MINIMUM_COL_WIDTH) {
-                        newWidth = MINIMUM_COL_WIDTH;
+                    if (newWidth < tBody.getCellExtraWidth()) {
+                        newWidth = tBody.getCellExtraWidth();
                     }
                     setColWidth(colIndex, newWidth, true);
                 }
@@ -1354,27 +1333,34 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
          * If column is resized by user or the width is defined by server the
          * actual width is returned. Else the natural min width is returned.
          * 
+         * @param columnIndex
+         *            column index hint, if -1 (unknown) it will be detected
+         * 
          * @return
          */
-        public int getNaturalColumnWidth() {
+        public int getNaturalColumnWidth(int columnIndex) {
             if (isDefinedWidth()) {
                 return width;
             } else {
-                if (naturalWidth == 0) {
+                if (naturalWidth < 0) {
                     // This is recently revealed column. Try to detect a proper
                     // value (greater of header and data
                     // cols)
-                    final int hw = getOffsetWidth();
-                    int i = 0;
-                    for (Iterator<Widget> it = tHead.iterator(); it.hasNext(); i++) {
-                        if (it.next() == this) {
-                            break;
+
+                    final int hw = ((Element) getElement().getLastChild())
+                            .getOffsetWidth()
+                            + tBody.getCellExtraWidth();
+                    if (columnIndex < 0) {
+                        columnIndex = 0;
+                        for (Iterator<Widget> it = tHead.iterator(); it
+                                .hasNext(); columnIndex++) {
+                            if (it.next() == this) {
+                                break;
+                            }
                         }
                     }
-                    final int cw = tBody.getColWidth(i);
-                    naturalWidth = (hw > cw ? hw : cw)
-                            + IScrollTableBody.CELL_EXTRA_WIDTH;
-
+                    final int cw = tBody.getColWidth(columnIndex);
+                    naturalWidth = (hw > cw ? hw : cw);
                 }
                 return naturalWidth;
             }
@@ -1428,6 +1414,10 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         private int focusedSlot = -1;
 
         public TableHead() {
+            if (BrowserInfo.get().isIE()) {
+                table.setPropertyInt("cellSpacing", 0);
+            }
+
             DOM.setStyleAttribute(hTableWrapper, "overflow", "hidden");
             DOM.setElementProperty(hTableWrapper, "className", CLASSNAME
                     + "-header");
@@ -1770,7 +1760,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
          * Returns column alignments for visible columns
          */
         public char[] getColumnAlignments() {
-            final Iterator it = visibleCells.iterator();
+            final Iterator<Widget> it = visibleCells.iterator();
             final char[] aligns = new char[visibleCells.size()];
             int colIndex = 0;
             while (it.hasNext()) {
@@ -1789,29 +1779,25 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
      */
     public class IScrollTableBody extends Panel {
 
-        public static final int CELL_EXTRA_WIDTH = 20;
-
         public static final int DEFAULT_ROW_HEIGHT = 24;
 
-        /**
-         * Amount of padding inside one table cell (this is reduced from the
-         * "cellContent" element's width). You may override this in your own
-         * widgetset.
-         */
-        public static final int CELL_CONTENT_PADDING = 8;
-
         private int rowHeight = -1;
 
         private final List<Widget> renderedRows = new Vector<Widget>();
 
-        private boolean initDone = false;
+        /**
+         * Due some optimizations row height measuring is deferred and initial
+         * set of rows is rendered detached. Flag set on when table body has
+         * been attached in dom and rowheight has been measured.
+         */
+        private boolean tBodyMeasurementsDone = false;
 
         Element preSpacer = DOM.createDiv();
         Element postSpacer = DOM.createDiv();
 
         Element container = DOM.createDiv();
 
-        Element tBody = DOM.createTBody();
+        TableSectionElement tBodyElement = Document.get().createTBodyElement();
         Element table = DOM.createTable();
 
         private int firstRendered;
@@ -1822,17 +1808,21 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
 
         IScrollTableBody() {
             constructDOM();
+
             setElement(container);
         }
 
         private void constructDOM() {
             DOM.setElementProperty(table, "className", CLASSNAME + "-table");
+            if (BrowserInfo.get().isIE()) {
+                table.setPropertyInt("cellSpacing", 0);
+            }
             DOM.setElementProperty(preSpacer, "className", CLASSNAME
                     + "-row-spacer");
             DOM.setElementProperty(postSpacer, "className", CLASSNAME
                     + "-row-spacer");
 
-            DOM.appendChild(table, tBody);
+            table.appendChild(tBodyElement);
             DOM.appendChild(container, preSpacer);
             DOM.appendChild(container, table);
             DOM.appendChild(container, postSpacer);
@@ -1840,13 +1830,13 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         }
 
         public int getAvailableWidth() {
-            return DOM.getElementPropertyInt(preSpacer, "offsetWidth");
+            return preSpacer.getOffsetWidth();
         }
 
         public void renderInitialRows(UIDL rowData, int firstIndex, int rows) {
             firstRendered = firstIndex;
             lastRendered = firstIndex + rows - 1;
-            final Iterator it = rowData.getChildIterator();
+            final Iterator<?> it = rowData.getChildIterator();
             aligns = tHead.getColumnAlignments();
             while (it.hasNext()) {
                 final IScrollTableRow row = new IScrollTableRow((UIDL) it
@@ -1861,7 +1851,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         public void renderRows(UIDL rowData, int firstIndex, int rows) {
             // FIXME REVIEW
             aligns = tHead.getColumnAlignments();
-            final Iterator it = rowData.getChildIterator();
+            final Iterator<?> it = rowData.getChildIterator();
             if (firstIndex == lastRendered + 1) {
                 while (it.hasNext()) {
                     final IScrollTableRow row = createRow((UIDL) it.next());
@@ -1915,7 +1905,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 rowRequestHandler.setReqFirstRow(lastRendered + 1);
                 rowRequestHandler.setReqRows(reactLastRow - lastRendered - 1);
                 rowRequestHandler.deferRowFetch(1);
-            } else if (IScrollTable.this.tBody.getFirstRendered() > reactFirstRow) {
+            } else if (tBody.getFirstRendered() > reactFirstRow) {
                 /*
                  * Branch for fetching cache above visible area.
                  * 
@@ -1946,9 +1936,9 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 final Element cell = DOM.getChild(row.getElement(), i);
                 final int w = IScrollTable.this
                         .getColWidth(getColKeyByIndex(i));
-                DOM.setStyleAttribute(DOM.getFirstChild(cell), "width",
-                        (w - CELL_CONTENT_PADDING) + "px");
-                DOM.setStyleAttribute(cell, "width", w + "px");
+                cell.getFirstChildElement().getStyle()
+                        .setPropertyPx("width", w);
+                cell.getStyle().setPropertyPx("width", w);
             }
             return row;
         }
@@ -1966,7 +1956,8 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             if (row.isSelected()) {
                 row.addStyleName("i-selected");
             }
-            DOM.insertChild(tBody, row.getElement(), 0);
+            tBodyElement.insertBefore(row.getElement(), tBodyElement
+                    .getFirstChild());
             adopt(row);
             renderedRows.add(0, row);
         }
@@ -1985,7 +1976,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             if (row.isSelected()) {
                 row.addStyleName("i-selected");
             }
-            DOM.appendChild(tBody, row.getElement());
+            tBodyElement.appendChild(row.getElement());
             adopt(row);
             renderedRows.add(row);
         }
@@ -2012,7 +2003,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             final IScrollTableRow toBeRemoved = (IScrollTableRow) renderedRows
                     .get(index);
             lazyUnregistryBag.add(toBeRemoved);
-            DOM.removeChild(tBody, toBeRemoved.getElement());
+            tBodyElement.removeChild(toBeRemoved.getElement());
             orphan(toBeRemoved);
             renderedRows.remove(index);
             fixSpacers();
@@ -2058,15 +2049,17 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         }
 
         public int getRowHeight(boolean forceUpdate) {
-            if (initDone && !forceUpdate) {
+            if (tBodyMeasurementsDone && !forceUpdate) {
                 return rowHeight;
             } else {
-                if (DOM.getChildCount(tBody) > 0) {
-                    rowHeight = getTableHeight() / DOM.getChildCount(tBody);
+
+                if (tBodyElement.getRows().getLength() > 0) {
+                    rowHeight = getTableHeight()
+                            / tBodyElement.getRows().getLength();
                 } else {
                     return DEFAULT_ROW_HEIGHT;
                 }
-                initDone = true;
+                tBodyMeasurementsDone = true;
                 return rowHeight;
             }
         }
@@ -2075,26 +2068,71 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             return table.getOffsetHeight();
         }
 
+        /**
+         * Returns the width available for column content.
+         * 
+         * @param i
+         * @return
+         */
         public int getColWidth(int i) {
-            if (initDone) {
-                final Element e = DOM.getChild(DOM.getChild(tBody, 0), i);
-                return DOM.getElementPropertyInt(e, "offsetWidth");
+            if (tBodyMeasurementsDone) {
+                final Element wrapper = (Element) tBodyElement
+                        .getFirstChildElement().getChildNodes().getItem(i)
+                        .getFirstChild();
+                return wrapper.getOffsetWidth();
             } else {
                 return 0;
             }
         }
 
+        /**
+         * Sets the content width of a column.
+         * 
+         * Due IE limitation, we must set the width to a wrapper elements inside
+         * table cells (with overflow hidden, which does not work on td
+         * elements).
+         * 
+         * To get this work properly crossplatform, we will also set the width
+         * of td.
+         * 
+         * @param colIndex
+         * @param w
+         */
         public void setColWidth(int colIndex, int w) {
-            final int rows = DOM.getChildCount(tBody);
+            NodeList<TableRowElement> rows2 = tBodyElement.getRows();
+            final int rows = rows2.getLength();
             for (int i = 0; i < rows; i++) {
-                final Element cell = DOM.getChild(DOM.getChild(tBody, i),
-                        colIndex);
-                DOM.setStyleAttribute(DOM.getFirstChild(cell), "width",
-                        (w - CELL_CONTENT_PADDING) + "px");
-                DOM.setStyleAttribute(cell, "width", w + "px");
+                TableRowElement row = rows2.getItem(i);
+                TableCellElement cell = row.getCells().getItem(colIndex);
+                cell.getFirstChildElement().getStyle()
+                        .setPropertyPx("width", w);
+                cell.getStyle().setPropertyPx("width", w);
             }
         }
 
+        private int cellExtraWidth = -1;
+        private int cellMarginLeft = -1;
+
+        /**
+         * Method to return the space used for cell paddings + border.
+         */
+        private int getCellExtraWidth() {
+            if (cellExtraWidth < 0) {
+                detectExtrawidth();
+            }
+            return cellExtraWidth;
+        }
+
+        private void detectExtrawidth() {
+            com.google.gwt.dom.client.Element firstTD = tBodyElement
+                    .getFirstChildElement().getFirstChildElement();
+            com.google.gwt.dom.client.Element wrapper = firstTD
+                    .getFirstChildElement();
+            cellExtraWidth = firstTD.getOffsetWidth()
+                    - wrapper.getOffsetWidth();
+            cellMarginLeft = wrapper.getOffsetLeft();
+        }
+
         private void reLayoutComponents() {
             for (Widget w : this) {
                 IScrollTableRow r = (IScrollTableRow) w;
@@ -2115,7 +2153,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         public void moveCol(int oldIndex, int newIndex) {
 
             // loop all rows and move given index to its new place
-            final Iterator rows = iterator();
+            final Iterator<?> rows = iterator();
             while (rows.hasNext()) {
                 final IScrollTableRow row = (IScrollTableRow) rows.next();
 
@@ -2131,7 +2169,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
         public class IScrollTableRow extends Panel implements ActionOwner,
                 Container {
 
-            Vector childWidgets = new Vector();
+            Vector<Widget> childWidgets = new Vector<Widget>();
             private boolean selected = false;
             private final int rowKey;
             private List<UIDL> pendingComponentPaints;
@@ -2193,7 +2231,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                     actionKeys = uidl.getStringArrayAttribute("al");
                 }
 
-                final Iterator cells = uidl.getChildIterator();
+                final Iterator<?> cells = uidl.getChildIterator();
                 while (cells.hasNext()) {
                     final Object cell = cells.next();
                     visibleColumnIndex++;
@@ -2229,26 +2267,26 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 if (style != null && !style.equals("")) {
                     className += " " + CLASSNAME + "-cell-content-" + style;
                 }
-
-                DOM.setElementProperty(container, "className", className);
+                td.setClassName(className);
+                container.setClassName(CLASSNAME + "-cell-wrapper");
                 if (textIsHTML) {
-                    DOM.setInnerHTML(container, text);
+                    container.setInnerHTML(text);
                 } else {
-                    DOM.setInnerText(container, text);
+                    container.setInnerText(text);
                 }
                 if (align != ALIGN_LEFT) {
                     switch (align) {
                     case ALIGN_CENTER:
-                        DOM.setStyleAttribute(container, "textAlign", "center");
+                        container.getStyle().setProperty("textAlign", "center");
                         break;
                     case ALIGN_RIGHT:
                     default:
-                        DOM.setStyleAttribute(container, "textAlign", "right");
+                        container.getStyle().setProperty("textAlign", "right");
                         break;
                     }
                 }
-                DOM.appendChild(td, container);
-                DOM.appendChild(getElement(), td);
+                td.appendChild(container);
+                getElement().appendChild(td);
             }
 
             public void addCell(Widget w, char align, String style) {
@@ -2258,7 +2296,8 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 if (style != null && !style.equals("")) {
                     className += " " + CLASSNAME + "-cell-content-" + style;
                 }
-                DOM.setElementProperty(container, "className", className);
+                td.setClassName(className);
+                container.setClassName(CLASSNAME + "-cell-wrapper");
                 // TODO most components work with this, but not all (e.g.
                 // Select)
                 // Old comment: make widget cells respect align.
@@ -2266,25 +2305,25 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 if (align != ALIGN_LEFT) {
                     switch (align) {
                     case ALIGN_CENTER:
-                        DOM.setStyleAttribute(container, "textAlign", "center");
+                        container.getStyle().setProperty("textAlign", "center");
                         break;
                     case ALIGN_RIGHT:
                     default:
-                        DOM.setStyleAttribute(container, "textAlign", "right");
+                        container.getStyle().setProperty("textAlign", "right");
                         break;
                     }
                 }
-                DOM.appendChild(td, container);
-                DOM.appendChild(getElement(), td);
+                td.appendChild(container);
+                getElement().appendChild(td);
                 // ensure widget not attached to another element (possible tBody
                 // change)
                 w.removeFromParent();
-                DOM.appendChild(container, w.getElement());
+                container.appendChild(w.getElement());
                 adopt(w);
                 childWidgets.add(w);
             }
 
-            public Iterator iterator() {
+            public Iterator<Widget> iterator() {
                 return childWidgets.iterator();
             }
 
@@ -2491,14 +2530,13 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
                 HeaderCell headerCell = tHead.getHeaderCell(i);
                 if (headerCell != null) {
                     if (initializedAndAttached) {
-                        w = headerCell.getWidth() - CELL_CONTENT_PADDING;
+                        w = headerCell.getWidth();
                     } else {
                         // header offset width is not absolutely correct value,
-                        // but
-                        // a best guess (expecting similar content in all
+                        // but a best guess (expecting similar content in all
                         // columns ->
                         // if one component is relative width so are others)
-                        w = headerCell.getOffsetWidth() - CELL_CONTENT_PADDING;
+                        w = headerCell.getOffsetWidth() - getCellExtraWidth();
                     }
                 }
                 return new RenderSpace(w, getRowHeight());
@@ -2573,19 +2611,7 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
 
         this.width = width;
         if (width != null && !"".equals(width)) {
-            int oldWidth = getOffsetWidth();
             super.setWidth(width);
-            int newWidth = getOffsetWidth();
-
-            if (scrollbarWidthReservedInColumn != -1 && oldWidth > newWidth
-                    && (oldWidth - newWidth) < scrollbarWidthReserved) {
-                int col = scrollbarWidthReservedInColumn;
-                String colKey = getColKeyByIndex(col);
-                setColWidth(scrollbarWidthReservedInColumn, getColWidth(colKey)
-                        - (oldWidth - newWidth), false);
-                scrollbarWidthReservedInColumn = -1;
-            }
-
             int innerPixels = getOffsetWidth() - getBorderWidth();
             if (innerPixels < 0) {
                 innerPixels = 0;
@@ -2619,54 +2645,57 @@ public class IScrollTable extends FlowPanel implements Table, ScrollListener {
             int usedMinimumWidth = 0;
             int totalExplicitColumnsWidths = 0;
             float expandRatioDivider = 0;
+            int colIndex = 0;
             while (headCells.hasNext()) {
                 final HeaderCell hCell = (HeaderCell) headCells.next();
-                usedMinimumWidth += hCell.getNaturalColumnWidth();
                 if (hCell.isDefinedWidth()) {
                     totalExplicitColumnsWidths += hCell.getWidth();
+                    usedMinimumWidth += hCell.getWidth();
                 } else {
-                    totalExplicitColumnsWidths += hCell.getNaturalColumnWidth();
+                    usedMinimumWidth += hCell.getNaturalColumnWidth(colIndex);
                     expandRatioDivider += hCell.getExpandRatio();
                 }
+                colIndex++;
             }
 
             int availW = tBody.getAvailableWidth();
             // Hey IE, are you really sure about this?
             availW = tBody.getAvailableWidth();
+            availW -= tBody.getCellExtraWidth() * visibleColOrder.length;
 
             int extraSpace = availW - usedMinimumWidth;
             if (extraSpace < 0) {
                 extraSpace = 0;
             }
-            int totalWidthR = usedMinimumWidth - totalExplicitColumnsWidths;
-            if (totalWidthR < 0) {
-                totalWidthR = 0;
-            }
+
+            int totalUndefinedNaturaWidths = usedMinimumWidth
+                    - totalExplicitColumnsWidths;
 
             // we have some space that can be divided optimally
             HeaderCell hCell;
-            int i = 0;
+            colIndex = 0;
             headCells = tHead.iterator();
             while (headCells.hasNext()) {
                 hCell = (HeaderCell) headCells.next();
                 if (!hCell.isDefinedWidth()) {
-                    int w = hCell.getNaturalColumnWidth();
+                    int w = hCell.getNaturalColumnWidth(colIndex);
                     int newSpace;
                     if (expandRatioDivider > 0) {
                         // divide excess space by expand ratios
                         newSpace = (int) (w + extraSpace
                                 * hCell.getExpandRatio() / expandRatioDivider);
                     } else {
-                        if (totalWidthR != 0) {
+                        if (totalUndefinedNaturaWidths != 0) {
                             // divide relatively to natural column widths
-                            newSpace = w + extraSpace * w / totalWidthR;
+                            newSpace = w + extraSpace * w
+                                    / totalUndefinedNaturaWidths;
                         } else {
                             newSpace = w;
                         }
                     }
-                    setColWidth(i, newSpace, false);
+                    setColWidth(colIndex, newSpace, false);
                 }
-                i++;
+                colIndex++;
             }
             Util.runWebkitOverflowAutoFix(bodyContainer.getElement());
             tBody.reLayoutComponents();