/*******************************************************************************
 * Copyright (c) 2012, 2020 Original authors and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Original authors and others - initial API and implementation
 *     Dirk Fauth <dirk.fauth@googlemail.com> - added ITraversalStrategy handling
 ******************************************************************************/
package org.eclipse.nebula.widgets.nattable.selection;

import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
import org.eclipse.nebula.widgets.nattable.selection.ITraversalStrategy.TraversalScope;
import org.eclipse.nebula.widgets.nattable.selection.command.MoveSelectionCommand;

/**
 * Specifies the semantics of moving the selection in the table, based on
 * selecting the adjoining cell(s).
 */
public class MoveCellSelectionCommandHandler extends MoveSelectionCommandHandler<MoveSelectionCommand> {

    protected PositionCoordinate lastSelectedCellPosition;
    protected int newSelectedColumnPosition;
    protected int newSelectedRowPosition;

    /**
     * Create a MoveCellSelectionCommandHandler for the given
     * {@link SelectionLayer}. Uses the
     * {@link ITraversalStrategy#AXIS_TRAVERSAL_STRATEGY} as default strategy
     * for selection movement.
     *
     * @param selectionLayer
     *            The {@link SelectionLayer} on which the selection should be
     *            performed.
     */
    public MoveCellSelectionCommandHandler(SelectionLayer selectionLayer) {
        super(selectionLayer);
    }

    /**
     * Create a MoveCellSelectionCommandHandler for the given
     * {@link SelectionLayer}.
     *
     * @param selectionLayer
     *            The {@link SelectionLayer} on which the selection should be
     *            performed.
     * @param traversalStrategy
     *            The strategy that should be used for selection movements. Can
     *            not be <code>null</code>.
     */
    public MoveCellSelectionCommandHandler(SelectionLayer selectionLayer, ITraversalStrategy traversalStrategy) {
        super(selectionLayer, traversalStrategy);
    }

    /**
     * Create a MoveCellSelectionCommandHandler for the given
     * {@link SelectionLayer} .
     *
     * @param selectionLayer
     *            The {@link SelectionLayer} on which the selection should be
     *            performed.
     * @param horizontalTraversalStrategy
     *            The strategy that should be used for horizontal selection
     *            movements. Can not be <code>null</code>.
     * @param verticalTraversalStrategy
     *            The strategy that should be used for vertical selection
     *            movements. Can not be <code>null</code>.
     */
    public MoveCellSelectionCommandHandler(SelectionLayer selectionLayer,
            ITraversalStrategy horizontalTraversalStrategy, ITraversalStrategy verticalTraversalStrategy) {
        super(selectionLayer, horizontalTraversalStrategy, verticalTraversalStrategy);
    }

    @Override
    protected void moveLastSelectedLeft(ITraversalStrategy traversalStrategy, boolean withShiftMask, boolean withControlMask) {
        if (this.selectionLayer.hasColumnSelection()) {
            this.lastSelectedCellPosition = this.selectionLayer.getCellPositionToMoveFrom(withShiftMask, withControlMask);
            ILayerCell lastSelectedCell = this.selectionLayer.getCellByPosition(
                    this.lastSelectedCellPosition.columnPosition,
                    this.lastSelectedCellPosition.rowPosition);
            if (lastSelectedCell != null) {
                int stepSize = traversalStrategy.getStepCount();
                this.newSelectedColumnPosition = (stepSize >= 0) ? (lastSelectedCell.getOriginColumnPosition() - stepSize) : 0;

                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;

                ILayerCell newSelected = this.selectionLayer.getCellByPosition(
                        this.newSelectedColumnPosition,
                        this.newSelectedRowPosition);
                if (newSelected != null) {
                    this.newSelectedColumnPosition = newSelected.getOriginColumnPosition();
                }

                // boolean flag to stop traversal if calculated target is
                // invalid needed to avoid endless loop if there are no further
                // valid traversal targets
                boolean stopTraversalOnInvalid = false;

                if (this.newSelectedColumnPosition < 0) {
                    if (traversalStrategy.getTraversalScope().equals(TraversalScope.AXIS)) {
                        if (!traversalStrategy.isCycle()) {
                            // on axis scope with no cycle, stop moving
                            this.newSelectedColumnPosition = 0;
                            stopTraversalOnInvalid = true;
                        } else {
                            // on axis scope with cycle, move to end
                            while (this.newSelectedColumnPosition < 0) {
                                this.newSelectedColumnPosition = this.newSelectedColumnPosition + this.selectionLayer.getColumnCount();
                            }
                        }
                    } else if (traversalStrategy.getTraversalScope().equals(TraversalScope.TABLE)) {
                        // on table scope, move to end
                        int rowMove = 0;
                        while (this.newSelectedColumnPosition < 0) {
                            this.newSelectedColumnPosition = this.newSelectedColumnPosition + this.selectionLayer.getColumnCount();
                            rowMove++;
                        }
                        this.newSelectedRowPosition = this.newSelectedRowPosition - rowMove;
                        if (this.newSelectedRowPosition < 0) {
                            if (traversalStrategy.isCycle()) {
                                // at the top and cycle so go to bottom
                                this.newSelectedRowPosition = this.newSelectedRowPosition + this.selectionLayer.getRowCount();
                            } else {
                                // at the top and no cycle so stop moving
                                this.newSelectedColumnPosition = 0;
                                this.newSelectedRowPosition = 0;
                                stopTraversalOnInvalid = true;
                            }
                        }
                    }
                }

                if (positionMoved()) {
                    // check if calculated target is valid, otherwise move to
                    // adjacent
                    if (!traversalStrategy.isValidTarget(lastSelectedCell,
                            this.selectionLayer.getCellByPosition(this.newSelectedColumnPosition, this.newSelectedRowPosition))) {

                        // for MOVE_ALL we need to go backwards to find the last
                        // valid position
                        if (stepSize == SelectionLayer.MOVE_ALL) {
                            for (int i = this.newSelectedColumnPosition; i < this.selectionLayer.getColumnCount(); i++) {
                                ILayerCell newPosition = this.selectionLayer.getCellByPosition(i, this.newSelectedRowPosition);
                                if (traversalStrategy.isValidTarget(lastSelectedCell, newPosition)) {
                                    this.newSelectedColumnPosition = i;

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

                                    this.selectionLayer.selectCell(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            withShiftMask,
                                            withControlMask);
                                    this.selectionLayer.fireCellSelectionEvent(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            true,
                                            withShiftMask,
                                            withControlMask);

                                    break;
                                }
                            }
                        } else {
                            if (!stopTraversalOnInvalid) {
                                moveLastSelectedLeft(
                                        createIncrementalStrategy(traversalStrategy),
                                        withShiftMask, withControlMask);
                            } else {
                                // since the calculated target is invalid and
                                // invalid traversal movement should stop, the
                                // new selected position is the last valid one
                                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;
                                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;
                            }
                        }
                    } else {
                        if (stepSize == SelectionLayer.MOVE_ALL && !withShiftMask) {
                            this.selectionLayer.clear(false);
                        }

                        this.selectionLayer.selectCell(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                withShiftMask,
                                withControlMask);
                        this.selectionLayer.fireCellSelectionEvent(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                true,
                                withShiftMask,
                                withControlMask);
                    }
                }
            }
        }
    }

    @Override
    protected void moveLastSelectedRight(final ITraversalStrategy traversalStrategy, boolean withShiftMask, boolean withControlMask) {
        if (this.selectionLayer.hasColumnSelection()) {
            this.lastSelectedCellPosition = this.selectionLayer.getCellPositionToMoveFrom(withShiftMask, withControlMask);
            ILayerCell lastSelectedCell = this.selectionLayer.getCellByPosition(
                    this.lastSelectedCellPosition.columnPosition,
                    this.lastSelectedCellPosition.rowPosition);
            if (lastSelectedCell != null) {
                int stepSize = traversalStrategy.getStepCount();
                this.newSelectedColumnPosition = (stepSize >= 0)
                        ? (lastSelectedCell.getOriginColumnPosition() + lastSelectedCell.getColumnSpan() - 1 + stepSize)
                        : (this.selectionLayer.getColumnCount() - 1);

                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;

                ILayerCell newSelected = this.selectionLayer.getCellByPosition(
                        this.newSelectedColumnPosition,
                        this.newSelectedRowPosition);
                if (newSelected != null) {
                    // if cell has column spanning, ensure that the whole cell
                    // is displayed
                    this.newSelectedColumnPosition = newSelected.getOriginColumnPosition() + newSelected.getColumnSpan() - 1;
                }

                // boolean flag to stop traversal if calculated target is
                // invalid needed to avoid endless loop if there are no further
                // valid traversal targets
                boolean stopTraversalOnInvalid = false;

                if (this.newSelectedColumnPosition >= this.selectionLayer.getColumnCount()) {
                    if (traversalStrategy.getTraversalScope().equals(TraversalScope.AXIS)) {
                        if (!traversalStrategy.isCycle()) {
                            // on axis scope with no cycle, stop moving
                            this.newSelectedColumnPosition = this.selectionLayer.getColumnCount() - 1;
                            stopTraversalOnInvalid = true;
                        } else {
                            // on axis scope with cycle, start over at table
                            // beginning
                            while (this.newSelectedColumnPosition >= this.selectionLayer.getColumnCount()) {
                                this.newSelectedColumnPosition = this.newSelectedColumnPosition - this.selectionLayer.getColumnCount();
                            }
                        }
                    } else if (traversalStrategy.getTraversalScope().equals(TraversalScope.TABLE)) {
                        // on table scope, start over at table beginning
                        int rowMove = 0;
                        while (this.newSelectedColumnPosition >= this.selectionLayer.getColumnCount()) {
                            this.newSelectedColumnPosition = this.newSelectedColumnPosition - this.selectionLayer.getColumnCount();
                            rowMove++;
                        }
                        this.newSelectedRowPosition = this.newSelectedRowPosition + rowMove;
                        if (this.newSelectedRowPosition >= this.selectionLayer.getRowCount()) {
                            if (traversalStrategy.isCycle()) {
                                // at the bottom and cycle so go to top
                                this.newSelectedRowPosition = this.newSelectedRowPosition - this.selectionLayer.getRowCount();
                            } else {
                                // at the bottom and no cycle so stop moving
                                this.newSelectedColumnPosition = this.selectionLayer.getColumnCount() - 1;
                                this.newSelectedRowPosition = this.selectionLayer.getRowCount() - 1;
                                stopTraversalOnInvalid = true;
                            }
                        }
                    }
                }

                if (positionMoved()) {
                    // check if calculated target is valid, otherwise move to
                    // adjacent
                    if (!traversalStrategy.isValidTarget(lastSelectedCell,
                            this.selectionLayer.getCellByPosition(this.newSelectedColumnPosition, this.newSelectedRowPosition))) {

                        // for MOVE_ALL we need to go backwards to find the last
                        // valid position
                        if (stepSize == SelectionLayer.MOVE_ALL) {
                            for (int i = this.newSelectedColumnPosition; i >= 0; i--) {
                                ILayerCell newPosition = this.selectionLayer.getCellByPosition(i, this.newSelectedRowPosition);
                                if (traversalStrategy.isValidTarget(lastSelectedCell, newPosition)) {
                                    this.newSelectedColumnPosition = i;

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

                                    this.selectionLayer.selectCell(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            withShiftMask,
                                            withControlMask);
                                    this.selectionLayer.fireCellSelectionEvent(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            true,
                                            withShiftMask,
                                            withControlMask);

                                    break;
                                }
                            }
                        } else {
                            if (!stopTraversalOnInvalid) {
                                moveLastSelectedRight(
                                        createIncrementalStrategy(traversalStrategy),
                                        withShiftMask, withControlMask);
                            } else {
                                // since the calculated target is invalid and
                                // invalid traversal movement should stop, the
                                // new selected position is the last valid one
                                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;
                                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;
                            }
                        }
                    } else {
                        if (stepSize == SelectionLayer.MOVE_ALL && !withShiftMask) {
                            this.selectionLayer.clear(false);
                        }

                        this.selectionLayer.selectCell(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                withShiftMask,
                                withControlMask);
                        this.selectionLayer.fireCellSelectionEvent(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                true,
                                withShiftMask,
                                withControlMask);
                    }
                }
            }
        }
    }

    @Override
    protected void moveLastSelectedUp(ITraversalStrategy traversalStrategy, boolean withShiftMask, boolean withControlMask) {
        if (this.selectionLayer.hasRowSelection()) {
            this.lastSelectedCellPosition = this.selectionLayer.getCellPositionToMoveFrom(withShiftMask, withControlMask);
            ILayerCell lastSelectedCell = this.selectionLayer.getCellByPosition(
                    this.lastSelectedCellPosition.columnPosition,
                    this.lastSelectedCellPosition.rowPosition);
            if (lastSelectedCell != null) {
                int stepSize = traversalStrategy.getStepCount();
                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;

                this.newSelectedRowPosition = (stepSize >= 0) ? lastSelectedCell.getOriginRowPosition() - stepSize : 0;

                ILayerCell newSelected = this.selectionLayer.getCellByPosition(
                        this.newSelectedColumnPosition,
                        this.newSelectedRowPosition);
                if (newSelected != null) {
                    this.newSelectedRowPosition = newSelected.getOriginRowPosition();
                }

                // boolean flag to stop traversal if calculated target is
                // invalid needed to avoid endless loop if there are no further
                // valid traversal targets
                boolean stopTraversalOnInvalid = false;

                if (this.newSelectedRowPosition < 0) {
                    if (traversalStrategy.getTraversalScope().equals(TraversalScope.AXIS)) {
                        if (!traversalStrategy.isCycle()) {
                            // on axis scope with no cycle, stop moving
                            this.newSelectedRowPosition = 0;
                            stopTraversalOnInvalid = true;
                        } else {
                            // on axis scope with cycle, move to bottom
                            while (this.newSelectedRowPosition < 0) {
                                this.newSelectedRowPosition = this.newSelectedRowPosition + this.selectionLayer.getRowCount();
                            }
                        }
                    } else if (traversalStrategy.getTraversalScope().equals(TraversalScope.TABLE)) {
                        // on table scope, move to bottom
                        int columnMove = 0;
                        while (this.newSelectedRowPosition < 0) {
                            this.newSelectedRowPosition = this.newSelectedRowPosition + this.selectionLayer.getRowCount();
                            columnMove++;
                        }
                        this.newSelectedColumnPosition = this.newSelectedColumnPosition - columnMove;
                        if (this.newSelectedColumnPosition < 0) {
                            if (traversalStrategy.isCycle()) {
                                // at the beginning and cycle so go to end
                                this.newSelectedColumnPosition = this.newSelectedColumnPosition + this.selectionLayer.getColumnCount();
                            } else {
                                // at the top and no cycle so stop moving
                                this.newSelectedColumnPosition = 0;
                                this.newSelectedRowPosition = 0;
                                stopTraversalOnInvalid = true;
                            }
                        }
                    }
                }

                if (positionMoved()) {
                    // check if calculated target is valid, otherwise move to
                    // adjacent
                    if (!traversalStrategy.isValidTarget(lastSelectedCell,
                            this.selectionLayer.getCellByPosition(this.newSelectedColumnPosition, this.newSelectedRowPosition))) {

                        // for MOVE_ALL we need to go backwards to find the last
                        // valid position
                        if (stepSize == SelectionLayer.MOVE_ALL) {
                            for (int i = this.newSelectedRowPosition; i < this.selectionLayer.getRowCount(); i++) {
                                ILayerCell newPosition = this.selectionLayer.getCellByPosition(this.newSelectedColumnPosition, i);
                                if (traversalStrategy.isValidTarget(lastSelectedCell, newPosition)) {
                                    this.newSelectedRowPosition = i;

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

                                    this.selectionLayer.selectCell(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            withShiftMask,
                                            withControlMask);
                                    this.selectionLayer.fireCellSelectionEvent(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            true,
                                            withShiftMask,
                                            withControlMask);

                                    break;
                                }
                            }
                        } else {
                            if (!stopTraversalOnInvalid) {
                                moveLastSelectedUp(
                                        createIncrementalStrategy(traversalStrategy),
                                        withShiftMask, withControlMask);
                            } else {
                                // since the calculated target is invalid and
                                // invalid traversal movement should stop, the
                                // new selected position is the last valid one
                                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;
                                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;
                            }
                        }
                    } else {
                        if (stepSize == SelectionLayer.MOVE_ALL && !withShiftMask) {
                            this.selectionLayer.clear(false);
                        }

                        this.selectionLayer.selectCell(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                withShiftMask,
                                withControlMask);
                        this.selectionLayer.fireCellSelectionEvent(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                true,
                                withShiftMask,
                                withControlMask);
                    }
                }
            }
        }
    }

    @Override
    protected void moveLastSelectedDown(ITraversalStrategy traversalStrategy, boolean withShiftMask, boolean withControlMask) {
        if (this.selectionLayer.hasRowSelection()) {
            this.lastSelectedCellPosition = this.selectionLayer.getCellPositionToMoveFrom(withShiftMask, withControlMask);
            ILayerCell lastSelectedCell = this.selectionLayer.getCellByPosition(
                    this.lastSelectedCellPosition.columnPosition,
                    this.lastSelectedCellPosition.rowPosition);
            if (lastSelectedCell != null) {
                int stepSize = traversalStrategy.getStepCount();
                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;

                this.newSelectedRowPosition = (stepSize >= 0)
                        ? lastSelectedCell.getOriginRowPosition() + lastSelectedCell.getRowSpan() - 1 + stepSize
                        : this.selectionLayer.getRowCount() - 1;

                ILayerCell newSelected = this.selectionLayer.getCellByPosition(
                        this.newSelectedColumnPosition,
                        this.newSelectedRowPosition);
                if (newSelected != null) {
                    // if cell has row spanning, ensure that the whole cell is
                    // displayed
                    this.newSelectedRowPosition = newSelected.getOriginRowPosition() + newSelected.getRowSpan() - 1;
                }

                // boolean flag to stop traversal if calculated target is
                // invalid needed to avoid endless loop if there are no further
                // valid traversal targets
                boolean stopTraversalOnInvalid = false;

                if (this.newSelectedRowPosition >= this.selectionLayer.getRowCount()) {
                    if (traversalStrategy.getTraversalScope().equals(TraversalScope.AXIS)) {
                        if (!traversalStrategy.isCycle()) {
                            // on axis scope with no cycle, stop moving
                            this.newSelectedRowPosition = this.selectionLayer.getRowCount() - 1;
                            stopTraversalOnInvalid = true;
                        } else {
                            // on axis scope with cycle, move to top
                            while (this.newSelectedRowPosition >= this.selectionLayer.getRowCount()) {
                                this.newSelectedRowPosition = this.newSelectedRowPosition - this.selectionLayer.getRowCount();
                            }
                        }
                    } else if (traversalStrategy.getTraversalScope().equals(TraversalScope.TABLE)) {
                        // on table scope, move to top
                        int columnMove = 0;
                        while (this.newSelectedRowPosition >= this.selectionLayer.getRowCount()) {
                            this.newSelectedRowPosition = this.newSelectedRowPosition - this.selectionLayer.getRowCount();
                            columnMove++;
                        }
                        this.newSelectedColumnPosition = this.newSelectedColumnPosition + columnMove;
                        if (this.newSelectedColumnPosition >= this.selectionLayer.getColumnCount()) {
                            if (traversalStrategy.isCycle()) {
                                // at the end and cycle so go to beginning
                                this.newSelectedColumnPosition = this.newSelectedColumnPosition - this.selectionLayer.getColumnCount();
                            } else {
                                // at the end and no cycle so stop moving
                                this.newSelectedColumnPosition = this.selectionLayer.getColumnCount() - 1;
                                this.newSelectedRowPosition = this.selectionLayer.getRowCount() - 1;
                                stopTraversalOnInvalid = true;
                            }
                        }
                    }
                }

                if (positionMoved()) {
                    // check if calculated target is valid, otherwise move to
                    // adjacent
                    int targetColumnPosition = newSelected != null ? newSelected.getColumnPosition() : this.newSelectedColumnPosition;
                    int targetRowPosition = newSelected != null ? newSelected.getRowPosition() : this.newSelectedRowPosition;

                    if (!traversalStrategy.isValidTarget(lastSelectedCell,
                            this.selectionLayer.getCellByPosition(targetColumnPosition, targetRowPosition))) {

                        // for MOVE_ALL we need to go backwards to find the last
                        // valid position
                        if (stepSize == SelectionLayer.MOVE_ALL) {
                            for (int i = this.newSelectedRowPosition; i >= 0; i--) {
                                ILayerCell newPosition = this.selectionLayer.getCellByPosition(this.newSelectedColumnPosition, i);
                                if (traversalStrategy.isValidTarget(lastSelectedCell, newPosition)) {
                                    this.newSelectedRowPosition = i;

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

                                    this.selectionLayer.selectCell(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            withShiftMask,
                                            withControlMask);
                                    this.selectionLayer.fireCellSelectionEvent(
                                            this.newSelectedColumnPosition,
                                            this.newSelectedRowPosition,
                                            true,
                                            withShiftMask,
                                            withControlMask);

                                    break;
                                }
                            }
                        } else {
                            if (!stopTraversalOnInvalid) {
                                moveLastSelectedDown(
                                        createIncrementalStrategy(traversalStrategy),
                                        withShiftMask, withControlMask);
                            } else {
                                // since the calculated target is invalid and
                                // invalid traversal movement should stop, the
                                // new selected position is the last valid one
                                this.newSelectedColumnPosition = this.lastSelectedCellPosition.columnPosition;
                                this.newSelectedRowPosition = this.lastSelectedCellPosition.rowPosition;
                            }
                        }
                    } else {
                        if (stepSize == SelectionLayer.MOVE_ALL && !withShiftMask) {
                            this.selectionLayer.clear(false);
                        }

                        this.selectionLayer.selectCell(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                withShiftMask,
                                withControlMask);
                        this.selectionLayer.fireCellSelectionEvent(
                                this.newSelectedColumnPosition,
                                this.newSelectedRowPosition,
                                true,
                                withShiftMask,
                                withControlMask);
                    }
                }
            }
        }
    }

    /**
     * Creates a {@link ITraversalStrategy} that wraps the given base strategy
     * but returning the step count + 1. Used to perform incremental movement in
     * case the base strategy specifies logic to determine whether a target cell
     * is a valid move target or not.
     *
     * @param baseStrategy
     *            The {@link ITraversalStrategy} to wrap.
     * @return A {@link ITraversalStrategy} that wraps the given base strategy
     *         using the given step count.
     */
    protected ITraversalStrategy createIncrementalStrategy(final ITraversalStrategy baseStrategy) {
        return new ITraversalStrategy() {

            @Override
            public TraversalScope getTraversalScope() {
                return baseStrategy.getTraversalScope();
            }

            @Override
            public boolean isCycle() {
                return baseStrategy.isCycle();
            }

            @Override
            public int getStepCount() {
                return baseStrategy.getStepCount() + 1;
            }

            @Override
            public boolean isValidTarget(ILayerCell from, ILayerCell to) {
                return baseStrategy.isValidTarget(from, to);
            }

        };
    }

    /**
     *
     * @return <code>true</code> if the selection moved in any direction,
     *         <code>false</code> if the selection stays at the same position
     */
    protected boolean positionMoved() {
        return (this.newSelectedColumnPosition != this.lastSelectedCellPosition.columnPosition
                || this.newSelectedRowPosition != this.lastSelectedCellPosition.rowPosition);
    }

    @Override
    public Class<MoveSelectionCommand> getCommandClass() {
        return MoveSelectionCommand.class;
    }

}