package org.litesoft.GWT.client.widgets.datatables;

import java.util.*;

import org.litesoft.GWT.client.widgets.datatables.DetailRowModel.*;
import org.litesoft.core.util.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.event.shared.*;
import com.google.gwt.gen2.table.client.*;
import com.google.gwt.gen2.table.client.TableDefinition.*;
import com.google.gwt.gen2.table.client.TableModelHelper.*;
import com.google.gwt.gen2.table.client.property.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.ui.HasHorizontalAlignment.*;
import com.google.gwt.user.client.ui.HasVerticalAlignment.*;
import com.google.gwt.widgetideas.client.*;

public class AccordionTable<RowType> extends Composite implements HasTableDefinition<RowType>, HasShowRangeHandlers<Integer>
{
    private final ListTableModel<RowType> mModel = new ListTableModel<RowType>();
    private final AccordionTableTable mTable = new AccordionTableTable();
    private final Element mGlassPane = Document.get().createDivElement().cast();

    private DetailRowModelImpl<RowType> mDetailRowModel = new DetailRowModelImpl<RowType>();
    private TableDefinitionPlus<RowType> mTableDefinition;
    private TableModel<RowType> mDataSource;
    private TableModelHelper.Request mOutstandingRequest = null;
    private TableRowCountCallback mRowCountCallback = null;
    private int mMaxWholeRows = 0;
    private int mViewportHeight = 0;
    private int mHeaderRowHeight = 0;
    private int mFooterRowHeight = 0;
    private int mPrototypeDetailRowHeight = 0;
    private int mPrototypeNormalRowHeight = 0;
    private Iterator<RowType> mDataToRenderPendingSize = null;

    public AccordionTable()
    {
        AbsolutePanel viewport = new AbsolutePanel();
        ResizableWidgetCollection.get().add(new ResizableWidgetAdaptor(this, viewport.getElement())
        {
            @Override
            public void onResize(int pWidth, int pHeight)
            {
                mViewportHeight = pHeight;
                sizeOrDataChanged();
            }
        });
        viewport.add(mTable, 0, 0);
        UIObject.setVisible(mGlassPane, false);
        mGlassPane.getStyle().setProperty("width", "100%");
        viewport.getElement().appendChild(mGlassPane);
        initWidget(viewport);
        setStyleName("AccordionTable");
        setHeight("100%");
        setWidth("100%");
        mTable.setWidth("100%");
        mTable.addHighlightHandler(new HoverController());
    }

    /**
     * Will be called when the data changes or the count of rendered rows
     * changes. Useful for updating calulations based on the data.
     * 
     * @see #getVisibleRowCount()
     */
    public HandlerRegistration addShowRangeHandler(ShowRangeHandler<Integer> pHandler)
    {
        return addHandler(pHandler, ShowRangeEvent.getType());
    }

    public void init(TableModel<RowType> pTableModel, TableDefinitionPlus<RowType> pTableDefinition)
    {
        RowType prototypeRowValue = pTableDefinition.getPrototypeRowValue();
        
        if (prototypeRowValue == null)
            throw new IllegalArgumentException("TableDefinition.prototypeRowValue cannot be null for AccordionTable");
        
        mDataSource = pTableModel;
        mTableDefinition = pTableDefinition;
        
        List<ColumnDefinition<RowType, ?>> colDefs = pTableDefinition.getVisibleColumnDefinitions();
        for (int col = 0, size = colDefs.size(); col < size; col++)
        {
            ColumnDefinition<RowType, ?> colDef = colDefs.get(col);
            Object headerValue = colDef.getColumnProperty(HeaderProperty.TYPE).getHeader(0);
            HorizontalAlignmentConstant alignment = colDef.getColumnProperty( HorizontalAlignmentProperty.TYPE).getValue();
            Element td = mTable.setHeader(col, headerValue, alignment);
            Style style = td.getStyle();
            style.setPropertyPx("paddingLeft", colDef.getColumnProperty(PaddingProperty.LEFT).getValue());
            style.setPropertyPx("paddingRight", colDef.getColumnProperty(PaddingProperty.RIGHT).getValue());
            style.setPropertyPx("paddingTop", colDef.getColumnProperty(PaddingProperty.TOP).getValue());
            style.setPropertyPx("paddingBottom", colDef.getColumnProperty(PaddingProperty.BOTTOM).getValue());
            int minWidth = colDef.getColumnProperty(MinimumWidthProperty.TYPE).getMinimumColumnWidth();
            int maxWidth = colDef.getColumnProperty(MaximumWidthProperty.TYPE).getMaximumColumnWidth();
            if (minWidth != MinimumWidthProperty.NO_MINIMUM_WIDTH)
            {
                mTable.setColumnWidth(col, maxWidth);
            }
            else if (maxWidth != MaximumWidthProperty.NO_MAXIMUM_WIDTH)
            {
                mTable.setColumnWidth(col, maxWidth);
            }
        }

        // setup w/ some fake data so we can calculate row heights
        mTable.setFooter(0, "&nbsp;", null, 0);
        mTable.resizeRows(2);
        final Element detailTr = mTable.getRowElement(0);
        final Element normalTr = mTable.getRowElement(1);
        detailTr.getStyle().setProperty("visibility", "hidden");
        normalTr.getStyle().setProperty("visibility", "hidden");
        AccordionTable.AccordionTableTable.RowView<RowType> rowView = mTable.new RowView<RowType>();
        AccordionTable.AccordionTableTable.CellView<RowType> cellView = mTable.new CellView<RowType>(-1, new DetailRowModel<RowType>()
        {
            public DetailRowAlignment getAlign()
            {
                return DetailRowAlignment.Top;
            }

            public int getDetailRow()
            {
                return 0;
            }

            public boolean isDetailRow(int pIndex)
            {
                return pIndex == 0;
            }
            
        });
        renderRowImpl(0, prototypeRowValue, rowView, cellView);
        renderRowImpl(1, prototypeRowValue, rowView, cellView);
        ResizableWidgetCollection.get().add(new TemporaryResizableWidgetAdaptor(this, mTable.getElement())
        {
            @Override
            protected void onSizeInitialized(int pWidth, int pHeight)
            {
                mHeaderRowHeight = mTable.getHeaderRowElement().getOffsetHeight();
                mFooterRowHeight = mTable.getFooterRowElement().getOffsetHeight();
                mPrototypeDetailRowHeight = detailTr.getOffsetHeight();
                mPrototypeNormalRowHeight = normalTr.getOffsetHeight();
                mTable.resizeRows(0);
                sizeOrDataChanged();
            }
        });
        
        mTable.addClickHandler(new TableHelper.GridClickHandler<RowType>(1, mTable.getGridHelper(), colDefs)
        {
            @Override
            protected RowType getRowValue(int pRow)
            {
                return mModel.get(pRow);
            }
        });
        loadData();
    }

    public void loadData()
    {
        mOutstandingRequest = new TableModelHelper.Request();
        mDataSource.requestRows(mOutstandingRequest, new TableModel.Callback<RowType>()
        {
            public void onRowsReady(Request pRequest, Response<RowType> pResponse)
            {
                // ignore responses to stale requests
                if (pRequest == mOutstandingRequest)
                {
                    mOutstandingRequest = null;
                    mDataToRenderPendingSize = pResponse.getRowValues();
                    sizeOrDataChanged();
                }
            }

            public void onFailure(Throwable pCaught)
            {
                // TODO: handle requestRows() failure
                Window.alert(pCaught.getMessage());
            }
        });
    }
    
    private boolean isSizeInitialized()
    {
        return mViewportHeight > 0 && 
            mHeaderRowHeight > 0 && 
            mFooterRowHeight > 0 && 
            mPrototypeDetailRowHeight > 0 && 
            mPrototypeNormalRowHeight > 0;
    }
    
    private void sizeOrDataChanged()
    {
        if (isSizeInitialized())
        {
            boolean fireRowCountChanged = false;
            boolean fireShowRange = false;
            int oldVisibleRowCount = getVisibleRowCount();
            // TODO: subtract header and (optional) footer height
            int maxWholeRows = Math.max(1, (mViewportHeight - mPrototypeDetailRowHeight - mHeaderRowHeight - mFooterRowHeight) / mPrototypeNormalRowHeight + 1);
            if (mMaxWholeRows != maxWholeRows)
            {
                mMaxWholeRows = maxWholeRows;
                fireRowCountChanged = true;
            }
            int visibleRowCount;
            if (mDataToRenderPendingSize != null)
            {
                int oldModelRowCount = getRowCount();
                mModel.setAll(mDataToRenderPendingSize);
                visibleRowCount = getVisibleRowCount(); // note: calculated using model size
                mDetailRowModel.update(mModel.mList, 0, visibleRowCount);
                mDataToRenderPendingSize = null;
                fireRowCountChanged |= getRowCount() != oldModelRowCount;
                fireShowRange = true;
                mTable.resizeRows(visibleRowCount);
                renderRows(0, visibleRowCount);
            }
            else
            {
                visibleRowCount = getVisibleRowCount();
                mTable.resizeRows(visibleRowCount);
                if (mDetailRowModel.update(mModel.mList, 0, visibleRowCount) && mDetailRowModel.getDetailRow() != -1)
                {
                    renderRow(mDetailRowModel.getDetailRow());
                }
                renderRows(oldVisibleRowCount, visibleRowCount - oldVisibleRowCount);
            }
            fireShowRange |= visibleRowCount != oldVisibleRowCount;
            if (fireRowCountChanged && mRowCountCallback != null)
            {
                mRowCountCallback.rowCountChanged(visibleRowCount, mModel.getRowCount(), mMaxWholeRows);
            }
            if (fireShowRange)
            {
                ShowRangeEvent.fire(AccordionTable.this, 0, visibleRowCount);
            }
        }
    }

    public void renderRow( int pIndex )
    {
        renderRows( pIndex, 1 );
    }

    /**
     * @param pCount negative or 0 will be NOOP 
     */
    private void renderRows(int pStartRow, int pCount)
    {
        if (pCount <= 0)
            return;
        
        AccordionTable.AccordionTableTable.RowView<RowType> rowView = mTable.new RowView<RowType>();
        AccordionTable.AccordionTableTable.CellView<RowType> cellView = mTable.new CellView<RowType>(mPrototypeNormalRowHeight, mDetailRowModel);
        for (int row = pStartRow, terminus = pStartRow + pCount; row < terminus; row++)
        {
            RowType rowValue = mModel.get(row);
            renderRowImpl(row, rowValue, rowView, cellView);
        }
    }

    private void renderRowImpl(int pRowIndex, RowType pRowValue, AccordionTable.AccordionTableTable.RowView<RowType> pRowView, AccordionTable.AccordionTableTable.CellView<RowType> pCellView)
    {
        setGlassPaneVisible(true);
        RowRenderer<RowType> rowRenderer = mTableDefinition.getRowRenderer();
        List<ColumnDefinition<RowType, ?>> colDefs = mTableDefinition.getVisibleColumnDefinitions();
        pRowView.setRowIndex(pRowIndex);
        rowRenderer.renderRowValue(pRowValue, pRowView);
        for (int col = 0, colCount = colDefs.size(); col < colCount; col++)
        {
            pCellView.renderAccordionCell(pRowIndex, col, pRowValue, colDefs.get(col));
        }
        setGlassPaneVisible(false);
    }

    public void renderFooter(String[] pValues)
    {
        if (pValues.length > mTable.getColumnCount())
            throw new IllegalArgumentException(String.valueOf(pValues.length));

        if (mTableDefinition == null)
            throw new IllegalStateException();

        List<ColumnDefinition<RowType, ?>> colDefs = mTableDefinition.getVisibleColumnDefinitions();
        for (int col = 0; col < pValues.length; col++)
        {
            ColumnDefinition<RowType, ?> colDef = colDefs.get(col);
            int zPaddingRight = colDef.getColumnProperty( PaddingProperty.RIGHT ).getValue();
            String footerValue = pValues[col];
            HorizontalAlignmentConstant alignment = colDef.getColumnProperty( HorizontalAlignmentProperty.TYPE).getValue();
            mTable.setFooter(col, footerValue, alignment, zPaddingRight );
        }
    }

    private void setGlassPaneVisible(boolean visible)
    {
        mGlassPane.getStyle().setPropertyPx("height", mViewportHeight);
        UIObject.setVisible(mGlassPane, visible);
    }

    public void setFooterAlignment(int col, HorizontalAlignmentConstant pAlign)
    {
        mTable.setFooterAlignment(col, pAlign);
    }

    public DetailRowCallback<RowType> getDetailRowCallback()
    {
        return mDetailRowModel.getCallback();
    }

    public void setDetailRowCallback(DetailRowCallback<RowType> pDetailRowCallback)
    {
        mDetailRowModel.setCallback(pDetailRowCallback);
    }

    public TableDefinitionPlus<RowType> getTableDefinition()
    {
        return mTableDefinition;
    }

    public RowType getRowValue(int pRow)
    {
        return mModel.get(pRow);
    }
    
    public int getVisibleRowCount()
    {
        return Math.min(mModel.size(), mMaxWholeRows);
    }

    public int getRowCount()
    {
        return mModel.size();
    }
    
    public TableRowCountCallback getRowCountCallback()
    {
        return mRowCountCallback;
    }
    
    public void setRowCountCallback(TableRowCountCallback pRowCountCallback)
    {
        mRowCountCallback = pRowCountCallback;
    }

    private class HoverController implements HighlightHandler<Integer>
    {
        private final HoverTimer mHoverTimer = new HoverTimer();
        
        public void onHighlight(HighlightEvent<Integer> pEvent)
        {
            mHoverTimer.setHoverRow(pEvent.getHighlighted());
        }
        
        private void doHighlight(int pNewRow)
        {
            int oldRow = mDetailRowModel.getDetailRow();
            if (mDetailRowModel.maybeSetDetailRow(pNewRow, mModel.get(pNewRow)))
            {
                // render greater row first to avoid layout settling from incremental rendering
                int greaterRow = Math.max(oldRow, pNewRow);
                int lesserRow = Math.min(oldRow, pNewRow);
                if (greaterRow != -1)
                {
                    renderRows(greaterRow, 1);
                }
                if (lesserRow != -1)
                {
                    renderRows(lesserRow, 1);
                }
            }
        }
        
        private class HoverTimer extends Timer
        {
            /**
             * This is -1 if not running, a valid value if running. 
             */
            private int mRow = -1;
            
            public void setHoverRow(int pRow)
            {
                if (mRow != -1)
                {
                    cancel();
                }
                mRow = pRow;
                if (mRow != -1)
                {
                    schedule(250);
                }
            }
            
            @Override
            public void run()
            {
                doHighlight(mRow);
                mRow = -1;
            }
        }
    }

    private static class AccordionTableTable extends FixedWidthFlexTable implements HasHighlightHandlers<Integer>
    {
        private static final int HEADER_ROW = 0;

        private final TableHelper.GridHelper mGridHelper;

        private int mFooterRow = -1;
        
        /**
         * The row that is currently under the mouse. Used for highlight. Not
         * necessarily the detail row due to delay in setting the detail row.
         */
        private int mHilightedRow = -1;

        public AccordionTableTable()
        {
            RowFormatter rowFormatter = new RowFormatter();
            setRowFormatter(rowFormatter);
            setCellFormatter(new CellFormatter());
            UIObject.setStylePrimaryName(rowFormatter.ensureElement(0), "AccordionTable-headerRow");
            setCellPadding(0);
            setCellSpacing(0);
            sinkEvents(Event.ONMOUSEOVER);
            sinkEvents(Event.ONMOUSEOUT);
            mGridHelper = new TableHelper.GridHelper(this)
            {
                @Override
                protected int getRowIndex(com.google.gwt.user.client.Element pRowElement)
                {
                    return AccordionTableTable.this.getRowIndex(pRowElement);
                }
                
                @Override
                protected int getCellIndex(Element pRowElement, Element pCellElement)
                {
                    return AccordionTableTable.this.getCellIndex(pRowElement, pCellElement);
                }
            };
        }

        public HandlerRegistration addClickHandler( ClickHandler pHandler )
        {
            return addDomHandler( pHandler, ClickEvent.getType() );
        }

        public HandlerRegistration addHighlightHandler(HighlightHandler<Integer> pHandler)
        {
            return addHandler(pHandler, HighlightEvent.getType());
        }

        public TableHelper.GridHelper getGridHelper()
        {
            return mGridHelper;
        }
        
        @Override
        protected Element getBodyElement()
        {
            return super.getBodyElement();
        }
        
        /**
         * Get the element for the normal row (index is adjusted to account for header row). 
         */
        public Element getRowElement(int pRow)
        {
            return getRowFormatter().getElement(pRow + 1);
        }
        
        public Element getHeaderRowElement()
        {
            return getRowFormatter().getElement(HEADER_ROW);
        }
        
        public Element getFooterRowElement()
        {
            ensureFooter();
            return getRowFormatter().getElement(mFooterRow);
        }

        public Element setHeader(int pCol, Object pValue, HorizontalAlignmentConstant pAlign)
        {
            Element innerTd = ((CellFormatter) getCellFormatter()).ensureElement(HEADER_ROW, pCol);
            Element innerTr = innerTd.getParentElement().cast();
            Element innerTbody = innerTr.getParentElement().cast();
            Element innerTable = innerTbody.getParentElement().cast();
            Element outerTd = innerTable.getParentElement().cast();
            
            // set the style name on the containing td so background styles will be 100% row height
            UIObject.setStylePrimaryName(outerTd, "AccordionTable-headerCell");
            if (pAlign != null)
            {
                innerTd.setPropertyString("align", pAlign.getTextAlignString());
            }
            String stringValue = UtilsCommon.noEmpty((String) pValue);
            innerTd.setInnerHTML((stringValue != null) ? stringValue : "&nbsp;");
            return innerTd;
        }

        public void setFooter(int pCol, Object pValue, HorizontalAlignmentConstant pAlign, int pPaddingRight)
        {
            int footerRow = ensureFooter();
            Element td = ((CellFormatter) getCellFormatter()).ensureElement(footerRow, pCol);
            UIObject.setStylePrimaryName(td, "AccordionTable-footerCell");
            if (pAlign != null)
            {
                td.setPropertyString("align", pAlign.getTextAlignString());
            }
            if( pPaddingRight > 0)
            {
                Style style = td.getStyle();
                style.setPropertyPx("paddingRight", pPaddingRight );
            }
            String stringValue = UtilsCommon.noEmpty((String) pValue);
            td.setInnerHTML((stringValue != null) ? stringValue : "&nbsp;");
        }

        public void setFooterAlignment(int pCol, HorizontalAlignmentConstant pAlign)
        {
            Element td = ((CellFormatter) getCellFormatter()).ensureElement(mFooterRow, pCol);
            td.setPropertyString("align", pAlign.getTextAlignString());
        }

        private int ensureFooter()
        {
            int footerRowIndex;
            boolean hasFooterRow = mFooterRow != -1;
            if (! hasFooterRow)
            {
                footerRowIndex = getRowCount();
                insertRow(footerRowIndex);
                mFooterRow = footerRowIndex;
            }
            else
            {
                footerRowIndex = getRowCount() - 1;
            }
            return footerRowIndex;
        }

        public void resizeRows(int pRowCount)
        {
            int actualCount = getRowCount() - 1; // subtract header row
            boolean hasFooterRow = mFooterRow != -1;
            if (hasFooterRow)
            {
                actualCount--;
            }
            while (actualCount > pRowCount)
            {
                removeRow(actualCount--);
            }
            while (actualCount < pRowCount)
            {
                insertRow(++actualCount);
            }
            if (hasFooterRow)
            {
                mFooterRow = actualCount + 1;
            }
            if (mHilightedRow >= actualCount)
            {
                mHilightedRow = -1;
            }
        }
        
        /**
         * Have to override super method to append div to td
         */
        @Override
        protected void addCells(int pRow, int pNum)
        {
            // Account for ghost row
            addCells(getBodyElement(), pRow + 1, pNum);
            clearIdealWidths0();
        }
        
        private native void clearIdealWidths0() /*-{
            this.@com.google.gwt.gen2.table.client.FixedWidthFlexTable::clearIdealWidths()();
        }-*/;
        
        private static native void addCells(Element table, int row, int num) /*-{
            var rowElem = table.rows[row];
            for(var i = 0; i < num; i++)
            {
                var cell = $doc.createElement("td");
                cell['colSpan'] = 1;
                cell['rowSpan'] = 1;
                
                var innerCell = $doc.createElement("td");
                innerCell.style["overflow"]="hidden";
                var tr = $doc.createElement("tr");
                tr.appendChild(innerCell);
                var tbody = $doc.createElement("tbody");
                tbody.appendChild(tr);
                var table = $doc.createElement("table");
                table.appendChild(tbody);
                table.style["width"]="100%";
                table["cellSpacing"]=0;
                table["cellPadding"]=0;
                cell.appendChild(table);
                
                rowElem.appendChild(cell);
            }
        }-*/;
        
        @Override
        public void onBrowserEvent( Event pEvent )
        {
            // the current incubator HTMLTable does not call super()
            switch (pEvent.getTypeInt())
            {
                case Event.ONCLICK:
                    DomEvent.fireNativeEvent( pEvent, this, getElement() );
                    break;

                case Event.ONMOUSEOVER:
                    int row = mGridHelper.getRowForEvent(pEvent);
                    updateHighlightedRow(row);
                    break;
                
                case Event.ONMOUSEOUT:
                    // only process mouse out if exiting the widget
                    Element toElement = pEvent.getRelatedEventTarget().cast();
                    if (toElement == null || ! getElement().isOrHasChild(toElement))
                    {
                        updateHighlightedRow(-1);
                    }
                    break;
            }
            super.onBrowserEvent( pEvent );
        }

        private void updateHighlightedRow(int pRow)
        {
            assert pRow >= -1;
            if (pRow == 0 || pRow == mFooterRow)
            {
                pRow = -1;
            }
            if (mHilightedRow != pRow)
            {
                RowFormatter rowFormatter = (RowFormatter) getRowFormatter();
                if (mHilightedRow != -1)
                {
                    Element tr = rowFormatter.getElement(mHilightedRow);
                    UIObject.setStyleName(tr, "highlighted", false);
                }
                mHilightedRow = pRow;
                if (mHilightedRow != -1)
                {
                    Element tr = rowFormatter.getElement(mHilightedRow);
                    UIObject.setStyleName(tr, "highlighted", true);
                }
                HighlightEvent.fire(this, (mHilightedRow == -1) ? -1 : mHilightedRow - 1);
            }
        }

        private class RowFormatter extends FixedWidthFlexRowFormatter
        {
            /**
             * Override to gain access
             */
            @Override
            protected Element ensureElement(int pRow)
            {
                return super.ensureElement(pRow);
            }

            /**
             * Override to gain access
             */
            @Override
            protected Element getRawElement(int pRow)
            {
                return super.getRawElement(pRow);
            }
        }

        private class CellFormatter extends FixedWidthFlexCellFormatter
        {
            /**
             * Override to gain access
             */
            @Override
            protected Element getRawElement(int pRow, int pColumn)
            {
                Element outerTd = super.getRawElement(pRow, pColumn);
                Element table = outerTd.getFirstChildElement().cast();
                Element tbody = table.getFirstChildElement().cast();
                Element tr = tbody.getFirstChildElement().cast();
                Element td = tr.getFirstChildElement().cast();
                return td;
            }

            /**
             * Override to gain access
             */
            @Override
            protected Element ensureElement(int pRow, int pColumn)
            {
                return super.ensureElement(pRow, pColumn);
            }
        }

        private class RowView<RowType> extends AbstractRowView<RowType>
        {
            private int mRowIndex;

            public RowView()
            {
                super(null);
            }

            @Override
            public int getRowIndex()
            {
                return mRowIndex;
            }

            public void setRowIndex(int pRowIndex)
            {
                mRowIndex = pRowIndex;
            }

            @Override
            public void setStyleAttribute(String attr, String value)
            {
                ((RowFormatter) getRowFormatter()).getRawElement(getRowIndex() + 1).getStyle().setProperty(attr, value);
            }

            @Override
            public void setStyleName(String stylename)
            {
                if (getRowIndex() + 1 == mHilightedRow)
                {
                    stylename += " highlighted";
                }
                getRowFormatter().setStyleName(getRowIndex() + 1, stylename);
            }
        }

        private class CellView<RowType> extends AbstractCellView<RowType>
        {
            private final DetailRowModel<RowType> mDetailRowModel;
            private final int mNormalRowHeight;
            
            private Element mViewTableElement; // the inner TD in each TD

            public CellView(int normalRowHeight, DetailRowModel<RowType> detailRowModel)
            {
                super(null);
                mNormalRowHeight = normalRowHeight;
                mDetailRowModel = detailRowModel;
            }

            public void renderAccordionCell(int rowIndex, int cellIndex, RowType rowValue, ColumnDefinition<RowType, ?> columnDef)
            {
                // ensure element first so we can getRawElement() for all future needs
                mViewTableElement = ((CellFormatter) getCellFormatter()).ensureElement(rowIndex + 1, cellIndex);
                Element tr = mViewTableElement.getParentElement().cast();
                Element tbody = tr.getParentElement().cast();
                Element table = tbody.getParentElement().cast();
                Element outerTd = table.getParentElement().cast();
                UIObject.setStylePrimaryName(mViewTableElement, "AccordionTable-dataCell");
                boolean detailRow = mDetailRowModel.isDetailRow(rowIndex);
                String valign = null;
                if (detailRow)
                {
                    valign = (mDetailRowModel.getAlign() == DetailRowAlignment.Top) ? "top" : "bottom";
                }
                outerTd.getStyle().setProperty("verticalAlign", valign);
                super.renderCellImpl(rowIndex, cellIndex, rowValue, columnDef);
                mViewTableElement = null;
            }

            @Override
            @SuppressWarnings("unchecked")
            protected void renderRowValue(RowType rowValue, ColumnDefinition columnDef)
            {
                CellRenderer cellRenderer = columnDef.getCellRenderer();
                boolean detailRow = mDetailRowModel.isDetailRow(getRowIndex());
                boolean maxHeight = false; // typically true for detail cells
                if (cellRenderer instanceof DetailCellRenderer)
                {
                    DetailCellRenderer<RowType> detailRenderer = (DetailCellRenderer<RowType>) cellRenderer;
                    maxHeight = detailRow && detailRenderer.isMaxHeight();
                    ((DetailCellRenderer) cellRenderer).setDetailRow(detailRow);
                }
                if (mNormalRowHeight > 0)
                {
                    mViewTableElement.getStyle().setProperty("height", (detailRow && ! maxHeight) ? mNormalRowHeight + "px" : "");
                }
                cellRenderer.renderRowValue(rowValue, columnDef, this);
            }

            @Override
            public void setHorizontalAlignment(HorizontalAlignmentConstant align)
            {
                mViewTableElement.setPropertyString("align", align.getTextAlignString());
            }

            @Override
            public void setHTML(String html)
            {
                AccordionTableTable.this.setHTML(getRowIndex() + 1, getCellIndex(), html);
            }

            @Override
            public void setStyleAttribute(String attr, String value)
            {
                mViewTableElement.getStyle().setProperty(attr, value != null ? value : ""); // de-null to avoid IE error
            }

            @Override
            public void setStyleName(String stylename)
            {
                if (stylename.length() > 0)
                {
                    UIObject.setStyleName(mViewTableElement, stylename);
                }
            }

            @Override
            public void setText(String text)
            {
                AccordionTableTable.this.setText(getRowIndex() + 1, getCellIndex(), text);
            }

            @Override
            public void setVerticalAlignment(VerticalAlignmentConstant align)
            {
                mViewTableElement.getStyle().setProperty("verticalAlign", align.getVerticalAlignString());
            }

            @Override
            public void setWidget(Widget widget)
            {
                AccordionTableTable.this.setWidget(getRowIndex() + 1, getCellIndex(), widget);
            }
        }
    }
}