/******************************************************************************* | |
* Copyright (c) 2005, 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 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.bpel.ui.editparts; | |
import java.util.ArrayList; | |
import java.util.Iterator; | |
import java.util.List; | |
import org.eclipse.bpel.common.ui.layouts.AlignedFlowLayout; | |
import org.eclipse.bpel.common.ui.markers.IModelMarkerConstants; | |
import org.eclipse.bpel.model.Activity; | |
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.BPELUIPlugin; | |
import org.eclipse.bpel.ui.IBPELUIConstants; | |
import org.eclipse.bpel.ui.adapters.ICompensationHandlerHolder; | |
import org.eclipse.bpel.ui.adapters.IContainer; | |
import org.eclipse.bpel.ui.adapters.IEventHandlerHolder; | |
import org.eclipse.bpel.ui.adapters.IFaultHandlerHolder; | |
import org.eclipse.bpel.ui.adapters.ILabeledElement; | |
import org.eclipse.bpel.ui.adapters.IMarkerHolder; | |
import org.eclipse.bpel.ui.adapters.ITerminationHandlerHolder; | |
import org.eclipse.bpel.ui.editparts.borders.DrawerBorder; | |
import org.eclipse.bpel.ui.editparts.borders.ScopeBorder; | |
import org.eclipse.bpel.ui.editparts.figures.CollapsableContainerFigure; | |
import org.eclipse.bpel.ui.editparts.figures.CollapsableScopeContainerFigure; | |
import org.eclipse.bpel.ui.editparts.policies.BPELOrderedLayoutEditPolicy; | |
import org.eclipse.bpel.ui.editparts.policies.ContainerHighlightEditPolicy; | |
import org.eclipse.bpel.ui.figures.CenteredConnectionAnchor; | |
import org.eclipse.bpel.ui.figures.ScopeHandlerLinker; | |
import org.eclipse.bpel.ui.util.BPELDragEditPartsTracker; | |
import org.eclipse.bpel.ui.util.BPELUtil; | |
import org.eclipse.bpel.ui.util.ModelHelper; | |
import org.eclipse.bpel.ui.util.marker.BPELEditPartMarkerDecorator; | |
import org.eclipse.core.resources.IMarker; | |
import org.eclipse.draw2d.Border; | |
import org.eclipse.draw2d.ConnectionAnchor; | |
import org.eclipse.draw2d.Figure; | |
import org.eclipse.draw2d.FigureListener; | |
import org.eclipse.draw2d.FlowLayout; | |
import org.eclipse.draw2d.IFigure; | |
import org.eclipse.draw2d.Label; | |
import org.eclipse.draw2d.LayoutManager; | |
import org.eclipse.draw2d.MarginBorder; | |
import org.eclipse.draw2d.PolylineConnection; | |
import org.eclipse.draw2d.geometry.Point; | |
import org.eclipse.emf.ecore.EObject; | |
import org.eclipse.gef.DragTracker; | |
import org.eclipse.gef.EditPart; | |
import org.eclipse.gef.EditPolicy; | |
import org.eclipse.gef.GraphicalEditPart; | |
import org.eclipse.gef.Request; | |
import org.eclipse.swt.graphics.Image; | |
/** | |
* Needs refactoring. Has the following responsibilities: | |
* -Knows whether or not FH/EH/CH/TH are showing | |
* -Marker decorator works when expanded and collapsed | |
* -Has a ScopeBorder which knows about FH/EH/CH/TH decorations | |
*/ | |
public class ScopeEditPart extends CollapsableEditPart { | |
// The amount of spacing to place between child items. Subclasses | |
// may use this value when creating a flow layout | |
// TODO: Fix this magic value | |
public static final int SPACING = 19; | |
// Whether to show each of the handlers. | |
// TODO: Initialize these from the preferences store | |
private boolean showFH = false, showEH = false, showCH = false, showTH = false; | |
// The images for the top and bottom drawer, if any. | |
private Image topImage, bottomImage; | |
// The figure which holds contentFigure and auxilaryFigure as children | |
private IFigure parentFigure; | |
// The figure which holds fault handler, compensation handler and event handler | |
private AuxiliaryFigure auxilaryFigure; | |
// The figure which holds the activity | |
private CollapsableScopeContainerFigure contentFigure; | |
// The Handler which handles the drawing of links to the handlers. | |
private ScopeHandlerLinker handlerLinker; | |
// The text and image labels to show when collapsed. | |
private Image collapsedImage; | |
private Label collapsedNameLabel, collapsedImageLabel; | |
public class ScopeOrderedLayoutEditPolicy extends BPELOrderedLayoutEditPolicy { | |
// return list of children to create vertical connections for. | |
@Override | |
protected List getConnectionChildren(BPELEditPart editPart) { | |
List originalChildren = getChildren(); | |
List newChildren = new ArrayList(); | |
Iterator it = originalChildren.iterator(); | |
while (it.hasNext()) { | |
Object next = it.next(); | |
if (next instanceof FaultHandlerEditPart) { | |
continue; | |
} | |
newChildren.add(next); | |
} | |
return newChildren; | |
} | |
} | |
/** | |
* A special figure which can be informed of a figureMoved event | |
* via a FigureListener. | |
* @author ascharf | |
* | |
*/ | |
private class AuxiliaryFigure extends Figure implements FigureListener{ | |
public void figureMoved(IFigure source) { | |
refreshMargin(); | |
} | |
private void refreshMargin(){ | |
if(ModelHelper.isHorizontalLayout(getModel())) | |
setBorder(new MarginBorder(contentFigure.getPreferredSize().height+10,0,0,0)); | |
else | |
setBorder(null); | |
} | |
} | |
private class ScopeOrderedHorizontalLayoutEditPolicy extends ScopeEditPart.ScopeOrderedLayoutEditPolicy{ | |
@Override | |
protected ArrayList<PolylineConnection> createHorizontalConnections(BPELEditPart parent) { | |
ArrayList<PolylineConnection> connections = new ArrayList<PolylineConnection>(); | |
List children = getConnectionChildren(parent); | |
BPELEditPart sourcePart, targetPart; | |
ConnectionAnchor sourceAnchor = null, targetAnchor = null; | |
sourcePart = parent; | |
sourceAnchor = sourcePart.getConnectionAnchor(CenteredConnectionAnchor.LEFT); | |
if (children != null){ | |
for (int i = 0; i < children.size(); i++) { | |
if(i == 0){ | |
targetPart = (BPELEditPart)children.get(i); | |
targetAnchor = targetPart.getConnectionAnchor(CenteredConnectionAnchor.LEFT); | |
if(sourceAnchor != null && targetAnchor != null) | |
connections.add(createConnection(sourceAnchor,targetAnchor,arrowColor)); | |
} | |
if(i < children.size()-1){ | |
if(i>0){ | |
sourcePart = (BPELEditPart)children.get(i); | |
sourceAnchor = sourcePart.getConnectionAnchor(CenteredConnectionAnchor.RIGHT); | |
} | |
targetPart = (BPELEditPart)children.get(i+1); | |
targetAnchor = targetPart.getConnectionAnchor(CenteredConnectionAnchor.LEFT); | |
}else{ | |
// Link from the last child to the right border | |
sourcePart = (BPELEditPart)children.get(i); | |
sourceAnchor = sourcePart.getConnectionAnchor(CenteredConnectionAnchor.RIGHT); | |
targetAnchor = parent.getConnectionAnchor(CenteredConnectionAnchor.RIGHT); | |
} | |
if(sourceAnchor != null && targetAnchor != null) | |
connections.add(createConnection(sourceAnchor,targetAnchor,arrowColor)); | |
} | |
} | |
return connections; | |
} | |
} | |
@Override | |
protected void createEditPolicies() { | |
super.createEditPolicies(); | |
// Show the selection rectangle | |
installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, new ContainerHighlightEditPolicy(false, true) { | |
@Override | |
protected int getDrawerInset() { | |
return DrawerBorder.DRAWER_WIDTH; | |
} | |
@Override | |
protected int getNorthInset() { | |
return 0; | |
} | |
@Override | |
protected int getSouthInset() { | |
return 3; | |
} | |
@Override | |
protected int getEastInset() { | |
return DrawerBorder.DRAWER_WIDTH; | |
} | |
@Override | |
protected int getWestInset() { | |
return DrawerBorder.DRAWER_WIDTH; | |
} | |
}); | |
if(ModelHelper.isHorizontalLayout(getModel())) | |
installEditPolicy(EditPolicy.LAYOUT_ROLE, new ScopeOrderedHorizontalLayoutEditPolicy()); | |
else | |
installEditPolicy(EditPolicy.LAYOUT_ROLE, new ScopeOrderedLayoutEditPolicy()); | |
} | |
@Override | |
protected DrawerBorder getDrawerBorder() { | |
Border border = getContentPane().getBorder(); | |
if (border instanceof DrawerBorder) return (DrawerBorder)border; | |
return null; | |
} | |
/** | |
* The label figure to return for direct editing | |
* TODO: Enable this | |
*/ | |
@Override | |
public Label getLabelFigure() { | |
return null; | |
} | |
@Override | |
protected IFigure createFigure() { | |
// TODO: Shouldn't have to initialize labels in each subclass. | |
initializeLabels(); | |
if (collapsedImage == null) { | |
// Create the actual figure for the collapsed edit part | |
ILabeledElement element = BPELUtil.adapt(getActivity(), ILabeledElement.class); | |
collapsedImage = element.getSmallImage(getActivity()); | |
} | |
this.collapsedImageLabel = new Label(collapsedImage); | |
this.collapsedNameLabel = new Label(getLabel()); | |
// TODO: Shouldn't have to set the decorator in each subclass. | |
editPartMarkerDecorator = new BPELEditPartMarkerDecorator((EObject)getModel(), | |
new CollapsableDecorationLayout(/*collapsedImage.getBounds().width*/0)); | |
editPartMarkerDecorator.addMarkerMotionListener(getMarkerMotionListener()); | |
this.parentFigure = new Figure(); | |
AlignedFlowLayout layout = new AlignedFlowLayout(); | |
layout.setHorizontal(true); | |
layout.setHorizontalSpacing(0); | |
layout.setVerticalSpacing(0); | |
parentFigure.setLayoutManager(layout); | |
this.contentFigure = new CollapsableScopeContainerFigure(getModel(), getImage(), getLabel()); | |
contentFigure.addMouseMotionListener(getMouseMotionListener()); | |
contentFigure.setEditPart(this); | |
contentFigure.setForegroundColor(BPELUIPlugin.INSTANCE.getColorRegistry().get(IBPELUIConstants.COLOR_BLACK)); | |
parentFigure.add(contentFigure); | |
// Configure the border and contents based on collapsed state | |
if (isCollapsed()) { | |
configureCollapsedFigure(contentFigure); | |
} else { | |
configureExpandedFigure(contentFigure); | |
} | |
boolean isHorizontal = ModelHelper.isHorizontalLayout(getModel()); | |
this.auxilaryFigure = new AuxiliaryFigure(); | |
layout = new AlignedFlowLayout(); | |
layout.setHorizontal(!isHorizontal); | |
auxilaryFigure.setLayoutManager(layout); | |
contentFigure.addFigureListener(auxilaryFigure); | |
parentFigure.add(auxilaryFigure); | |
ScopeBorder border = getScopeBorder(); | |
border.setShowFault(getFaultHandler() != null); | |
border.setShowCompensation(getCompensationHandler() != null); | |
border.setShowTermination(getTerminationHandler() != null); | |
border.setShowEvent(getEventHandler() != null); | |
return editPartMarkerDecorator.createFigure(parentFigure); | |
} | |
@Override | |
protected CollapsableContainerFigure getContentFigure() { | |
return this.contentFigure; | |
} | |
@Override | |
protected void unregisterVisuals() { | |
super.unregisterVisuals(); | |
this.editPartMarkerDecorator = null; | |
this.topImage = null; | |
this.bottomImage = null; | |
} | |
@Override | |
protected List getModelChildren() { | |
return getModelChildren(!isCollapsed()); | |
} | |
/** | |
* @see org.eclipse.gef.editparts.AbstractEditPart#refreshVisuals() | |
*/ | |
@Override | |
public void refreshVisuals() { | |
refreshDrawerImages(); | |
super.refreshVisuals(); | |
// Refresh any decorations on this edit part | |
editPartMarkerDecorator.refresh(); | |
ScopeBorder border = getScopeBorder(); | |
border.setShowFault(getFaultHandler() != null); | |
border.setShowCompensation(getCompensationHandler() != null); | |
border.setShowTermination(getTerminationHandler() != null); | |
border.setShowEvent(getEventHandler() != null); | |
auxilaryFigure.refreshMargin(); | |
// Force a repaint, as the drawer images may have changed. | |
getFigure().repaint(); | |
} | |
/** | |
* Return a string which should be displayed in this node while collapsed. | |
*/ | |
@Override | |
protected String getLabel() { | |
ILabeledElement element = BPELUtil.adapt(getActivity(), ILabeledElement.class); | |
if (element != null) { | |
return element.getLabel(getActivity()); | |
} | |
return null; | |
} | |
/** | |
* Make sure the images in the drawers are up to date. Recalculate them and | |
* inform the border of any changes. | |
*/ | |
@Override | |
protected void refreshDrawerImages() { | |
ScopeBorder border = getScopeBorder(); | |
if (topImage != null) { | |
topImage.dispose(); | |
topImage = null; | |
} | |
if (bottomImage != null) { | |
bottomImage.dispose(); | |
bottomImage = null; | |
} | |
IMarkerHolder holder = BPELUtil.adapt(getActivity(), IMarkerHolder.class); | |
IMarker[] markers = holder.getMarkers(getActivity()); | |
int topMarkerPriority = Integer.MIN_VALUE; | |
int bottomMarkerPriority = Integer.MIN_VALUE; | |
IMarker topMarker = null; | |
IMarker bottomMarker = null; | |
for (int i = 0; i < markers.length; i++) { | |
IMarker marker = markers[i]; | |
String value = marker.getAttribute(IModelMarkerConstants.DECORATION_GRAPHICAL_MARKER_ANCHOR_POINT_ATTR, ""); //$NON-NLS-1$ | |
if (value.equals(IBPELUIConstants.MARKER_ANCHORPOINT_DRAWER_TOP)) { | |
if (marker.getAttribute(IModelMarkerConstants.DECORATION_MARKER_VISIBLE_ATTR, true)) { | |
int priority = marker.getAttribute(IModelMarkerConstants.DECORATION_MARKER_PRIORITY_ATTR, Integer.MIN_VALUE); | |
if (priority > topMarkerPriority) { | |
topMarkerPriority = priority; | |
topImage = BPELUtil.getImage(marker); | |
topMarker = marker; | |
} | |
} | |
} else if (value.equals(IBPELUIConstants.MARKER_ANCHORPOINT_DRAWER_BOTTOM)) { | |
if (marker.getAttribute(IModelMarkerConstants.DECORATION_MARKER_VISIBLE_ATTR, true)) { | |
int priority = marker.getAttribute(IModelMarkerConstants.DECORATION_MARKER_PRIORITY_ATTR, Integer.MIN_VALUE); | |
if (priority > bottomMarkerPriority) { | |
bottomMarkerPriority = priority; | |
bottomImage = BPELUtil.getImage(marker); | |
bottomMarker = marker; | |
} | |
} | |
} | |
} | |
border.setTopImage(topImage); | |
border.setBottomImage(bottomImage); | |
border.setTopMarker(topMarker); | |
border.setBottomMarker(bottomMarker); | |
} | |
/** | |
* Return a list of the model children that should be displayed. | |
* This includes activities (if includeActivity is true), fault handlers, | |
* compensation handlers and event handlers. | |
*/ | |
protected List<EObject> getModelChildren(boolean includeActivity) { | |
ArrayList<EObject> children = new ArrayList<EObject>(); | |
if (includeActivity) { | |
// Use IContainer here for implicit sequence handling | |
IContainer container = BPELUtil.adapt(getModel(), IContainer.class); | |
for (Iterator<EObject> it = container.getChildren(getModel()).iterator(); it.hasNext(); ) { | |
EObject child = it.next(); | |
if (child instanceof Activity) children.add(child); | |
} | |
} | |
if (showFH) { | |
FaultHandler faultHandler = this.getFaultHandler(); | |
if (faultHandler != null) children.add(children.size(), faultHandler); | |
} | |
if (showCH) { | |
CompensationHandler compensationHandler = this.getCompensationHandler(); | |
if (compensationHandler != null) children.add(children.size(), compensationHandler); | |
} | |
if (showTH) { | |
TerminationHandler terminationHandler = this.getTerminationHandler(); | |
if (terminationHandler != null) children.add(children.size(), terminationHandler); | |
} | |
if (showEH) { | |
EventHandler eventHandler = this.getEventHandler(); | |
if (eventHandler != null) children.add(children.size(), eventHandler); | |
} | |
return children; | |
} | |
/** | |
* The top inner implicit connection needs an offset of eight to compensate for | |
* the expansion icon. All other connections are centered on the contentFigure | |
* with an offset of 0. | |
*/ | |
@Override | |
public ConnectionAnchor getConnectionAnchor(int location) { | |
switch(location){ | |
case CenteredConnectionAnchor.TOP_INNER: | |
return new CenteredConnectionAnchor(contentFigure, location, 8); | |
case CenteredConnectionAnchor.LEFT: | |
return new CenteredConnectionAnchor(contentFigure, CenteredConnectionAnchor.LEFT_INNER, 0); | |
case CenteredConnectionAnchor.RIGHT: | |
return new CenteredConnectionAnchor(contentFigure, CenteredConnectionAnchor.RIGHT_INNER, 0); | |
default: | |
return new CenteredConnectionAnchor(contentFigure, location, 0); | |
} | |
} | |
/** | |
* Override addChildVisual so that it adds the childEditPart to the correct | |
* figure. FH/EH/CH go in a different figure than the activity does. | |
*/ | |
@Override | |
protected void addChildVisual(EditPart childEditPart, int index) { | |
IFigure child = ((GraphicalEditPart)childEditPart).getFigure(); | |
IFigure content = getContentPane(childEditPart); | |
if (content != null) { | |
if (childEditPart instanceof ActivityEditPart) { | |
content.add(child, index); | |
} else { | |
// We want to have a kind of sorting, so get the | |
// correct index | |
content.add(child, getIndexForChild(content, childEditPart)); | |
} | |
} | |
} | |
/** | |
* Gets the index for the given <code>child</code> which should be | |
* inserted into the <code>container</code> afterwards. This method | |
* does a kind of really simple sorting. | |
* @param container The container where the child will be inserted. | |
* @param child The child to get the index for | |
* @return The index for inserting the child into the container | |
*/ | |
private int getIndexForChild(IFigure container, EditPart child) { | |
int result = 0; | |
Object model = child.getModel(); | |
if(model instanceof TerminationHandler){ | |
if(showEH) | |
result++; | |
}else if(model instanceof CompensationHandler){ | |
if(showEH) | |
result++; | |
if(showTH) | |
result++; | |
}else if(model instanceof FaultHandler){ | |
if(showEH) | |
result++; | |
if(showTH) | |
result++; | |
if(showCH) | |
result++; | |
} | |
return result; | |
} | |
/** | |
* Override removeChildVisual so that it removes the childEditPart from | |
* the correct figure. FH/EH/CH live in a different figure than the | |
* activity does. | |
*/ | |
@Override | |
protected void removeChildVisual(EditPart childEditPart) { | |
IFigure child = ((GraphicalEditPart)childEditPart).getFigure(); | |
getContentPane(childEditPart).remove(child); | |
} | |
/** | |
* Also overridden to call getContentPane(child) in the appropriate place. | |
*/ | |
@Override | |
protected void reorderChild(EditPart child, int index) { | |
// Save the constraint of the child so that it does not | |
// get lost during the remove and re-add. | |
IFigure childFigure = ((GraphicalEditPart) child).getFigure(); | |
LayoutManager layout = getContentPane(child).getLayoutManager(); | |
Object constraint = null; | |
if (layout != null) | |
constraint = layout.getConstraint(childFigure); | |
removeChildVisual(child); | |
List children = getChildren(); | |
children.remove(child); | |
children.add(index, child); | |
addChildVisual(child, index); | |
setLayoutConstraint(child, childFigure, constraint); | |
} | |
/** | |
* Yet Another Overridden Method. | |
*/ | |
@Override | |
public void setLayoutConstraint(EditPart child, IFigure childFigure, Object constraint) { | |
getContentPane(child).setConstraint(childFigure, constraint); | |
} | |
/** | |
* This method hopefully shouldn't be called, in favour of getContentPane(EditPart). | |
*/ | |
@Override | |
public IFigure getContentPane() { | |
return contentFigure; | |
} | |
/** | |
* Return the appropriate content pane into which the given child | |
* should be inserted. For faultHandler, compensationHandler and | |
* eventHandler, the answer is auxilaryFigure; for activities it | |
* is the contentFigure. | |
*/ | |
protected IFigure getContentPane(EditPart childEditPart) { | |
Object model = childEditPart.getModel(); | |
if (model instanceof FaultHandler) { | |
return auxilaryFigure; | |
} else if (model instanceof CompensationHandler) { | |
return auxilaryFigure; | |
} else if (model instanceof TerminationHandler) { | |
return auxilaryFigure; | |
} else if (model instanceof EventHandler) { | |
return auxilaryFigure; | |
} else if (model instanceof Activity) { | |
return contentFigure; | |
} | |
return contentFigure; | |
} | |
// Support for collapsability | |
@Override | |
public DragTracker getDragTracker(Request request) { | |
return new BPELDragEditPartsTracker(this) { | |
@Override | |
protected boolean handleDoubleClick(int button) { | |
//if (isCollapsed()) setCollapsed(false); | |
setCollapsed(!isCollapsed()); | |
return true; | |
} | |
@Override | |
protected boolean handleButtonDown(int button) { | |
Point point = getLocation(); | |
ScopeBorder border = getScopeBorder(); | |
if (border.isPointInFaultImage(point.x, point.y)) { | |
setShowFaultHandler(!showFH); | |
return true; | |
} | |
if (border.isPointInCompensationImage(point.x, point.y)) { | |
setShowCompensationHandler(!showCH); | |
return true; | |
} | |
if (border.isPointInTerminationImage(point.x, point.y)) { | |
setShowTerminationHandler(!showTH); | |
return true; | |
} | |
if (border.isPointInEventImage(point.x, point.y)) { | |
setShowEventHandler(!showEH); | |
return true; | |
} | |
if (isPointInCollapseIcon(getLocation())) { | |
setCollapsed(!isCollapsed()); | |
return true; | |
} | |
return super.handleButtonDown(button); | |
} | |
}; | |
} | |
@Override | |
protected boolean isPointInCollapseIcon(Point point) { | |
return getContentFigure().isPointInCollapseImage(point.x, point.y); | |
} | |
@Override | |
public boolean isCollapsed() { | |
return getContentFigure().isCollapsed(); | |
} | |
@Override | |
public void setCollapsed(boolean collapsed) { | |
if (isCollapsed() == collapsed) return; | |
getContentFigure().setCollapsed(collapsed); | |
IFigure figure = getContentPane(); | |
if (isCollapsed()) { | |
// First refresh children, which removes all model children's figures | |
refreshChildren(); | |
// Manually remove the rest of the children | |
IFigure[] children = (IFigure[])figure.getChildren().toArray(new IFigure[0]); | |
for (int i = 0; i < children.length; i++) { | |
figure.remove(children[i]); | |
} | |
// Now restore the collapsed children, border and layout | |
configureCollapsedFigure(figure); | |
} else { | |
// Manually remove the children | |
IFigure[] children = (IFigure[])figure.getChildren().toArray(new IFigure[0]); | |
for (int i = 0; i < children.length; i++) { | |
figure.remove(children[i]); | |
} | |
// Now restore the expanded children, border and layout | |
configureExpandedFigure(figure); | |
refreshChildren(); | |
} | |
// refreshSourceConnections(); | |
// refreshTargetConnections(); | |
// | |
// // Switching collapsed states may have changed the border, which is | |
// // responsible for drawing the drawer markers. Refresh these markers | |
// // now. | |
// // TODO: This isn't necessary anymore | |
// refreshDrawerImages(); | |
// // Force a repaint, as the drawer images may have changed. | |
// getFigure().repaint(); | |
// Instead of manually calling all refresh methods, | |
// a call to refreshVisuals should be enough | |
refreshVisuals(); | |
} | |
protected void configureCollapsedFigure(IFigure figure) { | |
figure.setLayoutManager(new FlowLayout()); | |
figure.addMouseMotionListener(getMouseMotionListener()); | |
figure.add(collapsedImageLabel); | |
figure.add(collapsedNameLabel); | |
} | |
/** | |
* Set the layout of the figure for expanded state. | |
*/ | |
@Override | |
protected void configureExpandedFigure(IFigure figure) { | |
FlowLayout layout = new FlowLayout(); | |
layout.setMajorAlignment(FlowLayout.ALIGN_CENTER); | |
layout.setMinorAlignment(FlowLayout.ALIGN_CENTER); | |
layout.setHorizontal(ModelHelper.isHorizontalLayout(getModel())); | |
layout.setMajorSpacing(SPACING); | |
layout.setMinorSpacing(SPACING); | |
figure.setLayoutManager(layout); | |
} | |
private ScopeBorder getScopeBorder() { | |
return (ScopeBorder)getContentPane().getBorder(); | |
} | |
public void setShowFaultHandler(boolean showFaultHandler) { | |
this.showFH = showFaultHandler; | |
// Call refresh so that both refreshVisuals and refreshChildren will be called. | |
refresh(); | |
} | |
public void setShowCompensationHandler(boolean showCompensationHandler) { | |
this.showCH = showCompensationHandler; | |
// Call refresh so that both refreshVisuals and refreshChildren will be called. | |
refresh(); | |
} | |
public void setShowTerminationHandler(boolean showTerminationHandler) { | |
this.showTH = showTerminationHandler; | |
// Call refresh so that both refreshVisuals and refreshChildren will be called. | |
refresh(); | |
} | |
public void setShowEventHandler(boolean showEventHandler) { | |
this.showEH = showEventHandler; | |
// Call refresh so that both refreshVisuals and refreshChildren will be called. | |
refresh(); | |
} | |
public boolean getShowFaultHandler() { | |
return showFH; | |
} | |
public boolean getShowEventHandler() { | |
return showEH; | |
} | |
public boolean getShowCompensationHandler() { | |
return showCH; | |
} | |
public boolean getShowTerminationHandler() { | |
return showTH; | |
} | |
public FaultHandler getFaultHandler() { | |
IFaultHandlerHolder holder = BPELUtil.adapt(getActivity(), IFaultHandlerHolder.class); | |
if (holder != null) { | |
return holder.getFaultHandler(getActivity()); | |
} | |
return null; | |
} | |
public CompensationHandler getCompensationHandler() { | |
ICompensationHandlerHolder holder = BPELUtil.adapt(getActivity(), ICompensationHandlerHolder.class); | |
if (holder != null) { | |
return holder.getCompensationHandler(getActivity()); | |
} | |
return null; | |
} | |
public TerminationHandler getTerminationHandler() { | |
ITerminationHandlerHolder holder = BPELUtil.adapt(getActivity(), ITerminationHandlerHolder.class); | |
if (holder != null) { | |
return holder.getTerminationHandler(getActivity()); | |
} | |
return null; | |
} | |
public EventHandler getEventHandler() { | |
IEventHandlerHolder holder = BPELUtil.adapt(getActivity(), IEventHandlerHolder.class); | |
if (holder != null) { | |
return holder.getEventHandler(getActivity()); | |
} | |
return null; | |
} | |
@Override | |
public IFigure getMainActivityFigure() { | |
return contentFigure; | |
} | |
public void switchLayout(boolean horizontal) { | |
((FlowLayout)contentFigure.getLayoutManager()).setHorizontal(horizontal); | |
((AlignedFlowLayout)auxilaryFigure.getLayoutManager()).setHorizontal(!horizontal); | |
this.removeEditPolicy(EditPolicy.LAYOUT_ROLE); | |
if(horizontal){ | |
installEditPolicy(EditPolicy.LAYOUT_ROLE, new ScopeOrderedHorizontalLayoutEditPolicy()); | |
}else{ | |
installEditPolicy(EditPolicy.LAYOUT_ROLE, new ScopeOrderedLayoutEditPolicy()); | |
} | |
} | |
/** | |
* Overridden to refresh the handlerLinks as needed. | |
*/ | |
@Override | |
public void refresh() { | |
super.refresh(); | |
getHandlerLinker().refreshHandlerLinks(); | |
} | |
@Override | |
protected void clearConnections() { | |
super.clearConnections(); | |
getHandlerLinker().clearHandlerConnections(); | |
} | |
private ScopeHandlerLinker getHandlerLinker() { | |
if(handlerLinker == null) | |
handlerLinker = new ScopeHandlerLinker(this); | |
return handlerLinker; | |
} | |
@Override | |
protected void handleModelChanged() { | |
super.handleModelChanged(); | |
this.showCH = getCompensationHandler() != null ? true : false; | |
this.showFH = getFaultHandler() != null ? true : false; | |
this.showEH = getEventHandler() != null ? true : false; | |
this.showTH = getTerminationHandler() != null ? true : false; | |
refresh(); | |
} | |
} |