/*******************************************************************************
* Copyright (c) 2012, 2013, 2014 Original authors and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Original authors and others - initial API and implementation
* neal zhang <nujiah001@126.com> - Bug 448934
******************************************************************************/
package org.eclipse.nebula.widgets.nattable.layer;
import java.util.Collection;
import java.util.Properties;
import org.eclipse.nebula.widgets.nattable.NatTable;
import org.eclipse.nebula.widgets.nattable.command.ILayerCommand;
import org.eclipse.nebula.widgets.nattable.command.StructuralRefreshCommand;
import org.eclipse.nebula.widgets.nattable.command.StructuralRefreshCommandHandler;
import org.eclipse.nebula.widgets.nattable.command.VisualRefreshCommandHandler;
import org.eclipse.nebula.widgets.nattable.coordinate.Range;
import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
import org.eclipse.nebula.widgets.nattable.edit.command.UpdateDataCommandHandler;
import org.eclipse.nebula.widgets.nattable.grid.command.ClientAreaResizeCommand;
import org.eclipse.nebula.widgets.nattable.layer.event.ResizeStructuralRefreshEvent;
import org.eclipse.nebula.widgets.nattable.layer.event.StructuralRefreshEvent;
import org.eclipse.nebula.widgets.nattable.persistence.IPersistable;
import org.eclipse.nebula.widgets.nattable.resize.command.ColumnResizeCommandHandler;
import org.eclipse.nebula.widgets.nattable.resize.command.MultiColumnResizeCommandHandler;
import org.eclipse.nebula.widgets.nattable.resize.command.MultiRowResizeCommandHandler;
import org.eclipse.nebula.widgets.nattable.resize.command.RowResizeCommandHandler;
import org.eclipse.nebula.widgets.nattable.resize.event.ColumnResizeEvent;
import org.eclipse.nebula.widgets.nattable.resize.event.RowResizeEvent;
/**
* Wraps the {@link IDataProvider}, and serves as the data source for all other
* layers. Also, tracks the size of the columns and the rows using
* {@link SizeConfig} objects. Since this layer sits directly on top of the data
* source, at this layer index == position.
*/
public class DataLayer extends AbstractLayer implements IUniqueIndexLayer {
public static final String PERSISTENCE_KEY_ROW_HEIGHT = ".rowHeight"; //$NON-NLS-1$
public static final String PERSISTENCE_KEY_COLUMN_WIDTH = ".columnWidth"; //$NON-NLS-1$
public static final int DEFAULT_COLUMN_WIDTH = 100;
public static final int DEFAULT_ROW_HEIGHT = 20;
protected IDataProvider dataProvider;
protected SizeConfig columnWidthConfig;
protected SizeConfig rowHeightConfig;
public DataLayer(IDataProvider dataProvider) {
this(dataProvider, DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT);
}
public DataLayer(IDataProvider dataProvider, int defaultColumnWidth,
int defaultRowHeight) {
this(defaultColumnWidth, defaultRowHeight);
setDataProvider(dataProvider);
}
protected DataLayer() {
this(DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT);
}
protected DataLayer(int defaultColumnWidth, int defaultRowHeight) {
this.columnWidthConfig = new SizeConfig(defaultColumnWidth);
this.rowHeightConfig = new SizeConfig(defaultRowHeight);
registerCommandHandlers();
}
// Persistence
@Override
public void saveState(String prefix, Properties properties) {
super.saveState(prefix, properties);
this.columnWidthConfig.saveState(prefix + PERSISTENCE_KEY_COLUMN_WIDTH,
properties);
this.rowHeightConfig.saveState(prefix + PERSISTENCE_KEY_ROW_HEIGHT,
properties);
}
@Override
public void loadState(String prefix, Properties properties) {
super.loadState(prefix, properties);
this.columnWidthConfig.loadState(prefix + PERSISTENCE_KEY_COLUMN_WIDTH,
properties);
this.rowHeightConfig.loadState(prefix + PERSISTENCE_KEY_ROW_HEIGHT,
properties);
if (!properties.containsKey(NatTable.INITIAL_PAINT_COMPLETE_FLAG))
fireLayerEvent(new StructuralRefreshEvent(this));
}
// Configuration
@Override
protected void registerCommandHandlers() {
registerCommandHandler(new ColumnResizeCommandHandler(this));
registerCommandHandler(new MultiColumnResizeCommandHandler(this));
registerCommandHandler(new RowResizeCommandHandler(this));
registerCommandHandler(new MultiRowResizeCommandHandler(this));
registerCommandHandler(new UpdateDataCommandHandler(this));
registerCommandHandler(new StructuralRefreshCommandHandler());
registerCommandHandler(new VisualRefreshCommandHandler());
}
public IDataProvider getDataProvider() {
return this.dataProvider;
}
protected void setDataProvider(IDataProvider dataProvider) {
if (this.dataProvider instanceof IPersistable) {
unregisterPersistable((IPersistable) this.dataProvider);
}
this.dataProvider = dataProvider;
if (dataProvider instanceof IPersistable) {
registerPersistable((IPersistable) dataProvider);
}
}
/**
* Gets the value at the given column and row index.
*
* @param columnIndex
* @param rowIndex
* @return the data value associated with the specified cell
*/
public Object getDataValue(int columnIndex, int rowIndex) {
return this.dataProvider.getDataValue(columnIndex, rowIndex);
}
/**
* Sets the value at the given column and row index. Optional operation.
* Should throw UnsupportedOperationException if this operation is not
* supported.
*
* @param columnIndex
* @param rowIndex
* @param newValue
*/
public void setDataValue(int columnIndex, int rowIndex, Object newValue) {
this.dataProvider.setDataValue(columnIndex, rowIndex, newValue);
}
// Horizontal features
// Columns
@Override
public int getColumnCount() {
return this.dataProvider.getColumnCount();
}
@Override
public int getPreferredColumnCount() {
return getColumnCount();
}
/**
* This is the root coordinate system, so the column index is always equal
* to the column position.
*/
@Override
public int getColumnIndexByPosition(int columnPosition) {
if (columnPosition >= 0 && columnPosition < getColumnCount()) {
return columnPosition;
} else {
return -1;
}
}
/**
* This is the root coordinate system, so the column position is always
* equal to the column index.
*/
@Override
public int getColumnPositionByIndex(int columnIndex) {
if (columnIndex >= 0 && columnIndex < getColumnCount()) {
return columnIndex;
} else {
return -1;
}
}
@Override
public int localToUnderlyingColumnPosition(int localColumnPosition) {
return localColumnPosition;
}
@Override
public int underlyingToLocalColumnPosition(ILayer sourceUnderlyingLayer,
int underlyingColumnPosition) {
return underlyingColumnPosition;
}
@Override
public Collection<Range> underlyingToLocalColumnPositions(
ILayer sourceUnderlyingLayer,
Collection<Range> underlyingColumnPositionRanges) {
return underlyingColumnPositionRanges;
}
// Width
@Override
public int getWidth() {
return this.columnWidthConfig.getAggregateSize(getColumnCount());
}
@Override
public int getPreferredWidth() {
return getWidth();
}
@Override
public int getColumnWidthByPosition(int columnPosition) {
return this.columnWidthConfig.getSize(columnPosition);
}
public void setColumnWidthByPosition(int columnPosition, int width) {
setColumnWidthByPosition(columnPosition, width, true);
}
public void setColumnWidthByPosition(int columnPosition, int width,
boolean fireEvent) {
this.columnWidthConfig.setSize(columnPosition, width);
if (fireEvent)
fireLayerEvent(new ColumnResizeEvent(this, columnPosition));
}
public void setColumnWidthPercentageByPosition(int columnPosition, int width) {
this.columnWidthConfig.setPercentage(columnPosition, width);
fireLayerEvent(new ColumnResizeEvent(this, columnPosition));
}
public void setDefaultColumnWidth(int width) {
this.columnWidthConfig.setDefaultSize(width);
}
public void setDefaultColumnWidthByPosition(int columnPosition, int width) {
this.columnWidthConfig.setDefaultSize(columnPosition, width);
}
// Column resize
@Override
public boolean isColumnPositionResizable(int columnPosition) {
return this.columnWidthConfig.isPositionResizable(columnPosition);
}
public void setColumnPositionResizable(int columnPosition, boolean resizable) {
this.columnWidthConfig.setPositionResizable(columnPosition, resizable);
}
public void setColumnsResizableByDefault(boolean resizableByDefault) {
this.columnWidthConfig.setResizableByDefault(resizableByDefault);
}
// Underlying
@Override
public Collection<ILayer> getUnderlyingLayersByColumnPosition(
int columnPosition) {
return null;
}
// Vertical features
// Rows
@Override
public int getRowCount() {
return this.dataProvider.getRowCount();
}
@Override
public int getPreferredRowCount() {
return getRowCount();
}
/**
* This is the root coordinate system, so the row index is always equal to
* the row position.
*/
@Override
public int getRowIndexByPosition(int rowPosition) {
if (rowPosition >= 0 && rowPosition < getRowCount()) {
return rowPosition;
} else {
return -1;
}
}
/**
* This is the root coordinate system, so the row position is always equal
* to the row index.
*/
@Override
public int getRowPositionByIndex(int rowIndex) {
if (rowIndex >= 0 && rowIndex < getRowCount()) {
return rowIndex;
} else {
return -1;
}
}
@Override
public int localToUnderlyingRowPosition(int localRowPosition) {
return localRowPosition;
}
@Override
public int underlyingToLocalRowPosition(ILayer sourceUnderlyingLayer,
int underlyingRowPosition) {
return underlyingRowPosition;
}
@Override
public Collection<Range> underlyingToLocalRowPositions(
ILayer sourceUnderlyingLayer,
Collection<Range> underlyingRowPositionRanges) {
return underlyingRowPositionRanges;
}
// Height
@Override
public int getHeight() {
return this.rowHeightConfig.getAggregateSize(getRowCount());
}
@Override
public int getPreferredHeight() {
return getHeight();
}
@Override
public int getRowHeightByPosition(int rowPosition) {
return this.rowHeightConfig.getSize(rowPosition);
}
public void setRowHeightByPosition(int rowPosition, int height) {
setRowHeightByPosition(rowPosition, height, true);
}
public void setRowHeightByPosition(int rowPosition, int height,
boolean fireEvent) {
this.rowHeightConfig.setSize(rowPosition, height);
if (fireEvent)
fireLayerEvent(new RowResizeEvent(this, rowPosition));
}
public void setRowHeightPercentageByPosition(int rowPosition, int height) {
this.rowHeightConfig.setPercentage(rowPosition, height);
fireLayerEvent(new ColumnResizeEvent(this, rowPosition));
}
public void setDefaultRowHeight(int height) {
this.rowHeightConfig.setDefaultSize(height);
}
public void setDefaultRowHeightByPosition(int rowPosition, int height) {
this.rowHeightConfig.setDefaultSize(rowPosition, height);
}
// Row resize
@Override
public boolean isRowPositionResizable(int rowPosition) {
return this.rowHeightConfig.isPositionResizable(rowPosition);
}
public void setRowPositionResizable(int rowPosition, boolean resizable) {
this.rowHeightConfig.setPositionResizable(rowPosition, resizable);
}
public void setRowsResizableByDefault(boolean resizableByDefault) {
this.rowHeightConfig.setResizableByDefault(resizableByDefault);
}
// Underlying
@Override
public Collection<ILayer> getUnderlyingLayersByRowPosition(int rowPosition) {
return null;
}
// Cell features
@Override
public Object getDataValueByPosition(int columnPosition, int rowPosition) {
int columnIndex = getColumnIndexByPosition(columnPosition);
int rowIndex = getRowIndexByPosition(rowPosition);
return getDataValue(columnIndex, rowIndex);
}
public void setDataValueByPosition(int columnPosition, int rowPosition,
Object newValue) {
int columnIndex = getColumnIndexByPosition(columnPosition);
int rowIndex = getRowIndexByPosition(rowPosition);
setDataValue(columnIndex, rowIndex, newValue);
}
@Override
public int getColumnPositionByX(int x) {
return LayerUtil.getColumnPositionByX(this, x);
}
@Override
public int getRowPositionByY(int y) {
return LayerUtil.getRowPositionByY(this, y);
}
@Override
public int getStartXOfColumnPosition(int columnPosition) {
return this.columnWidthConfig.getAggregateSize(columnPosition);
}
@Override
public int getStartYOfRowPosition(int rowPosition) {
return this.rowHeightConfig.getAggregateSize(rowPosition);
}
@Override
public ILayer getUnderlyingLayerByPosition(int columnPosition,
int rowPosition) {
return null;
}
@Override
public boolean doCommand(ILayerCommand command) {
if (command instanceof ClientAreaResizeCommand
&& command.convertToTargetLayer(this)) {
ClientAreaResizeCommand clientAreaResizeCommand = (ClientAreaResizeCommand) command;
boolean refresh = false;
if (isColumnPercentageSizing()) {
this.columnWidthConfig.calculatePercentages(
clientAreaResizeCommand.getCalcArea().width,
getColumnCount());
refresh = true;
}
if (isRowPercentageSizing()) {
this.rowHeightConfig.calculatePercentages(
clientAreaResizeCommand.getCalcArea().height,
getRowCount());
refresh = true;
}
if (refresh) {
fireLayerEvent(new ResizeStructuralRefreshEvent(this));
}
return refresh;
}
else if (command instanceof StructuralRefreshCommand) {
// if we receive a StructuralRefreshCommand we need to ensure
// that the percentage values are re-calculated
if (isColumnPercentageSizing()) {
this.columnWidthConfig.updatePercentageValues(getColumnCount());
}
if (isRowPercentageSizing()) {
this.rowHeightConfig.updatePercentageValues(getRowCount());
}
}
return super.doCommand(command);
}
/**
* @return <code>true</code> if the column sizing is done by percentage
* calculation, <code>false</code> if the column sizing is done by
* pixel (default)
*/
public boolean isColumnPercentageSizing() {
return this.columnWidthConfig.isPercentageSizing();
}
/**
* Configures how the column sizing of this {@link DataLayer} is handled.
* Default is pixel sizing. If percentage sizing should be used you have to
* ensure that the size value for every column is set explicitly and that
* the sum of the column sizes doesn't exceed 100.
*
* @param percentageSizing
* <code>true</code> if the column sizing should be done by
* percentage calculation, <code>false</code> if the column
* sizing should be done by pixel (default)
*/
public void setColumnPercentageSizing(boolean percentageSizing) {
this.columnWidthConfig.setPercentageSizing(percentageSizing);
}
/**
* @param position
* The position which is asked for the percentage sizing
* configuration.
* @return <code>true</code> if the column sizing for the given position is
* done by percentage calculation, <code>false</code> if the column
* sizing is done by pixel (default)
*/
public boolean isColumnPercentageSizing(int position) {
return this.columnWidthConfig.isPercentageSizing(position);
}
/**
* Configures how the column sizing of this {@link DataLayer} is handled.
* Default is pixel sizing. If percentage sizing should be used you have to
* ensure that the size value for every column is set explicitly and that
* the sum of the column sizes doesn't exceed 100.
*
* @param position
* The position for which the sizing configuration should be set.
* @param percentageSizing
* <code>true</code> if the column sizing should be done by
* percentage calculation, <code>false</code> if the column
* sizing should be done by pixel (default)
*/
public void setColumnPercentageSizing(int position, boolean percentageSizing) {
this.columnWidthConfig.setPercentageSizing(position, percentageSizing);
}
/**
* @return <code>true</code> if the row sizing is done by percentage
* calculation, <code>false</code> if the row sizing is done by
* pixel (default)
*/
public boolean isRowPercentageSizing() {
return this.rowHeightConfig.isPercentageSizing();
}
/**
* Configures how the row sizing of this {@link DataLayer} is handled.
* Default is pixel sizing. If percentage sizing should be used you have to
* ensure that the size value for every row is set explicitly and that the
* sum of the row sizes doesn't exceed 100.
*
* @param percentageSizing
* <code>true</code> if the row sizing should be done by
* percentage calculation, <code>false</code> if the row sizing
* should be done by pixel (default)
*/
public void setRowPercentageSizing(boolean percentageSizing) {
this.rowHeightConfig.setPercentageSizing(percentageSizing);
}
/**
* @param position
* The position which is asked for the percentage sizing
* configuration.
* @return <code>true</code> if the row sizing for the given position is
* done by percentage calculation, <code>false</code> if the row
* sizing is done by pixel (default)
*/
public boolean isRowPercentageSizing(int position) {
return this.rowHeightConfig.isPercentageSizing(position);
}
/**
* Configures how the row sizing of this {@link DataLayer} is handled.
* Default is pixel sizing. If percentage sizing should be used you have to
* ensure that the size value for every row is set explicitly and that the
* sum of the row sizes doesn't exceed 100.
*
* @param position
* The row position for which the sizing configuration should be
* set.
* @param percentageSizing
* <code>true</code> if the row sizing should be done by
* percentage calculation, <code>false</code> if the row sizing
* should be done by pixel (default)
*/
public void setRowPercentageSizing(int position, boolean percentageSizing) {
this.rowHeightConfig.setPercentageSizing(position, percentageSizing);
}
}