/*******************************************************************************
* Copyright (c) 2012 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
******************************************************************************/
package org.eclipse.nebula.widgets.nattable.extension.builder;
import static org.eclipse.nebula.widgets.nattable.util.ObjectUtils.isNotNull;
import java.util.Comparator;
import org.eclipse.nebula.widgets.nattable.NatTable;
import org.eclipse.nebula.widgets.nattable.columnCategories.ChooseColumnsFromCategoriesCommandHandler;
import org.eclipse.nebula.widgets.nattable.columnChooser.command.DisplayColumnChooserCommandHandler;
import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
import org.eclipse.nebula.widgets.nattable.config.NullComparator;
import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.data.IRowIdAccessor;
import org.eclipse.nebula.widgets.nattable.data.convert.DefaultBooleanDisplayConverter;
import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes;
import org.eclipse.nebula.widgets.nattable.edit.editor.TextCellEditor;
import org.eclipse.nebula.widgets.nattable.extension.builder.configuration.GridLayerConfiguration;
import org.eclipse.nebula.widgets.nattable.extension.builder.configuration.RightClickColumnHeaderMenuConfiguration;
import org.eclipse.nebula.widgets.nattable.extension.builder.configuration.RowSelectionUIBindings;
import org.eclipse.nebula.widgets.nattable.extension.builder.configuration.SelectionStyleConfiguration;
import org.eclipse.nebula.widgets.nattable.extension.builder.configuration.TableStyleConfiguration;
import org.eclipse.nebula.widgets.nattable.extension.builder.layers.BodyLayerStack;
import org.eclipse.nebula.widgets.nattable.extension.builder.layers.ColumnHeaderLayerStack;
import org.eclipse.nebula.widgets.nattable.extension.builder.layers.CornerLayerStack;
import org.eclipse.nebula.widgets.nattable.extension.builder.layers.RowHeaderLayerStack;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.ColumnStyle;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.IEditor;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.TableColumn;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.TableModel;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.TableRow;
import org.eclipse.nebula.widgets.nattable.extension.builder.model.TableStyle;
import org.eclipse.nebula.widgets.nattable.extension.builder.util.ColumnAccessor;
import org.eclipse.nebula.widgets.nattable.extension.builder.util.ColumnCategoriesModelAssembler;
import org.eclipse.nebula.widgets.nattable.extension.builder.util.ColumnGroupModelAssembler;
import org.eclipse.nebula.widgets.nattable.filterrow.FilterRowDataLayer;
import org.eclipse.nebula.widgets.nattable.filterrow.config.FilterRowConfigAttributes;
import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;
import org.eclipse.nebula.widgets.nattable.layer.cell.CellOverrideLabelAccumulator;
import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
import org.eclipse.nebula.widgets.nattable.painter.cell.CheckBoxPainter;
import org.eclipse.nebula.widgets.nattable.painter.cell.ComboBoxPainter;
import org.eclipse.nebula.widgets.nattable.selection.RowSelectionModel;
import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
import org.eclipse.nebula.widgets.nattable.selection.config.DefaultSelectionLayerConfiguration;
import org.eclipse.nebula.widgets.nattable.selection.config.RowOnlySelectionConfiguration;
import org.eclipse.nebula.widgets.nattable.sort.SortConfigAttributes;
import org.eclipse.nebula.widgets.nattable.style.CellStyleAttributes;
import org.eclipse.nebula.widgets.nattable.style.DisplayMode;
import org.eclipse.nebula.widgets.nattable.style.Style;
import org.eclipse.nebula.widgets.nattable.style.editor.command.DisplayColumnStyleEditorCommandHandler;
import org.eclipse.nebula.widgets.nattable.ui.menu.DebugMenuConfiguration;
import org.eclipse.nebula.widgets.nattable.util.ObjectUtils;
import org.eclipse.swt.widgets.Composite;
import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.FilterList;
import ca.odell.glazedlists.GlazedLists;
import ca.odell.glazedlists.SortedList;
/**
* Convenience class to configure the grid with the most commonly used features.
*
* @param <T>
* Type of the object in the underlying list
*/
public class NatTableBuilder<T extends TableRow> {
public static final String COLUMN_HEADER_COLUMN_LABEL_PREFIX = "columnHeaderColumnLabel_";
public static final String BODY_COLUMN_LABEL_PREFIX = "bodyColumnLabel_";
private final TableStyle tableStyle;
private final TableModel tableModel;
private final TableColumn[] columns;
private final IRowIdAccessor<T> rowIdAccessor;
private final Composite parent;
private NatTable natTable;
private final EventList<T> eventList;
private FilterList<T> filterList;
private ColumnOverrideLabelAccumulator columnLabelAccumulator;
private IConfigRegistry configRegistry;
// Layers
private BodyLayerStack<T> bodyLayer;
private ColumnHeaderLayerStack<T> columnHeaderLayer;
private RowHeaderLayerStack<T> rowHeaderLayer;
private CornerLayerStack<T> cornerLayer;
private GridLayer gridLayer;
public NatTableBuilder(Composite parent, TableModel tableModel,
EventList<T> eventList, IRowIdAccessor<T> rowIdAccessor) {
this.parent = parent;
this.tableModel = tableModel;
this.rowIdAccessor = rowIdAccessor;
this.tableStyle = tableModel.tableStyle;
this.columns = tableModel.columnProperties;
this.eventList = GlazedLists.threadSafeList(eventList);
}
public NatTable setupLayerStacks() {
IColumnPropertyAccessor<T> columnAccessor = new ColumnAccessor<T>(
columns);
configRegistry = new ConfigRegistry();
SortedList<T> sortedRows = new SortedList<T>(eventList, null);
filterList = new FilterList<T>(sortedRows);
setUpColumnGroupModel();
setUpColumnCategoriesModel();
// Body
bodyLayer = new BodyLayerStack<T>(tableModel, filterList);
// Column header
columnHeaderLayer = new ColumnHeaderLayerStack<T>(sortedRows,
filterList, tableModel, bodyLayer, columnAccessor,
configRegistry);
// Row header
rowHeaderLayer = new RowHeaderLayerStack<T>(bodyLayer, tableModel);
// Corner
cornerLayer = new CornerLayerStack<T>(columnHeaderLayer, rowHeaderLayer);
// Grid
gridLayer = new GridLayer(bodyLayer, columnHeaderLayer, rowHeaderLayer,
cornerLayer, false);
natTable = new NatTable(parent, gridLayer, false);
natTable.setConfigRegistry(configRegistry);
natTable.setBackground(tableStyle.tableBgColor);
// Configuration
natTable.addConfiguration(new TableStyleConfiguration(tableStyle));
configureColumnProperties();
configureSorting();
configureEditing();
configureFiltering();
configureColumnChooser();
configureCategoriesBasedColumnChooser();
configureColumnStyleCustomization();
configureGridLayer();
configureSelectionStyle();
configureColumnHeaderRightClickMenu();
return natTable;
}
private void setUpColumnGroupModel() {
if (tableModel.enableColumnGroups) {
tableModel.columnGroupModel = ColumnGroupModelAssembler
.setupColumnGroups(tableModel.columnProperties);
}
}
private void setUpColumnCategoriesModel() {
tableModel.columnCategoriesModel = ColumnCategoriesModelAssembler
.setupColumnCategories(tableModel.columnProperties);
}
public NatTable build() {
natTable.configure();
return natTable;
}
protected void configureColumnStyleCustomization() {
if (!tableModel.enableColumnStyleCustomization) {
return;
}
// Register a command handler for the StyleEditorDialog
DisplayColumnStyleEditorCommandHandler styleChooserCommandHandler = new DisplayColumnStyleEditorCommandHandler(
bodyLayer.getSelectionLayer(), columnLabelAccumulator,
configRegistry);
bodyLayer.registerCommandHandler(styleChooserCommandHandler);
// Register the style editor as persistable
// This will persist the style applied to the columns when
// NatTable#saveState is invoked
bodyLayer.registerPersistable(styleChooserCommandHandler);
bodyLayer.registerPersistable(columnLabelAccumulator);
}
protected void configureColumnHeaderRightClickMenu() {
if (tableModel.enableColumnHeaderRightClickMenu) {
natTable.addConfiguration(new RightClickColumnHeaderMenuConfiguration(
natTable, tableModel));
}
natTable.addConfiguration(new DebugMenuConfiguration(natTable));
}
/**
* Set up selection behavior. Select cells vs select rows.
*/
protected void configureSelectionStyle() {
SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();
if (tableModel.enableFullRowSelection) {
selectionLayer
.addConfiguration(new RowOnlySelectionConfiguration<T>());
natTable.addConfiguration(new RowSelectionUIBindings());
selectionLayer
.setSelectionModel(new RowSelectionModel<T>(selectionLayer,
bodyLayer.getDataProvider(), rowIdAccessor));
} else {
selectionLayer
.addConfiguration(new DefaultSelectionLayerConfiguration());
}
natTable.addConfiguration(new SelectionStyleConfiguration(tableStyle));
}
/**
* Configure the Alternate row color
*/
protected void configureGridLayer() {
gridLayer.addConfiguration(new GridLayerConfiguration(gridLayer,
tableStyle));
}
protected void configureColumnChooser() {
bodyLayer
.registerCommandHandler(new DisplayColumnChooserCommandHandler(
bodyLayer.getSelectionLayer(), bodyLayer
.getColumnHideShowLayer(), columnHeaderLayer
.getColumnHeaderLayer(), columnHeaderLayer
.getDataLayer(), columnHeaderLayer
.getColumnGroupHeaderLayer(),
tableModel.columnGroupModel));
}
protected void configureCategoriesBasedColumnChooser() {
if (ObjectUtils.isNull(tableModel.columnCategoriesModel)) {
return;
}
bodyLayer
.registerCommandHandler(new ChooseColumnsFromCategoriesCommandHandler(
bodyLayer.getColumnHideShowLayer(), columnHeaderLayer
.getColumnHeaderLayer(), columnHeaderLayer
.getDataLayer(),
tableModel.columnCategoriesModel));
}
protected void configureColumnProperties() {
columnLabelAccumulator = new ColumnOverrideLabelAccumulator(
bodyLayer.getDataLayer());
bodyLayer.addLabelAccumulator(columnLabelAccumulator);
for (int colIndex = 0; colIndex < columns.length; colIndex++) {
Integer width = columns[colIndex].width;
if (isNotNull(width)) {
bodyLayer.getDataLayer().setColumnWidthByPosition(colIndex,
width);
}
// Register a label on each column
String columnLabel = BODY_COLUMN_LABEL_PREFIX + colIndex;
columnLabelAccumulator.registerColumnOverrides(colIndex,
columnLabel);
// Add the display converter/formatter to the column
configRegistry.registerConfigAttribute(
CellConfigAttributes.DISPLAY_CONVERTER,
columns[colIndex].displayConverter, DisplayMode.NORMAL,
columnLabel);
// Add column visual style
Style style = new Style();
ColumnStyle columnStyle = columns[colIndex].style;
if (ObjectUtils.isNotNull(columnStyle)) {
style.setAttributeValue(CellStyleAttributes.BACKGROUND_COLOR,
columnStyle.bgColor);
style.setAttributeValue(CellStyleAttributes.FOREGROUND_COLOR,
columnStyle.fgColor);
style.setAttributeValue(
CellStyleAttributes.HORIZONTAL_ALIGNMENT,
columnStyle.hAlign);
style.setAttributeValue(CellStyleAttributes.VERTICAL_ALIGNMENT,
columnStyle.vAlign);
style.setAttributeValue(CellStyleAttributes.FONT,
columnStyle.font);
style.setAttributeValue(CellStyleAttributes.BORDER_STYLE,
columnStyle.borderStyle);
configRegistry.registerConfigAttribute(
CellConfigAttributes.CELL_STYLE, style,
DisplayMode.NORMAL, columnLabel);
}
}
}
protected void configureSorting() {
ColumnOverrideLabelAccumulator columnHeaderLabelAccumulator = new ColumnOverrideLabelAccumulator(
columnHeaderLayer.getDataLayer());
columnHeaderLayer.addLabelAccumulator(columnHeaderLabelAccumulator);
for (int colIndex = 0; colIndex < columns.length; colIndex++) {
String columnHeaderLabel = COLUMN_HEADER_COLUMN_LABEL_PREFIX
+ colIndex;
// Register an accumulator on the Column Header layer (since it
// triggers sort)
columnHeaderLabelAccumulator.registerColumnOverrides(colIndex,
columnHeaderLabel);
if (columns[colIndex].isSortable) {
Comparator<?> comparator = columns[colIndex].comparator;
configRegistry.registerConfigAttribute(
SortConfigAttributes.SORT_COMPARATOR, comparator,
DisplayMode.NORMAL, columnHeaderLabel);
} else {
configRegistry.registerConfigAttribute(
SortConfigAttributes.SORT_COMPARATOR,
new NullComparator(), DisplayMode.NORMAL,
columnHeaderLabel);
}
}
}
protected void configureFiltering() {
if (!tableModel.enableFilterRow) {
return;
}
for (int colIndex = 0; colIndex < columns.length; colIndex++) {
String filterRowLabel = FilterRowDataLayer.FILTER_ROW_COLUMN_LABEL_PREFIX
+ colIndex;
TableColumn column = columns[colIndex];
configRegistry.registerConfigAttribute(
FilterRowConfigAttributes.FILTER_COMPARATOR,
column.comparator, DisplayMode.NORMAL, filterRowLabel);
configRegistry.registerConfigAttribute(
FilterRowConfigAttributes.FILTER_DISPLAY_CONVERTER,
column.filterRowDisplayConverter, DisplayMode.NORMAL,
filterRowLabel);
configRegistry.registerConfigAttribute(
EditConfigAttributes.CELL_EDITOR,
column.filterRowEditor.getCellEditor(), DisplayMode.NORMAL,
filterRowLabel);
}
// Filter row style
Style style = new Style();
style.setAttributeValue(CellStyleAttributes.BACKGROUND_COLOR,
tableStyle.filterRowBGColor);
style.setAttributeValue(CellStyleAttributes.FOREGROUND_COLOR,
tableStyle.filterRowFGColor);
style.setAttributeValue(CellStyleAttributes.FONT,
tableStyle.filterRowFont);
configRegistry.registerConfigAttribute(CellConfigAttributes.CELL_STYLE,
style, DisplayMode.NORMAL, GridRegion.FILTER_ROW);
}
protected void configureEditing() {
for (int colIndex = 0; colIndex < columns.length; colIndex++) {
TableColumn column = columns[colIndex];
if (column.isEditable) {
IEditor editor = column.editor;
// Column label has been registered already
String columnLabel = BODY_COLUMN_LABEL_PREFIX + colIndex;
configRegistry
.registerConfigAttribute(
EditConfigAttributes.CELL_EDITABLE_RULE,
editor.getEditableRule(), DisplayMode.EDIT,
columnLabel);
configRegistry.registerConfigAttribute(
EditConfigAttributes.DATA_VALIDATOR,
editor.getValidator(), DisplayMode.EDIT, columnLabel);
switch (editor.getType()) {
case CHECKBOX:
configRegistry.registerConfigAttribute(
CellConfigAttributes.CELL_PAINTER,
new CheckBoxPainter(), DisplayMode.NORMAL,
columnLabel);
configRegistry.registerConfigAttribute(
CellConfigAttributes.DISPLAY_CONVERTER,
new DefaultBooleanDisplayConverter(),
DisplayMode.NORMAL, columnLabel);
configRegistry.registerConfigAttribute(
EditConfigAttributes.CELL_EDITOR,
editor.getCellEditor(), DisplayMode.NORMAL,
columnLabel);
break;
case COMBO:
configRegistry.registerConfigAttribute(
CellConfigAttributes.CELL_PAINTER,
new ComboBoxPainter(), DisplayMode.NORMAL,
columnLabel);
configRegistry.registerConfigAttribute(
EditConfigAttributes.CELL_EDITOR,
editor.getCellEditor(), DisplayMode.NORMAL,
columnLabel);
configRegistry.registerConfigAttribute(
EditConfigAttributes.CELL_EDITOR,
editor.getCellEditor(), DisplayMode.EDIT,
columnLabel);
break;
case TEXT:
configRegistry.registerConfigAttribute(
EditConfigAttributes.CELL_EDITOR,
new TextCellEditor());
break;
default:
break;
}
}
}
}
// Accessors for layers
public BodyLayerStack<T> getBodyLayerStack() {
return bodyLayer;
}
public ColumnHeaderLayerStack<T> getColumnHeaderLayerStack() {
return columnHeaderLayer;
}
public RowHeaderLayerStack<T> getRowHeaderLayer() {
return rowHeaderLayer;
}
public CornerLayerStack<T> getCornerLayer() {
return cornerLayer;
}
public GridLayer getGridLayer() {
return gridLayer;
}
public TableModel getTableModel() {
return tableModel;
}
public EventList<T> getEventList() {
return eventList;
}
public FilterList<T> getFilterList() {
return filterList;
}
public NatTable getNatTable() {
return natTable;
}
public void addCellLabelsToBody(
CellOverrideLabelAccumulator<? extends TableRow> myAccumulator) {
bodyLayer.addLabelAccumulator(myAccumulator);
}
}