Java SelectionLayer类代码示例

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
public int getSelectedRowPosition() {
    if (compositeLayer != null) {
        SelectionLayer selectionLayer = compositeLayer.getSelectionLayer();

        final Set<Range> selectedRows = selectionLayer.getSelectedRowPositions();
        List<Integer> selectedRowPositions = new ArrayList<Integer>();
        for (Range range : selectedRows) {
            for (int rowPosition = range.start; rowPosition < range.end; rowPosition++) {
                // + 1
                selectedRowPositions.add(rowPosition + 1);
            }
        }
        Collections.sort(selectedRowPositions);

        // at this moment return only first
        if (selectedRowPositions.size() > 0) {
            return selectedRowPositions.get(0).intValue();
        }
    }
    return -1;
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
@Override
public Control construct(Composite parent) {
	Composite content = new Composite(parent, SWT.NONE);
	GridDataFactory.fillDefaults().grab(true, true).applyTo(content);
	GridLayoutFactory.fillDefaults().numColumns(1).applyTo(content);

	CompositeLayer layer = new CompositeLayer(1, 1);
	layer.setChildLayer(GridRegion.BODY,
			new ViewportLayer(
					new SelectionLayer(new SpanningDataLayer(new DummySpanningBodyDataProvider(1000000, 1000000)))),
			0, 0);
	NatTable table = new NatTable(content, layer);
	
	GridDataFactory.fillDefaults().grab(true, true).applyTo(table);

	return content;
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
/**
 * Adds a selection listener.
 *
 * @param layer
 */
private void addSelectionListener(final SelectionLayer layer) {
    layer.addLayerListener(new ILayerListener(){
        @Override
        public void handleLayerEvent(ILayerEvent arg0) {
            if (arg0 instanceof CellSelectionEvent) {
                if (!actionCellSelected((CellSelectionEvent)arg0)){
                    layer.clear(true);
                }
            } else if (arg0 instanceof ColumnSelectionEvent) {
                if (!actionColumnSelected((ColumnSelectionEvent)arg0)){
                    layer.clear(true);
                }
            } else if (arg0 instanceof RowSelectionEvent) {
                if (!actionRowSelected((RowSelectionEvent)arg0)) {
                    layer.clear(true);
                }
            }
        }
    });

}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
public void init(){
		rowCount=1;
		
		bodyDataProvider=new DodyDataProvider();
		bodyDataLayer=new DataLayer(bodyDataProvider, colWidth, rowHeight);
		selectionLayer = new SelectionLayer(bodyDataLayer);
		selectionLayer.addConfiguration(new DefaultSelectionLayerConfiguration());
		selectionLayer.addLayerListener(layerListener);
		viewportLayer = new ViewportLayer(selectionLayer);
		viewportLayer.setRegionName(GridRegion.BODY);
		
		columnSpanHeaderDataProvider=new ColumnSpanHeaderDataProvider();
		columnSpanHeaderDataLayer=new SpanningDataLayer(columnSpanHeaderDataProvider, colWidth, rowHeight);
//		columnHeaderLayer = new ColumnSpanHeaderLayer(columnSpanHeaderDataLayer, viewportLayer, selectionLayer, false);
		columnSpanHeaderSelectionLayer=new SelectionLayer(columnSpanHeaderDataLayer);
		columnHeaderLayer = new ColumnSpanHeaderLayer(columnSpanHeaderSelectionLayer, viewportLayer, selectionLayer, false);
		
		rowSpanHeaderDataProvider=new RowSpanHeaderDataProvider();
		rowSpanHeaderDataLayer=new SpanningDataLayer(rowSpanHeaderDataProvider, colWidth*2, rowHeight);
		rowHeaderLayer = new RowSpanHeaderLayer(rowSpanHeaderDataLayer, viewportLayer, selectionLayer, false);
		
		cornerDataProvider = new DefaultCornerDataProvider(columnSpanHeaderDataProvider, rowSpanHeaderDataProvider);
		cornerDataLayer = new DataLayer(cornerDataProvider, colWidth, rowHeight);
		cornerLayer = new CornerLayer(cornerDataLayer, rowHeaderLayer, columnHeaderLayer);
		
		gridLayer = new GridLayer(viewportLayer, columnHeaderLayer, rowHeaderLayer, cornerLayer);
	}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
public ColumnSpanHeaderLayer(IUniqueIndexLayer baseLayer,
		ILayer horizontalLayerDependency,
		SelectionLayer selectionLayer, boolean useDefaultConfiguration,
		ILayerPainter layerPainter) {
	super(baseLayer, horizontalLayerDependency, selectionLayer,
			useDefaultConfiguration, layerPainter);
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
/**
 * clear selection
 */
public void clearSelection() {
    SelectionLayer selLayer = getSelectionLayer();
    if (selLayer != null) {
        selLayer.clear();
    }
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
/**
 * select first row in the table
 */
public void setDefaultSelection() {
    SelectionLayer selLayer = getSelectionLayer();
    if (selLayer != null) {
        selLayer.selectRow(0, 0, false, false);
    }
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
/**
 * @return true if selection layer have selected rows
 */
public boolean hasSelection() {
    SelectionLayer selLayer = getSelectionLayer();
    if (selLayer != null && selLayer.hasRowSelection()) {
        return true;
    }
    return false;
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的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.selection.SelectionLayer; //导入依赖的package包/类
public SelectionExampleBodyLayerStack(IUniqueIndexLayer underlyingLayer) {
    this.columnReorderLayer = new ColumnReorderLayer(underlyingLayer);
    this.columnHideShowLayer = new ColumnHideShowLayer(this.columnReorderLayer);

    // No autoconfig on selection layer
    this.selectionLayer = new SelectionLayer(this.columnHideShowLayer, false);

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

    registerCommandHandler(new CopyDataCommandHandler(this.selectionLayer));
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
public RowSpanHeaderLayer(IUniqueIndexLayer baseLayer,
		ILayer verticalLayerDependency, SelectionLayer selectionLayer,
		boolean useDefaultConfiguration, ILayerPainter layerPainter) {
	super(baseLayer, verticalLayerDependency, selectionLayer,
			useDefaultConfiguration, layerPainter);
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
public SelectionLayer getSelectionLayer() {
    return selectionLayer;
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
RowIndexSelectionModel(final IDataProvider dataProvider, final SelectionLayer selectionLayer) {
    super(selectionLayer, new RowIndexDataProvider(dataProvider), new RowIndexAccessor());
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
@Override
public void selectCell(
    final int columnPosition,
    final int rowPosition,
    final boolean withShiftMask,
    final boolean withControlMask) {

    if (!withShiftMask && !withControlMask) {
        this.selectionLayer.clear(false);
    }

    final ILayerCell cell = this.selectionLayer.getCellByPosition(columnPosition, rowPosition);

    if (cell != null) {
        this.selectionLayer.setLastSelectedCell(cell.getOriginColumnPosition(), cell.getOriginRowPosition());

        if (this.selectionLayer.getSelectionModel().isMultipleSelectionAllowed()
            && withShiftMask
            && this.selectionLayer.getLastSelectedRegion() != null
            && this.selectionLayer.hasRowSelection()
            && (this.selectionLayer.getSelectionAnchor().rowPosition != SelectionLayer.NO_SELECTION)
            && (this.selectionLayer.getSelectionAnchor().columnPosition != SelectionLayer.NO_SELECTION)) {

            final Rectangle lastSelected = copyRectangle(this.selectionLayer.getLastSelectedRegion());

            final Interval<Integer> newSelection = createOrderedInterval(
                    this.selectionLayer.getSelectionAnchor().rowPosition,
                    cell.getOriginRowPosition());

            lastSelected.height = calcDistance(newSelection) + 1;
            lastSelected.y = newSelection.getLeftBoundary();

            if (!withControlMask) {
                selectionLayer.getSelectionModel().clearSelection();
            }

            this.selectionLayer.setLastSelectedRegion(lastSelected);
            this.selectionLayer.addSelection(lastSelected);
        }
        else {
            this.selectionLayer.setLastSelectedRegion(null);
            final Rectangle selection = new Rectangle(
                cell.getOriginColumnPosition(),
                cell.getOriginRowPosition(),
                cell.getColumnSpan(),
                cell.getRowSpan());

            this.selectionLayer.addSelection(selection);
        }
    }
}
 

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; //导入依赖的package包/类
SelectionLayer getSelectionLayer() {
    return selectionLayer;
}