com.google.gwt.user.client.ui.FlexTable Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of vaadin-client Show documentation
Show all versions of vaadin-client Show documentation
Vaadin is a web application framework for Rich Internet Applications (RIA).
Vaadin enables easy development and maintenance of fast and
secure rich web
applications with a stunning look and feel and a wide browser support.
It features a server-side architecture with the majority of the logic
running
on the server. Ajax technology is used at the browser-side to ensure a
rich
and interactive user experience.
/*
* Copyright 2007 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.client.ui;
/**
* A flexible table that creates cells on demand. It can be jagged (that is,
* each row can contain a different number of cells) and individual cells can be
* set to span multiple rows or columns.
*
* 
*
*
*
Example
* {@example com.google.gwt.examples.FlexTableExample}
*
*/
public class FlexTable extends HTMLTable {
/**
* FlexTable-specific implementation of {@link HTMLTable.CellFormatter}. The
* formatter retrieved from {@link HTMLTable#getCellFormatter()} may be cast
* to this class.
*/
public class FlexCellFormatter extends CellFormatter {
/**
* Gets the column span for the given cell. This is the number of logical
* columns covered by the cell.
*
* @param row the cell's row
* @param column the cell's column
* @return the cell's column span
* @throws IndexOutOfBoundsException
*/
public int getColSpan(int row, int column) {
return getElement(row, column).getPropertyInt("colSpan");
}
/**
* Gets the row span for the given cell. This is the number of logical rows
* covered by the cell.
*
* @param row the cell's row
* @param column the cell's column
* @return the cell's row span
* @throws IndexOutOfBoundsException
*/
public int getRowSpan(int row, int column) {
return getElement(row, column).getPropertyInt("rowSpan");
}
/**
* Sets the column span for the given cell. This is the number of logical
* columns covered by the cell.
*
* @param row the cell's row
* @param column the cell's column
* @param colSpan the cell's column span
* @throws IndexOutOfBoundsException
*/
public void setColSpan(int row, int column, int colSpan) {
ensureElement(row, column).setPropertyInt("colSpan", colSpan);
}
/**
* Sets the row span for the given cell. This is the number of logical rows
* covered by the cell.
*
* @param row the cell's row
* @param column the cell's column
* @param rowSpan the cell's row span
* @throws IndexOutOfBoundsException
*/
public void setRowSpan(int row, int column, int rowSpan) {
ensureElement(row, column).setPropertyInt("rowSpan", rowSpan);
}
}
public FlexTable() {
super();
setCellFormatter(new FlexCellFormatter());
setRowFormatter(new RowFormatter());
setColumnFormatter(new ColumnFormatter());
}
/**
* Appends a cell to the specified row.
*
* @param row the row to which the new cell will be added
* @throws IndexOutOfBoundsException
*/
public void addCell(int row) {
insertCell(row, getCellCount(row));
}
/**
* Gets the number of cells on a given row.
*
* @param row the row whose cells are to be counted
* @return the number of cells present
* @throws IndexOutOfBoundsException
*/
@Override
public int getCellCount(int row) {
checkRowBounds(row);
return getDOMCellCount(getBodyElement(), row);
}
/**
* Explicitly gets the {@link FlexCellFormatter}. The results of
* {@link HTMLTable#getCellFormatter()} may also be downcast to a
* {@link FlexCellFormatter}.
*
* @return the FlexTable's cell formatter
*/
public FlexCellFormatter getFlexCellFormatter() {
return (FlexCellFormatter) getCellFormatter();
}
/**
* Gets the number of rows.
*
* @return number of rows
*/
@Override
public int getRowCount() {
return getDOMRowCount();
}
/**
* Inserts a cell into the FlexTable.
*
* @param beforeRow the cell's row
* @param beforeColumn the cell's column
*/
@Override
public void insertCell(int beforeRow, int beforeColumn) {
super.insertCell(beforeRow, beforeColumn);
}
/**
* Inserts a row into the FlexTable.
*
* @param beforeRow the row to insert
*/
@Override
public int insertRow(int beforeRow) {
return super.insertRow(beforeRow);
}
/**
* Remove all rows in this table.
*/
public void removeAllRows() {
int numRows = getRowCount();
for (int i = 0; i < numRows; i++) {
removeRow(0);
}
}
@Override
public void removeCell(int row, int col) {
super.removeCell(row, col);
}
/**
* Removes a number of cells from a row in the table.
*
* @param row the row of the cells to be removed
* @param column the column of the first cell to be removed
* @param num the number of cells to be removed
* @throws IndexOutOfBoundsException
*/
public void removeCells(int row, int column, int num) {
for (int i = 0; i < num; i++) {
removeCell(row, column);
}
}
@Override
public void removeRow(int row) {
super.removeRow(row);
}
/**
* Ensure that the cell exists.
*
* @param row the row to prepare.
* @param column the column to prepare.
* @throws IndexOutOfBoundsException if the row is negative
*/
@Override
protected void prepareCell(int row, int column) {
prepareRow(row);
if (column < 0) {
throw new IndexOutOfBoundsException(
"Cannot create a column with a negative index: " + column);
}
// Ensure that the requested column exists.
int cellCount = getCellCount(row);
int required = column + 1 - cellCount;
if (required > 0) {
addCells(getBodyElement(), row, required);
}
}
/**
* Ensure that the row exists.
*
* @param row The row to prepare.
* @throws IndexOutOfBoundsException if the row is negative
*/
@Override
protected void prepareRow(int row) {
if (row < 0) {
throw new IndexOutOfBoundsException(
"Cannot create a row with a negative index: " + row);
}
// Ensure that the requested row exists.
int rowCount = getRowCount();
for (int i = rowCount; i <= row; i++) {
insertRow(i);
}
}
}