/*
 * Copyright 2008 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.gen2.table.client;

import org.litesoft.commonfoundation.html.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.gen2.event.shared.*;
import com.google.gwt.gen2.table.client.CellEditor.*;
import com.google.gwt.gen2.table.client.FlexTable.*;
import com.google.gwt.gen2.table.client.SelectionGrid.*;
import com.google.gwt.gen2.table.client.SortableGrid.*;
import com.google.gwt.gen2.table.client.TableDefinition.*;
import com.google.gwt.gen2.table.client.TableModel.Callback;
import com.google.gwt.gen2.table.client.TableModelHelper.*;
import com.google.gwt.gen2.table.client.property.*;
import com.google.gwt.gen2.table.event.client.*;
import com.google.gwt.gen2.table.event.client.TableEvent.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.ui.HasHorizontalAlignment.*;
import com.google.gwt.user.client.ui.HasVerticalAlignment.*;

import java.util.*;

/**
 * An {@link AbstractScrollTable} that acts as a view for an underlying
 * {@link MutableTableModel}.
 *
 * @param <RowType> the data type of the row values
 */
public class PagingScrollTable<RowType> extends AbstractScrollTable implements HasTableDefinition<RowType>,
                                                                               HasPageCountChangeHandlers,
                                                                               HasPageLoadHandlers,
                                                                               HasPageChangeHandlers,
                                                                               HasPagingFailureHandlers {
    /**
     * A custom {@link AbstractCellView} used by the {@link PagingScrollTable}.
     *
     * @param <RowType> the type of the row values
     */
    protected static class PagingScrollTableCellView<RowType> extends AbstractCellView<RowType> {
        private PagingScrollTable<RowType> table;

        public PagingScrollTableCellView( PagingScrollTable<RowType> table ) {
            super( table );
            this.table = table;
        }

        @Override
        public void setHorizontalAlignment( HorizontalAlignmentConstant align ) {
            table.getDataTable().getCellFormatter().setHorizontalAlignment( getRowIndex(), getCellIndex(), align );
        }

        @Override
        public void setHTML( String html ) {
            table.getDataTable().setHTML( getRowIndex(), getCellIndex(), html );
        }

        @Override
        public void setStyleAttribute( String attr, String value ) {
            table.getDataTable().getFixedWidthGridCellFormatter().getRawElement( getRowIndex(), getCellIndex() ).getStyle().setProperty( attr, value );
        }

        @Override
        public void setStyleName( String stylename ) {
            table.getDataTable().getCellFormatter().setStyleName( getRowIndex(), getCellIndex(), stylename );
        }

        @Override
        public void setText( String text ) {
            table.getDataTable().setText( getRowIndex(), getCellIndex(), text );
        }

        @Override
        public void setVerticalAlignment( VerticalAlignmentConstant align ) {
            table.getDataTable().getCellFormatter().setVerticalAlignment( getRowIndex(), getCellIndex(), align );
        }

        @Override
        public void setWidget( Widget widget ) {
            table.getDataTable().setWidget( getRowIndex(), getCellIndex(), widget );
        }
    }

    /**
     * A custom {@link AbstractRowView} used by the {@link PagingScrollTable}.
     *
     * @param <RowType> the type of the row values
     */
    protected static class PagingScrollTableRowView<RowType> extends AbstractRowView<RowType> {
        private PagingScrollTable<RowType> table;

        public PagingScrollTableRowView( PagingScrollTable<RowType> table ) {
            super( new PagingScrollTableCellView<RowType>( table ) );
            this.table = table;
        }

        @Override
        public void setStyleAttribute( String attr, String value ) {
            table.getDataTable().getFixedWidthGridRowFormatter().getRawElement( getRowIndex() ).getStyle().setProperty( attr, value );
        }

        @Override
        public void setStyleName( String stylename ) {
            // If the row is selected, add the selected style name back
            if ( table.getDataTable().isRowSelected( getRowIndex() ) ) {
                stylename += " selected";
            }
            table.getDataTable().getRowFormatter().setStyleName( getRowIndex(), stylename );
        }
    }

    /**
     * Information about a column header.
     */
    private static class ColumnHeaderInfo {
        private int rowSpan = 1;
        private Object header;

        public ColumnHeaderInfo( Object header ) {
            this.header = (header == null) ? "" : header;
        }

        public ColumnHeaderInfo( Object header, int rowSpan ) {
            this.header = (header == null) ? HtmlEntity.NBSP : header;
            this.rowSpan = rowSpan;
        }

        @Override
        public boolean equals( Object o ) {
            if ( o == null ) {
                return false;
            }
            if ( o instanceof ColumnHeaderInfo ) {
                ColumnHeaderInfo info = (ColumnHeaderInfo) o;
                return (rowSpan == info.rowSpan) && header.equals( info.header );
            }
            return false;
        }

        public Object getHeader() {
            return header;
        }

        public int getRowSpan() {
            return rowSpan;
        }

        public void incrementRowSpan() {
            rowSpan++;
        }
    }

    /**
     * An iterator over the visible rows in an iterator over many rows.
     */
    private class VisibleRowsIterator implements Iterator<RowType> {
        /**
         * The iterator of row data.
         */
        private Iterator<RowType> rows;

        /**
         * The current row of the rows iterator.
         */
        private int curRow;

        /**
         * The last visible row in the grid.
         */
        private int lastVisibleRow;

        /**
         * Constructor.
         *
         * @param rows            the iterator over row data
         * @param firstRow        the first absolute row of the rows iterator
         * @param firstVisibleRow the first visible row in this grid
         * @param lastVisibleRow  the last visible row in this grid
         */
        public VisibleRowsIterator( Iterator<RowType> rows, int firstRow, int firstVisibleRow, int lastVisibleRow ) {
            this.curRow = firstRow;
            this.lastVisibleRow = lastVisibleRow;

            // Iterate up to the first row
            while ( curRow < firstVisibleRow && rows.hasNext() ) {
                rows.next();
                curRow++;
            }
            this.rows = rows;
        }

        public boolean hasNext() {
            return (curRow <= lastVisibleRow && rows.hasNext());
        }

        public RowType next() {
            // Check that the next row exists
            if ( !hasNext() ) {
                throw new NoSuchElementException();
            }
            return rows.next();
        }

        public void remove() {
            throw new UnsupportedOperationException( "Remove not supported" );
        }
    }

    /**
     * The bulk render used to render the contents of this table.
     */
    private FixedWidthGridBulkRenderer<RowType> bulkRenderer = null;

    /**
     * The wrapper around the empty table widget.
     */
    private SimplePanel emptyTableWidgetWrapper = new SimplePanel();

    /**
     * The definition of the columns in the table.
     */
    private TableDefinition<RowType> tableDefinition = null;

    /**
     * The current visible page.
     */
    private int currentPage = -1;

    /**
     * The last request that was sent to the {@link TableModel}.
     */
    private Request lastRequest = null;

    /**
     * A boolean indicating that cross page selection is enabled.
     */
    private boolean isCrossPageSelectionEnabled;

    /**
     * The set of selected row values.
     */
    private Set<RowType> selectedRowValues = new HashSet<RowType>();

    /**
     * A boolean indicating that the footer should be generated automatically.
     */
    private boolean isFooterGenerated;

    /**
     * A boolean indicating that the header should be generated automatically.
     */
    private boolean isHeaderGenerated;

    /**
     * A boolean indicating that the page is currently being loaded.
     */
    private boolean isPageLoading;

    /**
     * The old page count, used to detect when the number of pages changes.
     */
    private int oldPageCount;

    /**
     * The number of rows per page. If the number of rows per page is equal to the
     * number of rows, paging is disabled because only one page exists.
     */
    private int pageSize = 0;

    /**
     * The callback that handles page requests.
     */
    private Callback<RowType> pagingCallback = new Callback<RowType>() {
        public void onFailure( Throwable caught ) {
            isPageLoading = false;
            fireEvent( new PagingFailureEvent( caught ) );
        }

        public void onRowsReady( Request request, Response<RowType> response ) {
            if ( lastRequest == request ) {
                setData( request.getStartRow(), response.getRowValues() );
                lastRequest = null;
            }
        }
    };

    /**
     * The values associated with each row. This is an optional list of data that
     * ties the visible content in each row to an underlying object.
     */
    private List<RowType> rowValues = new ArrayList<RowType>();

    /**
     * The view of this table.
     */
    private AbstractRowView<RowType> rowView = new PagingScrollTableRowView<RowType>( this );

    /**
     * The {@link CheckBox} used to select all rows.
     */
    private Widget selectAllWidget;

    /**
     * The underlying table model.
     */
    private TableModel<RowType> tableModel;

    /**
     * The {@link RendererCallback} used when table rendering completes.
     */
    private RendererCallback tableRendererCallback = new RendererCallback() {
        public void onRendered() {
            onDataTableRendered();
        }
    };

    /**
     * The columns that are currently visible.
     */
    private List<ColumnDefinition<RowType, ?>> visibleColumns = new ArrayList<ColumnDefinition<RowType, ?>>();

    /**
     * The boolean indicating that the header tables are obsolete.
     */
    private boolean headersObsolete;

    /**
     * Construct a new {@link PagingScrollTable}.
     *
     * @param tableModel      the underlying table model
     * @param tableDefinition the column definitions
     */
    public PagingScrollTable( TableModel<RowType> tableModel, TableDefinition<RowType> tableDefinition ) {
        this( tableModel, new FixedWidthGrid(), new FixedWidthFlexTable(), tableDefinition );
        isHeaderGenerated = true;
        isFooterGenerated = true;
    }

    /**
     * Construct a new {@link PagingScrollTable}.
     *
     * @param tableModel      the underlying table model
     * @param dataTable       the table used to display data
     * @param headerTable     the header table
     * @param tableDefinition the column definitions
     */
    public PagingScrollTable( TableModel<RowType> tableModel, FixedWidthGrid dataTable, FixedWidthFlexTable headerTable,
                              TableDefinition<RowType> tableDefinition ) {
        super( dataTable, headerTable );
        this.tableModel = tableModel;
        setTableDefinition( tableDefinition );
        refreshVisibleColumnDefinitions();
        oldPageCount = getPageCount();

        // Setup the empty table widget wrapper
        emptyTableWidgetWrapper.getElement().getStyle().setProperty( "width", "100%" );
        emptyTableWidgetWrapper.getElement().getStyle().setProperty( "overflow", "hidden" );
        emptyTableWidgetWrapper.getElement().getStyle().setPropertyPx( "border", 0 );
        emptyTableWidgetWrapper.getElement().getStyle().setPropertyPx( "margin", 0 );
        emptyTableWidgetWrapper.getElement().getStyle().setPropertyPx( "padding", 0 );
        insert( emptyTableWidgetWrapper, getAbsoluteElement(), 2, true );
        setEmptyTableWidgetVisible( false );

        // Listen to table model events
        tableModel.addRowCountChangeHandler( new RowCountChangeHandler() {
            public void onRowCountChange( RowCountChangeEvent event ) {
                int pageCount = getPageCount();
                if ( pageCount != oldPageCount ) {
                    fireEvent( new PageCountChangeEvent( oldPageCount, pageCount ) );
                    oldPageCount = pageCount;
                }
            }
        } );
        if ( tableModel instanceof HasRowInsertionHandlers ) {
            ((HasRowInsertionHandlers) tableModel).addRowInsertionHandler( new RowInsertionHandler() {
                public void onRowInsertion( RowInsertionEvent event ) {
                    insertAbsoluteRow( event.getRowIndex() );
                }
            } );
        }
        if ( tableModel instanceof HasRowRemovalHandlers ) {
            ((HasRowRemovalHandlers) tableModel).addRowRemovalHandler( new RowRemovalHandler() {
                public void onRowRemoval( RowRemovalEvent event ) {
                    removeAbsoluteRow( event.getRowIndex() );
                }
            } );
        }
        if ( tableModel instanceof HasRowValueChangeHandlers ) {
            ((HasRowValueChangeHandlers<RowType>) tableModel).addRowValueChangeHandler( new RowValueChangeHandler<RowType>() {
                public void onRowValueChange( RowValueChangeEvent<RowType> event ) {
                    int rowIndex = event.getRowIndex();
                    if ( rowIndex < getAbsoluteFirstRowIndex() || rowIndex > getAbsoluteLastRowIndex() ) {
                        return;
                    }
                    setRowValue( rowIndex - getAbsoluteFirstRowIndex(), event.getRowValue() );
                }
            } );
        }

        // Listen for cell click events
        dataTable.addTableListener( new TableListener() {
            public void onCellClicked( SourcesTableEvents sender, int row, int cell ) {
                editCell( row, cell );
            }
        } );

        // Override the column sorter
        if ( dataTable.getColumnSorter() == null ) {
            ColumnSorter sorter = new ColumnSorter() {
                @Override
                public void onSortColumn( SortableGrid grid, ColumnSortList sortList, ColumnSorterCallback callback ) {
                    reloadPage();
                    callback.onSortingComplete();
                }
            };
            dataTable.setColumnSorter( sorter );
        }

        // Listen for selection events
        dataTable.addRowSelectionHandler( new RowSelectionHandler() {
            public void onRowSelection( RowSelectionEvent event ) {
                if ( isPageLoading ) {
                    return;
                }
                Set<Row> deselected = event.getDeselectedRows();
                for ( Row row : deselected ) {
                    selectedRowValues.remove( getRowValue( row.getRowIndex() ) );
                }
                Set<Row> selected = event.getSelectedRows();
                for ( Row row : selected ) {
                    selectedRowValues.add( getRowValue( row.getRowIndex() ) );
                }
            }
        } );
    }

    public HandlerRegistration addPageChangeHandler( PageChangeHandler handler ) {
        return addHandler( PageChangeEvent.TYPE, handler );
    }

    public HandlerRegistration addPageCountChangeHandler( PageCountChangeHandler handler ) {
        return addHandler( PageCountChangeEvent.TYPE, handler );
    }

    public HandlerRegistration addPageLoadHandler( PageLoadHandler handler ) {
        return addHandler( PageLoadEvent.TYPE, handler );
    }

    public HandlerRegistration addPagingFailureHandler( PagingFailureHandler handler ) {
        return addHandler( PagingFailureEvent.TYPE, handler );
    }

    /**
     * @return the absolute index of the first visible row
     */
    public int getAbsoluteFirstRowIndex() {
        return currentPage * pageSize;
    }

    /**
     * @return the absolute index of the last visible row
     */
    public int getAbsoluteLastRowIndex() {
        if ( tableModel.getRowCount() < 0 ) {
            // Unknown row count, so just return based on current page
            return (currentPage + 1) * pageSize - 1;
        } else if ( pageSize == 0 ) {
            // Only one page, so return row count
            return tableModel.getRowCount() - 1;
        }
        return Math.min( tableModel.getRowCount(), (currentPage + 1) * pageSize ) - 1;
    }

    /**
     * @return the current page
     */
    public int getCurrentPage() {
        return currentPage;
    }

    /**
     * @return the widget displayed when the data table is empty
     */
    public Widget getEmptyTableWidget() {
        return emptyTableWidgetWrapper.getWidget();
    }

    @Override
    public int getMaximumColumnWidth( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return -1;
        }
        return colDef.getColumnProperty( MaximumWidthProperty.TYPE ).getMaximumColumnWidth();
    }

    @Override
    public int getMinimumColumnWidth( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return FixedWidthGrid.MIN_COLUMN_WIDTH;
        }
        int minWidth = colDef.getColumnProperty( MinimumWidthProperty.TYPE ).getMinimumColumnWidth();
        return Math.max( FixedWidthGrid.MIN_COLUMN_WIDTH, minWidth );
    }

    /**
     * @return the number of pages, or -1 if not known
     */
    public int getPageCount() {
        if ( pageSize < 1 ) {
            return 1;
        } else {
            int numDataRows = tableModel.getRowCount();
            if ( numDataRows < 0 ) {
                return -1;
            }
            return (int) Math.ceil( numDataRows / (pageSize + 0.0) );
        }
    }

    /**
     * @return the number of rows per page
     */
    public int getPageSize() {
        return pageSize;
    }

    @Override
    public int getPreferredColumnWidth( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return FixedWidthGrid.DEFAULT_COLUMN_WIDTH;
        }
        return colDef.getColumnProperty( PreferredWidthProperty.TYPE ).getPreferredColumnWidth();
    }

    /**
     * Get the value associated with a row.
     *
     * @param row the row index
     *
     * @return the value associated with the row
     */
    public RowType getRowValue( int row ) {
        if ( rowValues.size() <= row ) {
            return null;
        }
        return rowValues.get( row );
    }

    /**
     * Get the selected row values. If cross page selection is enabled, this will
     * include row values selected on all pages.
     *
     * @return the selected row values
     *
     * @see #setCrossPageSelectionEnabled(boolean)
     */
    public Set<RowType> getSelectedRowValues() {
        return selectedRowValues;
    }

    public TableDefinition<RowType> getTableDefinition() {
        return tableDefinition;
    }

    /**
     * @return the table model
     */
    public TableModel<RowType> getTableModel() {
        return tableModel;
    }

    /**
     * Go to the first page.
     */
    public void gotoFirstPage() {
        gotoPage( 0, false );
    }

    /**
     * Go to the last page. If the number of pages is not known, this method is
     * ignored.
     */
    public void gotoLastPage() {
        if ( getPageCount() >= 0 ) {
            gotoPage( getPageCount(), false );
        }
    }

    /**
     * Go to the next page.
     */
    public void gotoNextPage() {
        gotoPage( currentPage + 1, false );
    }

    /**
     * Set the current page. If the page is out of bounds, it will be
     * automatically set to zero or the last page without throwing any errors.
     *
     * @param page   the page
     * @param forced reload the page even if it is already loaded
     */
    public void gotoPage( int page, boolean forced ) {
        int oldPage = currentPage;
        int numPages = getPageCount();
        if ( numPages >= 0 ) {
            currentPage = Math.max( 0, Math.min( page, numPages - 1 ) );
        } else {
            currentPage = page;
        }

        if ( currentPage != oldPage || forced ) {
            isPageLoading = true;

            // Deselect rows when switching pages
            FixedWidthGrid dataTable = getDataTable();
            dataTable.deselectAllRows();
            if ( !isCrossPageSelectionEnabled ) {
                selectedRowValues = new HashSet<RowType>();
            }

            // Fire listeners
            fireEvent( new PageChangeEvent( oldPage, currentPage ) );

            // Clear out existing data if we aren't bulk rendering
            if ( bulkRenderer == null ) {
                int rowCount = getAbsoluteLastRowIndex() - getAbsoluteFirstRowIndex() + 1;
                if ( rowCount != dataTable.getRowCount() ) {
                    dataTable.resizeRows( rowCount );
                }
                dataTable.clearAll();
            }

            // Request the new data from the table model
            int firstRow = getAbsoluteFirstRowIndex();
            int lastRow = pageSize == 0 ? tableModel.getRowCount() : pageSize;
            lastRequest = new Request( firstRow, lastRow, dataTable.getColumnSortList() );
            tableModel.requestRows( lastRequest, pagingCallback );
        }
    }

    /**
     * Go to the previous page.
     */
    public void gotoPreviousPage() {
        gotoPage( currentPage - 1, false );
    }

    @Override
    public boolean isColumnSortable( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return true;
        }
        if ( getSortPolicy() == SortPolicy.DISABLED ) {
            return false;
        }
        return colDef.getColumnProperty( SortableProperty.TYPE ).isColumnSortable();
    }

    @Override
    public boolean isColumnTruncatable( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return true;
        }
        return colDef.getColumnProperty( TruncationProperty.TYPE ).isColumnTruncatable();
    }

    /**
     * @return true if cross page selection is enabled
     */
    public boolean isCrossPageSelectionEnabled() {
        return isCrossPageSelectionEnabled;
    }

    @Override
    public boolean isFooterColumnTruncatable( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return true;
        }
        return colDef.getColumnProperty( TruncationProperty.TYPE ).isFooterTruncatable();
    }

    /**
     * @return true if the footer table is automatically generated
     */
    public boolean isFooterGenerated() {
        return isFooterGenerated;
    }

    @Override
    public boolean isHeaderColumnTruncatable( int column ) {
        ColumnDefinition<RowType, ?> colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return true;
        }
        return colDef.getColumnProperty( TruncationProperty.TYPE ).isHeaderTruncatable();
    }

    /**
     * @return true if the header table is automatically generated
     */
    public boolean isHeaderGenerated() {
        return isHeaderGenerated;
    }

    /**
     * @return true if a page load is pending
     */
    public boolean isPageLoading() {
        return isPageLoading;
    }

    /**
     * Reload the current page.
     */
    public void reloadPage() {
        if ( currentPage >= 0 ) {
            gotoPage( currentPage, true );
        } else {
            gotoPage( 0, true );
        }
    }

    /**
     * Set the {@link FixedWidthGridBulkRenderer} used to render the data table.
     *
     * @param bulkRenderer the table renderer
     */
    public void setBulkRenderer( FixedWidthGridBulkRenderer<RowType> bulkRenderer ) {
        this.bulkRenderer = bulkRenderer;
    }

    /**
     * Enable or disable cross page selection. When enabled, row value selections
     * are maintained across page loads. Selections are remembered by type (not by
     * row index), so row values can move around and still maintain their
     * selection.
     *
     * @param enabled true to enable, false to disable
     */
    public void setCrossPageSelectionEnabled( boolean enabled ) {
        if ( isCrossPageSelectionEnabled != enabled ) {
            this.isCrossPageSelectionEnabled = enabled;

            // Reselected only the rows on this page
            if ( !enabled ) {
                selectedRowValues = new HashSet<RowType>();
                Set<Integer> selectedRows = getDataTable().getSelectedRows();
                for ( Integer selectedRow : selectedRows ) {
                    selectedRowValues.add( getRowValue( selectedRow ) );
                }
            }
        }
    }

    /**
     * Set the {@link Widget} that will be displayed in place of the data table
     * when the data table has no data to display.
     *
     * @param emptyTableWidget the widget to display when the data table is empty
     */
    public void setEmptyTableWidget( Widget emptyTableWidget ) {
        emptyTableWidgetWrapper.setWidget( emptyTableWidget );
    }

    /**
     * Set whether or not the footer table should be automatically generated.
     *
     * @param isGenerated true to enable, false to disable
     */
    public void setFooterGenerated( boolean isGenerated ) {
        this.isFooterGenerated = isGenerated;
        if ( isGenerated ) {
            refreshFooterTable();
        }
    }

    /**
     * Set whether or not the header table should be automatically generated.
     *
     * @param isGenerated true to enable, false to disable
     */
    public void setHeaderGenerated( boolean isGenerated ) {
        this.isHeaderGenerated = isGenerated;
        if ( isGenerated ) {
            refreshHeaderTable();
        }
    }

    /**
     * Set the number of rows per page.
     * <p/>
     * By default, the page size is zero, which indicates that all rows should be
     * shown on the page.
     *
     * @param pageSize the number of rows per page
     */
    public void setPageSize( int pageSize ) {
        pageSize = Math.max( 0, pageSize );
        this.pageSize = pageSize;

        int pageCount = getPageCount();
        if ( pageCount != oldPageCount ) {
            fireEvent( new PageCountChangeEvent( oldPageCount, pageCount ) );
            oldPageCount = pageCount;
        }

        // Reset the page
        if ( currentPage >= 0 ) {
            gotoPage( currentPage, true );
        }
    }

    /**
     * Associate a row in the table with a value.
     *
     * @param row   the row index
     * @param value the value to associate
     */
    public void setRowValue( int row, RowType value ) {
        // Make sure the list can fit the row
        for ( int i = rowValues.size(); i <= row; i++ ) {
            rowValues.add( null );
        }

        // Set the row value
        rowValues.set( row, value );

        // Render the new row value
        refreshRow( row );
    }

    /**
     * Set the {@link TableDefinition} used to define the columns.
     *
     * @param tableDefinition the new table definition.
     */
    public void setTableDefinition( TableDefinition<RowType> tableDefinition ) {
        assert tableDefinition != null : "tableDefinition cannot be null";
        this.tableDefinition = tableDefinition;
    }

    /**
     * Invoke the cell editor on a cell, if one is set. If a cell editor is not
     * specified, this method has no effect.
     */
    protected void editCell( int row, int column ) {
        // Get the cell editor
        final ColumnDefinition colDef = getColumnDefinition( column );
        if ( colDef == null ) {
            return;
        }
        CellEditor cellEditor = colDef.getCellEditor();
        if ( cellEditor == null ) {
            return;
        }

        // Forward the request to the cell editor
        final RowType rowValue = getRowValue( row );
        CellEditInfo editInfo = new CellEditInfo( getDataTable(), row, column );
        cellEditor.editCell( editInfo, colDef.getCellValue( rowValue ), new CellEditor.Callback() {
            public void onCancel( CellEditInfo cellEditInfo ) {
            }

            public void onComplete( CellEditInfo cellEditInfo, Object cellValue ) {
                colDef.setCellValue( rowValue, cellValue );
                if ( tableModel instanceof MutableTableModel ) {
                    int row = getAbsoluteFirstRowIndex() + cellEditInfo.getRowIndex();
                    ((MutableTableModel<RowType>) tableModel).setRowValue( row, rowValue );
                } else {
                    refreshRow( cellEditInfo.getRowIndex() );
                }
            }
        } );
    }

    /**
     * Get the {@link ColumnDefinition} currently associated with a column.
     *
     * @param colIndex the index of the column
     *
     * @return the {@link ColumnDefinition} associated with the column, or null
     */
    protected ColumnDefinition<RowType, ?> getColumnDefinition( int colIndex ) {
        if ( colIndex < visibleColumns.size() ) {
            return visibleColumns.get( colIndex );
        }
        return null;
    }

    /**
     * @return the index of the first visible row
     *
     * @deprecated use {@link #getAbsoluteFirstRowIndex()} instead
     */
    @Deprecated
    protected int getFirstRow() {
        return getAbsoluteFirstRowIndex();
    }

    /**
     * @return the index of the last visible row
     *
     * @deprecated use {@link #getAbsoluteLastRowIndex()} instead
     */
    @Deprecated
    protected int getLastRow() {
        return getAbsoluteLastRowIndex();
    }

    /**
     * Get the list of row values associated with the table.
     *
     * @return the list of row value
     */
    protected List<RowType> getRowValues() {
        return rowValues;
    }

    /**
     * @return the header widget used to select all rows
     */
    protected Widget getSelectAllWidget() {
        if ( selectAllWidget == null ) {
            final CheckBox box = new CheckBox();
            selectAllWidget = box;
            box.addClickHandler( new ClickHandler() {
                public void onClick( ClickEvent event ) {
                    if ( box.getValue() ) {
                        getDataTable().selectAllRows();
                    } else {
                        getDataTable().deselectAllRows();
                    }
                }
            } );
        }
        return selectAllWidget;
    }

    /**
     * @return the list of current visible column definitions
     */
    protected List<ColumnDefinition<RowType, ?>> getVisibleColumnDefinitions() {
        return visibleColumns;
    }

    /**
     * Insert a row into the table relative to the total number of rows.
     *
     * @param beforeRow the row index
     */
    protected void insertAbsoluteRow( int beforeRow ) {
        // Physically insert the row
        int lastRow = getAbsoluteLastRowIndex() + 1;
        if ( beforeRow <= lastRow ) {
            int firstRow = getAbsoluteFirstRowIndex();
            if ( beforeRow >= firstRow ) {
                // Insert row in the middle of the page
                getDataTable().insertRow( beforeRow - firstRow );
            } else {
                // Insert zero row because row is before this page
                getDataTable().insertRow( 0 );
            }
            if ( getDataTable().getRowCount() > pageSize ) {
                getDataTable().removeRow( pageSize );
            }
        }
    }

    /**
     * Called when the data table has finished rendering.
     */
    protected void onDataTableRendered() {
        // Refresh the headers if needed
        if ( headersObsolete ) {
            refreshHeaderTable();
            refreshFooterTable();
            headersObsolete = false;
        }

        // Select rows
        FixedWidthGrid dataTable = getDataTable();
        int rowCount = dataTable.getRowCount();
        for ( int i = 0; i < rowCount; i++ ) {
            if ( selectedRowValues.contains( getRowValue( i ) ) ) {
                dataTable.selectRow( i, false );
            }
        }

        // Update the UI of the table
        dataTable.clearIdealWidths();
        redraw();
        isPageLoading = false;
        fireEvent( new PageLoadEvent( currentPage ) );
    }

    /**
     * Update the footer table based on the new {@link ColumnDefinition}.
     */
    protected void refreshFooterTable() {
        if ( !isFooterGenerated ) {
            return;
        }

        // Generate the list of lists of ColumnHeaderInfo.
        List<List<ColumnHeaderInfo>> allInfos = new ArrayList<List<ColumnHeaderInfo>>();
        int columnCount = visibleColumns.size();
        int footerCounts[] = new int[columnCount];
        int maxFooterCount = 0;
        for ( int col = 0; col < columnCount; col++ ) {
            // Get the header property.
            ColumnDefinition<RowType, ?> colDef = visibleColumns.get( col );
            FooterProperty prop = colDef.getColumnProperty( FooterProperty.TYPE );
            int footerCount = prop.getFooterCount();
            footerCounts[col] = footerCount;
            maxFooterCount = Math.max( maxFooterCount, footerCount );

            // Add each ColumnHeaderInfo
            List<ColumnHeaderInfo> infos = new ArrayList<ColumnHeaderInfo>();
            ColumnHeaderInfo prev = null;
            for ( int row = 0; row < footerCount; row++ ) {
                Object footer = prop.getFooter( row, col );
                if ( prev != null && prev.header.equals( footer ) ) {
                    prev.incrementRowSpan();
                } else {
                    prev = new ColumnHeaderInfo( footer );
                    infos.add( prev );
                }
            }
            allInfos.add( infos );
        }

        // Return early if there is no footer
        if ( maxFooterCount == 0 ) {
            return;
        }

        // Fill in missing rows
        for ( int col = 0; col < columnCount; col++ ) {
            int footerCount = footerCounts[col];
            if ( footerCount < maxFooterCount ) {
                allInfos.get( col ).add( new ColumnHeaderInfo( null, maxFooterCount - footerCount ) );
            }
        }

        // Ensure that we have a footer table
        if ( getFooterTable() == null ) {
            setFooterTable( new FixedWidthFlexTable() );
        }

        // Refresh the table
        refreshHeaderTable( getFooterTable(), allInfos, false );
    }

    /**
     * Update the header table based on the new {@link ColumnDefinition}.
     */
    protected void refreshHeaderTable() {
        if ( !isHeaderGenerated ) {
            return;
        }

        // Generate the list of lists of ColumnHeaderInfo.
        List<List<ColumnHeaderInfo>> allInfos = new ArrayList<List<ColumnHeaderInfo>>();
        int columnCount = visibleColumns.size();
        int headerCounts[] = new int[columnCount];
        int maxHeaderCount = 0;
        for ( int col = 0; col < columnCount; col++ ) {
            // Get the header property.
            ColumnDefinition<RowType, ?> colDef = visibleColumns.get( col );
            HeaderProperty prop = colDef.getColumnProperty( HeaderProperty.TYPE );
            int headerCount = prop.getHeaderCount();
            headerCounts[col] = headerCount;
            maxHeaderCount = Math.max( maxHeaderCount, headerCount );

            // Add each ColumnHeaderInfo
            List<ColumnHeaderInfo> infos = new ArrayList<ColumnHeaderInfo>();
            ColumnHeaderInfo prev = null;
            for ( int row = 0; row < headerCount; row++ ) {
                Object header = prop.getHeader( row, col );
                if ( prev != null && prev.header.equals( header ) ) {
                    prev.incrementRowSpan();
                } else {
                    prev = new ColumnHeaderInfo( header );
                    infos.add( 0, prev );
                }
            }
            allInfos.add( infos );
        }

        // Return early if there is no header
        if ( maxHeaderCount == 0 ) {
            return;
        }

        // Fill in missing rows
        for ( int col = 0; col < columnCount; col++ ) {
            int headerCount = headerCounts[col];
            if ( headerCount < maxHeaderCount ) {
                allInfos.get( col ).add( 0, new ColumnHeaderInfo( null, maxHeaderCount - headerCount ) );
            }
        }

        // Refresh the table
        refreshHeaderTable( getHeaderTable(), allInfos, true );
    }

    /**
     * Refresh the list of the currently visible column definitions based on the
     * {@link TableDefinition}.
     */
    protected void refreshVisibleColumnDefinitions() {
        List<ColumnDefinition<RowType, ?>> colDefs = new ArrayList<ColumnDefinition<RowType, ?>>( tableDefinition.getVisibleColumnDefinitions() );
        if ( !colDefs.equals( visibleColumns ) ) {
            visibleColumns = colDefs;
            headersObsolete = true;
        } else {
            // Check if any of the headers are dynamic
            for ( ColumnDefinition<RowType, ?> colDef : colDefs ) {
                if ( colDef.getColumnProperty( HeaderProperty.TYPE ).isDynamic() || colDef.getColumnProperty( FooterProperty.TYPE ).isDynamic() ) {
                    headersObsolete = true;
                    return;
                }
            }
        }
    }

    /**
     * Remove a row from the table relative to the total number of rows.
     *
     * @param row the row index
     */
    protected void removeAbsoluteRow( int row ) {
        // Physically remove the row if it is in the middle of the data table
        int firstRow = getAbsoluteFirstRowIndex();
        int lastRow = getAbsoluteLastRowIndex();
        if ( row <= lastRow && row >= firstRow ) {
            FixedWidthGrid dataTable = getDataTable();
            int relativeRow = row - firstRow;
            if ( relativeRow < dataTable.getRowCount() ) {
                dataTable.removeRow( relativeRow );
            }
        }
    }

    /**
     * Set a block of data. This method is used when responding to data requests.
     * <p/>
     * This method takes an iterator of iterators, where each iterator represents
     * one row of data starting with the first row.
     *
     * @param firstRow the row index that the rows iterator starts with
     * @param rows     the values associated with each row
     */
    protected void setData( int firstRow, Iterator<RowType> rows ) {
        getDataTable().deselectAllRows();
        rowValues = new ArrayList<RowType>();
        if ( rows != null && rows.hasNext() ) {
            setEmptyTableWidgetVisible( false );

            // Get an iterator over the visible rows
            int firstVisibleRow = getAbsoluteFirstRowIndex();
            int lastVisibleRow = getAbsoluteLastRowIndex();
            Iterator<RowType> visibleIter = new VisibleRowsIterator( rows, firstRow, firstVisibleRow, lastVisibleRow );

            // Set the row values
            while ( visibleIter.hasNext() ) {
                rowValues.add( visibleIter.next() );
            }

            // Copy the visible column definitions
            refreshVisibleColumnDefinitions();

            // Render using the bulk renderer
            if ( bulkRenderer != null ) {
                bulkRenderer.renderRows( rowValues.iterator(), tableRendererCallback );
                return;
            }

            // Get rid of unneeded rows and columns
            int rowCount = rowValues.size();
            int colCount = visibleColumns.size();
            getDataTable().resize( rowCount, colCount );

            // Render the rows
            tableDefinition.renderRows( 0, rowValues.iterator(), rowView );
        } else {
            setEmptyTableWidgetVisible( true );
        }

        // Fire page loaded event
        onDataTableRendered();
    }

    /**
     * Set whether or not the empty table widget is visible.
     *
     * @param visible true to show the empty table widget
     */
    protected void setEmptyTableWidgetVisible( boolean visible ) {
        emptyTableWidgetWrapper.setVisible( visible );
        if ( visible ) {
            getDataWrapper().getStyle().setProperty( "display", "none" );
        } else {
            getDataWrapper().getStyle().setProperty( "display", "" );
        }
    }

    /**
     * Update the header or footer tables based on the new
     * {@link ColumnDefinition}.
     *
     * @param table    the header or footer table
     * @param allInfos the header info
     * @param isHeader false if refreshing the footer table
     */
    private void refreshHeaderTable( FixedWidthFlexTable table, List<List<ColumnHeaderInfo>> allInfos, boolean isHeader ) {
        // Return if we have no column definitions.
        if ( visibleColumns == null ) {
            return;
        }

        // Reset the header table.
        int rowCount = table.getRowCount();
        for ( int i = 0; i < rowCount; i++ ) {
            table.removeRow( 0 );
        }

        // Generate the header table
        int columnCount = allInfos.size();
        FlexCellFormatter formatter = table.getFlexCellFormatter();
        List<ColumnHeaderInfo> prevInfos = null;
        for ( int col = 0; col < columnCount; col++ ) {
            List<ColumnHeaderInfo> infos = allInfos.get( col );
            int row = 0;
            for ( ColumnHeaderInfo info : infos ) {
                // Get the actual row and cell index
                int rowSpan = info.getRowSpan();
                int cell = 0;
                if ( table.getRowCount() > row ) {
                    cell = table.getCellCount( row );
                }

                // Compare to the cell in the previous column
                if ( prevInfos != null ) {
                    boolean headerAdded = false;
                    int prevRow = 0;
                    for ( ColumnHeaderInfo prevInfo : prevInfos ) {
                        // Increase the colSpan of the previous cell
                        if ( prevRow == row && info.equals( prevInfo ) ) {
                            int colSpan = formatter.getColSpan( row, cell - 1 );
                            formatter.setColSpan( row, cell - 1, colSpan + 1 );
                            headerAdded = true;
                            break;
                        }
                        prevRow += prevInfo.getRowSpan();
                    }

                    if ( headerAdded ) {
                        row += rowSpan;
                        continue;
                    }
                }

                // Set the new header
                Object header = info.getHeader();
                if ( header instanceof Widget ) {
                    table.setWidget( row, cell, (Widget) header );
                } else {
                    table.setHTML( row, cell, header.toString() );
                }

                // Update the rowSpan
                if ( rowSpan > 1 ) {
                    formatter.setRowSpan( row, cell, rowSpan );
                }

                // Increment the row
                row += rowSpan;
            }

            // Increment the previous info
            prevInfos = infos;
        }

        // Insert the checkbox column
        SelectionPolicy selectionPolicy = getDataTable().getSelectionPolicy();
        if ( selectionPolicy.hasInputColumn() ) {
            // Get the select all box
            Widget box = null;
            if ( isHeader && getDataTable().getSelectionPolicy() == SelectionPolicy.CHECKBOX ) {
                box = getSelectAllWidget();
            }

            // Add the offset column
            table.insertCell( 0, 0 );
            if ( box != null ) {
                table.setWidget( 0, 0, box );
            } else {
                table.setHTML( 0, 0, HtmlEntity.NBSP );
            }
            formatter.setRowSpan( 0, 0, table.getRowCount() );
            formatter.setHorizontalAlignment( 0, 0, HasHorizontalAlignment.ALIGN_CENTER );
            table.setColumnWidth( 0, getDataTable().getInputColumnWidth() );
        }
    }

    /**
     * Refresh a single row in the table.
     *
     * @param rowIndex the index of the row
     */
    private void refreshRow( int rowIndex ) {
        final RowType rowValue = getRowValue( rowIndex );
        Iterator<RowType> singleIterator = new Iterator<RowType>() {
            private boolean nextCalled = false;

            public boolean hasNext() {
                return !nextCalled;
            }

            public RowType next() {
                if ( !hasNext() ) {
                    throw new NoSuchElementException();
                }
                nextCalled = true;
                return rowValue;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
        tableDefinition.renderRows( rowIndex, singleIterator, rowView );
    }
}