import java.util.Collections;

import org.eclipse.swt.widgets.Display;

import org.eclipse.gef.AutoexposeHelper;

private PrecisionPoint sourceRelativeStartPoint;

private AutoexposeHelper exposeHelper;

class QueuedAutoexpose implements Runnable {

    public void run() {

        if (exposeHelper != null)

            doAutoexpose();

    }

}

/**

 * Called to perform an iteration of the autoexpose process.  If the expose helper is set,

 * it will be asked to step at the current mouse location.  If it returns true, another

 * expose iteration will be queued.  There is no delay between autoexpose events, other

 * than the time required to perform the step().

 */

protected void doAutoexpose() {

    if (exposeHelper == null)

        return;

    if (exposeHelper.step(getLocation())) {

        handleAutoexpose();

        Display.getCurrent().asyncExec(new QueuedAutoexpose());

    } else

        setAutoexposeHelper(null);

}

protected void handleAutoexpose() {

    updateSourceRequest();

    showSourceFeedback();

    showTargetFeedback();

    setCurrentCommand(getCommand());

}

/**

 * Returns <code>null</code> or the current autoexpose helper.

 * @return null or a helper

 */

protected AutoexposeHelper getAutoexposeHelper() {

    return exposeHelper;

}

/**

 * Sets the active autoexpose helper to the given helper, or <code>null</code>.  If the

 * helper is not <code>null</code>, a runnable is queued on the event thread that will

 * trigger a subsequent {@link #doAutoexpose()}.  The helper is typically updated only on

 * a hover event.

 * @param helper the new autoexpose helper or <code>null</code>

 */

protected void setAutoexposeHelper(AutoexposeHelper helper) {

    exposeHelper = helper;

    if (exposeHelper == null)

        return;

    Display.getCurrent().asyncExec(new QueuedAutoexpose());

    if (sourceRelativeStartPoint == null && isInDragInProgress()) {

        IFigure figure = getTargetEditPart().getFigure();

        sourceRelativeStartPoint = new PrecisionPoint(getStartLocation());

        figure.translateToRelative(sourceRelativeStartPoint);

    }

}

/**

 * Updates the active {@link AutoexposeHelper}. Does nothing if there is still an active

 * helper. Otherwise, obtains a new helper (possible <code>null</code>) at the current

 * mouse location and calls {@link #setAutoexposeHelper(AutoexposeHelper)}.

 */

protected void updateAutoexposeHelper() {

    if (exposeHelper != null)

        return;

    AutoexposeHelper.Search search;

    search = new AutoexposeHelper.Search(getLocation());

    getCurrentViewer()

        .findObjectAtExcluding(getLocation(), Collections.EMPTY_LIST, search);

    setAutoexposeHelper(search.result);

}

/**

 * If auto scroll (also called auto expose) is being performed, the start location moves 

 * during the scroll. This method updates that location.

 */

protected void repairStartLocation() {

    if (sourceRelativeStartPoint == null)

        return;

    IFigure figure = getTargetEditPart().getFigure();

    PrecisionPoint newStart = (PrecisionPoint)sourceRelativeStartPoint.getCopy();

    figure.translateToAbsolute(newStart);

    Point delta = new Point(newStart.x - getStartLocation().x,

                            newStart.y - getStartLocation().y);

    setStartLocation(newStart);

    // sourceRect needs to be updated as well when auto-scrolling

    if (sourceRect != null)

        sourceRect.translate(delta);

;

}

	sourceRelativeStartPoint = null;

	setAutoexposeHelper(null);

protected boolean handleHover() {

    if (isInDragInProgress())

        updateAutoexposeHelper();

    return true;

}

    repairStartLocation();