/******************************************************************************* | |
* Copyright (c) 2008, 2012 IBM Corporation and others. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License 2.0 | |
* which accompanies this distribution, and is available at | |
* https://www.eclipse.org/legal/epl-2.0/ | |
* | |
* SPDX-License-Identifier: EPL-2.0 | |
* | |
* Contributors: | |
* IBM Corporation - initial API and implementation | |
*******************************************************************************/ | |
package org.eclipse.bpel.ui.figures; | |
import java.util.ArrayList; | |
import java.util.List; | |
import java.util.Map; | |
import org.eclipse.bpel.model.CompensationHandler; | |
import org.eclipse.bpel.model.EventHandler; | |
import org.eclipse.bpel.model.FaultHandler; | |
import org.eclipse.bpel.model.TerminationHandler; | |
import org.eclipse.bpel.ui.BPELEditor; | |
import org.eclipse.bpel.ui.BPELUIPlugin; | |
import org.eclipse.bpel.ui.IBPELUIConstants; | |
import org.eclipse.bpel.ui.editparts.BPELEditPart; | |
import org.eclipse.bpel.ui.editparts.FaultHandlerEditPart; | |
import org.eclipse.bpel.ui.editparts.borders.RoundRectangleBorderWithDecoration; | |
import org.eclipse.bpel.ui.util.ModelHelper; | |
import org.eclipse.draw2d.ConnectionAnchor; | |
import org.eclipse.draw2d.IFigure; | |
import org.eclipse.draw2d.PolylineConnection; | |
import org.eclipse.draw2d.geometry.Ray; | |
import org.eclipse.gef.LayerConstants; | |
import org.eclipse.gef.editparts.LayerManager; | |
public abstract class AbstractHandlerLinker { | |
/** | |
* List of all connections handled by this handlerLinker. This | |
* list has to be maintained during the creation of the handlerLinks. | |
*/ | |
private List<PolylineConnection> handlerConnectionsList = new ArrayList<PolylineConnection>(); | |
/** | |
* The editPart to which this handler belongs to | |
*/ | |
private BPELEditPart editPart; | |
/** | |
* Reference to the GEF connectionLayer | |
*/ | |
private IFigure connLayer; | |
public AbstractHandlerLinker(BPELEditPart editPart) { | |
this.editPart = editPart; | |
connLayer = ((LayerManager) editPart.getViewer().getEditPartRegistry() | |
.get(LayerManager.ID)) | |
.getLayer(LayerConstants.CONNECTION_LAYER); | |
} | |
/** | |
* Refreshes all handlerLinks | |
*/ | |
public void refreshHandlerLinks() { | |
clearHandlerConnections(); | |
ConnectionAnchor source = null; | |
ConnectionAnchor target = null; | |
BPELEditor editor = ModelHelper.getBPELEditor(editPart.getModel()); | |
if (editor == null) | |
return; | |
Map reg = editor.getGraphicalViewer().getEditPartRegistry(); | |
FaultHandlerEditPart fhEditPart = (FaultHandlerEditPart) reg | |
.get(getFaultHandler()); | |
FaultHandlerEditPart ehEditPart = (FaultHandlerEditPart) reg | |
.get(getEventHandler()); | |
FaultHandlerEditPart chEditPart = (FaultHandlerEditPart) reg | |
.get(getCompensationHandler()); | |
FaultHandlerEditPart thEditPart = (FaultHandlerEditPart) reg | |
.get(getTerminationHandler()); | |
if (isShowFH()) { | |
if (fhEditPart == null) | |
// not yet initialized | |
return; | |
source = new CenteredConnectionAnchor(getFHFigure(),getFHSourceAnchorLoc(),0); | |
target = new CenteredConnectionAnchor(getFHHandlerFigure(fhEditPart),getFHTargetAnchorLoc(),0); | |
PolylineConnection conn = new PolylineConnection(); | |
conn.setSourceAnchor(source); | |
conn.setTargetAnchor(target); | |
conn.setForegroundColor(BPELUIPlugin.INSTANCE.getColorRegistry() | |
.get(IBPELUIConstants.COLOR_HANDLER_LINK_FH)); | |
// conn.setConnectionRouter(new HandlerConnectionRouter()); | |
conn | |
.setConnectionRouter(new ManhattanConnectionRouterEx( | |
getFHRoutingStartConstraint(), | |
getFHRoutingEndConstraint())); | |
handlerConnectionsList.add(conn); | |
connLayer.add(conn); | |
} | |
if (isShowEH()) { | |
if (ehEditPart == null) | |
// not yet initialized | |
return; | |
source = new CenteredConnectionAnchor(getEHFigure(),getEHSourceAnchorLoc(),0); | |
target = new CenteredConnectionAnchor(getFHHandlerFigure(ehEditPart),getEHTargetAnchorLoc(),0); | |
PolylineConnection conn = new PolylineConnection(); | |
conn.setSourceAnchor(source); | |
conn.setTargetAnchor(target); | |
conn.setForegroundColor(BPELUIPlugin.INSTANCE.getColorRegistry() | |
.get(IBPELUIConstants.COLOR_HANDLER_LINK_EH)); | |
// conn.setConnectionRouter(new HandlerConnectionRouter()); | |
conn | |
.setConnectionRouter(new ManhattanConnectionRouterEx( | |
getEHRoutingStartConstraint(), | |
getEHRoutingEndConstraint())); | |
handlerConnectionsList.add(conn); | |
connLayer.add(conn); | |
} | |
if (isShowCH()) { | |
if (chEditPart == null) | |
// not yet initialized | |
return; | |
source = new CenteredConnectionAnchor(getCHFigure(),getCHSourceAnchorLoc(),0); | |
target = new CenteredConnectionAnchor(getFHHandlerFigure(chEditPart),getCHTargetAnchorLoc(),0); | |
PolylineConnection conn = new PolylineConnection(); | |
conn.setSourceAnchor(source); | |
conn.setTargetAnchor(target); | |
conn.setForegroundColor(BPELUIPlugin.INSTANCE.getColorRegistry() | |
.get(IBPELUIConstants.COLOR_HANDLER_LINK_CH)); | |
// conn.setConnectionRouter(new HandlerConnectionRouter()); | |
conn | |
.setConnectionRouter(new ManhattanConnectionRouterEx( | |
getCHRoutingStartConstraint(), | |
getCHRoutingEndConstraint())); | |
handlerConnectionsList.add(conn); | |
connLayer.add(conn); | |
} | |
if (isShowTH()) { | |
if (thEditPart == null) | |
// not yet initialized | |
return; | |
source = new CenteredConnectionAnchor(getTHFigure(),getTHSourceAnchorLoc(),0); | |
target = new CenteredConnectionAnchor(getFHHandlerFigure(thEditPart),getTHTargetAnchorLoc(),0); | |
PolylineConnection conn = new PolylineConnection(); | |
conn.setSourceAnchor(source); | |
conn.setTargetAnchor(target); | |
conn.setForegroundColor(BPELUIPlugin.INSTANCE.getColorRegistry() | |
.get(IBPELUIConstants.COLOR_HANDLER_LINK_TH)); | |
// conn.setConnectionRouter(new HandlerConnectionRouter()); | |
conn | |
.setConnectionRouter(new ManhattanConnectionRouterEx( | |
getTHRoutingStartConstraint(), | |
getTHRoutingEndConstraint())); | |
handlerConnectionsList.add(conn); | |
connLayer.add(conn); | |
} | |
} | |
/** | |
* Removes all connections which are handled by this handlerLinker | |
* from the connectionLayer | |
*/ | |
public void clearHandlerConnections() { | |
if (handlerConnectionsList.size() > 0) { | |
for (PolylineConnection p : handlerConnectionsList) { | |
connLayer.remove(p); | |
} | |
handlerConnectionsList.clear(); | |
} | |
} | |
/** | |
* Gets the faultHandler model | |
* @return | |
*/ | |
protected abstract FaultHandler getFaultHandler(); | |
/** | |
* Gets the eventHandler model | |
* @return | |
*/ | |
protected abstract EventHandler getEventHandler(); | |
/** | |
* Gets the compensationHandler model | |
* @return | |
*/ | |
protected abstract CompensationHandler getCompensationHandler(); | |
/** | |
* Gets the terminationHandler model | |
* @return | |
*/ | |
protected abstract TerminationHandler getTerminationHandler(); | |
/** | |
* Returns if the compensationHandler is shown | |
* @return | |
*/ | |
protected abstract boolean isShowCH(); | |
/** | |
* Returns if the eventHandler is shown | |
* @return | |
*/ | |
protected abstract boolean isShowEH(); | |
/** | |
* Returns if the faultHandler is shown | |
* @return | |
*/ | |
protected abstract boolean isShowFH(); | |
/** | |
* Returns if the terminationHandler is shown | |
* @return | |
*/ | |
protected abstract boolean isShowTH(); | |
/** | |
* Gets the position of the connectionAnchor of an faultHandler. | |
* By default this is HandlerConnectionAnchor.LEFT in case of a horizontal | |
* layout and HandlerConnectionAnchor.TOP if layout orientation is vertical. | |
* @return | |
*/ | |
protected int getFHTargetAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.LEFT | |
: CenteredConnectionAnchor.TOP; | |
} | |
/** | |
* Gets the position of the connectionAnchor of an eventHandler. | |
* By default this is HandlerConnectionAnchor.LEFT in case of a horizontal | |
* layout and HandlerConnectionAnchor.TOP if layout orientation is vertical. | |
* @return | |
*/ | |
protected int getEHTargetAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.LEFT | |
: CenteredConnectionAnchor.TOP; | |
} | |
/** | |
* Gets the position of the connectionAnchor of a compensationHandler. | |
* By default this is HandlerConnectionAnchor.LEFT in case of a horizontal | |
* layout and HandlerConnectionAnchor.TOP if layout orientation is vertical. | |
* @return | |
*/ | |
protected int getCHTargetAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.LEFT | |
: CenteredConnectionAnchor.TOP; | |
} | |
/** | |
* Gets the position of the connectionAnchor of a terminationHandler. | |
* By default this is HandlerConnectionAnchor.LEFT in case of a horizontal | |
* layout and HandlerConnectionAnchor.TOP if layout orientation is vertical. | |
* @return | |
*/ | |
protected int getTHTargetAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.LEFT | |
: CenteredConnectionAnchor.TOP; | |
} | |
/** | |
* Gets the direction in which the first segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getFHRoutingStartConstraint(){ | |
switch (getFHSourceAnchorLoc()) { | |
case CenteredConnectionAnchor.BOTTOM: | |
return ManhattanConnectionRouterEx.DOWN; | |
default: | |
return ManhattanConnectionRouterEx.RIGHT; | |
} | |
} | |
/** | |
* Gets the direction in which the last segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getFHRoutingEndConstraint(){ | |
switch (getFHTargetAnchorLoc()) { | |
case CenteredConnectionAnchor.TOP: | |
return ManhattanConnectionRouterEx.UP; | |
default: | |
return ManhattanConnectionRouterEx.LEFT; | |
} | |
} | |
/** | |
* Gets the direction in which the first segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getEHRoutingStartConstraint(){ | |
switch (getEHSourceAnchorLoc()) { | |
case CenteredConnectionAnchor.BOTTOM: | |
return ManhattanConnectionRouterEx.DOWN; | |
default: | |
return ManhattanConnectionRouterEx.RIGHT; | |
} | |
} | |
/** | |
* Gets the direction in which the last segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getEHRoutingEndConstraint(){ | |
switch (getEHTargetAnchorLoc()) { | |
case CenteredConnectionAnchor.TOP: | |
return ManhattanConnectionRouterEx.UP; | |
default: | |
return ManhattanConnectionRouterEx.LEFT; | |
} | |
} | |
/** | |
* Gets the direction in which the first segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getCHRoutingStartConstraint(){ | |
switch (getCHSourceAnchorLoc()) { | |
case CenteredConnectionAnchor.BOTTOM: | |
return ManhattanConnectionRouterEx.DOWN; | |
default: | |
return ManhattanConnectionRouterEx.RIGHT; | |
} | |
} | |
/** | |
* Gets the direction in which the last segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getCHRoutingEndConstraint(){ | |
switch (getCHTargetAnchorLoc()) { | |
case CenteredConnectionAnchor.TOP: | |
return ManhattanConnectionRouterEx.UP; | |
default: | |
return ManhattanConnectionRouterEx.LEFT; | |
} | |
} | |
/** | |
* Gets the direction in which the first segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getTHRoutingStartConstraint(){ | |
switch (getTHSourceAnchorLoc()) { | |
case CenteredConnectionAnchor.BOTTOM: | |
return ManhattanConnectionRouterEx.DOWN; | |
default: | |
return ManhattanConnectionRouterEx.RIGHT; | |
} | |
} | |
/** | |
* Gets the direction in which the last segment of the connection | |
* should point | |
* @return | |
*/ | |
protected Ray getTHRoutingEndConstraint(){ | |
switch (getCHTargetAnchorLoc()) { | |
case CenteredConnectionAnchor.TOP: | |
return ManhattanConnectionRouterEx.UP; | |
default: | |
return ManhattanConnectionRouterEx.LEFT; | |
} | |
} | |
/** | |
* Gets the faultHandlerFigure from the editPart | |
* @return | |
*/ | |
protected abstract IFigure getFHFigure(); | |
/** | |
* Gets the compensationHandlerFigure from the editPart | |
* @return | |
*/ | |
protected abstract IFigure getCHFigure(); | |
/** | |
* Gets the terminationHandlerFigure from the editPart | |
* @return | |
*/ | |
protected abstract IFigure getTHFigure(); | |
/** | |
* Gets the eventHandlerFigure from the editPart | |
* @return | |
*/ | |
protected abstract IFigure getEHFigure(); | |
/** | |
* Gets the location of the source connectionAnchor of the faultHandlerIcon | |
* @return | |
*/ | |
protected int getFHSourceAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.BOTTOM : CenteredConnectionAnchor.RIGHT; | |
} | |
/** | |
* Gets the location of the source connectionAnchor of the compensationHandlerIcon | |
* @return | |
*/ | |
protected int getCHSourceAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.BOTTOM : CenteredConnectionAnchor.RIGHT; | |
} | |
/** | |
* Gets the location of the source connectionAnchor of the terminationHandlerIcon | |
* @return | |
*/ | |
protected int getTHSourceAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.BOTTOM : CenteredConnectionAnchor.RIGHT; | |
} | |
/** | |
* Gets the location of the source connectionAnchor of the eventHandlerIcon | |
* @return | |
*/ | |
protected int getEHSourceAnchorLoc(){ | |
return isHorizontalLayout() ? CenteredConnectionAnchor.BOTTOM : CenteredConnectionAnchor.RIGHT; | |
} | |
/** | |
* Convenience method which gets the orientation property from the editor | |
* | |
* @return True if the orientation is horizontal, false if it is vertical | |
*/ | |
protected boolean isHorizontalLayout() { | |
return ModelHelper.getBPELEditor(editPart.getModel()) | |
.isHorizontalLayout(); | |
} | |
/** | |
* Convienience method which gets the HandlerIconFigure from a FaultHandler. | |
* @return | |
*/ | |
protected IFigure getFHHandlerFigure(FaultHandlerEditPart fhEditPart){ | |
return ((RoundRectangleBorderWithDecoration)fhEditPart.getContentPane().getBorder()).getDecorationFigure(); | |
} | |
} |