/*******************************************************************************
* <copyright>
*
* Copyright (c) 2005, 2012 SAP AG.
* 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:
* SAP AG - initial API, implementation and documentation
* mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
* cbrand - Bug 376585 - Clean-up deprecations in Graphiti
*
* </copyright>
*
*******************************************************************************/
package org.eclipse.graphiti.examples.common.pattern.compartment;
import java.util.List;
import org.eclipse.graphiti.examples.common.Messages;
import org.eclipse.graphiti.features.IDirectEditingInfo;
import org.eclipse.graphiti.features.IReason;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.context.ILayoutContext;
import org.eclipse.graphiti.features.context.IUpdateContext;
import org.eclipse.graphiti.features.impl.Reason;
import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
import org.eclipse.graphiti.mm.algorithms.Image;
import org.eclipse.graphiti.mm.algorithms.Polyline;
import org.eclipse.graphiti.mm.algorithms.Rectangle;
import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.algorithms.styles.Orientation;
import org.eclipse.graphiti.mm.algorithms.styles.Point;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.PictogramLink;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.pattern.AbstractPattern;
import org.eclipse.graphiti.pattern.mapping.ILinkCreationInfo;
import org.eclipse.graphiti.pattern.mapping.IStructureMapping;
import org.eclipse.graphiti.pattern.mapping.IStructureMappingMulti;
import org.eclipse.graphiti.pattern.mapping.IStructureMappingSingle;
import org.eclipse.graphiti.pattern.mapping.data.IDataMapping;
import org.eclipse.graphiti.pattern.mapping.data.IImageDataMapping;
import org.eclipse.graphiti.pattern.mapping.data.ITextDataMapping;
import org.eclipse.graphiti.pattern.mapping.data.LabelDataMapping;
import org.eclipse.graphiti.platform.IPlatformImageConstants;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.IGaCreateService;
import org.eclipse.graphiti.services.IGaService;
import org.eclipse.graphiti.services.ILinkService;
import org.eclipse.graphiti.services.IPeCreateService;
/**
* The Class CompartmentPattern.
*/
public abstract class CompartmentPattern extends AbstractPattern {
private final static int TEXT_HEIGHT = 25;
private IStructureMappingSingle headerMapping;
private IStructureMappingMulti[] compartmentMappings;
/**
* Instantiates a new compartment pattern.
*/
public CompartmentPattern() {
super(new DefaultCompartmentPatternConfiguration());
}
@Override
public PictogramElement add(IAddContext context) {
Object mainBusinessObject = context.getNewObject();
ContainerShape parentContainerShape = context.getTargetContainer();
// CONTAINER SHAPE WITH ROUNDED RECTANGLE
final IPeCreateService peCreateService = Graphiti.getPeCreateService();
IGaCreateService gaCreateService = Graphiti.getGaCreateService();
IGaService gaService = Graphiti.getGaService();
ContainerShape containerShape = peCreateService.createContainerShape(parentContainerShape, true);
getFeatureProvider().getDirectEditingInfo().setMainPictogramElement(containerShape);
// check whether valid size is available, e.g. if called from the create
// feature
int width = context.getWidth() <= 0 ? 100 : context.getWidth();
int height = context.getHeight() <= 0 ? 120 : context.getHeight();
{
// create and set graphics algorithm
RoundedRectangle roundedRectangle = gaCreateService.createRoundedRectangle(containerShape, getConfiguration().getCornerWidth(),
getConfiguration().getCornerHeight());
roundedRectangle.setForeground(manageColor(getConfiguration().getForegroundColor()));
roundedRectangle.setBackground(manageColor(getConfiguration().getBackgroundColor()));
roundedRectangle.setLineWidth(getConfiguration().getLineWidth());
roundedRectangle.setTransparency(getConfiguration().getTransparency());
Graphiti.getGaService().setLocationAndSize(roundedRectangle, context.getX(), context.getY(), width, height);
// create link and wire it
link(containerShape, mainBusinessObject);
}
// HEADER SHAPE
{
// create shape for text
Shape shape = peCreateService.createShape(containerShape, false);
Text text;
if (getConfiguration().isHeaderImageVisible()) {
Rectangle rectangle = gaCreateService.createRectangle(shape);
rectangle.setFilled(false);
rectangle.setLineVisible(false);
gaCreateService.createImage(rectangle, IPlatformImageConstants.IMG_EDIT_EXPANDALL);
text = gaCreateService.createText(rectangle);
text.setForeground(manageColor(getConfiguration().getTextColor()));
text.setHorizontalAlignment(Orientation.ALIGNMENT_LEFT);
text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
text.setFont(gaService.manageDefaultFont(getDiagram(), false, true));
} else { // just a text data mapping
text = gaCreateService.createText(shape);
text.setForeground(manageColor(getConfiguration().getTextColor()));
text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
text.setFont(gaService.manageDefaultFont(getDiagram(), false, true));
}
IDirectEditingInfo dei = getFeatureProvider().getDirectEditingInfo();
dei.setPictogramElement(shape);
dei.setGraphicsAlgorithm(text);
// create link and wire it
ILinkCreationInfo linkCreationInfo = getHeaderMapping().getLinkCreationInfo(mainBusinessObject);
String linkProperty = linkCreationInfo.getProperty();
if (linkProperty != null) {
getLinkService().setLinkProperty(shape, linkProperty);
}
link(shape, linkCreationInfo.getBusinessObjects());
}
{
for (int compartmentIndex = 0; compartmentIndex < getCompartmentCount(); compartmentIndex++) {
// create a line shape above each compartment
// SHAPE WITH LINE
{
// create shape for line
Shape shape = peCreateService.createShape(containerShape, false);
// create and set graphics algorithm
Polyline polyline = gaCreateService.createPolyline(shape, new int[] { 0, 0, 0, 0 });
polyline.setForeground(manageColor(getConfiguration().getForegroundColor()));
polyline.setLineWidth(getConfiguration().getLineWidth());
}
ContainerShape compartmentContainerShape = peCreateService.createContainerShape(containerShape, false);
Rectangle compartmentRectangle = gaCreateService.createRectangle(compartmentContainerShape);
compartmentRectangle.setFilled(false);
compartmentRectangle.setLineVisible(false);
// createLink(compartmentContainerShape, mainBusinessObject);
}
}
peCreateService.createChopboxAnchor(containerShape);
updatePictogramElement(containerShape);
return containerShape;
}
/**
* Activates direct editing for header text control.
*/
protected void activateHeaderTextAutoDirectEditing() {
getFeatureProvider().getDirectEditingInfo().setActive(true);
}
@Override
public boolean layout(ILayoutContext context) {
boolean ret = false;
IGaService gaService = Graphiti.getGaService();
ContainerShape containerShape = (ContainerShape) context.getPictogramElement();
int continousY = getConfiguration().getOuterIndentTop();
List<Shape> containerShapeChildren = containerShape.getChildren();
// width
{
int containerWidth = containerShape.getGraphicsAlgorithm().getWidth();
int minimumWidth = getConfiguration().getMinimumWidth();
if (containerWidth < minimumWidth) {
containerShape.getGraphicsAlgorithm().setWidth(minimumWidth);
containerWidth = minimumWidth;
ret = true;
}
int innerWidth = containerWidth - getConfiguration().getOuterIndentLeft() - getConfiguration().getOuterIndentRight(); // without
// indents
for (Shape shape : containerShapeChildren) {
GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
// move horizontal lines
if (ga instanceof Polyline) {
Polyline pl = (Polyline) ga;
List<Point> points = pl.getPoints();
int x0 = points.get(0).getX();
points.set(0, gaService.createPoint(x0, continousY));
points.set(1, gaService.createPoint(containerWidth, continousY));
} else {
if (shape instanceof ContainerShape) {
ContainerShape compartmentContainerShape = (ContainerShape) shape;
compartmentContainerShape.getGraphicsAlgorithm().setY(continousY);
// loop the shapes inside a compartment
int innerY = 0;
for (Shape innerCompartmentShape : compartmentContainerShape.getChildren()) {
GraphicsAlgorithm innerGa = innerCompartmentShape.getGraphicsAlgorithm();
gaService.setLocationAndSize(innerGa, 0, innerY, innerWidth, TEXT_HEIGHT);
GraphicsAlgorithm imageGa = innerGa.getGraphicsAlgorithmChildren().get(0);
gaService.setLocationAndSize(imageGa, 0, 0, TEXT_HEIGHT, TEXT_HEIGHT);
GraphicsAlgorithm textGa = innerGa.getGraphicsAlgorithmChildren().get(1);
gaService.setLocationAndSize(textGa, TEXT_HEIGHT, 0, innerWidth - TEXT_HEIGHT, TEXT_HEIGHT);
innerY += TEXT_HEIGHT;
}
int compartmentHeight = compartmentContainerShape.getChildren().size() * TEXT_HEIGHT;
gaService.setLocationAndSize(compartmentContainerShape.getGraphicsAlgorithm(), getConfiguration()
.getOuterIndentLeft(), continousY, innerWidth, compartmentHeight, true);
} else { // header shape
gaService.setLocationAndSize(shape.getGraphicsAlgorithm(), getConfiguration().getOuterIndentLeft(),
getConfiguration().getOuterIndentTop(), innerWidth, TEXT_HEIGHT);
if (getConfiguration().isHeaderImageVisible()) {
GraphicsAlgorithm imageGa = ga.getGraphicsAlgorithmChildren().get(0);
GraphicsAlgorithm textGa = ga.getGraphicsAlgorithmChildren().get(1);
gaService.setLocationAndSize(imageGa, 0, 0, TEXT_HEIGHT, TEXT_HEIGHT);
gaService.setLocationAndSize(textGa, TEXT_HEIGHT, 0, innerWidth - TEXT_HEIGHT, TEXT_HEIGHT);
}
}
continousY += gaService.calculateSize(ga).getHeight();
}
}
}
// height
{
int additionalHeight = 0;
int compartmentCount = containerShapeChildren.size();
if (compartmentCount >= 1) {
Object lastCompartment = containerShapeChildren.get(compartmentCount - 1);
if (lastCompartment instanceof ContainerShape) {
ContainerShape lastCompartmentCs = (ContainerShape) lastCompartment;
if (lastCompartmentCs.getChildren().size() == 0) {
additionalHeight = getConfiguration().getCornerHeight() / 2;
}
}
}
int containerHeight = containerShape.getGraphicsAlgorithm().getHeight();
int newHeight = Math.max(containerHeight, continousY + additionalHeight + getConfiguration().getOuterIndentBottom());
newHeight = Math.max(newHeight, getConfiguration().getMinimumHeight());
if (containerHeight != newHeight) {
containerShape.getGraphicsAlgorithm().setHeight(newHeight);
ret = true;
}
}
return ret;
}
@Override
public boolean update(IUpdateContext context) {
boolean ret = false;
PictogramElement pe = context.getPictogramElement();
if (isPatternRoot(pe)) {
ret = updateAndLayoutRoot((ContainerShape) pe);
} else {
ContainerShape rootContainer = getPatternRoot(pe);
if (rootContainer != null) {
ret = updateAndLayoutRoot(rootContainer);
}
}
return ret;
}
@Override
public IReason updateNeeded(IUpdateContext context) {
// check only if the given pictogram element is the outer container
// shape
PictogramElement pe = context.getPictogramElement();
if (isPatternRoot(pe)) {
ContainerShape outerContainerShape = (ContainerShape) pe;
// check header
if (getHeaderMapping().getDataMapping() instanceof LabelDataMapping) {
} else {
Shape textShape = outerContainerShape.getChildren().get(0);
PictogramLink linkForPictogramElement = getLinkService().getLinkForPictogramElement(textShape);
if (linkForPictogramElement != null) {
GraphicsAlgorithm ga = textShape.getGraphicsAlgorithm();
String currentValue = ((Text) ga).getValue();
String value = getText(getHeaderMapping(), linkForPictogramElement);
// compare values
if (currentValue == null || !currentValue.equals(value)) {
return Reason.createTrueReason(getHeaderMapping().getDataMapping().getUpdateWarning(linkForPictogramElement)); // ("header
// out
// of
// date");
}
}
}
// check compartments
Object mainBusinessObject = getBusinessObjectForPictogramElement(outerContainerShape);
for (int compartmentIndex = 0; compartmentIndex < getCompartmentCount(); compartmentIndex++) {
ContainerShape compartmentContainerShape = (ContainerShape) outerContainerShape.getChildren().get(
(compartmentIndex + 1) * 2);
if (compartmentContainerShape != null) {
IStructureMappingMulti mapping = getCompartmentMapping(compartmentIndex);
IReason ret = updateCompartmentNeeded(compartmentContainerShape, mainBusinessObject, mapping);
if (ret.toBoolean()) {
return ret;
}
}
}
}
return Reason.createFalseReason();
}
/**
* Creates the compartment mappings.
*
* @return the i structure mapping multi[]
*/
abstract protected IStructureMappingMulti[] createCompartmentMappings();
/**
* Creates the header mapping.
*
* @return the i structure mapping single
*/
abstract protected IStructureMappingSingle createHeaderMapping();
/**
* @param compartmentContainerShape
* @param linkCreationInfos
*/
private void createShapesInCompartment(ContainerShape compartmentContainerShape, List<ILinkCreationInfo> linkCreationInfos) {
IGaCreateService gaCreateService = Graphiti.getGaCreateService();
IGaService gaService = Graphiti.getGaService();
// add multi text shapes
for (ILinkCreationInfo linkCreationInfo : linkCreationInfos) {
Shape shape = Graphiti.getPeCreateService().createShape(compartmentContainerShape, false);
Rectangle rectangle = gaCreateService.createRectangle(shape);
rectangle.setFilled(false);
rectangle.setLineVisible(false);
gaCreateService.createImage(rectangle, IPlatformImageConstants.IMG_EDIT_EXPANDALL);
Text text = gaCreateService.createText(rectangle);
text.setForeground(manageColor(getConfiguration().getTextColor()));
text.setHorizontalAlignment(Orientation.ALIGNMENT_LEFT);
text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
text.setFont(gaService.manageDefaultFont(getDiagram(), false, true));
// create link and wire it
Object[] businessObjects = linkCreationInfo.getBusinessObjects();
link(shape, businessObjects);
String linkProperty = linkCreationInfo.getProperty();
if (linkProperty != null) {
getLinkService().setLinkProperty(shape, linkProperty);
}
}
}
/**
* @return Returns the compartmentCount.
*/
private int getCompartmentCount() {
return getCompartmentMappings().length;
}
private IStructureMappingMulti getCompartmentMapping(int index) {
return getCompartmentMappings()[index];
}
private IStructureMappingMulti[] getCompartmentMappings() {
if (compartmentMappings == null) {
compartmentMappings = createCompartmentMappings();
}
return compartmentMappings;
}
private IStructureMappingSingle getHeaderMapping() {
if (headerMapping == null) {
headerMapping = createHeaderMapping();
}
return headerMapping;
}
private ContainerShape getPatternRoot(PictogramElement pe) {
ContainerShape ret = null;
// Check that a pictogram element was provided and that it is alive
if (pe == null || pe.eResource() == null) {
return ret;
}
int i = 0;
do {
if (isPatternRoot(pe)) {
ret = (ContainerShape) pe;
} else if (pe instanceof Shape) {
pe = ((Shape) pe).getContainer();
}
i++;
} while (ret == null && i < 3);
return ret;
}
private boolean isCompartment(PictogramElement pe) {
boolean ret = false;
if (pe instanceof ContainerShape) {
ContainerShape cs = (ContainerShape) pe;
ContainerShape container = cs.getContainer();
ret = isPatternRoot(container);
}
return ret;
}
@SuppressWarnings("unused")
private boolean isCompartmentEntry(PictogramElement pe) {
boolean ret = false;
if (pe instanceof ContainerShape) {
ContainerShape cs = (ContainerShape) pe;
ContainerShape container = cs.getContainer();
ret = isCompartment(container);
}
return ret;
}
@SuppressWarnings("unused")
private boolean isHeader(PictogramElement pe) {
boolean ret = false;
if (pe instanceof Shape) {
Shape shape = (Shape) pe;
GraphicsAlgorithm ga = shape.getGraphicsAlgorithm();
if (ga instanceof Text) {
ContainerShape container = shape.getContainer();
ret = isPatternRoot(container);
}
}
return ret;
}
@Override
protected boolean isPatternControlled(PictogramElement pictogramElement) {
ContainerShape patternRoot = getPatternRoot(pictogramElement);
return patternRoot != null;
}
@Override
protected boolean isPatternRoot(PictogramElement pe) {
boolean ret = false;
// Check if not null, of right instance and alive
if (pe instanceof ContainerShape && pe.eResource() != null) {
GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
if (ga instanceof RoundedRectangle) {
Object bo = getBusinessObjectForPictogramElement(pe);
ret = isMainBusinessObjectApplicable(bo);
}
}
return ret;
}
private boolean updateCompartment(Object mainBusinessObject, ContainerShape compartmentContainerShape, IStructureMappingMulti mapping) {
boolean ret = false;
List<ILinkCreationInfo> linkCreationInfos = mapping.getLinkCreationInfos(mainBusinessObject);
List<Shape> currentCompartmentElements = compartmentContainerShape.getChildren();
if (linkCreationInfos.size() != currentCompartmentElements.size()) {
Object[] a = compartmentContainerShape.getChildren().toArray();
for (int i = 0; i < a.length; i++) {
Graphiti.getPeService().deletePictogramElement((PictogramElement) a[i]);
}
createShapesInCompartment(compartmentContainerShape, linkCreationInfos);
ret = true;
}
List<Shape> childShapes = compartmentContainerShape.getChildren();
for (Shape shape : childShapes) {
ret = ret | updateCompartmentEntry(shape, mapping);
}
return ret;
}
private boolean updateCompartmentEntry(Shape shape, IStructureMappingMulti mapping) {
boolean ret = false;
PictogramLink linkForPictogramElement;
linkForPictogramElement = getLinkService().getLinkForPictogramElement(shape);
if (linkForPictogramElement != null) {
Image imageGa = (Image) shape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
Text textGa = (Text) shape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(1);
imageGa.setId(getImage(mapping, linkForPictogramElement));
textGa.setValue(getText(mapping, linkForPictogramElement));
ret = true;
}
return ret;
}
private IReason updateCompartmentNeeded(ContainerShape compartmentContainerShape, Object mainBusinessObject,
IStructureMappingMulti mapping) {
PictogramLink linkForPictogramElement;
List<ILinkCreationInfo> linkCreationInfos = mapping.getLinkCreationInfos(mainBusinessObject);
List<Shape> childShapes = compartmentContainerShape.getChildren();
int childShapeCount = childShapes.size();
if (linkCreationInfos.size() != childShapeCount) {
// structural change inside the compartment
return Reason.createTrueReason(Messages.CompartmentPattern_CompartmentChangesText);
} else {
// check whether compartment content has changed
for (Shape shape : childShapes) {
linkForPictogramElement = getLinkService().getLinkForPictogramElement(shape);
if (linkForPictogramElement != null) {
Image imageGa = (Image) shape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
Text textGa = (Text) shape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(1);
String currentImage = imageGa.getId();
String currentText = textGa.getValue();
String image = getImage(mapping, linkForPictogramElement);
String text = getText(mapping, linkForPictogramElement);
// compare values
if (currentText == null || !currentText.equals(text)) {
return Reason.createTrueReason(mapping.getDataMapping().getUpdateWarning(linkForPictogramElement)); // ("text
// differs");
}
if (!(currentImage == null && image == null)) {
if (currentImage == null || !currentImage.equals(image)) {
return Reason.createTrueReason(mapping.getDataMapping().getUpdateWarning(linkForPictogramElement)); // ("image
// differs");
}
}
}
}
}
return Reason.createFalseReason();
}
private boolean updateHeader(Shape headerShape) {
boolean ret = false;
PictogramLink linkForPictogramElement = getLinkService().getLinkForPictogramElement(headerShape);
if (linkForPictogramElement != null) {
if (getConfiguration().isHeaderImageVisible()) {
Image imageGa = (Image) headerShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(0);
Text textGa = (Text) headerShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(1);
imageGa.setId(getImage(getHeaderMapping(), linkForPictogramElement));
textGa.setValue(getText(getHeaderMapping(), linkForPictogramElement));
} else {
String value = getText(getHeaderMapping(), linkForPictogramElement);
((Text) headerShape.getGraphicsAlgorithm()).setValue(value);
}
ret = true;
}
return ret;
}
private boolean updateAndLayoutRoot(ContainerShape outerContainerShape) {
Object mainBusinessObject = getBusinessObjectForPictogramElement(outerContainerShape);
// header text
Shape textShape = outerContainerShape.getChildren().get(0);
boolean ret = updateHeader(textShape);
// compartments
for (int compartmentIndex = 0; compartmentIndex < getCompartmentCount(); compartmentIndex++) {
ContainerShape compartmentContainerShape = (ContainerShape) outerContainerShape.getChildren().get((compartmentIndex + 1) * 2);
IStructureMappingMulti mapping = getCompartmentMapping(compartmentIndex);
if (compartmentContainerShape != null) {
ret = ret | updateCompartment(mainBusinessObject, compartmentContainerShape, mapping);
}
}
layoutPictogramElement(outerContainerShape);
return ret;
}
/**
* Gets the configuration.
*
* @return the configuration
*/
protected ICompartmentPatternConfiguration getConfiguration() {
return (ICompartmentPatternConfiguration) getPatternConfiguration();
}
@Override
public void completeInfo(IDirectEditingInfo info, Object bo) {
super.completeInfo(info, bo);
PictogramElement mainPictogramElement = info.getMainPictogramElement();
ContainerShape mainCs = (ContainerShape) mainPictogramElement;
if (mainCs != null) {
for (Object childShape : mainCs.getChildren()) {
if (childShape instanceof ContainerShape) {
ContainerShape compartmentCs = (ContainerShape) childShape;
for (Object compartmentEntry : compartmentCs.getChildren()) {
if (compartmentEntry instanceof Shape) {
Shape compartmentEntryShape = (Shape) compartmentEntry;
Object firstBusinessObjectForPictogramElement = getBusinessObjectForPictogramElement(compartmentEntryShape);
if (bo.equals(firstBusinessObjectForPictogramElement)) {
GraphicsAlgorithm ga = compartmentEntryShape.getGraphicsAlgorithm().getGraphicsAlgorithmChildren().get(1);
if (ga instanceof Text) {
info.setPictogramElement(compartmentEntryShape);
info.setGraphicsAlgorithm(ga);
return;
}
}
}
}
}
}
}
}
protected ILinkService getLinkService() {
return Graphiti.getLinkService();
}
/**
* Gets the text.
*
* @param structureMapping
* the structure mapping
* @param link
* the pictogram link
* @return the text
*/
protected String getText(IStructureMapping structureMapping, PictogramLink link) {
String ret = null;
IDataMapping dm = structureMapping.getDataMapping();
if (dm instanceof ITextDataMapping) {
ret = ((ITextDataMapping) dm).getText(link);
}
return ret;
}
/**
* Gets the image.
*
* @param structureMapping
* the structure mapping
* @param link
* the pictogram link
* @return the image
*/
protected String getImage(IStructureMapping structureMapping, PictogramLink link) {
String ret = null;
IDataMapping dm = structureMapping.getDataMapping();
if (dm instanceof IImageDataMapping) {
ret = ((IImageDataMapping) dm).getImageId(link);
}
return ret;
}
}