/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.gef.tools;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartListener;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.Request;
import org.eclipse.gef.RequestConstants;
import org.eclipse.gef.SharedCursors;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.requests.CreateConnectionRequest;
import org.eclipse.gef.requests.CreateRequest;
import org.eclipse.gef.requests.CreationFactory;
/**
* The base implementation for tools which create a connection. A connection is
* a link between two existing GraphicalEditParts.
* <P>
* A connection creation tool uses a {@link CreateConnectionRequest} to perform
* the creation. This request is sent to both graphical editparts which serve as
* the "nodes" at each end of the connection. The first node clicked on is the
* source. The source is asked for a <code>Command</code> that represents
* creating the first half of the connection. This command is then passed to the
* target editpart, which is reponsible for creating the final Command that is
* executed.
*
* @author hudsonr
*/
public class AbstractConnectionCreationTool extends TargetingTool {
/**
* The state which indicates that the connection creation has begun. This
* means that the source of the connection has been identified, and the user
* is still to determine the target.
*/
protected static final int STATE_CONNECTION_STARTED = TargetingTool.MAX_STATE << 1;
/**
* The max state.
*/
protected static final int MAX_STATE = STATE_CONNECTION_STARTED;
private static final int FLAG_SOURCE_FEEDBACK = TargetingTool.MAX_FLAG << 1;
/**
* The max flag.
*/
protected static final int MAX_FLAG = FLAG_SOURCE_FEEDBACK;
private EditPart connectionSource;
private CreationFactory factory;
private EditPartViewer viewer;
private EditPartListener.Stub deactivationListener = new EditPartListener.Stub() {
public void partDeactivated(EditPart editpart) {
handleSourceDeactivated();
}
};
/**
* The default constructor
*/
public AbstractConnectionCreationTool() {
setDefaultCursor(SharedCursors.CURSOR_PLUG);
setDisabledCursor(SharedCursors.CURSOR_PLUG_NOT);
}
/**
* Constructs a new abstract creation tool with the given creation factory.
*
* @param factory
* the creation factory
*/
public AbstractConnectionCreationTool(CreationFactory factory) {
this();
setFactory(factory);
}
/**
* @see org.eclipse.gef.tools.AbstractTool#calculateCursor()
*/
protected Cursor calculateCursor() {
if (isInState(STATE_INITIAL)) {
if (getCurrentCommand() != null)
return getDefaultCursor();
}
return super.calculateCursor();
}
/**
* @see org.eclipse.gef.tools.TargetingTool#createTargetRequest()
*/
protected Request createTargetRequest() {
CreateRequest req = new CreateConnectionRequest();
req.setFactory(getFactory());
return req;
}
/**
* Erases feedback and sets fields to <code>null</code>.
*
* @see org.eclipse.gef.Tool#deactivate()
*/
public void deactivate() {
eraseSourceFeedback();
setConnectionSource(null);
super.deactivate();
setState(STATE_TERMINAL);
viewer = null;
}
/**
* Asks the source editpart to erase connection creation feedback.
*/
protected void eraseSourceFeedback() {
if (!isShowingSourceFeedback())
return;
setFlag(FLAG_SOURCE_FEEDBACK, false);
if (connectionSource != null) {
connectionSource.eraseSourceFeedback(getSourceRequest());
}
}
/**
* @see org.eclipse.gef.tools.AbstractTool#getCommandName()
*/
protected String getCommandName() {
if (isInState(STATE_CONNECTION_STARTED
| STATE_ACCESSIBLE_DRAG_IN_PROGRESS))
return REQ_CONNECTION_END;
else
return REQ_CONNECTION_START;
}
/**
* @see org.eclipse.gef.tools.AbstractTool#getDebugName()
*/
protected String getDebugName() {
return "Connection Creation Tool";//$NON-NLS-1$
}
/**
* @see org.eclipse.gef.tools.AbstractTool#getDebugNameForState(int)
*/
protected String getDebugNameForState(int s) {
if (s == STATE_CONNECTION_STARTED
|| s == STATE_ACCESSIBLE_DRAG_IN_PROGRESS)
return "Connection Started";//$NON-NLS-1$
return super.getDebugNameForState(s);
}
/**
* Returns the creation factory that will be used with the create connection
* request.
*
* @return the creation factory
*/
protected CreationFactory getFactory() {
return factory;
}
/**
* Returns the request sent to the source node. The source node receives the
* same request that is used with the target node. The only difference is
* that at that time the request will be typed as
* {@link RequestConstants#REQ_CONNECTION_START}.
*
* @return the request used with the source node editpart
*/
protected Request getSourceRequest() {
return getTargetRequest();
}
/**
* When the button is first pressed, the source node and its command
* contribution are determined and locked in. After that time, the tool will
* be looking for the target node to complete the connection
*
* @see org.eclipse.gef.tools.AbstractTool#handleButtonDown(int)
* @param button
* which button is pressed
* @return <code>true</code> if the button down was processed
*/
protected boolean handleButtonDown(int button) {
if (isInState(STATE_INITIAL) && button == 1) {
updateTargetRequest();
updateTargetUnderMouse();
setConnectionSource(getTargetEditPart());
Command command = getCommand();
((CreateConnectionRequest) getTargetRequest())
.setSourceEditPart(getTargetEditPart());
if (command != null) {
setState(STATE_CONNECTION_STARTED);
setCurrentCommand(command);
viewer = getCurrentViewer();
}
}
if (isInState(STATE_INITIAL) && button != 1) {
setState(STATE_INVALID);
handleInvalidInput();
}
return true;
}
/**
* Unloads or resets the tool if the state is in the terminal or invalid
* state.
*
* @see org.eclipse.gef.tools.AbstractTool#handleButtonUp(int)
*/
protected boolean handleButtonUp(int button) {
if (isInState(STATE_TERMINAL | STATE_INVALID))
handleFinished();
return true;
}
/**
* @see org.eclipse.gef.tools.AbstractTool#handleCommandStackChanged()
*/
protected boolean handleCommandStackChanged() {
if (!isInState(STATE_INITIAL)) {
if (getCurrentInput().isMouseButtonDown(1))
setState(STATE_INVALID);
else
setState(STATE_INITIAL);
handleInvalidInput();
return true;
}
return false;
}
/**
* Method that is called when the gesture to create the connection has been
* received. Subclasses may extend or override this method to do additional
* creation setup, such as prompting the user to choose an option about the
* connection being created. Returns <code>true</code> to indicate that the
* connection creation succeeded.
*
* @return <code>true</code> if the connection creation was performed
*/
protected boolean handleCreateConnection() {
eraseSourceFeedback();
Command endCommand = getCommand();
setCurrentCommand(endCommand);
executeCurrentCommand();
return true;
}
/**
* @see org.eclipse.gef.tools.AbstractTool#handleDrag()
*/
protected boolean handleDrag() {
if (isInState(STATE_CONNECTION_STARTED))
return handleMove();
return false;
}
/**
* @see org.eclipse.gef.tools.AbstractTool#handleDragInProgress()
*/
protected boolean handleDragInProgress() {
if (isInState(STATE_ACCESSIBLE_DRAG_IN_PROGRESS))
return handleMove();
return false;
}
/**
* @see org.eclipse.gef.tools.AbstractTool#handleFocusLost()
*/
protected boolean handleFocusLost() {
if (isInState(STATE_CONNECTION_STARTED)) {
eraseSourceFeedback();
eraseTargetFeedback();
setState(STATE_INVALID);
handleFinished();
}
return super.handleFocusLost();
}
/**
* @see org.eclipse.gef.tools.TargetingTool#handleHover()
*/
protected boolean handleHover() {
if (isInState(STATE_CONNECTION_STARTED))
updateAutoexposeHelper();
return true;
}
/**
* @see org.eclipse.gef.tools.TargetingTool#handleInvalidInput()
*/
protected boolean handleInvalidInput() {
eraseSourceFeedback();
setConnectionSource(null);
return super.handleInvalidInput();
}
/**
* @see org.eclipse.gef.tools.AbstractTool#handleMove()
*/
protected boolean handleMove() {
if (isInState(STATE_CONNECTION_STARTED) && viewer != getCurrentViewer())
return false;
if (isInState(STATE_CONNECTION_STARTED | STATE_INITIAL
| STATE_ACCESSIBLE_DRAG_IN_PROGRESS)) {
updateTargetRequest();
updateTargetUnderMouse();
showSourceFeedback();
showTargetFeedback();
setCurrentCommand(getCommand());
}
return true;
}
/**
* Called if the source editpart is deactivated for some reason during the
* creation process. For example, the user performs an Undo while in the
* middle of creating a connection, which undoes a prior command which
* created the source.
*/
protected void handleSourceDeactivated() {
setState(STATE_INVALID);
handleInvalidInput();
handleFinished();
}
/**
* Returns <code>true</code> if feedback is being shown.
*
* @return <code>true</code> if showing source feedback
*/
protected boolean isShowingSourceFeedback() {
return getFlag(FLAG_SOURCE_FEEDBACK);
}
/**
* Sets the source editpart for the creation
*
* @param source
* the source editpart node
*/
protected void setConnectionSource(EditPart source) {
if (connectionSource != null)
connectionSource.removeEditPartListener(deactivationListener);
connectionSource = source;
if (connectionSource != null)
connectionSource.addEditPartListener(deactivationListener);
}
/**
* Sets the creation factory used in the request.
*
* @param factory
* the factory
*/
public void setFactory(CreationFactory factory) {
this.factory = factory;
}
/**
* Sends a show feedback request to the source editpart and sets the
* feedback flag.
*/
protected void showSourceFeedback() {
if (connectionSource != null) {
connectionSource.showSourceFeedback(getSourceRequest());
}
setFlag(FLAG_SOURCE_FEEDBACK, true);
}
/**
* @see org.eclipse.gef.tools.TargetingTool#updateTargetRequest()
*/
protected void updateTargetRequest() {
CreateConnectionRequest request = (CreateConnectionRequest) getTargetRequest();
request.setType(getCommandName());
request.setLocation(getLocation());
}
}