WIP Rework Data Pager

MaterialDataPager.java

/*
 * #%L
 * GwtMaterial
 * %%
 * Copyright (C) 2015 - 2016 GwtMaterialDesign
 * %%
 * 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.
 * #L%
 */
package gwt.material.design.client.ui.pager;

import com.google.gwt.core.client.GWT;
import gwt.material.design.client.data.DataSource;
import gwt.material.design.client.data.SortContext;
import gwt.material.design.client.data.component.CategoryComponent;
import gwt.material.design.client.data.loader.LoadCallback;
import gwt.material.design.client.data.loader.LoadConfig;
import gwt.material.design.client.data.loader.LoadResult;
import gwt.material.design.client.ui.table.MaterialDataTable;

import java.util.List;

/**
 * Material Data Pager - a simple pager for Material Data Table component
 *
 * @author kevzlou7979
 */
public class MaterialDataPager<T> extends MaterialDataPagerBase<T> implements HasPager {

    private MaterialDataTable<T> table;
    private DataSource<T> dataSource;
    private int offset = 1;
    private int limit = 5;
    private int[] limitOptions = new int[]{5, 10, 15};

    public MaterialDataPager(MaterialDataTable<T> table, DataSource<T> dataSource) {
        super();
        this.table = table;
        this.dataSource = dataSource;
    }

    @Override
    protected void onLoad() {
        super.onLoad();
        initialize();
    }

    protected void initialize() {
        firstPage();
        GWT.log(table.getTotalRows() + " Total Rows");
        iconNext.addClickHandler(event -> {
            next();
        });
        iconPrev.addClickHandler(event -> {
            previous();
        });

        // Build the page number listbox
        for (int i = 1; i <= table.getTotalRows() / limit; i++) {
            listPages.addItem(i);
        }
        listPages.addValueChangeHandler(event -> {
            gotoPage(event.getValue());
        });

        // Build the limit options listbox
        for (int i = 0; i < limitOptions.length; i++) {
            listLimitOptions.addItem(limitOptions[i]);
        }
        listLimitOptions.addValueChangeHandler(valueChangeEvent -> {
            limit = valueChangeEvent.getValue();
            gotoPage(listPages.getValue());
        });
    }

    @Override
    public void next() {
        doLoad(offset + limit, limit);
    }

    @Override
    public void previous() {
        doLoad(offset - limit, limit);
    }

    @Override
    public void lastPage() {
        //TODO Validation
        doLoad(offset - table.getTotalRows(), limit);
    }

    @Override
    public void firstPage() {
        //TODO Validation
        doLoad(1, limit);
    }

    @Override
    public void gotoPage(int page) {
        // TODO Validation and sync
        doLoad((page * limit) - limit + 1, limit);
    }

    @Override
    public void setLimit(int limit) {
        this.limit = limit;
    }

    protected void doLoad(int offset, int limit) {
        this.offset = offset;
        dataSource.load(new LoadConfig<T>() {
            @Override
            public int getOffset() {
                return offset;
            }

            @Override
            public int getLimit() {
                return limit;
            }

            @Override
            public SortContext<T> getSortContext() {
                return table.getSortContext();
            }

            @Override
            public List<CategoryComponent> getOpenCategories() {
                return table.getOpenCategories();
            }
        }, new LoadCallback<T>() {
            @Override
            public void onSuccess(LoadResult<T> loadResult) {
                table.setVisibleRange(offset, limit);
                table.loaded(loadResult.getOffset(), loadResult.getData());
            }

            @Override
            public void onFailure(Throwable caught) {
                GWT.log("Load failure", caught);
                //TODO: What we need to do on failure? May be clear table?
            }
        });
    }
}