org.kie.workbench.common.widgets.client.tables.AbstractPathPagedTable.java Source code

Java tutorial

Introduction

Here is the source code for org.kie.workbench.common.widgets.client.tables.AbstractPathPagedTable.java

Source

/*
 * Copyright 2011 Red Hat, Inc. and/or its affiliates.
 * 
 * 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 org.kie.workbench.common.widgets.client.tables;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;

import com.google.gwt.cell.client.CheckboxCell;
import com.google.gwt.cell.client.FieldUpdater;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.cellview.client.Column;
import com.google.gwt.user.cellview.client.TextColumn;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.view.client.AsyncDataProvider;
import com.google.gwt.view.client.MultiSelectionModel;
import com.google.gwt.view.client.ProvidesKey;
import org.gwtbootstrap3.client.ui.Button;
import org.gwtbootstrap3.client.ui.constants.ButtonSize;
import org.gwtbootstrap3.client.ui.constants.IconType;
import org.gwtbootstrap3.client.ui.gwt.ButtonCell;
import org.jboss.errai.ioc.client.container.IOC;
import org.uberfire.backend.vfs.Path;
import org.uberfire.client.mvp.PlaceManager;
import org.uberfire.ext.widgets.common.client.resources.i18n.CommonConstants;
import org.uberfire.ext.widgets.common.client.tables.PagedTable;
import org.uberfire.paging.AbstractPathPageRow;

/**
 * Widget that shows rows of paged data where columns "uuid", "name" and
 * "format" are common. A "checkbox" and "open" button column are added by
 * default. Additional columns can be inserted inbetween these columns by
 * overriding <code>addAncillaryColumns()</code>. A "RSS Feed" button can also
 * be included if required.
 * <p/>
 * Based upon work by Geoffrey de Smet.
 */
public abstract class AbstractPathPagedTable<T extends AbstractPathPageRow> extends Composite {

    protected MultiSelectionModel<T> selectionModel;

    protected final PagedTable dataGrid;

    private final ProvidesKey<T> providesKey = new ProvidesKey<T>() {
        public Object getKey(T row) {
            return row.getPath();
        }
    };

    public AbstractPathPagedTable(final int pageSize) {
        dataGrid = new PagedTable(pageSize, providesKey);
        selectionModel = new MultiSelectionModel<T>(providesKey);
        dataGrid.setSelectionModel(selectionModel);

        Column<T, Boolean> selectionColumn = new Column<T, Boolean>(new CheckboxCell(true, true)) {
            @Override
            public Boolean getValue(T object) {
                return dataGrid.getSelectionModel().isSelected(object);
            }
        };
        selectionColumn.setFieldUpdater(new FieldUpdater<T, Boolean>() {
            public void update(int index, T object, Boolean value) {
                dataGrid.getSelectionModel().setSelected(object, value);
            }
        });
        dataGrid.addColumn(selectionColumn, "");

        addAncillaryColumns();

        final TextColumn<T> uriColumn = new TextColumn<T>() {
            public String getValue(T row) {
                return row.getPath().toURI();
            }
        };
        dataGrid.addColumn(uriColumn, CommonConstants.INSTANCE.AbstractTableFileURI(), false);

        // Add "Open" button column
        Column<T, String> openColumn = new Column<T, String>(new ButtonCell(ButtonSize.SMALL)) {
            public String getValue(T row) {
                return CommonConstants.INSTANCE.AbstractTableOpen();
            }
        };
        openColumn.setFieldUpdater(new FieldUpdater<T, String>() {
            public void update(int index, T row, String value) {
                getPlaceManager().goTo(row.getPath());
            }
        });
        dataGrid.addColumn(openColumn, CommonConstants.INSTANCE.AbstractTableOpen());

        final Button refreshButton = new Button();
        refreshButton.setIcon(IconType.REFRESH);
        refreshButton.setTitle(CommonConstants.INSTANCE.Refresh());
        refreshButton.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                dataGrid.refresh();
            }
        });
        dataGrid.getToolbar().add(refreshButton);

        final Button openSelectedButton = new Button(CommonConstants.INSTANCE.AbstractTableOpenSelected());
        openSelectedButton.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                final Set<T> selectedSet = selectionModel.getSelectedSet();
                for (T selected : selectedSet) {
                    getPlaceManager().goTo(selected.getPath());
                }
            }
        });
        dataGrid.getToolbar().add(openSelectedButton);

        initWidget(dataGrid);
    }

    protected abstract void addAncillaryColumns();

    /**
     * Return an array of selected Paths. API is maintained for backwards
     * compatibility of legacy code with AssetItemGrid's implementation
     * @return
     */
    public Collection<Path> getSelectedRowPaths() {
        Set<T> selectedRows = selectionModel.getSelectedSet();

        // Compatibility with existing API
        if (selectedRows.size() == 0) {
            return null;
        }

        // Create the array of Paths
        final Collection<Path> paths = new ArrayList<Path>(selectedRows.size());
        for (T row : selectedRows) {
            paths.add(row.getPath());
        }

        return paths;
    }

    /**
     * Refresh table programmatically
     */
    public void refresh() {
        selectionModel.clear();
        dataGrid.setVisibleRangeAndClearData(dataGrid.getVisibleRange(), true);
    }

    /**
     * Link a data provider to the table
     * @param dataProvider
     */
    public void setDataProvider(final AsyncDataProvider<T> dataProvider) {
        dataProvider.addDataDisplay(dataGrid);
    }

    private PlaceManager getPlaceManager() {
        return IOC.getBeanManager().lookupBean(PlaceManager.class).getInstance();
    }
}