import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Sets the displayed data.
 *
 * @param handle
 */
public void setData(final DataHandle handle) {
    this.table.setRedraw(false);
    this.context.setHandle(handle);
    this.gridLayer = new DataTableGridLayerStack(new DataTableHandleDataProvider(context), table, context, parent);
    this.table.setLayer(gridLayer);
    this.table.refresh();
    this.gridLayer.getBodyLayer().getViewportLayer().recalculateScrollBars();
    ((DataLayer)this.gridLayer.getBodyDataLayer()).setColumnWidthByPosition(0, 18);
    ((DataLayer)this.gridLayer.getBodyDataLayer()).setColumnPositionResizable(0, false);
    this.table.getVerticalBar().setVisible(false);
    this.table.getHorizontalBar().setVisible(false);
    this.table.setRedraw(true);
    this.table.redraw();
    this.table.setVisible(true);
    this.table.getVerticalBar().setVisible(true);
    this.table.getHorizontalBar().setVisible(true);
    this.table.setVisible(true);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Creates a new instance.
 *
 * @param parent
 * @param dataProvider
 * @param bodyLayer
 * @param config
 * @param context
 */
public LayerColumnHeader(Composite parent,
                              IDataProvider dataProvider,
                              LayerBody bodyLayer,
                              CTConfiguration config, CTContext context) {
    super(config, context);
    
    DataLayer dataLayer = new DataLayer(dataProvider);
    ColumnHeaderLayer colHeaderLayer = new ColumnHeaderLayer(dataLayer,
                                                             bodyLayer,
                                                             bodyLayer.getSelectionLayer(),
                                                             false);
    colHeaderLayer.addConfiguration(new StyleConfigurationHeader(parent, GridRegion.COLUMN_HEADER, config));
    colHeaderLayer.addConfiguration(new DefaultColumnResizeBindings());
    setUnderlyingLayer(colHeaderLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
private void setColumnWidthFromModel(final int columnIndex) {
    final DataLayer dataLayer = tableLayers.getDataLayer();
    final int width = columnModel.getColumn(columnIndex).getWidth();
    if (width >= 0) {
        //the data layer is not reordered so the index must be used here instead 
        //of position (index and position are the same in this layer)
        if (width != dataLayer.getColumnWidthByPosition(columnIndex)) {
            dataLayer.setColumnWidthByPosition(columnIndex, width);
        }
    }
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public NatTableLayers(
    final ITableDataModel dataModel,
    final ITableColumnModelSpi columnModel,
    final boolean columsResizable,
    final boolean columnsMoveable,
    final TableSelectionPolicy selectionPolicy) {

    Assert.paramNotNull(dataModel, "dataModel");
    Assert.paramNotNull(columnModel, "columnModel");
    Assert.paramNotNull(selectionPolicy, "selectionPolicy");

    final IDataProvider dataProvider = new DefaultDataProvider(dataModel, columnModel);
    final IDataProvider rowDataProvider = new DefaultRowDataProvider();
    final IDataProvider columnDataProvider = new DefaultColumnDataProvider(columnModel);

    final BodyLayerStack bodyLayer = new BodyLayerStack(dataProvider, columsResizable, columnsMoveable, selectionPolicy);
    this.dataLayer = bodyLayer.getDataLayer();
    this.selectionModel = bodyLayer.getSelectionModel();
    this.selectionLayer = bodyLayer.getSelectionLayer();
    this.columnReorderLayer = bodyLayer.getColumnReorderLayer();
    this.viewPortLayer = bodyLayer.getViewportLayer();

    this.columnHeaderLayer = new ColumnHeaderLayerStack(columnDataProvider, bodyLayer);
    final RowHeaderLayerStack rowHeaderLayer = new RowHeaderLayerStack(rowDataProvider, bodyLayer);

    final DefaultCornerDataProvider cornerDataProvider = new DefaultCornerDataProvider(columnDataProvider, rowDataProvider);
    final CornerLayer cornerLayer = new CornerLayer(new DataLayer(cornerDataProvider), rowHeaderLayer, columnHeaderLayer);

    //remark: false also disable editing, but when editing is enabled selection drag mode is enabled and must
    //be disabled to allow drag and drop on tables
    this.gridLayer = new GridLayer(bodyLayer, columnHeaderLayer, rowHeaderLayer, cornerLayer, false);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
BodyLayerStack(
    final IDataProvider dataProvider,
    final boolean columsResizable,
    final boolean columnsMoveable,
    final TableSelectionPolicy selectionPolicy) {

    this.dataLayer = new DataLayer(dataProvider);
    dataLayer.setDefaultRowHeight(CellConstants.DEFAULT_ROW_HEIGHT);
    dataLayer.setColumnsResizableByDefault(columsResizable);

    this.columnReorderLayer = new JoColumnReorderLayer(dataLayer);
    if (columnsMoveable) {
        this.selectionLayer = new JoSelectionLayer(columnReorderLayer);
    }
    else {
        this.selectionLayer = new JoSelectionLayer(dataLayer);
    }

    if (TableSelectionPolicy.NO_SELECTION.equals(selectionPolicy)) {
        this.selectionModel = new NoSelectionRowSelectionModel();
    }
    else {
        this.selectionModel = new RowIndexSelectionModel(dataProvider, selectionLayer);
        if (TableSelectionPolicy.SINGLE_ROW_SELECTION.equals(selectionPolicy)) {
            selectionModel.setMultipleSelectionAllowed(false);
        }
    }
    selectionLayer.setSelectionModel(selectionModel);
    selectionLayer.clearConfiguration();
    selectionLayer.addConfiguration(new SelectionLayerConfiguration());

    this.viewportLayer = new ViewportLayer(selectionLayer);
    setUnderlyingLayer(viewportLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public BodyLayerStack(List<T> values,
        IColumnPropertyAccessor<T> columnPropertyAccessor,
        ColumnGroupModel... columnGroupModel) {
    // wrapping of the list to show into GlazedLists
    // see http://publicobject.com/glazedlists/ for further information
    EventList<T> eventList = GlazedLists.eventList(values);
    TransformedList<T, T> rowObjectsGlazedList = GlazedLists.threadSafeList(eventList);

    // use the SortedList constructor with 'null' for the Comparator
    // because the Comparator will be set by configuration
    this.sortedList = new SortedList<T>(rowObjectsGlazedList, null);
    // wrap the SortedList with the FilterList
    this.filterList = new FilterList<T>(getSortedList());

    this.bodyDataProvider =
            new ListDataProvider<T>(this.filterList, columnPropertyAccessor);
    DataLayer bodyDataLayer = new DataLayer(this.bodyDataProvider);

    // layer for event handling of GlazedLists and PropertyChanges
    GlazedListsEventLayer<T> glazedListsEventLayer =
            new GlazedListsEventLayer<T>(bodyDataLayer, this.filterList);

    this.columnReorderLayer = new ColumnReorderLayer(glazedListsEventLayer);
    this.columnGroupReorderLayer =
            new ColumnGroupReorderLayer(this.columnReorderLayer, columnGroupModel[columnGroupModel.length - 1]);
    this.columnHideShowLayer = new ColumnHideShowLayer(this.columnGroupReorderLayer);
    this.columnGroupExpandCollapseLayer =
            new ColumnGroupExpandCollapseLayer(this.columnHideShowLayer, columnGroupModel);
    this.selectionLayer = new SelectionLayer(this.columnGroupExpandCollapseLayer);
    this.viewportLayer = new ViewportLayer(this.selectionLayer);

    final FreezeLayer freezeLayer = new FreezeLayer(this.selectionLayer);
    final CompositeFreezeLayer compositeFreezeLayer =
            new CompositeFreezeLayer(freezeLayer, this.viewportLayer, this.selectionLayer);

    setUnderlyingLayer(compositeFreezeLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public Control createExampleControl(Composite parent) {
    SelectionExampleGridLayer gridLayer = new SelectionExampleGridLayer();
    NatTable natTable = new NatTable(parent, gridLayer, false);

    DataLayer bodyDataLayer = gridLayer.getBodyDataLayer();

    // Label accumulator - adds labels to all cells with the given data
    // value
    CellOverrideLabelAccumulator<RowDataFixture> cellLabelAccumulator =
            new CellOverrideLabelAccumulator<RowDataFixture>(gridLayer.getBodyDataProvider());
    cellLabelAccumulator.registerOverride("AAA", 2, CELL_LABEL);

    // Register your cell style, against the label applied to the cell
    // Other configuration which can be added (apart from style) include
    // CellConfigAttributes, EditConfigAttributes, SortConfigAttributes etc.
    IConfigRegistry configRegistry = new ConfigRegistry();
    addColumnHighlight(configRegistry);

    // Register label accumulator
    bodyDataLayer.setConfigLabelAccumulator(cellLabelAccumulator);
    gridLayer.getSelectionLayer().addConfiguration(new DefaultSelectionLayerConfiguration());

    natTable.addConfiguration(new DefaultNatTableStyleConfiguration());
    natTable.setConfigRegistry(configRegistry);

    natTable.configure();
    return natTable;
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Initialize.
 *
 * @param bodyDataProvider
 * @param columnHeaderDataProvider
 * @param rowHeaderDataProvider
 * @param cornerDataProvider
 * @param parent
 */
protected void init(IDataProvider bodyDataProvider,
                    IDataProvider columnHeaderDataProvider,
                    IDataProvider rowHeaderDataProvider,
                    IDataProvider cornerDataProvider,
                    Control parent) {
    init(new DataLayer(bodyDataProvider),
         new DefaultColumnHeaderDataLayer(columnHeaderDataProvider),
         new DefaultRowHeaderDataLayer(rowHeaderDataProvider),
         new DataLayer(cornerDataProvider),
         parent);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
@Override
public boolean doCommand(ILayerCommand command) {
    if (command instanceof FillLayerResetCommand) {
        this.modified = false;
        this.ignore = true;
        for (int i = 0; i < getColumnCount(); i++) {
            ColumnResizeCommand resize = new ColumnResizeCommand(this, i, DataLayer.DEFAULT_COLUMN_WIDTH);
            underlyingLayer.doCommand(resize);
        }
        this.ignore = false;
    }
    return super.doCommand(command);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Creates a new instance.
 *
 * @param parent
 * @param dataProvider
 * @param bodyLayer
 * @param config
 * @param context
 */
public LayerRowHeader(Composite parent,
                           IDataProvider dataProvider,
                           LayerBody bodyLayer,
                           CTConfiguration config, CTContext context) {
    super(config, context);
    DataLayer dataLayer = new DataLayer(dataProvider, 50, 20);
    RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(dataLayer, bodyLayer, bodyLayer.getSelectionLayer(), false);
    rowHeaderLayer.addConfiguration(new StyleConfigurationHeader(parent, GridRegion.ROW_HEADER, config));
    rowHeaderLayer.addConfiguration(new DefaultRowResizeBindings());
    setUnderlyingLayer(rowHeaderLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Creates a new instance.
 *
 * @param dataProvider
 * @param config
 * @param context
 */
public LayerBody(IDataProvider dataProvider, CTConfiguration config, CTContext context) {
    super(config, context);
    
    dataLayer = new DataLayer(dataProvider);

    selectionLayer = new LayerSelection(dataLayer, config);
    selectionLayer.addConfiguration(new StyleConfigurationSelection(config));
    IUniqueIndexLayer layer = selectionLayer;
    
    switch(config.getColumnHeaderLayout()){
        case CTConfiguration.COLUMN_HEADER_LAYOUT_FILL:
            layer = new LayerColumnFillLayout(layer, config, context);
            break;
        case CTConfiguration.COLUMN_HEADER_LAYOUT_FILL_EQUAL:
            layer = new LayerColumnFillLayout(layer, config, context, true);
            break;
    }
 
    switch(config.getRowHeaderLayout()){
        case CTConfiguration.ROW_HEADER_LAYOUT_FILL:
            layer = new LayerRowFillLayout(layer, config, context);
            break;
    }
    
    viewportLayer = new LayerViewport(layer, context);
    setUnderlyingLayer(viewportLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public DataLayer getDataLayer() {
    return dataLayer;
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
RowHeaderLayerStack(final IDataProvider dataProvider, final BodyLayerStack bodyLayer) {
	final DataLayer dataLayer = new DataLayer(dataProvider);
	final RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(dataLayer, bodyLayer, bodyLayer.getSelectionLayer());
	setUnderlyingLayer(rowHeaderLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
ColumnHeaderLayerStack(final IDataProvider dataProvider, final BodyLayerStack bodyLayer) {
    final DataLayer dataLayer = new DataLayer(dataProvider);
    dataLayer.setDefaultRowHeight(CellConstants.COLUMN_HEADER_HEIGHT);
    setUnderlyingLayer(new ColumnHeaderLayer(dataLayer, bodyLayer, bodyLayer.getSelectionLayer()));
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
DataLayer getDataLayer() {
    return dataLayer;
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param rootPath
 * @param eventBroker
 */
public PathCompositeLayer(Path rootPath, IEventBroker eventBroker) {
    super(1, 2);

    this.rootPath = rootPath;
    fillContentList(rootPath);

    // TODO
    propertyToLabelMap.put(PathFixture.FIELD_NAME, "Name");
    propertyToLabelMap.put(PathFixture.FIELD_SIZE, "Size");
    propertyToLabelMap.put(PathFixture.FIELD_ATTRS, "Attr");

    columnPropertyAccessor = new PathColumnPropertyAccessor(propertyToLabelMap, rootPath);
    bodyDataProvider = new ListDataProvider<PathFixture>(this.contentlist, columnPropertyAccessor);

    bodyDataLayer = new DataLayer(bodyDataProvider);

    // set columns fixed percentage sizing
    bodyDataLayer.setColumnWidthPercentageByPosition(0, 80);
    bodyDataLayer.setColumnWidthPercentageByPosition(1, 10);
    bodyDataLayer.setColumnWidthPercentageByPosition(2, 10);

    selectionLayer = new SelectionLayer(bodyDataLayer, false);
    ViewportLayer viewportLayer = new ViewportLayer(selectionLayer);

    // use a RowSelectionModel that will perform row selections and is able
    // to identify a row via unique ID
    selectionLayer.setSelectionModel(new RowSelectionModel<PathFixture>(selectionLayer, bodyDataProvider,
            new PathFixtureRowIdAccessor(this.contentlist)));

    // register different selection move command handler that always moves
    // by row
    selectionLayer.addConfiguration(new RowOnlySelectionConfiguration<PathFixture>());

    // register path handler
    OpenPathHandler pathHandler = new OpenPathHandler(selectionLayer, bodyDataProvider, eventBroker);
    viewportLayer.registerCommandHandler(pathHandler);

    // register selection bindings that will perform row selections instead
    // of cell selections
    // registering the bindings on a layer that is above the SelectionLayer
    // will consume the
    // commands before they are handled by the SelectionLayer
    viewportLayer.addConfiguration(new PathSelectionUiBinding());

    ILayer columnHeaderLayer = new ColumnHeaderLayer(new DataLayer(new SimpleColumnHeaderDataProvider(
            propertyToLabelMap)), viewportLayer, selectionLayer);

    setChildLayer(GridRegion.COLUMN_HEADER, columnHeaderLayer, 0, 0);
    setChildLayer(GridRegion.BODY, viewportLayer, 0, 1);

}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
protected void init() {
	dataProvider = new DataProvider();
	headingProvider = new HeadingProvider();

	gridLayer = new DefaultGridLayer(dataProvider, headingProvider);

	// CellLabelAccumulator determines how cells will be displayed
	class CellLabelAccumulator implements IConfigLabelAccumulator {
		@Override
		public void accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition) {
			configLabels.addLabel("column" + columnPosition);
			if (dataProvider.isEditableNonscalarDefinition(rowPosition) && columnPosition == Attr.HEADING_COLUMN)
				configLabels.addLabel("nonscalareditor");
		}
	}

	DataLayer bodyDataLayer = (DataLayer) gridLayer.getBodyDataLayer();
	CellLabelAccumulator cellLabelAccumulator = new CellLabelAccumulator();
	bodyDataLayer.setConfigLabelAccumulator(cellLabelAccumulator);

	table = new NatTable(parent, gridLayer, false);

	editorConfiguration = new EditorConfiguration();

	DefaultNatTableStyleConfiguration defaultStyle = new DefaultNatTableStyleConfiguration();
	table.addConfiguration(defaultStyle);
	table.addConfiguration(editorConfiguration);

	ContributionItem rowMenuItems = new ContributionItem() {
		@Override
		public void fill(Menu menu, int index) {
			MenuItem doesDelete = new MenuItem(menu, SWT.PUSH);
			doesDelete.setText("Delete");
			doesDelete.setImage(IconLoader.loadIcon("table_row_delete"));
			doesDelete.addListener(SWT.Selection, e -> askDeleteSelected());
		}
	};
	table.addConfiguration(new MenuConfiguration(GridRegion.ROW_HEADER,
			new PopupMenuBuilder(table).withContributionItem(rowMenuItems)));

	// Tabbing wraps and moves up/down
	gridLayer.registerCommandHandler(new MoveCellSelectionCommandHandler(
			gridLayer.getBodyLayer().getSelectionLayer(), ITraversalStrategy.TABLE_CYCLE_TRAVERSAL_STRATEGY));

	table.configure();

	// Tooltip for row/column headings
	new NatTableContentTooltip(table, GridRegion.ROW_HEADER) {
		protected String getText(Event event) {
			return "Right-click for options.";
		}
	};
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public DataLayer getDataLayer() {
    return this.dataLayer;
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public GlazedListsGridLayer(EventList<T> eventList,
        IColumnPropertyAccessor<T> columnPropertyAccessor,
        IDataProvider columnHeaderDataProvider,
        IConfigRegistry configRegistry, boolean useDefaultConfiguration) {

    super(useDefaultConfiguration);

    // Body - with list event listener
    // NOTE: Remember to use the SortedList constructor with 'null' for the
    // Comparator
    SortedList<T> sortedList = new SortedList<T>(eventList, null);
    this.bodyDataProvider = new ListDataProvider<T>(sortedList,
            columnPropertyAccessor);

    this.bodyDataLayer = new DataLayer(this.bodyDataProvider);
    GlazedListsEventLayer<T> glazedListsEventLayer = new GlazedListsEventLayer<T>(
            this.bodyDataLayer, eventList);
    this.bodyLayerStack = new DefaultBodyLayerStack(glazedListsEventLayer);

    // Column header
    this.columnHeaderLayerStack = new GlazedListsColumnHeaderLayerStack<T>(
            columnHeaderDataProvider, sortedList, columnPropertyAccessor,
            configRegistry, this.bodyLayerStack);

    // Row header
    DefaultRowHeaderDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(
            this.bodyDataProvider);
    DefaultRowHeaderDataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(
            rowHeaderDataProvider);
    RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(rowHeaderDataLayer,
            this.bodyLayerStack, this.bodyLayerStack.getSelectionLayer());

    // Corner
    DefaultCornerDataProvider cornerDataProvider = new DefaultCornerDataProvider(
            this.columnHeaderLayerStack.getDataProvider(), rowHeaderDataProvider);
    DataLayer cornerDataLayer = new DataLayer(cornerDataProvider);
    CornerLayer cornerLayer = new CornerLayer(cornerDataLayer,
            rowHeaderLayer, this.columnHeaderLayerStack);

    // Grid
    setBodyLayer(this.bodyLayerStack);
    setColumnHeaderLayer(this.columnHeaderLayerStack);
    setRowHeaderLayer(rowHeaderLayer);
    setCornerLayer(cornerLayer);
}
 

import org.eclipse.nebula.widgets.nattable.layer.DataLayer; //导入依赖的package包/类
public DataLayer getBodyDataLayer() {
    return this.bodyDataLayer;
}