plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/util/TransferBuffer.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * 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;
 		}
 	}


 }
	/*******************************************************************************
	* 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;
	}
	}


	}