Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.apache.wicket.extensions.markup.html.repeater.data.table; import java.util.List; import org.apache.wicket.AttributeModifier; import org.apache.wicket.Component; import org.apache.wicket.behavior.Behavior; import org.apache.wicket.extensions.markup.html.repeater.data.grid.DataGridView; import org.apache.wicket.markup.ComponentTag; import org.apache.wicket.markup.html.WebMarkupContainer; import org.apache.wicket.markup.html.basic.Label; import org.apache.wicket.markup.html.navigation.paging.IPageableItems; import org.apache.wicket.markup.html.panel.Panel; import org.apache.wicket.markup.repeater.IItemReuseStrategy; import org.apache.wicket.markup.repeater.Item; import org.apache.wicket.markup.repeater.RefreshingView; import org.apache.wicket.markup.repeater.RepeatingView; import org.apache.wicket.markup.repeater.data.IDataProvider; import org.apache.wicket.model.IModel; import org.apache.wicket.util.lang.Args; import org.apache.wicket.util.string.Strings; import org.apache.wicket.util.visit.IVisit; import org.apache.wicket.util.visit.IVisitor; /** * A data table builds on data grid view to introduce toolbars. Toolbars can be used to display * sortable column headers, paging information, filter controls, and other information. * <p> * Data table also provides its own markup for an html table so the user does not need to provide it * himself. This makes it very simple to add a datatable to the markup, however, some flexibility. * <p> * Example * * <pre> * <table wicket:id="datatable"></table> * </pre> * * And the related Java code: ( the first column will be sortable because its sort property is * specified, the second column will not ) * * <pre> * List<IColumn<T>> columns = new ArrayList<IColumn<T>>(); * * columns.add(new PropertyColumn(new Model<String>("First Name"), "name.first", "name.first")); * columns.add(new PropertyColumn(new Model<String>("Last Name"), "name.last")); * * DataTable table = new DataTable("datatable", columns, new UserProvider(), 10); * table.addBottomToolbar(new NavigationToolbar(table)); * table.addTopToolbar(new HeadersToolbar(table, null)); * add(table); * </pre> * * @see DefaultDataTable * * @author Igor Vaynberg (ivaynberg) * * @param <T> * The model object type * @param <S> * the type of the sorting parameter * */ public class DataTable<T, S> extends Panel implements IPageableItems { static abstract class CssAttributeBehavior extends Behavior { private static final long serialVersionUID = 1L; protected abstract String getCssClass(); /** * @see Behavior#onComponentTag(Component, ComponentTag) */ @Override public void onComponentTag(final Component component, final ComponentTag tag) { String className = getCssClass(); if (!Strings.isEmpty(className)) { tag.append("class", className, " "); } } } private static final long serialVersionUID = 1L; private final DataGridView<T> datagrid; private final WebMarkupContainer body; private final List<? extends IColumn<T, S>> columns; private final ToolbarsContainer topToolbars; private final ToolbarsContainer bottomToolbars; private final Caption caption; private final ColGroup colGroup; private long toolbarIdCounter; /** * Constructor * * @param id * component id * @param columns * list of IColumn objects * @param dataProvider * imodel for data provider * @param rowsPerPage * number of rows per page */ public DataTable(final String id, final List<? extends IColumn<T, S>> columns, final IDataProvider<T> dataProvider, final long rowsPerPage) { super(id); Args.notNull(columns, "columns"); this.columns = columns; this.caption = new Caption("caption", getCaptionModel()); add(caption); this.colGroup = new ColGroup("colGroup"); add(colGroup); body = newBodyContainer("body"); datagrid = newDataGridView("rows", columns, dataProvider); datagrid.setItemsPerPage(rowsPerPage); body.add(datagrid); add(body); topToolbars = new ToolbarsContainer("topToolbars"); bottomToolbars = new ToolbarsContainer("bottomToolbars"); add(topToolbars); add(bottomToolbars); } /** * Factory method for the DataGridView * * @param id * The component id * @param columns * list of IColumn objects * @param dataProvider * imodel for data provider * @return the data grid view */ protected DataGridView<T> newDataGridView(String id, List<? extends IColumn<T, S>> columns, IDataProvider<T> dataProvider) { return new DefaultDataGridView(id, columns, dataProvider); } /** * Returns the model for table's caption. The caption wont be rendered if the model has empty * value. * * @return the model for table's caption */ protected IModel<String> getCaptionModel() { return null; } public final ColGroup getColGroup() { return colGroup; } /** * Create the MarkupContainer for the <tbody> tag. Users may subclass it to provide their own * (modified) implementation. * * @param id * @return A new markup container */ protected WebMarkupContainer newBodyContainer(final String id) { return new WebMarkupContainer(id); } /** * Set the 'class' attribute for the tbody tag. * * @param cssStyle */ public final void setTableBodyCss(final String cssStyle) { body.add(AttributeModifier.replace("class", cssStyle)); } /** * Adds a toolbar to the datatable that will be displayed after the data * * @param toolbar * toolbar to be added * * @see AbstractToolbar */ public void addBottomToolbar(final AbstractToolbar toolbar) { addToolbar(toolbar, bottomToolbars); } /** * Adds a toolbar to the datatable that will be displayed before the data * * @param toolbar * toolbar to be added * * @see AbstractToolbar */ public void addTopToolbar(final AbstractToolbar toolbar) { addToolbar(toolbar, topToolbars); } /** * @return the container with the toolbars at the top */ public final ToolbarsContainer getTopToolbars() { return topToolbars; } /** * @return the container with the toolbars at the bottom */ public final ToolbarsContainer getBottomToolbars() { return bottomToolbars; } /** * @return the container used for the table body */ public final WebMarkupContainer getBody() { return body; } /** * @return the component used for the table caption */ public final Caption getCaption() { return caption; } /** * @return dataprovider */ public final IDataProvider<T> getDataProvider() { return datagrid.getDataProvider(); } /** * @return array of column objects this table displays */ public final List<? extends IColumn<T, S>> getColumns() { return columns; } /** * @see org.apache.wicket.markup.html.navigation.paging.IPageable#getCurrentPage() */ @Override public final long getCurrentPage() { return datagrid.getCurrentPage(); } /** * @see org.apache.wicket.markup.html.navigation.paging.IPageable#getPageCount() */ @Override public final long getPageCount() { return datagrid.getPageCount(); } /** * @return total number of rows in this table */ public final long getRowCount() { return datagrid.getRowCount(); } /** * @return number of rows per page */ @Override public final long getItemsPerPage() { return datagrid.getItemsPerPage(); } /** * @see org.apache.wicket.markup.html.navigation.paging.IPageable#setCurrentPage(long) */ @Override public final void setCurrentPage(final long page) { datagrid.setCurrentPage(page); onPageChanged(); } /** * Sets the item reuse strategy. This strategy controls the creation of {@link Item}s. * * @see RefreshingView#setItemReuseStrategy(IItemReuseStrategy) * @see IItemReuseStrategy * * @param strategy * item reuse strategy * @return this for chaining */ public final DataTable<T, S> setItemReuseStrategy(final IItemReuseStrategy strategy) { datagrid.setItemReuseStrategy(strategy); return this; } /** * Sets the number of items to be displayed per page * * @param items * number of items to display per page * */ public void setItemsPerPage(final long items) { datagrid.setItemsPerPage(items); } /** * @see org.apache.wicket.markup.html.navigation.paging.IPageableItems#getItemCount() */ @Override public long getItemCount() { return datagrid.getItemCount(); } private void addToolbar(final AbstractToolbar toolbar, final ToolbarsContainer container) { Args.notNull(toolbar, "toolbar"); container.getRepeatingView().add(toolbar); } /** * Factory method for Item container that represents a cell in the underlying DataGridView * * @see Item * * @param id * component id for the new data item * @param index * the index of the new data item * @param model * the model for the new data item * * @return DataItem created DataItem */ protected Item<IColumn<T, S>> newCellItem(final String id, final int index, final IModel<IColumn<T, S>> model) { return new Item<>(id, index, model); } /** * Factory method for Item container that represents a row in the underlying DataGridView * * @see Item * * @param id * component id for the new data item * @param index * the index of the new data item * @param model * the model for the new data item. * * @return DataItem created DataItem */ protected Item<T> newRowItem(final String id, final int index, final IModel<T> model) { return new Item<>(id, index, model); } /** * @see org.apache.wicket.Component#onDetach() */ @Override protected void onDetach() { super.onDetach(); for (IColumn<T, S> column : columns) { column.detach(); } } /** * Event listener for page-changed event */ protected void onPageChanged() { // noop } /** * @see AbstractToolbar */ String newToolbarId() { toolbarIdCounter++; return String.valueOf(toolbarIdCounter).intern(); } @Override protected void onComponentTag(ComponentTag tag) { checkComponentTag(tag, "table"); super.onComponentTag(tag); } /** * This class acts as a repeater that will contain the toolbar. It makes sure that the table row * group (e.g. thead) tags are only visible when they contain rows in accordance with the HTML * specification. * * @author igor.vaynberg */ private static class ToolbarsContainer extends WebMarkupContainer { private static final long serialVersionUID = 1L; private final RepeatingView toolbars; /** * Constructor * * @param id */ private ToolbarsContainer(final String id) { super(id); toolbars = new RepeatingView("toolbars"); add(toolbars); } public RepeatingView getRepeatingView() { return toolbars; } @Override public void onConfigure() { super.onConfigure(); toolbars.configure(); Boolean visible = toolbars.visitChildren(new IVisitor<Component, Boolean>() { @Override public void component(Component object, IVisit<Boolean> visit) { object.configure(); if (object.isVisible()) { visit.stop(Boolean.TRUE); } else { visit.dontGoDeeper(); } } }); if (visible == null) { visible = false; } setVisible(visible); } } /** * A caption for the table. It renders itself only if {@link DataTable#getCaptionModel()} has * non-empty value. */ public static class Caption extends Label { /** */ private static final long serialVersionUID = 1L; /** * Construct. * * @param id * the component id * @param model * the caption model */ public Caption(String id, IModel<String> model) { super(id, model); } @Override protected void onConfigure() { setRenderBodyOnly(Strings.isEmpty(getDefaultModelObjectAsString())); super.onConfigure(); } @Override protected IModel<String> initModel() { // don't try to find the model in the parent return null; } } private class DefaultDataGridView extends DataGridView<T> { public DefaultDataGridView(String id, List<? extends IColumn<T, S>> columns, IDataProvider<T> dataProvider) { super(id, columns, dataProvider); } @SuppressWarnings({ "rawtypes", "unchecked" }) @Override protected Item newCellItem(final String id, final int index, final IModel model) { Item item = DataTable.this.newCellItem(id, index, model); final IColumn<T, S> column = DataTable.this.columns.get(index); if (column instanceof IStyledColumn) { item.add(new CssAttributeBehavior() { private static final long serialVersionUID = 1L; @Override protected String getCssClass() { return ((IStyledColumn<T, S>) column).getCssClass(); } }); } return item; } @Override protected Item<T> newRowItem(final String id, final int index, final IModel<T> model) { return DataTable.this.newRowItem(id, index, model); } } }