/*******************************************************************************
* Copyright (c) 2012, 2013 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.reorder.event;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.eclipse.nebula.widgets.nattable.coordinate.PositionUtil;
import org.eclipse.nebula.widgets.nattable.coordinate.Range;
import org.eclipse.nebula.widgets.nattable.layer.ILayer;
import org.eclipse.nebula.widgets.nattable.layer.event.ColumnStructuralChangeEvent;
import org.eclipse.nebula.widgets.nattable.layer.event.StructuralDiff;
import org.eclipse.nebula.widgets.nattable.layer.event.StructuralDiff.DiffTypeEnum;
/**
* Event indicating that one or multiple columns are moved to a new position.
*/
public class ColumnReorderEvent extends ColumnStructuralChangeEvent {
private Collection<Range> beforeFromColumnPositionRanges;
private int beforeToColumnPosition;
private boolean reorderToLeftEdge;
public ColumnReorderEvent(ILayer layer, int beforeFromColumnPosition,
int beforeToColumnPosition, boolean reorderToLeftEdge) {
this(layer, Arrays.asList(new Integer[] { Integer
.valueOf(beforeFromColumnPosition) }), beforeToColumnPosition,
reorderToLeftEdge);
}
public ColumnReorderEvent(ILayer layer,
List<Integer> beforeFromColumnPositions,
int beforeToColumnPosition, boolean reorderToLeftEdge) {
super(layer);
this.beforeFromColumnPositionRanges = PositionUtil
.getRanges(beforeFromColumnPositions);
this.reorderToLeftEdge = reorderToLeftEdge;
this.beforeToColumnPosition = beforeToColumnPosition;
List<Integer> allColumnPositions = new ArrayList<Integer>(
beforeFromColumnPositions);
allColumnPositions.add(Integer.valueOf(beforeToColumnPosition));
setColumnPositionRanges(PositionUtil.getRanges(allColumnPositions));
}
/**
* Constructor for internal use to clone this event.
*
* @param event
* The event out of which the new one should be created
*/
public ColumnReorderEvent(ColumnReorderEvent event) {
super(event);
this.beforeFromColumnPositionRanges = event.beforeFromColumnPositionRanges;
this.beforeToColumnPosition = event.beforeToColumnPosition;
this.reorderToLeftEdge = event.reorderToLeftEdge;
}
public Collection<Range> getBeforeFromColumnPositionRanges() {
return this.beforeFromColumnPositionRanges;
}
public int getBeforeToColumnPosition() {
return this.beforeToColumnPosition;
}
public boolean isReorderToLeftEdge() {
return this.reorderToLeftEdge;
}
@Override
public Collection<StructuralDiff> getColumnDiffs() {
Collection<StructuralDiff> columnDiffs = new ArrayList<StructuralDiff>();
Collection<Range> beforeFromColumnPositionRanges = getBeforeFromColumnPositionRanges();
final int beforeToColumnPosition = (this.reorderToLeftEdge) ? this.beforeToColumnPosition
: (this.beforeToColumnPosition + 1);
int afterAddColumnPosition = beforeToColumnPosition;
for (Range beforeFromColumnPositionRange : beforeFromColumnPositionRanges) {
if (beforeFromColumnPositionRange.start < beforeToColumnPosition) {
afterAddColumnPosition -= Math.min(
beforeFromColumnPositionRange.end,
beforeToColumnPosition)
- beforeFromColumnPositionRange.start;
} else {
break;
}
}
int cumulativeAddSize = 0;
for (Range beforeFromColumnPositionRange : beforeFromColumnPositionRanges) {
cumulativeAddSize += beforeFromColumnPositionRange.size();
}
int offset = 0;
for (Range beforeFromColumnPositionRange : beforeFromColumnPositionRanges) {
int afterDeleteColumnPosition = beforeFromColumnPositionRange.start
- offset;
if (afterAddColumnPosition < afterDeleteColumnPosition) {
afterDeleteColumnPosition += cumulativeAddSize;
}
columnDiffs.add(new StructuralDiff(DiffTypeEnum.DELETE,
beforeFromColumnPositionRange, new Range(
afterDeleteColumnPosition,
afterDeleteColumnPosition)));
offset += beforeFromColumnPositionRange.size();
}
Range beforeAddRange = new Range(beforeToColumnPosition,
beforeToColumnPosition);
offset = 0;
for (Range beforeFromColumnPositionRange : beforeFromColumnPositionRanges) {
int size = beforeFromColumnPositionRange.size();
columnDiffs.add(new StructuralDiff(DiffTypeEnum.ADD,
beforeAddRange, new Range(afterAddColumnPosition + offset,
afterAddColumnPosition + offset + size)));
offset += size;
}
return columnDiffs;
}
@Override
public boolean convertToLocal(ILayer targetLayer) {
this.beforeFromColumnPositionRanges = targetLayer
.underlyingToLocalColumnPositions(getLayer(),
this.beforeFromColumnPositionRanges);
this.beforeToColumnPosition = targetLayer.underlyingToLocalColumnPosition(
getLayer(), this.beforeToColumnPosition);
if (this.beforeToColumnPosition >= 0) {
return super.convertToLocal(targetLayer);
} else {
return false;
}
}
@Override
public ColumnReorderEvent cloneEvent() {
return new ColumnReorderEvent(this);
}
}