/*******************************************************************************
* Copyright (c) 2011, 2012 Red Hat, Inc.
* All rights reserved.
* This program is 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:
* Red Hat, Inc. - initial API and implementation
*
* @author Bob Brodt
******************************************************************************/
package org.eclipse.bpmn2.modeler.core.model;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.eclipse.bpmn2.Assignment;
import org.eclipse.bpmn2.BaseElement;
import org.eclipse.bpmn2.Bpmn2Factory;
import org.eclipse.bpmn2.Bpmn2Package;
import org.eclipse.bpmn2.CompensateEventDefinition;
import org.eclipse.bpmn2.DataAssociation;
import org.eclipse.bpmn2.Definitions;
import org.eclipse.bpmn2.Documentation;
import org.eclipse.bpmn2.Expression;
import org.eclipse.bpmn2.ExtensionAttributeValue;
import org.eclipse.bpmn2.FormalExpression;
import org.eclipse.bpmn2.Import;
import org.eclipse.bpmn2.ItemDefinition;
import org.eclipse.bpmn2.Lane;
import org.eclipse.bpmn2.Participant;
import org.eclipse.bpmn2.Process;
import org.eclipse.bpmn2.RootElement;
import org.eclipse.bpmn2.SubProcess;
import org.eclipse.bpmn2.di.BPMNDiagram;
import org.eclipse.bpmn2.di.BPMNEdge;
import org.eclipse.bpmn2.di.BPMNLabel;
import org.eclipse.bpmn2.di.BPMNLabelStyle;
import org.eclipse.bpmn2.di.BPMNPlane;
import org.eclipse.bpmn2.di.BPMNShape;
import org.eclipse.bpmn2.di.BpmnDiPackage;
import org.eclipse.bpmn2.modeler.core.Activator;
import org.eclipse.bpmn2.modeler.core.LifecycleEvent;
import org.eclipse.bpmn2.modeler.core.LifecycleEvent.EventType;
import org.eclipse.bpmn2.modeler.core.adapters.ExtendedPropertiesAdapter;
import org.eclipse.bpmn2.modeler.core.adapters.IExtensionValueAdapter;
import org.eclipse.bpmn2.modeler.core.features.GraphitiConstants;
import org.eclipse.bpmn2.modeler.core.model.Bpmn2ModelerFactory.Bpmn2ModelerDocumentRootImpl;
import org.eclipse.bpmn2.modeler.core.model.Bpmn2ModelerFactory.KeyValue;
import org.eclipse.bpmn2.modeler.core.preferences.Bpmn2Preferences;
import org.eclipse.bpmn2.modeler.core.runtime.TargetRuntime;
import org.eclipse.bpmn2.modeler.core.runtime.TargetRuntimeAdapter;
import org.eclipse.bpmn2.modeler.core.runtime.TypeLanguageDescriptor;
import org.eclipse.bpmn2.modeler.core.utils.FeatureSupport;
import org.eclipse.bpmn2.modeler.core.utils.ImportUtil;
import org.eclipse.bpmn2.modeler.core.utils.ModelUtil;
import org.eclipse.bpmn2.modeler.core.utils.NamespaceUtil;
import org.eclipse.bpmn2.modeler.core.validation.SyntaxCheckerUtils;
import org.eclipse.bpmn2.util.Bpmn2ResourceImpl;
import org.eclipse.bpmn2.util.ImportHelper;
import org.eclipse.bpmn2.util.OnlyContainmentTypeInfo;
import org.eclipse.bpmn2.util.QNameURIHandler;
import org.eclipse.bpmn2.util.XmlExtendedMetadata;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.dd.dc.Bounds;
import org.eclipse.dd.dc.DcFactory;
import org.eclipse.dd.dc.DcPackage;
import org.eclipse.dd.dc.Point;
import org.eclipse.dd.di.DiPackage;
import org.eclipse.dd.di.DiagramElement;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.ECollections;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.EMap;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.BasicFeatureMap;
import org.eclipse.emf.ecore.util.EObjectWithInverseEList;
import org.eclipse.emf.ecore.util.ExtendedMetaData;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.FeatureMapUtil;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLLoad;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xmi.XMLSave;
import org.eclipse.emf.ecore.xmi.impl.ElementHandlerImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLLoadImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLString;
import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.PortType;
import org.eclipse.wst.wsdl.util.WSDLResourceImpl;
import org.xml.sax.helpers.DefaultHandler;
/**
* <!-- begin-user-doc --> The <b>Resource </b> associated with the package.
*
* @implements Bpmn2Resource <!-- end-user-doc -->
* @see org.eclipse.bpmn2.util.Bpmn2ResourceFactoryImpl
*/
public class Bpmn2ModelerResourceImpl extends Bpmn2ResourceImpl {
public static final String BPMN2_CONTENT_TYPE_ID = "org.eclipse.bpmn2.content-type.xml"; //$NON-NLS-1$
protected BpmnXmlHelper xmlHelper;
protected QNameURIHandler uriHandler;
public HashMap xmlNameToFeatureMap = new HashMap();
protected static HashSet<EStructuralFeature> qnameMap = new HashSet<EStructuralFeature>();
static {
qnameMap.add(Bpmn2Package.eINSTANCE.getExtension_Definition());
qnameMap.add(Bpmn2Package.eINSTANCE.getRelationship_Sources());
qnameMap.add(Bpmn2Package.eINSTANCE.getRelationship_Targets());
qnameMap.add(Bpmn2Package.eINSTANCE.getAssociation_SourceRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getAssociation_TargetRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getGroup_CategoryValueRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCorrelationKey_CorrelationPropertyRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCorrelationProperty_Type());
qnameMap.add(Bpmn2Package.eINSTANCE.getCorrelationPropertyBinding_CorrelationPropertyRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCorrelationPropertyRetrievalExpression_MessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCorrelationSubscription_CorrelationPropertyBinding());
qnameMap.add(Bpmn2Package.eINSTANCE.getError_StructureRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getEscalation_StructureRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getFlowElement_CategoryValueRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getFlowNode_Incoming());
qnameMap.add(Bpmn2Package.eINSTANCE.getFlowNode_Outgoing());
qnameMap.add(Bpmn2Package.eINSTANCE.getFormalExpression_EvaluatesToTypeRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getInputOutputBinding_OperationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getItemDefinition_StructureRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessage_ItemRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getResourceParameter_Type());
qnameMap.add(Bpmn2Package.eINSTANCE.getInterface_ImplementationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getOperation_InMessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getOperation_OutMessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getOperation_ErrorRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getOperation_ImplementationRef());
// qnameMap.add(Bpmn2Package.eINSTANCE.getCallConversation_CalledCollaborationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationAssociation_InnerConversationNodeRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationAssociation_OuterConversationNodeRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationLink_SourceRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationLink_TargetRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationNode_MessageFlowRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationNode_ParticipantRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getConversationNode_CorrelationKeys());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageFlow_SourceRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageFlow_TargetRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageFlow_MessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageFlowAssociation_InnerMessageFlowRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageFlowAssociation_OuterMessageFlowRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getParticipant_InterfaceRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getParticipant_EndPointRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getParticipant_ProcessRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getParticipantAssociation_InnerParticipantRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getParticipantAssociation_OuterParticipantRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCallableElement_SupportedInterfaceRefs());
// qnameMap.add(Bpmn2Package.eINSTANCE.getCallActivity_CalledElementRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMultiInstanceLoopCharacteristics_LoopDataInputRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMultiInstanceLoopCharacteristics_LoopDataOutputRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMultiInstanceLoopCharacteristics_OneBehaviorEventRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMultiInstanceLoopCharacteristics_NoneBehaviorEventRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getReceiveTask_MessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getReceiveTask_OperationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getResourceRole_ResourceRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getSendTask_MessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getSendTask_OperationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getServiceTask_OperationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getItemAwareElement_ItemSubjectRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getBoundaryEvent_AttachedToRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getCatchEvent_EventDefinitionRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getCompensateEventDefinition_ActivityRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getErrorEventDefinition_ErrorRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getEscalationEventDefinition_EscalationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getLinkEventDefinition_Source());
qnameMap.add(Bpmn2Package.eINSTANCE.getLinkEventDefinition_Target());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageEventDefinition_OperationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getMessageEventDefinition_MessageRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getSignal_StructureRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getSignalEventDefinition_SignalRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getThrowEvent_EventDefinitionRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getProcess_Supports());
qnameMap.add(Bpmn2Package.eINSTANCE.getProcess_DefinitionalCollaborationRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getLane_PartitionElementRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getGlobalChoreographyTask_InitiatingParticipantRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getChoreographyActivity_ParticipantRefs());
qnameMap.add(Bpmn2Package.eINSTANCE.getChoreographyActivity_InitiatingParticipantRef());
qnameMap.add(Bpmn2Package.eINSTANCE.getChoreographyTask_MessageFlowRef());
// qnameMap.add(Bpmn2Package.eINSTANCE.getCallChoreography_CalledChoreographyRef());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNPlane_BpmnElement());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNShape_BpmnElement());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNShape_ChoreographyActivityShape());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNEdge_BpmnElement());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNEdge_SourceElement());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNEdge_TargetElement());
qnameMap.add(BpmnDiPackage.eINSTANCE.getBPMNLabel_LabelStyle());
}
public class OnlyNamedContainmentTypeInfo extends OnlyContainmentTypeInfo {
public boolean shouldSaveType(EClass objectType, EClassifier featureType, EStructuralFeature feature) {
String name = ExtendedMetaData.INSTANCE.getName(objectType);
if (name==null || name.isEmpty())
return false;
return super.shouldSaveType(objectType, featureType, feature);
}
public boolean shouldSaveType(EClass objectType, EClass featureType, EStructuralFeature feature) {
String name = ExtendedMetaData.INSTANCE.getName(objectType);
if (name==null || name.isEmpty())
return false;
return super.shouldSaveType(objectType, featureType, feature);
}
}
/**
* Creates an instance of the resource.
*
* @param uri
* the URI of the new resource.
*/
public Bpmn2ModelerResourceImpl(URI uri) {
super(uri);
// override helper and uri handler in options map
this.xmlHelper = (BpmnXmlHelper)createXMLHelper();
this.uriHandler = new FragmentQNameURIHandler(xmlHelper);
uriHandler.setBaseURI(uri);
this.getDefaultLoadOptions().put(XMLResource.OPTION_URI_HANDLER, uriHandler);
this.getDefaultLoadOptions().put(XMLResource.OPTION_DEFER_IDREF_RESOLUTION, true);
this.getDefaultLoadOptions().put(XMLResource.OPTION_DISABLE_NOTIFY, true);
this.getDefaultSaveOptions().put(XMLResource.OPTION_URI_HANDLER, uriHandler);
ExtendedMetaData extendedMetadata = new XmlExtendedMetadata();
this.getDefaultSaveOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, extendedMetadata);
this.getDefaultLoadOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, extendedMetadata);
this.getDefaultSaveOptions().put(XMLResource.OPTION_SAVE_TYPE_INFORMATION, new OnlyNamedContainmentTypeInfo());
this.getDefaultSaveOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
this.getDefaultLoadOptions().put(XMLResource.OPTION_USE_LEXICAL_HANDLER, Boolean.TRUE);
this.getDefaultSaveOptions().put(XMLResource.OPTION_ELEMENT_HANDLER, new ElementHandlerImpl(true));
this.getDefaultSaveOptions().put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
this.getDefaultSaveOptions().put(XMLResource.OPTION_USE_CACHED_LOOKUP_TABLE, new ArrayList<Object>());
// some interesting things to play with:
// this.getDefaultLoadOptions().put(XMLResource.OPTION_LAX_FEATURE_PROCESSING, true);
// this.getDefaultLoadOptions().put(XMLResource.OPTION_LAX_WILDCARD_PROCESSING, true);
// this.getDefaultLoadOptions().put(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, true);
// this.getDefaultLoadOptions().put(XMLResource.OPTION_ANY_TYPE, BpmnDiPackage.eINSTANCE.getBPMNPlane());
this.getDefaultLoadOptions().put(XMLResource.OPTION_USE_XML_NAME_TO_FEATURE_MAP, xmlNameToFeatureMap);
// only necessary if this resource will not be added to a ResourceSet instantly
this.eAdapters().add(oppositeReferenceAdapter);
}
@Override
public void load(Map<?, ?> options) throws IOException {
try {
Bpmn2ModelerFactory.lock();
Bpmn2ModelerFactory.setEnableModelExtensions(false);
super.load(options);
}
finally {
Bpmn2ModelerFactory.setEnableModelExtensions(true);
Bpmn2ModelerFactory.setResource(null);
Bpmn2ModelerFactory.unlock();
}
}
public void save(Map<?, ?> options) throws IOException {
uriHandler.setBaseURI(getURI());
xmlHelper.setResource(this);
super.save(options);
}
@Override
protected XMLHelper createXMLHelper() {
if (xmlHelper!=null)
return xmlHelper;
return new Bpmn2ModelerXmlHelper(this);
}
/**
* Override this method to hook in our own XmlHandler
*/
@Override
protected XMLLoad createXMLLoad() {
XMLLoad xmlLoad = new XMLLoadImpl(createXMLHelper()) {
Bpmn2ModelerXmlHandler handler;
@Override
protected DefaultHandler makeDefaultHandler() {
handler = new Bpmn2ModelerXmlHandler(resource, helper, options);
return handler;
}
@Override
public void load(XMLResource resource, InputStream inputStream, Map<?, ?> options) throws IOException {
try {
super.load(resource, inputStream, options);
}
catch (Exception e) {
e.printStackTrace();
BPMNDiagnostic error = new BPMNDiagnostic(e.getMessage());
error.setLine(handler.getLineNumber());
error.setColumn(handler.getColumnNumber());
error.setLocation(handler.getLocation());
if (!resource.getErrors().contains(error))
resource.getErrors().add(error);
throw new IOException(e);
}
}
};
return xmlLoad;
}
static class BPMNDiagnostic implements Resource.Diagnostic {
private String message;
private String location;
private int column;
private int line;
public BPMNDiagnostic(String message) {
this.message = message;
}
public void setLocation(String location) {
this.location = location;
}
public String getLocation() {
return location;
}
public void setColumn(int column) {
this.column = column;;
}
public int getColumn() {
return column;
}
public void setLine(int line) {
this.line = line;
}
public int getLine() {
return line;
}
public String getMessage() {
return message;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof BPMNDiagnostic) {
BPMNDiagnostic that = (BPMNDiagnostic)obj;
return
(this.message!=null && this.message.equals(that.message)) &&
this.line==that.line &&
this.column==that.column;
}
else if (obj instanceof Exception) {
String message = ((Exception)obj).getMessage();
return message.equals(this.message);
}
return super.equals(obj);
}
}
@Override
protected XMLSave createXMLSave() {
prepareSave();
return new Bpmn2ModelerXMLSave(createXMLHelper()) {
};
}
@Override
protected void prepareSave() {
EObject cur;
// Definitions definitions = ImportHelper.getDefinitions(this);
for (Iterator<EObject> iter = getAllContents(); iter.hasNext();) {
cur = iter.next();
setDefaultId(cur);
// for (EObject referenced : cur.eCrossReferences()) {
// setDefaultId(referenced);
// if (definitions != null) {
// Resource refResource = referenced.eResource();
// if (refResource != null && refResource != this) {
// createImportIfNecessary(definitions, refResource);
// }
// }
// }
}
}
/**
* Generate an ID attribute for the given BPMN2 element if not already set.
*
* @param obj
* The object whose ID should be set.
*/
private void setDefaultId(EObject obj) {
if (obj.eClass() != null) {
EStructuralFeature idAttr = obj.eClass().getEIDAttribute();
if (idAttr != null && !obj.eIsSet(idAttr)) {
obj.eSetDeliver(false);
ModelUtil.setID(obj);
obj.eSetDeliver(true);
}
}
}
@Override
public void setURI(URI uri) {
super.setURI(uri);
xmlHelper.setResource(this);
uriHandler.setBaseURI(uri);
}
/**
* We need to extend the standard SAXXMLHandler to hook into the handling of
* attribute references which may be either simple ID Strings or QNames.
* We'll search through all of the objects' IDs first to find the one we're
* looking for. If not, we'll try a QName search.
*/
protected static class Bpmn2ModelerXmlHandler extends BpmnXmlHandler {
protected Bpmn2Preferences preferences = null;
protected ImportUtil importHandler = new ImportUtil();
protected String targetNamespace = null;
public Bpmn2ModelerXmlHandler(XMLResource xmiResource, XMLHelper helper, Map<?, ?> options) {
super(xmiResource, helper, options);
}
/**
* Subclasses should override this to provide their own namespace URI.
* Default is to use that "targetNamespace" attribute in the <definitions> element.
* @param defs
* @return
*/
protected String getTargetNamespace(Definitions defs) {
return defs.getTargetNamespace();
}
@Override
public void startDocument() {
Bpmn2ModelerFactory.setResource(xmlResource);
preferences = Bpmn2Preferences.getInstance(xmlResource);
super.startDocument();
}
@Override
public void endDocument() {
super.endDocument();
// Make sure there's a namespace prefix definition for typeLanguage.
// We'll need that prefix to qualify data types defined in the type language.
Definitions definitions = ModelUtil.getDefinitions(xmlResource);
String typeLanguage = definitions.getTypeLanguage();
if (typeLanguage!=null) {
String prefix = NamespaceUtil.getPrefixForNamespace(helper.getResource(), typeLanguage);
if (prefix==null) {
TargetRuntime rt = TargetRuntime.getRuntime(xmlResource);
TypeLanguageDescriptor tld = rt.getTypeLanguageDescriptor(typeLanguage);
if (tld!=null)
prefix = tld.getPrefix();
NamespaceUtil.addNamespace(helper.getResource(), prefix, typeLanguage);
}
}
// Load all of the Imports and generate Interfaces, Operations, Messages, Faults and ItemDefinitions
for (Import imp : definitions.getImports()) {
try {
Object importObject = importHandler.loadImport(imp);
if (importObject!=null) {
importHandler.addImportObjects(imp, importObject);
}
}
catch (Exception e) {
BPMNDiagnostic error = new BPMNDiagnostic(e.getMessage());
error.setLine(getLineNumber());
error.setColumn(getColumnNumber());
error.setLocation(getLocation());
xmlResource.getErrors().add(error);
}
}
// Fix up the descriptions for BPMNDiagrams
for (BPMNDiagram d : definitions.getDiagrams()) {
// Set the diagram's description AFTER it has been completely populated
ExtendedPropertiesAdapter epa = ExtendedPropertiesAdapter.adapt(d);
if (epa!=null) {
epa.setProperty(ExtendedPropertiesAdapter.LONG_DESCRIPTION, epa.getDescription(d));
}
}
}
@Override
protected void handleForwardReferences(boolean isEndDocument) {
if (isEndDocument) {
List<SingleReference> resolved = new ArrayList<SingleReference>();
for (SingleReference ref : forwardSingleReferences) {
EObject referencedObject = null;
try {
referencedObject = xmlResource.getEObject((String) ref.getValue());
} catch (RuntimeException exception) {}
if (referencedObject==null) {
// The forward reference may be in an external document.
// Check the reference type and its owner, then search
// external documents contained in the same project.
EObject referencingObject = ref.getObject();
EStructuralFeature referencingFeature = ref.getFeature();
String id = (String) ref.getValue();
referencedObject = importHandler.resolveExternalReference(referencingObject, referencingFeature, id);
if (referencedObject != null) {
resolved.add(ref);
if (shouldResolveExternals(referencingObject, referencedObject, id)) {
importHandler.addImport(xmlResource, ModelUtil.getDefinitions(referencedObject));
xmlResource.getResourceSet().getResources().add(referencedObject.eResource());
setFeatureValue(referencingObject, referencingFeature, referencedObject, ref.getPosition());
}
}
}
}
if (!resolved.isEmpty())
forwardSingleReferences.removeAll(resolved);
}
super.handleForwardReferences(isEndDocument);
}
/**
* Check if the loader should allow external references to other files
* in the project. This is controlled by a User Preference setting.
*
* @param referencingObject the object referencing an external object.
* @param referencedObject the referenced object contained in another
* file in the project.
* @param id the ID string of the referenced object.
* @return true if externals should be resolved, false to cause an error
* for missing references.
*/
private boolean shouldResolveExternals(EObject referencingObject, EObject referencedObject, String id) {
if (preferences.getResolveExternals()==0)
return false;
if (preferences.getResolveExternals()==1)
return true;
try {
Resource resource = referencedObject.eResource();
IPath path = new Path(resource.getURI().toPlatformString(true));
boolean doit = MessageDialog.openQuestion(new Shell(),
Messages.Bpmn2ModelerResourceSetImpl_External_Reference_Found_Title,
NLS.bind(
Messages.Bpmn2ModelerResourceSetImpl_External_Reference_Found_Message,
new Object[] {
referencedObject.eClass().getName(),
id,
ModelUtil.getLabel(referencingObject)+" \""+ModelUtil.getName((BaseElement)referencingObject)+"\"", //$NON-NLS-1$ //$NON-NLS-2$
path.toString()}
)
);
return doit;
}
catch (Exception e) {}
return true;
}
@Override
protected EStructuralFeature getFeature(EObject object, String prefix, String name, boolean isElement) {
EStructuralFeature feature = null;
String nsURI = (prefix==null ? targetNamespace : helper.getURI(prefix));
ModelDecorator md = ModelDecorator.getModelDecorator(nsURI);
if (md!=null) {
feature = md.getEStructuralFeature(object, name);
if (feature!=null) {
// System.out.println("found feature "+object.eClass().getName()+"."+name+" in pkg "+pkg.getName());
return feature;
}
}
feature = super.getFeature(object, prefix, name, isElement);
// if (feature!=null)
// System.out.println("found feature "+object.eClass().getName()+"."+name);
// else
// System.out.println("feature "+prefix+":"+name+" not found!!!");
return feature;
}
@Override
protected EObject createObjectFromFeatureType(EObject peekObject, EStructuralFeature feature) {
int lineNumber = getLineNumber();
EObject newObject = null;
String nsURI = ExtendedMetaData.INSTANCE.getNamespace(feature);
EPackage pkg = ModelDecorator.getEPackage(nsURI);
if (pkg!=null) {
EClassifier eType = feature.getEType();
newObject = pkg.getEFactoryInstance().create((EClass)eType);
// ModelDecoratorAdapter mda = AdapterUtil.adapt(pkg, ModelDecoratorAdapter.class);
// feature = mda.getEStructuralFeature(peekObject, feature);
if (feature!=null) {
ExtendedPropertiesAdapter epa = ExtendedPropertiesAdapter.adapt(peekObject);
if (epa!=null) {
epa.getFeatureDescriptor(feature).setValue(newObject);
processObject(newObject);
handleObjectAttribs(newObject);
}
}
}
else {
newObject = super.createObjectFromFeatureType(peekObject, feature);
}
if (newObject!=null) {
ExtendedPropertiesAdapter epa = ExtendedPropertiesAdapter.adapt(newObject);
if (epa!=null) {
epa.setProperty(ExtendedPropertiesAdapter.LINE_NUMBER, lineNumber);
}
}
return newObject;
}
protected EObject validateCreateObjectFromFactory(EFactory factory, String typeName, EObject newObject, EStructuralFeature feature) {
if (newObject != null) {
TargetRuntime rt = TargetRuntime.getRuntime(xmlResource);
String id = rt.getCustomTaskId(newObject);
if (id!=null) {
// if this is a CustomElement we need to discard this object and construct it
// properly such that all extension attributes and elements are created and
// initialized.
newObject = Bpmn2ModelerFactory.create(xmlResource, newObject.eClass(),
new KeyValue(GraphitiConstants.CUSTOM_ELEMENT_ID, id));
handleObjectAttribs(newObject);
}
}
return super.validateCreateObjectFromFactory(factory, typeName, newObject, feature);
}
@Override
protected void setFeatureValue(EObject object, EStructuralFeature feature, Object value, int position) {
ModelDecorator md = ModelDecorator.getModelDecorator(feature);
if (md!=null) {
EStructuralFeature f = md.getEStructuralFeature(object, feature.getName());
if (f!=null) {
ExtendedPropertiesAdapter epa = ExtendedPropertiesAdapter.adapt(object);
epa.getFeatureDescriptor(f).setValue(value, position);
return;
}
// ExtendedPropertiesAdapter epa = ExtendedPropertiesAdapter.adapt(object);
// epa.getFeatureDescriptor(feature).setValue(value, position);
}
super.setFeatureValue(object, feature, value, position);
}
@Override
protected void handleObjectAttribs(EObject obj) {
if (obj instanceof BPMNShape) {
// Enable immediate ID resolution because we need to link up
// the BPMNShape's "bpmnElement" reference. This is required
// by the Bpmn2Preferences so it can determine how to handle
// certain DI attributes, e.g. isHorizontal, isExpanded, etc.
deferIDREFResolution = false;
}
super.handleObjectAttribs(obj);
String xmlns = null;
String tns = null;
if (attribs != null) {
for (int i = 0, size = attribs.getLength(); i < size; ++i) {
String name = attribs.getQName(i);
if (name.equals(XMLResource.XML_NS)) {
// create an ns prefix in the prefix map for this default namespace
// and qualify any qnameFeatures contained in this object...
xmlns = attribs.getValue(i);
for (EStructuralFeature f : obj.eClass().getEAllStructuralFeatures()) {
if (qnameMap.contains(f)) {
Object value = obj.eGet(f);
if (ModelUtil.isStringWrapper(value)) {
String localpart = ModelUtil.getStringWrapperValue(value);
if (localpart!=null && !localpart.isEmpty() && !localpart.contains(":")) { //$NON-NLS-1$
String prefix = helper.getPrefix(xmlns);
if (prefix==null || prefix.isEmpty()) {
for (int index = 0; true; ++index) {
prefix = "ns" + index; //$NON-NLS-1$
String ns = helper.getPrefixToNamespaceMap().get(prefix);
if (ns==null)
break;
}
helper.addPrefix(prefix, xmlns);
}
ModelUtil.setStringWrapperValue(value, prefix + ":" + localpart); //$NON-NLS-1$
}
}
}
}
}
else if (name.startsWith(XMLResource.XML_NS+":")) { //$NON-NLS-1$
String prefix = name.substring(name.indexOf(':')+1);
String namespace = attribs.getValue(i);
NamespaceUtil.addNamespace(xmlResource, prefix, namespace);
}
else if (name.equals("tns")) {
tns = attribs.getValue(i);
}
}
}
if (obj instanceof BPMNShape) {
// Defer ID resolution until after resource is loaded.
// See above.
deferIDREFResolution = true;
BPMNShape bpmnShape = (BPMNShape)obj;
Hashtable<String,String> map = new Hashtable<String,String>();
if (attribs != null) {
for (int i = 0, size = attribs.getLength(); i < size; ++i) {
String key = attribs.getQName(i);
String value = attribs.getValue(i);
map.put(key, value);
}
preferences.applyBPMNDIDefaults(bpmnShape, map);
}
}
else if (obj instanceof ItemDefinition) {
ItemDefinition itemDef = (ItemDefinition)obj;
Definitions definitions = ModelUtil.getDefinitions(xmlResource);
URI referencingURI = ImportHelper.makeURICanonical(resourceURI);
String location = ModelUtil.getStringWrapperValue(itemDef.getStructureRef());
if (location!=null) {
int i = location.indexOf("$"); //$NON-NLS-1$
if (i>0)
location = location.substring(0,i);
URI uri = URI.createURI(location).resolve(referencingURI);
uri = uri.trimFragment();
Import imp = ImportHelper.findImportForLocation(definitions, uri);
itemDef.setImport(imp);
}
}
/* it's already too late at this point to identify targetNamespace - see createDocumentRoot()
else if (obj instanceof Definitions) {
// Fetch the targetNamespace from Definitions object:
// this is where we allow the TargetRuntime extension to provide
// its own targetNamespace if the file doesn't define one.
// The targetNamespace determines the TargetRuntime and therefore
// how the file is handled, since the TargetRuntime may have special
// processing that needs to be done during loading. Therefore,
// it's important that we have a targetNamespace after the <definitions>
// element is parsed, or the remainder of the file may not be processed
// correctly.
targetNamespace = getTargetNamespace((Definitions)obj);
// if targetNamespace is not provided, use "tns" from file
if (targetNamespace==null && tns!=null && !tns.isEmpty())
targetNamespace = tns;
// if that didn't work, try "xmlns"
if (targetNamespace==null && xmlns!=null && !xmlns.isEmpty())
targetNamespace = xmlns;
// if that still didn't work use the default namespace
if (targetNamespace==null)
targetNamespace = TargetRuntime.getDefaultRuntime().getRuntimeExtension().getTargetNamespace(null);
((Bpmn2ModelerXmlHelper)helper).initializeTargetRuntime(targetNamespace);
}
*/
}
protected EObject createDocumentRoot(String prefix, String uri, String name, EFactory eFactory, boolean top) {
// Fetch the targetNamespace from DocumentRoot (<definitions>) object:
// this is where we allow the TargetRuntime extension to provide
// its own targetNamespace if the file doesn't define one, by overriding
// the Bpmn2ModelerXmlHandler#getTargetNamespace(Definitions) method.
// The targetNamespace determines the TargetRuntime and therefore
// how the file is handled, since the TargetRuntime may have special
// processing that needs to be done during loading. Therefore,
// it's important that we have a targetNamespace after the <definitions>
// element is parsed, or the remainder of the file may not be processed
// correctly.
//
// TargetNamespace identification needs to happen very early in the resource
// load process, sometime before the first EObject is created by Bpmn2ModelerFactory
Definitions definitions = Bpmn2Factory.eINSTANCE.createDefinitions();
String tns = null;
String xmlns = null;
for (int i = 0, size = attribs.getLength(); i < size; ++i) {
String attrib = attribs.getQName(i);
if (attrib.equals("tns")) {
tns = attribs.getValue(i);
}
else if (attrib.equals("targetNamespace")) {
targetNamespace = attribs.getValue(i);
definitions.setTargetNamespace(targetNamespace);
}
else if (attrib.equals(XMLResource.XML_NS)) {
xmlns = attribs.getValue(i);
}
}
targetNamespace = getTargetNamespace(definitions);
// if targetNamespace is not provided, use "tns" from file
if (targetNamespace==null && tns!=null && !tns.isEmpty())
targetNamespace = tns;
// if that didn't work, try "xmlns"
if (targetNamespace==null && xmlns!=null && !xmlns.isEmpty())
targetNamespace = xmlns;
// if that still didn't work use the default namespace
if (targetNamespace==null)
targetNamespace = TargetRuntime.getDefaultRuntime().getRuntimeExtension().getTargetNamespace(null);
((Bpmn2ModelerXmlHelper)helper).initializeTargetRuntime(targetNamespace);
return super.createDocumentRoot(prefix, uri, name, eFactory, top);
}
/**
* Overridden to be able to convert ID references in attributes to URIs
* during load. If the reference can't be found by its ID, we'll try a
* QName search (done in the super class)
*
* @param ids
* In our case the parameter will contain exactly one ID that
* we resolve to URI.
*/
@Override
protected void setValueFromId(EObject object, EReference eReference, String ids) {
Object value = null;
// Handle QNames and arbitrary strings in BPMN2 element references
if ( qnameMap.contains(eReference) ) {
// This reference might be a QName (according to the BPMN2 spec!)
// or it might not, in the case of some jBPM Java type references.
int i = ids.indexOf(":"); //$NON-NLS-1$
if (i>0) {
// if the ID string is a QName, try to resolve and load the object
String prefix = ids.substring(0,i);
String localname = ids.substring(i+1);
String namespace = helper.getNamespaceURI(prefix);
if (namespace!=null && namespace.equals(targetNamespace)) {
// namespace for prefix is the same as targetNamespace
// so remove the prefix to avoid confusing the XMLHandler
ids = localname;
}
else {
// this thing is in another namespace, possibly in an external document
Import imp = importHandler.findImportForNamespace(helper.getResource(), namespace);
if (imp!=null) {
value = importHandler.getObjectForId(imp, object, eReference, ids);
}
}
}
if (value==null) {
// we can't find the object in any of our imports,
// so create a string wrapper EObject for this thing
value = ModelUtil.createStringWrapper(ids);
}
if (value!=null && eReference.getEType().isInstance(value)) {
try {
if (eReference.isMany()) {
((EList)object.eGet(eReference)).add(value);
}
else {
object.eSet(eReference, value);
}
return;
} catch (Exception e) {
String msg = NLS.bind(
Messages.Bpmn2ModelerResourceImpl_Invalid_Reference,
new Object[] {object, eReference, value});
IStatus s = new Status(Status.ERROR, Activator.PLUGIN_ID,
msg, e);
Activator.getDefault().logStatus(s);
}
}
}
// And yet another hack to deal with files generated by Savara:
// Savara creates some object references as QNames and, while the
// "Official" BPMN 2.0 xsd says these SHOULD be QNames, the bpmn2 EMF
// model has these defined as "resolveProxies=false" which means they
// will NOT get resolved.
if (/*!eReference.isResolveProxies() && */ids.contains(":")) { //$NON-NLS-1$
// Resolve QNames here: if they are internal objects,
// simply replace the ID string with the URI fragment.
// If they are not internal objects, then there's a
// problem with the file!
String resolvedId = ((QNameURIHandler) uriHandler).convertQNameToUri(ids);
URI resolvedURI = URI.createURI(resolvedId);
URI resourceURI = xmlResource.getURI();
if (resolvedURI.trimFragment().equals(resourceURI))
ids = resolvedURI.fragment();
}
super.setValueFromId(object, eReference, ids);
}
public int getLineNumber() {
return super.getLineNumber();
}
public int getColumnNumber() {
return super.getColumnNumber();
}
public String getLocation() {
return super.getLocation();
}
@Override
public void startElement(String uri, String localName, String name) {
super.startElement(uri, localName, name);
EObject peekObject = objects.peekEObject();
// if (peekObject instanceof Definitions) {
// // create all model extensions for this target runtime so that all
// // extension attributes and elements are available during loading.
// TargetRuntime rt = TargetRuntime.getCurrentRuntime();
// rt.createModelExtensions(peekObject.eResource());
// }
if (peekObject!=null && peekObject.getClass()==Expression.class) {
// If the element is an Expression (not a FormalExpression) then use the CDATA
// as the body of a Formal Expression (because Expression does not have a body)
text = new StringBuffer();
}
}
@Override
public void endElement(String uri, String localName, String name) {
EObject peekObject = objects.peek();
if (peekObject!=null && peekObject.getClass()==Expression.class) {
// if the element is an Expression, replace it with a FormalExpression and set
// its body using the CDATA of the Expression element.
FormalExpression fe = Bpmn2Factory.eINSTANCE.createFormalExpression();
EObject owner = peekObject.eContainer();
if (owner!=null) {
for (EStructuralFeature f : owner.eClass().getEAllStructuralFeatures()) {
if (owner.eGet(f) == peekObject) {
owner.eSet(f, fe);
break;
}
}
objects.pop();
objects.push(fe);
types.pop();
types.push(Bpmn2Package.eINSTANCE.getFormalExpression_Body());
EStructuralFeature mixedFeature = extendedMetaData.getMixedFeature(fe.eClass());
if (mixedFeature != null)
{
mixedTargets.push((FeatureMap)fe.eGet(mixedFeature));
}
else
{
mixedTargets.push(null);
}
}
}
super.endElement(uri, localName, name);
TargetRuntime rt = TargetRuntime.getRuntime(xmlResource);
LifecycleEvent.notify(new LifecycleEvent(EventType.BUSINESSOBJECT_LOADED, peekObject, rt));
}
}
public class Bpmn2ModelerXMLSave extends XMLSaveImpl {
protected float minX = Float.MAX_VALUE;
protected float minY = Float.MAX_VALUE;
protected int lineNum = 1;
protected int lineOffset = 0;
protected Bpmn2Preferences preferences;
@SuppressWarnings("serial")
protected class Bpmn2ModelerXMLString extends XMLString {
public Bpmn2ModelerXMLString(String publicId, String systemId) {
super(Integer.MAX_VALUE, publicId, systemId, null);
}
@Override
public void addAttribute(String name, String value) {
// This special little hack removes namespace declarations
// and schemaLocation attributes for the XSI namespace if the prefix
// is anything other than "xsi". The EMF serializers rely on the fact
// that the XSI namespace prefix is ALWAYS "xsi" and they WILL create
// a duplicate namespace declaration if one already existed under a
// different prefix. This would result a nasty warning from the parser.
if (XSI_URI.equals(value) && name.startsWith("xmlns:")) { //$NON-NLS-1$
int i = name.indexOf(":"); //$NON-NLS-1$
String prefix = name.substring(i+1);
if (!ExtendedMetaData.XSI_PREFIX.equals(prefix))
return;
}
if (name.contains(":schemaLocation")) { //$NON-NLS-1$
if (!XSI_SCHEMA_LOCATION.equals(name))
return;
}
super.addAttribute(name, value);
}
@Override
public void addAttributeNS(String prefix, String localName, String value) {
// Same hack as above - see comments.
if (XSI_URI.equals(value) && !ExtendedMetaData.XSI_PREFIX.equals(localName))
return;
super.addAttributeNS(prefix, localName, value);
}
@Override
public void addLine() {
++lineNum;
super.addLine();
lineOffset = getLength();
}
public int getLineNum() {
return lineNum;
}
@Override
public void addAttributeContent(String content) {
// convert to XML string with entities
super.addAttributeContent(SyntaxCheckerUtils.toXMLString(content));
}
public int getColumnNum() {
return getLength() - lineOffset + 1;
}
};
public Bpmn2ModelerXMLSave(XMLHelper helper) {
super(helper);
helper.getPrefixToNamespaceMap().clear();
preferences = Bpmn2Preferences.getInstance(helper.getResource());
}
@Override
protected void addNamespaceDeclarations() {
EMap<String,String> map = helper.getPrefixToNamespaceMap();
Definitions definitions = ModelUtil.getDefinitions(helper.getResource());
String typeLanguage = definitions.getTypeLanguage();
if (!map.containsValue(typeLanguage)) {
String prefix = "tl"; //$NON-NLS-1$
TargetRuntime rt = TargetRuntime.getRuntime(xmlResource);
TypeLanguageDescriptor tld = rt.getTypeLanguageDescriptor(typeLanguage);
if (tld!=null)
prefix = tld.getPrefix();
doc.addAttributeNS(XMLResource.XML_NS, prefix, typeLanguage);
}
super.addNamespaceDeclarations();
}
@Override
protected void init(XMLResource resource, Map<?, ?> options) {
super.init(resource, options);
featureTable = new Bpmn2ModelerXMLSave.Bpmn2Lookup(map, extendedMetaData, elementHandler);
final List<BPMNDiagram> diagrams = getAll(BPMNDiagram.class, resource);
for (BPMNDiagram bpmnDiagram : diagrams) {
findMinXY(bpmnDiagram);
}
doc = createXMLString();
if (contents.size()>0 && contents.get(0) instanceof Bpmn2ModelerDocumentRootImpl) {
Bpmn2ModelerDocumentRootImpl documentRoot = (Bpmn2ModelerDocumentRootImpl)contents.get(0);
Definitions definitions = ModelUtil.getDefinitions(helper.getResource());
try {
documentRoot.setDeliver(false);
documentRoot.eSetDeliver(false);
FeatureMap featureMap = documentRoot.getMixed();
if (featureMap.size()>0) {
// insert a comment before the Definitions node
String comment = " origin at X="+(minX<0 ? minX : 0)+ //$NON-NLS-1$
" Y="+(minY<0 ? minY : 0)+" "; //$NON-NLS-1$ //$NON-NLS-2$
if (featureMap.get(0).getEStructuralFeature() != XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__COMMENT) {
featureMap.add(0,XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__COMMENT, comment);
}
else {
FeatureMap.Entry e = FeatureMapUtil.createEntry(XMLTypePackage.Literals.XML_TYPE_DOCUMENT_ROOT__COMMENT, comment);
featureMap.set(0, e);
}
}
definitions.eSetDeliver(false);
definitions.setExporter(Activator.PLUGIN_ID);
String version = Platform.getBundle(Activator.PLUGIN_ID).getHeaders().get("Bundle-Version"); //$NON-NLS-1$
version = version.replaceAll(".qualifier", ""); //$NON-NLS-1$ //$NON-NLS-2$
definitions.setExporterVersion(version);
}
finally {
documentRoot.setDeliver(true);
documentRoot.eSetDeliver(true);
definitions.eSetDeliver(true);
}
}
}
protected XMLString createXMLString() {
return new Bpmn2ModelerXMLString(publicId, systemId);
}
protected Bpmn2ModelerXMLString getXMLString() {
if (doc==null) {
createXMLString();
}
return (Bpmn2ModelerXMLString)doc;
}
@Override
protected void endSave(List<? extends EObject> contents) throws IOException
{
Bpmn2ModelerDocumentRootImpl documentRoot = null;
if (contents.size()>0 && contents.get(0) instanceof Bpmn2ModelerDocumentRootImpl) {
documentRoot = (Bpmn2ModelerDocumentRootImpl)contents.get(0);
documentRoot.setDeliver(false);
documentRoot.eSetDeliver(false);
}
try {
super.endSave(contents);
}
finally {
if (documentRoot!=null) {
documentRoot.setDeliver(true);
documentRoot.eSetDeliver(true);
}
}
}
@Override
protected boolean shouldSaveFeature(EObject o, EStructuralFeature f) {
if (o instanceof BPMNShape) {
BPMNShape s = (BPMNShape)o;
if (f==BpmnDiPackage.eINSTANCE.getBPMNShape_IsExpanded()) {
if (FeatureSupport.isExpandableElement(s.getBpmnElement()))
return true;
}
if (f==BpmnDiPackage.eINSTANCE.getBPMNShape_IsHorizontal()) {
if (s.getBpmnElement() instanceof Lane || s.getBpmnElement() instanceof Participant)
return true;
}
}
// we also want to store x and y with value zero, would be skipped because of default value otherwise
if (o instanceof Bounds || o instanceof Point) {
return true;
}
if (o instanceof Process && f==Bpmn2Package.eINSTANCE.getProcess_IsExecutable())
return true;
if (o instanceof ItemDefinition && f==Bpmn2Package.eINSTANCE.getItemDefinition_IsCollection())
return true;
if (o instanceof CompensateEventDefinition && f==Bpmn2Package.eINSTANCE.getCompensateEventDefinition_WaitForCompletion())
return true;
// empty Expressions should not be saved
if (f!=null && (f.getEType() == Bpmn2Package.eINSTANCE.getExpression() ||
f.getEType() == Bpmn2Package.eINSTANCE.getFormalExpression())) {
Expression expression = (Expression)o.eGet(f);
if (expression==null)
return false;
if (expression instanceof FormalExpression) {
FormalExpression formalExpression = (FormalExpression)expression;
String body = ModelUtil.getExpressionBody(formalExpression);
if (body==null) {
return false;
}
}
}
if (o!=null && o instanceof Documentation) {
Documentation doc = (Documentation)o;
if (doc.getText()==null || doc.getText().isEmpty())
return false;
}
if (f!=null && f.getEType() == Bpmn2Package.eINSTANCE.getDocumentation()) {
EList<Documentation> docList = (EList<Documentation>)o.eGet(f);
if (docList.isEmpty())
return false;
int empty = 0;
for (Documentation doc : docList) {
if (doc.getText()==null || doc.getText().isEmpty())
++empty;
}
if (empty==docList.size())
return false;
}
// don't serialize the "body" attribute of FormalExpressions because the expression text
// is already in the CDATA section of the <bpmn2:expression> element. This would cause
// the expression text to be duplicated on deserialization.
// Same goes for Documentation.text
if (Bpmn2Package.eINSTANCE.getFormalExpression_Body().equals(f) ||
Bpmn2Package.eINSTANCE.getDocumentation_Text().equals(f))
return false;
// don't save Assignments if they are invalid: Assignments must have
// both a "from" and "to" expression and they may not be empty strings.
if (o instanceof DataAssociation && "assignment".equals(f.getName())) { //$NON-NLS-1$
DataAssociation da = (DataAssociation)o;
for (Assignment a : da.getAssignment()) {
Expression from = a.getFrom();
if (from instanceof FormalExpression) {
String body = ModelUtil.getExpressionBody(((FormalExpression)from));
if (body==null || body.isEmpty())
return false;
}
Expression to = a.getTo();
if (to instanceof FormalExpression) {
String body = ModelUtil.getExpressionBody(((FormalExpression)to));
if (body==null || body.isEmpty())
return false;
}
}
}
if (f == Bpmn2Package.eINSTANCE.getBaseElement_ExtensionValues()) {
// check if this element is (or should be) empty
int entryCount = 0;
for (ExtensionAttributeValue ev : (EList<ExtensionAttributeValue>)o.eGet(f)) {
BasicFeatureMap map = (BasicFeatureMap) ev.getValue();
Iterator<FeatureMap.Entry> mi = map.iterator();
while (mi.hasNext()) {
FeatureMap.Entry entry = mi.next();
Object v = entry.getValue();
boolean entryCounted = false;
if (v instanceof EObject) {
Iterator<Adapter> ai = ((EObject)v).eAdapters().iterator();
while (ai.hasNext()) {
Adapter a = ai.next();
if (a instanceof IExtensionValueAdapter) {
if (((IExtensionValueAdapter)a).shouldSaveElement((EObject)v)) {
++entryCount;
}
entryCounted = true;
}
}
}
if (!entryCounted)
++entryCount;
}
}
return entryCount>0;
}
Iterator<Adapter> ai = o.eAdapters().iterator();
while (ai.hasNext()) {
Adapter a = ai.next();
if (a instanceof IExtensionValueAdapter) {
if (!((IExtensionValueAdapter)a).shouldSaveFeature(o,f))
return false;
}
}
return super.shouldSaveFeature(o, f);
}
protected <T> List<T> getAll(Class<T> class1, Resource resource) {
ArrayList<T> l = new ArrayList<T>();
TreeIterator<EObject> contents = resource.getAllContents();
for (; contents.hasNext();) {
Object t = contents.next();
if (class1.isInstance(t)) {
l.add((T) t);
}
}
return l;
}
protected void findMinXY(BPMNDiagram bpmnDiagram) {
EList<DiagramElement> elements = (EList<DiagramElement>) bpmnDiagram.getPlane().getPlaneElement();
for (DiagramElement e : elements) {
if (e instanceof BPMNShape) {
Bounds b = ((BPMNShape)e).getBounds();
minX = Math.min(minX, b.getX());
minY = Math.min(minY, b.getY());
}
else if (e instanceof BPMNEdge) {
List<Point> points = ((BPMNEdge)e).getWaypoint();
for (Point p : points) {
minX = Math.min(minX, p.getX());
minY = Math.min(minY, p.getY());
}
}
else if (e instanceof BPMNLabel) {
Bounds b = ((BPMNLabel)e).getBounds();
minX = Math.min(minX, b.getX());
minY = Math.min(minY, b.getY());
}
}
}
@Override
protected void saveContainedMany(EObject o, EStructuralFeature f) {
if (o instanceof BPMNPlane && f==DiPackage.eINSTANCE.getPlane_PlaneElement()) {
// Sort the Diagram Elements in ascending Z-order
BPMNPlane plane = (BPMNPlane) o;
EList<DiagramElement> originalList = new BasicEList<DiagramElement>();
originalList.addAll(plane.getPlaneElement());
plane.eSetDeliver(false);
ECollections.sort((EList<DiagramElement>) plane.getPlaneElement(), new DIZorderComparator());
super.saveContainedMany(o, f);
ECollections.setEList((EList)plane.getPlaneElement(),originalList);
plane.eSetDeliver(true);
}
else if (o instanceof Definitions && f==Bpmn2Package.eINSTANCE.getDefinitions_RootElements()) {
// Sort the Definitions Root Elements to avoid forward references
Definitions definitions = (Definitions) o;
EList<RootElement> originalList = new BasicEList<RootElement>();
originalList.addAll(definitions.getRootElements());
definitions.eSetDeliver(false);
ECollections.sort((EList<RootElement>)definitions.getRootElements(), new RootElementComparator());
super.saveContainedMany(o, f);
ECollections.setEList((EList)definitions.getRootElements(),originalList);
definitions.eSetDeliver(true);
}
else {
super.saveContainedMany(o, f);
}
}
@Override
protected void saveElement(EObject o, EStructuralFeature f) {
Iterator<Adapter> ai = o.eAdapters().iterator();
while (ai.hasNext()) {
Adapter a = ai.next();
if (a instanceof IExtensionValueAdapter) {
if (!((IExtensionValueAdapter)a).shouldSaveElement(o))
return;
}
}
if (o instanceof BPMNLabel) {
if (!preferences.getSaveBPMNLabels())
return;
}
if (o instanceof BPMNLabelStyle) {
// is anyone still using this BPMNLabelStyle?
// if not, get rid of it.
boolean save = false;
if (preferences.getSaveBPMNLabels()) {
Definitions definitions = ModelUtil.getDefinitions(o);
TreeIterator<EObject> iter = definitions.eAllContents();
while (iter.hasNext()) {
EObject eo = iter.next();
if (eo instanceof BPMNLabel) {
if (((BPMNLabel)eo).getLabelStyle() == o)
save = true;
}
}
}
if (!save)
return;
}
float oldX = 0, oldY = 0;
List<Point> oldPoints = null;
if (minX<0 || minY<0) {
if (o instanceof BPMNShape) {
Bounds b = ((BPMNShape)o).getBounds();
b.eSetDeliver(false);
if (minX<0) {
oldX = b.getX();
b.setX(oldX - minX);
}
if (minY<0) {
oldY = b.getY();
b.setY(oldY - minY);
}
}
else if (o instanceof BPMNEdge) {
List<Point> points = ((BPMNEdge)o).getWaypoint();
oldPoints = new ArrayList<Point>();
for (Point p : points) {
p.eSetDeliver(false);
Point oldPoint = DcFactory.eINSTANCE.createPoint();
oldPoint.setX(p.getX());
oldPoint.setY(p.getY());
oldPoints.add(oldPoint);
if (minX<0)
p.setX( p.getX() - minX);
if (minY<0)
p.setY( p.getY() - minY);
}
}
else if (o instanceof BPMNLabel) {
Bounds b = ((BPMNLabel)o).getBounds();
if (b!=null) {
b.eSetDeliver(false);
if (minX<0) {
oldX = b.getX();
b.setX(oldX - minX);
}
if (minY<0) {
oldY = b.getY();
b.setY(oldY - minY);
}
}
}
}
super.saveElement(o, f);
if (minX<0 || minY<0) {
if (o instanceof BPMNShape) {
Bounds b = ((BPMNShape)o).getBounds();
if (minX<0) {
b.setX(oldX);
}
if (minY<0) {
b.setY(oldY);
}
b.eSetDeliver(true);
}
else if (o instanceof BPMNEdge) {
List<Point> points = ((BPMNEdge)o).getWaypoint();
int index = 0;
for (Point p : points) {
if (minX<0)
p.setX(oldPoints.get(index).getX());
if (minY<0)
p.setY(oldPoints.get(index).getY());
p.eSetDeliver(true);
++index;
}
}
else if (o instanceof BPMNLabel) {
Bounds b = ((BPMNLabel)o).getBounds();
if (b!=null) {
if (minX<0) {
b.setX(oldX);
}
if (minY<0) {
b.setY(oldY);
}
b.eSetDeliver(true);
}
}
}
}
@Override
protected String convertURI(String s) {
URI uri = helper.deresolve( URI.createURI(s) );
return uri.toString();
}
@Override
public void traverse(List<? extends EObject> contents) {
for (EObject e : contents) {
if (e instanceof Definitions) {
List<RootElement> roots = ((Definitions) e).getRootElements();
Process p = null;
for (RootElement root : roots) {
if (root instanceof Process) {
p = (Process) root;
}
}
if (p != null) {
((Definitions) e).getRootElements().remove(p);
((Definitions) e).getRootElements().add((RootElement) p);
}
}
}
super.traverse(contents);
}
public class Bpmn2Lookup extends XMLSaveImpl.Lookup {
public Bpmn2Lookup(XMLMap map, ExtendedMetaData extendedMetaData, ElementHandler elementHandler) {
super(map, extendedMetaData, elementHandler);
}
@Override
public EStructuralFeature[] getFeatures(EClass cls) {
int index = getIndex(cls);
EClass c = classes[index];
if (c == cls) {
return features[index];
}
EStructuralFeature[] featureList = listFeatures(cls);
EStructuralFeature[] newFeatureList = featureList;
if (c == null) {
newFeatureList = reorderFeatureList(cls, featureList);
classes[index] = cls;
features[index] = newFeatureList;
featureKinds[index] = listKinds(newFeatureList);
}
return newFeatureList;
}
/**
* Specifies the serialization order of features for a given ECLass.
* Subclasses should override this behavior.
* The default implementation simply returns the original list.
*
* @param cls - EClass whose features need to be reordered
* @param featureList - the original feature list as provided by the Bpmn2Package
* @return a feature list that specifies the new ordering
*/
protected EStructuralFeature[] reorderFeatureList(EClass cls, EStructuralFeature[] featureList) {
return featureList;
}
/**
* Change the serialization order of features for a given EClass. The string array "featureNames"
* specifies a new ordering for some or all of the features in the feature list; these names must
* be contiguous in the original list. For example, given the following original feature list:
*
* "w"
* "x"
* "a"
* "b"
* "c"
* "d"
* "e"
* "y"
* "z"
*
* The featureNames list may not contain this:
*
* "b"
* "a"
* "e"
* "d"
*
* because the two sets "b", "a" and "e", "d" are not contiguous. The correct way of specifying this is:
*
* "b"
* "a"
* "c"
* "e"
* "d"
*
* Alternatively, the client could call this method twice, the first time with the first set ("b" and "a")
* and a second time with the second set ("e" and "d).
*
* @param cls
* @param featureList
* @param featureNames
* @return
*/
protected EStructuralFeature[] reorderFeatureList(EClass cls, EStructuralFeature[] featureList, String[] featureNames) {
// the reordered list of features
EStructuralFeature[] newFeatureList = new EStructuralFeature[featureList.length];
// map of old to new array indexes
int[] indexMap = new int[featureList.length];
for (int i=0; i<indexMap.length; ++i)
indexMap[i] = -1;
int startIndex = Integer.MAX_VALUE;
for (int i=0; i<featureList.length; ++i) {
for (int j=0; j<featureNames.length; ++j) {
if (featureList[i].getName().equals(featureNames[j])) {
if (i<startIndex) {
startIndex = i;
break;
}
}
}
}
for (int newIndex=0; newIndex<featureNames.length; ++newIndex) {
String fn = featureNames[newIndex];
for (int oldIndex=0; oldIndex<featureList.length; ++oldIndex) {
EStructuralFeature f = featureList[oldIndex];
if (f.getName().equalsIgnoreCase(fn)) {
indexMap[oldIndex] = newIndex + startIndex;
break;
}
}
}
for (int oldIndex=0; oldIndex<featureList.length; ++oldIndex) {
EStructuralFeature f = featureList[oldIndex];
int newIndex = indexMap[oldIndex];
if (newIndex>=0) {
newFeatureList[newIndex] = featureList[oldIndex];
}
else
newFeatureList[oldIndex] = featureList[oldIndex];
}
return newFeatureList;
}
}
}
// TODO check this, is this the correct way to deal with this ID prefixes
/**
* QName handler to make create URIs out of the fragment, which is the local part of the QName
*
* Most other tools dont understand QNames in referencing attributes
*
* @author drobisch
*
*/
public static class FragmentQNameURIHandler extends QNameURIHandler {
protected BpmnXmlHelper xmlHelper;
public FragmentQNameURIHandler(BpmnXmlHelper xmlHelper) {
super(xmlHelper);
this.xmlHelper = xmlHelper;
}
@Override
public URI resolve(URI uri) {
URI resolvedUri = super.resolve(uri);
if (resolvedUri.isRelative())
resolvedUri = resolvedUri.resolve(baseURI);
return resolvedUri;
}
@Override
public URI deresolve(URI uri) {
String fragment = uri.fragment();
if (fragment != null && !fragment.startsWith("/")) { //$NON-NLS-1$
// return just fragment (i.e. without the '#') but only if local reference
URI otherURI = uri.trimFragment();
if (baseURI.equals(otherURI))
return URI.createURI(fragment);
}
if (
(uri.isPlatformResource() && baseURI.isPlatformResource()) ||
(uri.isFile() && baseURI.isFile())) {
uri = uri.deresolve(baseURI, false, true, true);
return uri;
}
return super.deresolve(uri);
}
@Override
public String convertQNameToUri(String qName) {
if (qName.contains("#") || qName.contains("/")) { //$NON-NLS-1$ //$NON-NLS-2$
// We already have an URI and not QName, e.g. URL
return qName;
}
// Split into prefix and local part (fragment)
String[] parts = qName.split(":"); //$NON-NLS-1$
String prefix, fragment;
if (parts.length == 1) {
prefix = null;
fragment = qName;
} else if (parts.length == 2) {
prefix = parts[0];
fragment = parts[1];
} else
throw new IllegalArgumentException(Messages.Bpmn2ModelerResourceImpl_Illegal_QName + qName);
if (fragment.contains(".")) { //$NON-NLS-1$
// HACK: officially IDs can contain ".", but unfortunately
// XmlHandler calls resolve also for xsi:schemaLocation stuff
// and similar, that are
// NO URIs. We must not process them.
return qName;
}
boolean isTargetNamespacePrefix = false;
try {
isTargetNamespacePrefix = xmlHelper.isTargetNamespace(prefix);
} catch (Exception e) {
}
if (!isTargetNamespacePrefix) {
String uriString = xmlHelper.getPathForPrefix(prefix).appendFragment(fragment).toString();
URI uri = URI.createURI(uriString);
ResourceSet rs = ModelUtil.slightlyHackedResourceSet(xmlHelper.getResource().getResourceSet());
Resource r = ((Bpmn2ModelerResourceSetImpl)rs).getResource(uri, true, "wsdl"); // the only problem here... //$NON-NLS-1$
if (r instanceof WSDLResourceImpl) {
EObject o = r.getContents().get(0);
Definition def = (Definition)o;
// if eReference -- operation.implementationref
// search all of these:
for (PortType pt : (List<PortType>)def.getEPortTypes()) {
for (org.eclipse.wst.wsdl.Operation op : (List<org.eclipse.wst.wsdl.Operation>)pt.getEOperations()) {
}
}
// and so on for other eReference bpmn2 types
}
return xmlHelper.getPathForPrefix(prefix).appendFragment(fragment).toString();
}
else {
return URI.createURI("").appendFragment(fragment).toString(); //$NON-NLS-1$
}
}
}
public static class Bpmn2ModelerXmlHelper extends BpmnXmlHelper {
// List of all EReferences that are defined as type="xsd:QName" in the BPMN 2.0 Schema
// This information is not represented in the MDT BPMN2 project metamodel.
boolean isQNameFeature = false;
ImportUtil importHandler = new ImportUtil();
/** associated target runtime, only used in "load" scenario */
protected TargetRuntime runtime = null;
public Bpmn2ModelerXmlHelper(Bpmn2ResourceImpl resource) {
super(resource);
}
/**
* initialize the target runtime according to the parsed namespace
*
* @param targetNamespace
*/
protected void initializeTargetRuntime(String targetNamespace) {
runtime = TargetRuntime.getRuntimeByNamespace(targetNamespace);
if (runtime == null) {
runtime = TargetRuntime.getDefaultRuntime();
}
TargetRuntimeAdapter.adapt(resource, runtime);
}
@Override
public Object getValue(EObject eObject, EStructuralFeature eStructuralFeature) {
Object o = super.getValue(eObject, eStructuralFeature);
if (qnameMap.contains(eStructuralFeature)) {
List<String> prefixes = urisToPrefixes.get(getTargetNamespace());
if (prefixes!=null && prefixes.contains("")) //$NON-NLS-1$
isQNameFeature = false;
else
isQNameFeature = true;
}
else
isQNameFeature = false;
return o;
}
@Override
public String getHREF(EObject obj) {
// convert the attribute ID references to a QName
String s = null;
if (ModelUtil.isStringWrapper(obj)) {
s = ModelUtil.getStringWrapperValue(obj);
}
else
s = super.getHREF(obj);
if (isQNameFeature) {
if (s != null && s.contains("#")) { //$NON-NLS-1$
// object is a reference possibly to another document
Import imp = importHandler.findImportForObject(resource, obj);
if (imp != null) {
return importHandler.getQNameForObject(resource, obj);
}
}
}
return s;
}
public String getIDREF(EObject obj) {
// convert the element ID references to a QName
String s = null;
if (ModelUtil.isStringWrapper(obj)) {
s = ModelUtil.getStringWrapperValue(obj);
}
else {
s = super.getIDREF(obj);
if (isQNameFeature) {
// Don't use targetNamespace prefixes for BPMN2 object ID references
// See https://bugzilla.redhat.com/show_bug.cgi?id=1150060
EPackage ePackage = obj.eClass().getEPackage();
if (!Bpmn2Package.class.isInstance(ePackage) &&
!DiPackage.class.isInstance(ePackage) &&
!DcPackage.class.isInstance(ePackage))
s = convertToQName(s);
}
}
return s;
}
/**
* Returns the targetNamespace defined in the <definitions> root element.
*
* @return a namespace URI or null if targetNamespace is not defined.
*/
private String getTargetNamespace() {
Definitions definitions = ModelUtil.getDefinitions(getResource());
if (definitions==null)
return null;
return definitions.getTargetNamespace();
}
/**
* Get the namespace prefix for the targetNamespace.
*
* @return null if the document does not define a targetNamespace,
* an empty string if there is a targetNamespace, but no prefix has been
* defined for it, or the prefix for the targetNamespace
*
* Examples:
*
* <bpmn2:definitions tns="http://eclipse.org/example" targetNamespace="http://eclipse.org/example"/>
* return "tns"
*
* <bpmn2:definitions targetNamespace="http://eclipse.org/example"/>
* returns ""
*
* <bpmn2:definitions tns="http://eclipse.org/example"/>
* returns null
*/
private String getTargetNamespacePrefix() {
String targetNamespace = getTargetNamespace();
if (targetNamespace!=null && !targetNamespace.isEmpty()) {
String prefix = getPrefix(targetNamespace);
if (prefix==null || prefix.isEmpty()) {
for (Entry<String, String> e : this.getPrefixToNamespaceMap().entrySet()) {
if (targetNamespace.equals(e.getValue()) && !e.getKey().isEmpty()) {
return e.getKey();
}
}
}
return ""; //$NON-NLS-1$
}
return null;
}
/**
* Converts the NCName "s" to a QName that maps to the targetNamespace
*
* @param s - a non-colonized name string
* @return the string "s" prefixed with the NS prefix for the targetNamespace.
*/
private String convertToQName(String s) {
if (s!=null && !s.contains(":")) { //$NON-NLS-1$
String prefix = getTargetNamespacePrefix();
if (prefix!=null && !prefix.isEmpty()) {
s = prefix + ":" + s; //$NON-NLS-1$
}
}
return s;
}
public void setValue(EObject object, EStructuralFeature feature, Object value, int position) {
// fix some kind of bug which causes duplicate entries in objects that have
// mutual reference lists.
if ( object!=null
&& feature!=null
&& object.eClass()!=null
&& feature == object.eClass().getEStructuralFeature(feature.getFeatureID())
) {
Object v = object.eGet(feature);
if (v instanceof EObjectWithInverseEList) {
EObjectWithInverseEList list = (EObjectWithInverseEList)v;
if (list.contains(value)) {
// it's already in there!
return;
}
}
}
// // check if we need to change the attribute's data type:
// if (feature instanceof EAttribute) {
// // and only if the attribute's data type is "Object"
// EClassifier t = feature.getEType();
// if (t!=null && t.getInstanceClass() == Object.class) {
// // search for the attribute in the target runtime's Custom Task and
// // Model Extension definitions by name
// List<Property>properties = new ArrayList<Property>();
// TargetRuntime rt = TargetRuntime.getCurrentRuntime();
// String className = object.eClass().getName();
// String featureName = feature.getName();
// for (CustomTaskDescriptor ctd : rt.getCustomTasks()) {
// if (className.equals(ctd.getType())) {
// properties.addAll(ctd.getProperties());
// }
// }
// for (ModelExtensionDescriptor med : rt.getModelExtensions()) {
// if (className.equals(med.getType())) {
// properties.addAll(med.getProperties());
// }
// }
// for (Property p : properties) {
// if (p.name.equals(featureName)) {
// String type = p.type;
// if (type==null)
// type = "EString"; //$NON-NLS-1$
// EClassifier eClassifier = ModelDecorator.findEClassifier(
// rt.getModelDescriptor().getEPackage(),type);
// if (eClassifier instanceof EDataType) {
// feature.setEType(eClassifier);
// }
// break;
// }
// }
// }
// }
super.setValue(object, feature, value, position);
}
@Override
public EStructuralFeature getFeature(EClass eClass, String nsURI, String name, boolean isElement) {
// This fixes https://bugs.eclipse.org/bugs/show_bug.cgi?id=378296
// I'm still not convinced that getFeature() shouldn't simply return the feature
// from the given EClass instead of searching the EPackage of the Resource being
// loaded (if the EClass has a feature with that name of course).
EStructuralFeature feature = null;
EPackage pkg = eClass.getEPackage();
if (pkg != Bpmn2Package.eINSTANCE &&
pkg != BpmnDiPackage.eINSTANCE &&
pkg != DcPackage.eINSTANCE &&
pkg != DiPackage.eINSTANCE &&
pkg != TargetRuntime.getRuntime(resource).getModelDescriptor().getEPackage()) {
feature = eClass.getEStructuralFeature(name);
}
if (feature==null)
feature = super.getFeature(eClass, nsURI, name, isElement);
return feature;
}
}
}