/*******************************************************************************
* 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.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.bpel.common.extension.model.ExtensionMap;
import org.eclipse.bpel.model.Activity;
import org.eclipse.bpel.model.CorrelationSet;
import org.eclipse.bpel.model.PartnerLink;
import org.eclipse.bpel.model.Source;
import org.eclipse.bpel.model.Sources;
import org.eclipse.bpel.model.Target;
import org.eclipse.bpel.model.Targets;
import org.eclipse.bpel.model.Variable;
import org.eclipse.bpel.model.resource.BPELResource;
import org.eclipse.bpel.model.resource.BPELWriter;
import org.eclipse.bpel.model.util.BPELConstants;
import org.eclipse.bpel.ui.adapters.IContainer;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.widgets.Display;
/**
* The transfer buffer is the de-facto clipboard that us being used by the BPEL editor.
*
* Each BPEL editor has its own transfer buffer. The objects in the transfer buffer
* are just clones of the selected EMF objects. A little post processing is done to make
* sure that in the case of a multiple selection only the top most objects of any tree
* are in the selection (so if you select "empty" and a "sequence" in which the "empty"
* resides then only "sequence" is copied to the transfer buffer.
*
* In addition to coping the objects to the transfer buffer a serialized version of the
* them is dumped into the system clipboard as BPEL XML. This allows for cross-editor copy/paste
* that works reasonably well.
*
* It also allows for valid BPEL XML to be pasted into the editor from other (textual) representations.
*
*
* @author IBM, Original contribution.
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
* @date Jun 4, 2007
*
*/
@SuppressWarnings("nls")
public class TransferBuffer {
protected static final boolean DEBUG = false;
static final String NL = System.getProperty("line.separator");
/**
* @author IBM, Original contribution.
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
* @date Jun 4, 2007
*
*/
public class Contents {
Map<EObject, EObject> fExtensionMap;
/** The list of root objects in our transfer buffer */
List<EObject> fRootObjects;
/** The textual content of the clipboard */
String fText;
Contents (Map<EObject, EObject> extensionMap, List<EObject> rootList ) {
fExtensionMap = extensionMap;
fRootObjects = rootList;
}
@SuppressWarnings("nls")
void transferToClipboard () {
// Populate the clipboard with the XML version of this object list.
if (fRootObjects.size() == 1) {
EObject ref = fRootObjects.get(0);
fText = fWriter.toXML ( ref );
} else if (fRootObjects.size() > 1) {
StringBuilder builder = new StringBuilder();
builder.append("<bag>").append("\n\n");
for(EObject obj : fRootObjects) {
builder.append(fWriter.toXML ( obj ));
}
builder.append("\n</bag>");
fText = builder.toString();
}
// System.out.println("BPEL Source: " + fClipboardText);
/** Clipboard clipboard = new Clipboard(display);
* String textData = "Hello World";
* String rtfData = "{\\rtf1\\b\\i Hello World}";
* TextTransfer textTransfer = TextTransfer.getInstance();
* RTFTransfer rtfTransfer = RTFTransfer.getInstance();
* Transfer[] transfers = new Transfer[]{textTransfer, rtfTransfer};
* Object[] data = new Object[]{textData, rtfData};
* clipboard.setContents(data, transfers, DND.CLIPBOARD);
* clipboard.dispose();
*
* Object[] data, Transfer[] dataTypes
*/
fClipboard.setContents(new Object[] { fText } , new Transfer[] { TextTransfer.getInstance() }) ;
}
}
/** The system clipboard */
Clipboard fClipboard = null;
/** The model BPEL Reader that we use to read the content from a clipboard (text paste) */
org.eclipse.bpel.model.resource.BPELReader fReader = null;
/** The model BPEL Writer that we use to serialize the content */
BPELWriter fWriter = null;
/** The current contents of the transfer buffer */
Contents fContents;
/** The target resource */
BPELResource fTargetResource;
/**
* Brand new shiny transfer buffer with clipboard support.
*
* @param display
*/
public TransferBuffer ( Display display ) {
fClipboard = new Clipboard(display);
fWriter = new BPELWriter() {
@Override
public BPELResource getResource() {
return fTargetResource;
}
};
fReader = new org.eclipse.bpel.model.resource.BPELReader () {
@Override
public Resource getResource() {
return fTargetResource;
}
};
}
/**
* Return the contents of the transfer buffer.
*
* @return contents of the transfer buffer.
*/
public Contents getContents() {
return fContents;
}
/**
* Set the contents of this transfer buffer.
*
* This happens from the BPEL editor side, that is, when the Copy command is issued.
*
* @param aContents contents of this transfer buffer.
*/
@SuppressWarnings("nls")
void setContents (Contents aContents) {
fContents = aContents;
}
String getClipboardText () {
return (String) fClipboard.getContents( TextTransfer.getInstance() );
}
/**
* Get the list of outermost objects from the list of objects passed.
* If a sequence and an activity in the sequence are present in aList, then only
* the sequence is returned.
*
* @param aList
* @return the list of outermost objects.
*/
List<EObject> getOutermostObjects(List<EObject> aList) {
ArrayList<EObject> trimmedList = new ArrayList<EObject>(aList.size());
for (EObject next : aList) {
boolean skipNext = false;
for (EObject parent : aList) {
if (next != parent
&& ModelHelper.isChildContainedBy(parent, next)) {
skipNext = true;
break;
}
}
if (skipNext) {
continue;
}
trimmedList.add(next);
}
return trimmedList;
}
/**
* Copy the passed source objects to the transfer buffer.
*
*
* @param sourceObjects
* @param sourceMap
*/
public void copyObjectsToTransferBuffer (List<EObject> sourceObjects, ExtensionMap sourceMap) {
if (DEBUG) {
System.out
.println("copyObjectsToTransferBuffer(" + sourceObjects.size() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
}
Map<EObject, EObject> targetMap = new HashMap<EObject, EObject>();
List<EObject> sourceList = getOutermostObjects (sourceObjects);
List<EObject> targetList = new ArrayList<EObject>();
// TODO: are there issues here with processing subtrees one-by-one?
// E.g. references
// to an object which is copied in a different subtree? (Probably not,
// for our model)
for (EObject source : sourceList) {
EObject target = BPELUtil
.cloneSubtree(source, sourceMap, targetMap).targetRoot;
targetList.add(target);
}
// Remove links which are referenced by root activities and were not
// copied! Otherwise, when the root activities are pasted the stale
// references from
// roots to these links will be pasted too.
for ( EObject next : targetList ) {
if (next instanceof Activity == false) {
continue;
}
Activity activity = (Activity) next;
Sources sources = activity.getSources();
if (sources != null) {
for(Source source : sources.getChildren() ) {
if (!targetMap.containsValue(source.getLink())) {
source.setLink(null);
sources.getChildren().remove(source);
}
}
if (sources.getChildren().isEmpty()) {
activity.setSources(null);
}
}
Targets targets = activity.getTargets();
if (targets != null) {
for (Target target : targets.getChildren() ) {
if (!targetMap.containsValue(target.getLink())) {
target.setLink(null);
targets.getChildren().remove(target);
}
}
if (targets.getChildren().isEmpty()) {
activity.setTargets(null);
}
}
}
/**
* This has to have a better way of being computed.
* The transfer buffer belongs to the editor and an editor edits one resource. So this should be an invariant
* over the lifetime of the transfer buffer.
*
*/
if (fTargetResource == null) {
fTargetResource = (BPELResource) ModelHelper.getBPELEditor( sourceList.get(0) ).getResource();
}
Contents contents = new Contents( targetMap,targetList );
contents.transferToClipboard();
setContents( contents );
}
/**
* Copy the transfer buffer to the targetObject.
*
* @param targetObject
* the target object to act as an anchor point.
*
* @param targetMap
* @param bReference treat target as reference.
*
* @return the list of new objects added.
*/
@SuppressWarnings("nls")
public List<EObject> copyTransferBuffer (EObject targetObject,
ExtensionMap targetMap, boolean bReference ) {
String xml = getClipboardText();
// First check if we need to copy from clipboard.
if (fContents == null || xml.equals(fContents.fText) == false ) {
if (couldBeXML(xml) == false) {
setContents( null );
} else {
if (fTargetResource == null) {
// This has to have a better way of being computed.
fTargetResource = (BPELResource) ModelHelper.getBPELEditor( targetObject ).getResource();
}
List<EObject> result = fReader.fromXML( adjustXMLSource(xml) , "Clipboard", fTargetResource );
if (result.size() > 0) {
setContents( new Contents(null,result) );
} else {
setContents( null );
}
}
}
Anchors anchors = getAnchors (targetObject,bReference,fContents);
return copyContentsTo (fContents, anchors, targetMap);
}
List<EObject> copyContentsTo ( Contents contents, Anchors anchors, ExtensionMap targetMap ) {
ArrayList<EObject> newObjects = new ArrayList<EObject>();
if (contents == null) {
return newObjects;
}
for (EObject source : contents.fRootObjects) {
BPELUtil.CloneResult cloneResult = BPELUtil.cloneSubtree(source,contents.fExtensionMap, targetMap);
anchors.fContainer.addChild(anchors.fTarget, cloneResult.targetRoot, anchors.fRefObject );
// Resolve name of the source activity to be unique
if (source instanceof Activity) {
Activity node = (Activity) cloneResult.targetRoot;
String uniqueName = BPELUtil.generateUniqueModelName ( anchors.fTarget, node.getName(), node );
node.setName(BPELUtil.upperCaseFirstLetter (uniqueName) );
} else if (source instanceof Variable) {
Variable node = (Variable) cloneResult.targetRoot;
String uniqueName = BPELUtil.generateUniqueModelName ( anchors.fTarget, node.getName(), node );
node.setName(uniqueName);
} else if (source instanceof PartnerLink) {
PartnerLink node = (PartnerLink) cloneResult.targetRoot;
String uniqueName = BPELUtil.generateUniqueModelName ( anchors.fTarget, node.getName(), node );
node.setName(uniqueName);
} else if (source instanceof CorrelationSet ) {
CorrelationSet node = (CorrelationSet) cloneResult.targetRoot;
String uniqueName = BPELUtil.generateUniqueModelName (anchors.fTarget, node.getName(), node );
node.setName(uniqueName);
}
newObjects.add(cloneResult.targetRoot);
}
return newObjects;
}
class Anchors {
EObject fTarget;
EObject fRefObject;
IContainer<EObject> fContainer;
}
/**
* Anchors just represent the anchor points for the paste operation.
*
* There are several possibilities to consider.
*
* <ol>
* <li> The
*/
Anchors getAnchors ( EObject targetObject, boolean bReference, Contents contents ) {
Anchors anchors = new Anchors();
anchors.fTarget = targetObject;
anchors.fContainer = BPELUtil.adapt(anchors.fTarget, IContainer.class);
/**
* If we are not a container, then we presume that a container is our parent
* (such an an activity and its container being say a sequence).
*
* Also, if bReference is forced, then were a reference object (the insertion point)
* and so we must go to our container.
*/
if (anchors.fContainer == null || bReference ) {
// check its container
anchors.fRefObject = targetObject;
anchors.fTarget = targetObject.eContainer();
anchors.fContainer = BPELUtil.adapt(anchors.fTarget, IContainer.class);
} else {
/** Otherwise we are container.
*
* But can we take the contents that is given to us ?
*/
if (canCopyContents(anchors, contents) == true) {
return anchors;
}
/** Otherwise we assume that we are referenced container*/
anchors.fRefObject = targetObject;
anchors.fTarget = targetObject.eContainer();
anchors.fContainer = BPELUtil.adapt(anchors.fTarget, IContainer.class);
}
return anchors;
}
boolean canCopyContents ( Anchors anchors, Contents content ) {
if (content == null) {
return false;
}
// check each root object's type against the container..
for (EObject next : content.fRootObjects ) {
if (anchors.fContainer.canAddObject(anchors.fTarget, next, anchors.fRefObject) ) {
return true;
}
}
return false;
}
/**
*
*
* @param targetObject
* the target reference object around which the copy-from-buffer
* should be made.
* @param bReference - treat the target as a reference, even if it is a container.
* @return true of copy of transfer buffer can be made, false otherwise.
*/
@SuppressWarnings("nls")
public boolean canCopyTransferBufferTo (EObject targetObject, boolean bReference ) {
if (targetObject == null ) {
return false;
}
Anchors anchors = getAnchors (targetObject,bReference, fContents );
if (anchors.fContainer == null) {
return false;
}
return canCopyContents ( anchors, fContents ) || couldBeXML(getClipboardText()) ;
}
/**
* This is a completely heuristic test to see if we have something in XML in the clipboard
* that "could" be converted into objects in our little world.
*
*
*
* @param xml
* @return
*/
boolean couldBeXML (String xml) {
if (xml == null || xml.length() < 4) {
return false;
}
// Short valid XML element would be .... ?
// <f/>
int nOpen = 0;
int nClose = 0;
int nNonWhitespace = 0;
int nWhitespace = 0;
/** open and close should match, we count them, and then make sure we have about 0.95 ratio */
for (char ch : xml.toCharArray() ) {
if (Character.isWhitespace(ch)) {
nWhitespace += 1;
} else if (ch == '<') {
// leading non-whitespace
if (nOpen == 0 && nNonWhitespace > 0) {
return false;
}
nOpen += 1;
} else if (ch == '>') {
nClose += 1;
} else {
nNonWhitespace += 1;
}
}
if (nOpen == 0 || nClose == 0) {
return false;
}
float ratio = (float) (Math.min(nOpen, nClose) * 1.0 / 1.0 * Math.max(nOpen,nClose));
if (ratio < 0.95) {
return false;
}
return true;
}
/** Any namespace declaration, either xmlns="" or pfx:xmlns="xx" */
static Pattern anyNamespace = Pattern.compile("(\\:|\\s)xmlns=(\\\"|\\')", Pattern.MULTILINE );
/** BPEL 2004 namespace, as default (no prefix mapping) */
static Pattern bpel2004DefaultNS = Pattern.compile("\\sxmlns=(\"|\')" + Pattern.quote(BPELConstants.NAMESPACE_2004) + "(\"|\')",
Pattern.MULTILINE);
/** BPEL 2003 namespace, as default (no prefix mapping) */
static Pattern bpel2003DefaultNS = Pattern.compile("\\sxmlns=(\"|\')" + Pattern.quote(BPELConstants.NAMESPACE_2003) + "(\"|\')",
Pattern.MULTILINE);
static String EMPTY_STRING = "";
/**
* Adjust XML source so that we can parse it as BPEL 2.0
*
* @param buffer the current XML source.
* @return the adjust source.
*/
static public String adjustXMLSource ( String buffer ) {
/** Check if no Namespaces at all. Then there are no prefixes that are namespace bound */
Matcher matcher = anyNamespace.matcher(buffer);
if (matcher.find() == false) {
StringBuilder sb = new StringBuilder(buffer.length() + 128);
sb.append("<bag xmlns=\"").append( BPELConstants.NAMESPACE ).append("\">").append(NL);
sb.append(buffer);
sb.append(NL).append("</bag>");
return sb.toString();
}
/** Check if there is a BPELNamespace source mapping in the buffer. */
/** Check pre-2.0 namespaces as well and replace them by the 2.0 BPEL namespace */
matcher = bpel2004DefaultNS.matcher(buffer);
if ( matcher.find() ) {
return adjustXMLSource(matcher.replaceAll( EMPTY_STRING )) ;
}
matcher = bpel2003DefaultNS.matcher(buffer);
if ( matcher.find() ) {
return adjustXMLSource ( matcher.replaceAll( EMPTY_STRING ) );
}
/** Return buffer as is */
return buffer;
}
/**
*
*/
public void dispose() {
setContents(null);
if (fClipboard != null) {
fClipboard.dispose();
fClipboard = null;
}
}
}