Java tutorial
/* * Copyright 2011 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.user.cellview.client; import com.google.gwt.cell.client.Cell.Context; import com.google.gwt.dom.builder.shared.DivBuilder; import com.google.gwt.dom.builder.shared.ElementBuilderBase; import com.google.gwt.dom.builder.shared.HtmlBuilderFactory; import com.google.gwt.dom.builder.shared.HtmlTableSectionBuilder; import com.google.gwt.dom.builder.shared.StylesBuilder; import com.google.gwt.dom.builder.shared.TableRowBuilder; import com.google.gwt.dom.builder.shared.TableSectionBuilder; import com.google.gwt.dom.client.Document; import com.google.gwt.dom.client.Element; import com.google.gwt.dom.client.Style.Position; import com.google.gwt.dom.client.Style.Unit; import com.google.gwt.dom.client.TableRowElement; import com.google.gwt.i18n.client.LocaleInfo; import com.google.gwt.resources.client.ImageResource; import com.google.gwt.safehtml.shared.SafeHtml; import com.google.gwt.safehtml.shared.SafeHtmlBuilder; import com.google.gwt.safehtml.shared.SafeHtmlUtils; import com.google.gwt.user.client.ui.AbstractImagePrototype; import java.util.HashMap; import java.util.Map; /** * Default implementation of {@link HeaderBuilder} that renders columns. * * @param <T> the data type of the table */ public abstract class AbstractHeaderOrFooterBuilder<T> implements HeaderBuilder<T>, FooterBuilder<T> { /** * A map that provides O(1) access to a value given the key, or to the key * given the value. */ private static class TwoWayHashMap<K, V> { private final Map<K, V> keyToValue = new HashMap<K, V>(); private final Map<V, K> valueToKey = new HashMap<V, K>(); void clear() { keyToValue.clear(); valueToKey.clear(); } K getKey(V value) { return valueToKey.get(value); } V getValue(K key) { return keyToValue.get(key); } void put(K key, V value) { keyToValue.put(key, value); valueToKey.put(value, key); } } /** * The attribute used to indicate that an element contains a Column. */ private static final String COLUMN_ATTRIBUTE = "__gwt_column"; /** * The attribute used to indicate that an element contains a header. */ private static final String HEADER_ATTRIBUTE = "__gwt_header"; /** * The attribute used to specify the row index of a TR element in the header. */ private static final String ROW_ATTRIBUTE = "__gwt_header_row"; private static final int ICON_PADDING = 6; private final boolean isFooter; private boolean isSortIconStartOfLine = true; private final int sortAscIconHalfHeight; private SafeHtml sortAscIconHtml; private final int sortAscIconWidth; private final int sortDescIconHalfHeight; private SafeHtml sortDescIconHtml; private final int sortDescIconWidth; private final AbstractCellTable<T> table; private int rowIndex; // The following fields are reset on every build. private HtmlTableSectionBuilder section; private final Map<String, Column<T, ?>> idToColumnMap = new HashMap<String, Column<T, ?>>(); private final TwoWayHashMap<String, Header<?>> idToHeaderMap = new TwoWayHashMap<String, Header<?>>(); /** * Create a new DefaultHeaderBuilder for the header of footer section. * * @param table the table being built * @param isFooter true if building the footer, false if the header */ public AbstractHeaderOrFooterBuilder(AbstractCellTable<T> table, boolean isFooter) { this.isFooter = isFooter; this.table = table; /* * Cache the height and width of the sort icons. We do not cache the * rendered image source so the compiler can optimize it out if the user * overrides renderHeader and does not use the sort icon. */ ImageResource asc = table.getResources().sortAscending(); ImageResource desc = table.getResources().sortDescending(); if (asc != null) { sortAscIconWidth = asc.getWidth() + ICON_PADDING; sortAscIconHalfHeight = (int) Math.round(asc.getHeight() / 2.0); } else { sortAscIconWidth = 0; sortAscIconHalfHeight = 0; } if (desc != null) { sortDescIconWidth = desc.getWidth() + ICON_PADDING; sortDescIconHalfHeight = (int) Math.round(desc.getHeight() / 2.0); } else { sortDescIconWidth = 0; sortDescIconHalfHeight = 0; } } @Override public final TableSectionBuilder buildFooter() { if (!isFooter) { throw new UnsupportedOperationException( "Cannot build footer because this builder is designated to build a header"); } return buildHeaderOrFooter(); } @Override public final TableSectionBuilder buildHeader() { if (isFooter) { throw new UnsupportedOperationException( "Cannot build header because this builder is designated to build a footer"); } return buildHeaderOrFooter(); } @Override public Column<T, ?> getColumn(Element elem) { String cellId = getColumnId(elem); return (cellId == null) ? null : idToColumnMap.get(cellId); } @Override public Header<?> getHeader(Element elem) { String headerId = getHeaderId(elem); return (headerId == null) ? null : idToHeaderMap.getValue(headerId); } @Override public int getRowIndex(TableRowElement row) { return Integer.parseInt(row.getAttribute(ROW_ATTRIBUTE)); } /** * Check if this builder is building a header or footer table. * * @return true if a footer, false if a header */ public boolean isBuildingFooter() { return isFooter; } @Override public boolean isColumn(Element elem) { return getColumnId(elem) != null; } @Override public boolean isHeader(Element elem) { return getHeaderId(elem) != null; } /** * Check if the icon is located at the start or end of the line. The start of * the line refers to the left side in LTR mode and the right side in RTL * mode. The default location is the start of the line. */ public boolean isSortIconStartOfLine() { return isSortIconStartOfLine; } /** * Set the position of the sort icon to the start or end of the line. The * start of the line refers to the left side in LTR mode and the right side in * RTL mode. The default location is the start of the line. */ public void setSortIconStartOfLine(boolean isStartOfLine) { this.isSortIconStartOfLine = isStartOfLine; } /** * Implementation that builds the header or footer using the convenience * methods in this class. * * @return true if the header contains content, false if empty */ protected abstract boolean buildHeaderOrFooterImpl(); /** * Enables column-specific event handling for the specified element. If a * column is sortable, then clicking on the element or a child of the element * will trigger a sort event. * * @param builder the builder to associate with the column. The builder should * be a child element of a row returned by {@link #startRow} and must * be in a state where an attribute can be added. * @param column the column to associate */ protected final void enableColumnHandlers(ElementBuilderBase<?> builder, Column<T, ?> column) { String columnId = "column-" + Document.get().createUniqueId(); idToColumnMap.put(columnId, column); builder.attribute(COLUMN_ATTRIBUTE, columnId); } /** * Get the header or footer at the specified index. * * @param index the column index of the header * @return the header or footer, depending on the value of isFooter */ protected final Header<?> getHeader(int index) { return isFooter ? getTable().getFooter(index) : getTable().getHeader(index); } protected AbstractCellTable<T> getTable() { return table; } /** * Renders a given Header into a given ElementBuilderBase. This method ensures * that the CellTable widget will handle events events originating in the * Header. * * @param <H> the data type of the header * @param out the {@link ElementBuilderBase} to render into. The builder * should be a child element of a row returned by {@link #startRow} * and must be in a state that allows both attributes and elements to * be added * @param context the {@link Context} of the header being rendered * @param header the {@link Header} to render */ protected final <H> void renderHeader(ElementBuilderBase<?> out, Context context, Header<H> header) { // Generate a unique ID for the header. String headerId = idToHeaderMap.getKey(header); if (headerId == null) { headerId = "header-" + Document.get().createUniqueId(); idToHeaderMap.put(headerId, header); } out.attribute(HEADER_ATTRIBUTE, headerId); // Render the cell into the builder. SafeHtmlBuilder sb = new SafeHtmlBuilder(); header.render(context, sb); out.html(sb.toSafeHtml()); } /** * Render a header, including a sort icon if the column is sortable and * sorted. * * @param out the builder to render into * @param header the header to render * @param context the context of the header * @param isSorted true if the column is sorted * @param isSortAscending indicated the sort order, if sorted */ protected final void renderSortableHeader(ElementBuilderBase<?> out, Context context, Header<?> header, boolean isSorted, boolean isSortAscending) { ElementBuilderBase<?> headerContainer = out; // Wrap the header in a sort icon if sorted. isSorted = isSorted && !isFooter; if (isSorted) { // Determine the position of the sort icon. boolean posRight = LocaleInfo.getCurrentLocale().isRTL() ? isSortIconStartOfLine : !isSortIconStartOfLine; // Create an outer container to hold the icon and the header. int iconWidth = isSortAscending ? sortAscIconWidth : sortDescIconWidth; int halfHeight = isSortAscending ? sortAscIconHalfHeight : sortDescIconHalfHeight; DivBuilder outerDiv = out.startDiv(); StylesBuilder style = outerDiv.style().position(Position.RELATIVE).trustedProperty("zoom", "1"); if (posRight) { style.paddingRight(iconWidth, Unit.PX); } else { style.paddingLeft(iconWidth, Unit.PX); } style.endStyle(); // Add the icon. DivBuilder imageHolder = outerDiv.startDiv(); style = outerDiv.style().position(Position.ABSOLUTE).top(50.0, Unit.PCT).lineHeight(0.0, Unit.PX) .marginTop(-halfHeight, Unit.PX); if (posRight) { style.right(0, Unit.PX); } else { style.left(0, Unit.PX); } style.endStyle(); imageHolder.html(getSortIcon(isSortAscending)); imageHolder.endDiv(); // Create the header wrapper. headerContainer = outerDiv.startDiv(); } // Build the header. renderHeader(headerContainer, context, header); // Close the elements used for the sort icon. if (isSorted) { headerContainer.endDiv(); // headerContainer. headerContainer.endDiv(); // outerDiv } } /** * Add a header (or footer) row to the table, below any rows previously added. * * @return the row to add */ protected final TableRowBuilder startRow() { // End any dangling rows. while (section.getDepth() > 1) { section.end(); } // Verify the depth. if (section.getDepth() < 1) { throw new IllegalStateException( "Cannot start a row. Did you call TableRowBuilder.end() too many times?"); } // Start the next row. TableRowBuilder row = section.startTR(); row.attribute(ROW_ATTRIBUTE, rowIndex); rowIndex++; return row; } private TableSectionBuilder buildHeaderOrFooter() { // Reset the state of the header. section = isFooter ? HtmlBuilderFactory.get().createTFootBuilder() : HtmlBuilderFactory.get().createTHeadBuilder(); idToHeaderMap.clear(); idToColumnMap.clear(); rowIndex = 0; // Build the header. if (!buildHeaderOrFooterImpl()) { // The header is empty. return null; } // End dangling elements. while (section.getDepth() > 0) { section.end(); } // Return the section. return section; } /** * Check if an element is the parent of a rendered header. * * @param elem the element to check * @return the id if a header parent, null if not */ private String getColumnId(Element elem) { return getElementAttribute(elem, COLUMN_ATTRIBUTE); } private String getElementAttribute(Element elem, String attribute) { if (elem == null) { return null; } String value = elem.getAttribute(attribute); return (value == null) || (value.length() == 0) ? null : value; } /** * Check if an element is the parent of a rendered header. * * @param elem the element to check * @return the id if a header parent, null if not */ private String getHeaderId(Element elem) { return getElementAttribute(elem, HEADER_ATTRIBUTE); } /** * Get the HTML representation of the sort icon. These are loaded lazily so * the compiler has a chance to strip this method, and the icon source code, * if the user overrides renderHeader. * * @param isAscending true for the ascending icon, false for descending * @return the rendered HTML */ private SafeHtml getSortIcon(boolean isAscending) { if (isAscending) { if (sortAscIconHtml == null) { AbstractImagePrototype proto = AbstractImagePrototype.create(table.getResources().sortAscending()); sortAscIconHtml = SafeHtmlUtils.fromTrustedString(proto.getHTML()); } return sortAscIconHtml; } else { if (sortDescIconHtml == null) { AbstractImagePrototype proto = AbstractImagePrototype.create(table.getResources().sortDescending()); sortDescIconHtml = SafeHtmlUtils.fromTrustedString(proto.getHTML()); } return sortDescIconHtml; } } }