plugins/org.eclipse.bpel.model/src/org/eclipse/bpel/model/util/ElementPlacer.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 Intel Corporation.
  * 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:
  *    Dennis Ushakov, Intel - Initial API and Implementation
  *    Oleg Danilov, Intel
  *
  *******************************************************************************/

 package org.eclipse.bpel.model.util;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;

 import org.eclipse.bpel.model.ExtensionActivity;
 import org.eclipse.wst.wsdl.WSDLElement;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.Text;

 public class ElementPlacer {
 	private static HashMap<String, List<String>> mapper = new HashMap<String, List<String>>();
 	private static final String ACTIVITY = "activity";

 	static {
 		// TODO: (DU) add other activities
 		// Process
 		String processElements[] = { BPELConstants.ND_EXTENSIONS,
 				BPELConstants.ND_IMPORT, BPELConstants.ND_PARTNER_LINKS,
 				BPELConstants.ND_MESSAGE_EXCHANGES, BPELConstants.ND_VARIABLES,
 				BPELConstants.ND_CORRELATION_SETS,
 				BPELConstants.ND_FAULT_HANDLERS,
 				BPELConstants.ND_EVENT_HANDLERS, ACTIVITY };
 		mapper.put(BPELConstants.ND_PROCESS, Arrays.asList(processElements));
 		// FaultHandlers
 		String faultHandlersElements[] = { BPELConstants.ND_CATCH,
 				BPELConstants.ND_CATCH_ALL };
 		mapper.put(BPELConstants.ND_FAULT_HANDLERS, Arrays
 				.asList(faultHandlersElements));
 		// EventHandlers
 		String eventHandlersElements[] = { BPELConstants.ND_ON_EVENT,
 				BPELConstants.ND_ON_ALARM };
 		mapper.put(BPELConstants.ND_EVENT_HANDLERS, Arrays
 				.asList(eventHandlersElements));
 		// Invoke
 		String invokeElements[] = { BPELConstants.ND_CORRELATIONS,
 				BPELConstants.ND_CATCH, BPELConstants.ND_CATCH_ALL,
 				BPELConstants.ND_COMPENSATION_HANDLER,
 				BPELConstants.ND_TO_PARTS, BPELConstants.ND_FROM_PARTS };
 		mapper.put(BPELConstants.ND_INVOKE, Arrays.asList(invokeElements));
 		// While
 		String whileElements[] = { BPELConstants.ND_CONDITION, ACTIVITY };
 		mapper.put(BPELConstants.ND_WHILE, Arrays.asList(whileElements));
 		// ForEach
 		String forEachElements[] = { BPELConstants.ND_START_COUNTER_VALUE,
 				BPELConstants.ND_FINAL_COUNTER_VALUE,
 				BPELConstants.ND_COMPLETION_CONDITION, ACTIVITY };
 		mapper.put(BPELConstants.ND_FOR_EACH, Arrays.asList(forEachElements));
 		// RepeatUntil
 		String repeatElements[] = { ACTIVITY, BPELConstants.ND_CONDITION };
 		mapper
 				.put(BPELConstants.ND_REPEAT_UNTIL, Arrays
 						.asList(repeatElements));
 		// If
 		String ifElements[] = { BPELConstants.ND_CONDITION, ACTIVITY,
 				BPELConstants.ND_ELSEIF, BPELConstants.ND_ELSE };
 		mapper.put(BPELConstants.ND_IF, Arrays.asList(ifElements));
 		// ElseIf
 		String elseIfElements[] = { BPELConstants.ND_CONDITION, ACTIVITY };
 		mapper.put(BPELConstants.ND_ELSEIF, Arrays.asList(elseIfElements));
 	}

 	public static void placeChild(WSDLElement parent, Node child) {
 		Element parentElement = parent.getElement();

 		if (parent instanceof ExtensionActivity){
 			parentElement = ReconciliationHelper.getExtensionActivityChildElement(parentElement);
 		}

 		List<String> nodeTypeList = mapper.get(parentElement.getLocalName());
 		if (nodeTypeList != null) {
 			String nodeName = child.getLocalName();
 			String nodeType = findType(nodeName, nodeTypeList);
 			if (nodeType != null) {
 				Node beforeElement = parentElement.getFirstChild();
 				while (beforeElement != null
 						&& (!isPreviousType(nodeType, findType(beforeElement
 								.getLocalName(), nodeTypeList), nodeTypeList) || beforeElement
 								.getNodeType() != Node.ELEMENT_NODE)) {
 					beforeElement = beforeElement.getNextSibling();
 				}
 				while (beforeElement != null
 						&& (isType(beforeElement.getLocalName(), nodeType) || beforeElement
 								.getNodeType() != Node.ELEMENT_NODE)) {
 					beforeElement = beforeElement.getNextSibling();
 				}
 				ElementPlacer.niceInsertBefore(parent, child, beforeElement);
 				return;
 			}
 		}
 		ElementPlacer.niceAppend(parent, child);
 	}

 	private static String findType(String nodeName, List<String> nodeTypeList) {
 		for (String nodeType : nodeTypeList) {
 			if (isType(nodeName, nodeType)) {
 				return nodeType;
 			}
 		}
 		return null;
 	}

 	private static boolean isPreviousType(String typeName1, String typeName2,
 			List<String> nodeTypeList) {
 		int type1Index = nodeTypeList.indexOf(typeName1);
 		int type2Index = nodeTypeList.indexOf(typeName2);
 		return type1Index < type2Index || (type2Index < 0 && type1Index >= 0);
 	}

 	private static boolean isType(String nodeName, String typeName) {
 		return ACTIVITY.equals(typeName) ? isActivity(nodeName) : typeName
 				.equals(nodeName);
 	}

 	private static boolean isActivity(String nodeName) {
 		return BPELConstants.ND_ASSIGN.equals(nodeName)
 				|| BPELConstants.ND_COMPENSATE.equals(nodeName)
 				|| BPELConstants.ND_COMPENSATE_SCOPE.equals(nodeName)
 				|| BPELConstants.ND_EMPTY.equals(nodeName)
 				|| BPELConstants.ND_EXIT.equals(nodeName)
 				|| BPELConstants.ND_EXTENSION_ACTIVITY.equals(nodeName)
 				|| BPELConstants.ND_FLOW.equals(nodeName)
 				|| BPELConstants.ND_FOR_EACH.equals(nodeName)
 				|| BPELConstants.ND_IF.equals(nodeName)
 				|| BPELConstants.ND_INVOKE.equals(nodeName)
 				|| BPELConstants.ND_PICK.equals(nodeName)
 				|| BPELConstants.ND_RECEIVE.equals(nodeName)
 				|| BPELConstants.ND_REPEAT_UNTIL.equals(nodeName)
 				|| BPELConstants.ND_REPLY.equals(nodeName)
 				|| BPELConstants.ND_RETHROW.equals(nodeName)
 				|| BPELConstants.ND_SCOPE.equals(nodeName)
 				|| BPELConstants.ND_SEQUENCE.equals(nodeName)
 				|| BPELConstants.ND_THROW.equals(nodeName)
 				|| BPELConstants.ND_VALIDATE.equals(nodeName)
 				|| BPELConstants.ND_WAIT.equals(nodeName)
 				|| BPELConstants.ND_WHILE.equals(nodeName)
 				|| BPELConstants.ND_OPAQUEACTIVITY.equals(nodeName);
 	}

 	public static void niceInsertBefore(WSDLElement parent, Node newChild,
 			Node referenceChild) {
 		boolean was = ReconciliationHelper.isUpdatingDom(parent);
 		Element parentElement = parent.getElement();

 		if (parent instanceof ExtensionActivity){
 			parentElement = ReconciliationHelper.getExtensionActivityChildElement(parentElement);
 		}

 		ReconciliationHelper.setUpdatingDom(parent, true);
 		Node child = (referenceChild == null) ? parentElement.getLastChild()
 				: referenceChild.getPreviousSibling();

 		// DO: parentElement has no children ( <tag /> )
 		if (child == null) {
 			StringBuffer indent = new StringBuffer();
 			for (Node ancestor = parentElement.getParentNode(); ancestor != null
 					&& ancestor.getNodeType() != Node.DOCUMENT_NODE; ancestor = ancestor
 					.getParentNode()) {
 				indent.append("    ");
 			}
 			Text text = parentElement.getOwnerDocument().createTextNode(
 					"\n" + indent + "    ");
 			parentElement.insertBefore(text, referenceChild);
 			text = parentElement.getOwnerDocument().createTextNode(
 					"\n" + indent);
 			referenceChild = parentElement.insertBefore(text, referenceChild);
 			parentElement.insertBefore(newChild, referenceChild);
 			return;
 		}

 		while (child != null) {
 			short nodeType = child.getNodeType();
 			if (nodeType == Node.ELEMENT_NODE)
 				break;
 			if (nodeType != Node.TEXT_NODE) {
 				child = child.getPreviousSibling();
 				continue;
 			}

 			Text text = (Text) child;
 			String data = text.getData();
 			int index = data.lastIndexOf('\n');
 			if (index == -1) {
 				child = child.getPreviousSibling();
 				continue;
 			}

 			StringBuffer indent = new StringBuffer();
 			for (Node ancestor = parentElement.getParentNode(); ancestor != null
 					&& ancestor.getNodeType() != Node.DOCUMENT_NODE; ancestor = ancestor
 					.getParentNode()) {
 				indent.append("    ");
 			}
 			if (index + 1 < data.length() && data.charAt(index + 1) == '\r') {
 				index++;
 			}
 			text.replaceData(index + 1, data.length() - index - 1, indent
 					+ "    ");

 			// DO:
 			// Format children of the newChild.
 			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458
 			// traverse the child's descendants also, inserting the
 			// proper indentation for each
 			StringBuffer childIndent = new StringBuffer(indent);
 			Node nextNewChild = newChild;
 			Node innerChild = newChild.getFirstChild();
 			while (innerChild != null) {
 				// add "\n" + indent before every child
 				Node nextInnerChild = innerChild;
 				while (nextInnerChild != null) {
 					boolean textNodeIsWhitespaceOnly = false;
 					if (nextInnerChild instanceof Text) {
 						String content = ((Text)nextInnerChild).getData();
 						textNodeIsWhitespaceOnly = (content==null || content.trim().isEmpty());
 					}
 					if (textNodeIsWhitespaceOnly) {
 						// remove an old indentation
 						nextNewChild.removeChild(nextInnerChild);
 					} else {
 						nextNewChild.insertBefore(nextNewChild.getOwnerDocument()
 								.createTextNode("\n" + childIndent + "        "),
 								nextInnerChild);
 					}
 					nextInnerChild = nextInnerChild.getNextSibling();
 				}
 				// add "\n" after the last child
 				nextNewChild.appendChild(nextNewChild.getOwnerDocument()
 						.createTextNode("\n" + childIndent + "    "));
 				childIndent.append("    ");
 				nextNewChild = innerChild;
 				innerChild = innerChild.getFirstChild();
 			}

 			if (referenceChild != null) {
 				indent.append("    ");
 			}
 			text = parentElement.getOwnerDocument().createTextNode(
 					"\n" + indent);
 			parentElement.insertBefore(text, referenceChild);
 			referenceChild = text;
 			break;
 		}

 		parentElement.insertBefore(newChild, referenceChild);
 		ReconciliationHelper.setUpdatingDom(parent, was);
 	}

 	public static void niceAppend(WSDLElement parent, Node child) {
 		niceInsertBefore(parent, child, null);
 	}

 	public static void niceRemoveChild(WSDLElement parent, Node child) {
 		boolean was = ReconciliationHelper.isUpdatingDom(parent);
 		ReconciliationHelper.setUpdatingDom(parent, true);


 		Element parseElement = parent.getElement();

 		if (parent instanceof ExtensionActivity) {
 			parseElement = ReconciliationHelper.getExtensionActivityChildElement(parseElement);
 		}

 		boolean done = false;

 		Node previous = child.getPreviousSibling();
 		if (previous != null && previous.getNodeType() == Node.TEXT_NODE) {
 			Text text = (Text) previous;
 			String data = text.getData();
 			int index = data.lastIndexOf('\n');
 			if (index != -1) {
 				if (index - 1 > 0 && data.charAt(index - 1) == '\r') {
 					text.deleteData(index - 1, data.length() - index + 1);
 				} else {
 					text.deleteData(index, data.length() - index);
 				}
 				done = true;
 			}
 		}

 		if (!done) {
 			for (Node next = child.getNextSibling(); next != null; next = next
 					.getNextSibling()) {
 				if (next.getNodeType() == Node.TEXT_NODE) {
 					Text text = (Text) next;
 					String data = text.getData();
 					int index = data.indexOf('\n');
 					if (index != -1) {
 						if (index + 1 < data.length()
 								&& data.charAt(index + 1) == '\r') {
 							text.deleteData(0, index + 2);
 						} else {
 							text.deleteData(0, index + 1);
 						}
 						break;
 					}
 					continue;
 				}

 				if (next.getNodeType() == Node.ELEMENT_NODE) {
 					break;
 				}
 			}
 		}

 		parseElement.removeChild(child);
 		ReconciliationHelper.setUpdatingDom(parent, was);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007 Intel Corporation.
	* 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:
	* Dennis Ushakov, Intel - Initial API and Implementation
	* Oleg Danilov, Intel
	*
	*******************************************************************************/

	package org.eclipse.bpel.model.util;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.List;

	import org.eclipse.bpel.model.ExtensionActivity;
	import org.eclipse.wst.wsdl.WSDLElement;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.Text;

	public class ElementPlacer {
	private static HashMap<String, List<String>> mapper = new HashMap<String, List<String>>();
	private static final String ACTIVITY = "activity";

	static {
	// TODO: (DU) add other activities
	// Process
	String processElements[] = { BPELConstants.ND_EXTENSIONS,
	BPELConstants.ND_IMPORT, BPELConstants.ND_PARTNER_LINKS,
	BPELConstants.ND_MESSAGE_EXCHANGES, BPELConstants.ND_VARIABLES,
	BPELConstants.ND_CORRELATION_SETS,
	BPELConstants.ND_FAULT_HANDLERS,
	BPELConstants.ND_EVENT_HANDLERS, ACTIVITY };
	mapper.put(BPELConstants.ND_PROCESS, Arrays.asList(processElements));
	// FaultHandlers
	String faultHandlersElements[] = { BPELConstants.ND_CATCH,
	BPELConstants.ND_CATCH_ALL };
	mapper.put(BPELConstants.ND_FAULT_HANDLERS, Arrays
	.asList(faultHandlersElements));
	// EventHandlers
	String eventHandlersElements[] = { BPELConstants.ND_ON_EVENT,
	BPELConstants.ND_ON_ALARM };
	mapper.put(BPELConstants.ND_EVENT_HANDLERS, Arrays
	.asList(eventHandlersElements));
	// Invoke
	String invokeElements[] = { BPELConstants.ND_CORRELATIONS,
	BPELConstants.ND_CATCH, BPELConstants.ND_CATCH_ALL,
	BPELConstants.ND_COMPENSATION_HANDLER,
	BPELConstants.ND_TO_PARTS, BPELConstants.ND_FROM_PARTS };
	mapper.put(BPELConstants.ND_INVOKE, Arrays.asList(invokeElements));
	// While
	String whileElements[] = { BPELConstants.ND_CONDITION, ACTIVITY };
	mapper.put(BPELConstants.ND_WHILE, Arrays.asList(whileElements));
	// ForEach
	String forEachElements[] = { BPELConstants.ND_START_COUNTER_VALUE,
	BPELConstants.ND_FINAL_COUNTER_VALUE,
	BPELConstants.ND_COMPLETION_CONDITION, ACTIVITY };
	mapper.put(BPELConstants.ND_FOR_EACH, Arrays.asList(forEachElements));
	// RepeatUntil
	String repeatElements[] = { ACTIVITY, BPELConstants.ND_CONDITION };
	mapper
	.put(BPELConstants.ND_REPEAT_UNTIL, Arrays
	.asList(repeatElements));
	// If
	String ifElements[] = { BPELConstants.ND_CONDITION, ACTIVITY,
	BPELConstants.ND_ELSEIF, BPELConstants.ND_ELSE };
	mapper.put(BPELConstants.ND_IF, Arrays.asList(ifElements));
	// ElseIf
	String elseIfElements[] = { BPELConstants.ND_CONDITION, ACTIVITY };
	mapper.put(BPELConstants.ND_ELSEIF, Arrays.asList(elseIfElements));
	}

	public static void placeChild(WSDLElement parent, Node child) {
	Element parentElement = parent.getElement();

	if (parent instanceof ExtensionActivity){
	parentElement = ReconciliationHelper.getExtensionActivityChildElement(parentElement);
	}

	List<String> nodeTypeList = mapper.get(parentElement.getLocalName());
	if (nodeTypeList != null) {
	String nodeName = child.getLocalName();
	String nodeType = findType(nodeName, nodeTypeList);
	if (nodeType != null) {
	Node beforeElement = parentElement.getFirstChild();
	while (beforeElement != null
	&& (!isPreviousType(nodeType, findType(beforeElement
	.getLocalName(), nodeTypeList), nodeTypeList) \|\| beforeElement
	.getNodeType() != Node.ELEMENT_NODE)) {
	beforeElement = beforeElement.getNextSibling();
	}
	while (beforeElement != null
	&& (isType(beforeElement.getLocalName(), nodeType) \|\| beforeElement
	.getNodeType() != Node.ELEMENT_NODE)) {
	beforeElement = beforeElement.getNextSibling();
	}
	ElementPlacer.niceInsertBefore(parent, child, beforeElement);
	return;
	}
	}
	ElementPlacer.niceAppend(parent, child);
	}

	private static String findType(String nodeName, List<String> nodeTypeList) {
	for (String nodeType : nodeTypeList) {
	if (isType(nodeName, nodeType)) {
	return nodeType;
	}
	}
	return null;
	}

	private static boolean isPreviousType(String typeName1, String typeName2,
	List<String> nodeTypeList) {
	int type1Index = nodeTypeList.indexOf(typeName1);
	int type2Index = nodeTypeList.indexOf(typeName2);
	return type1Index < type2Index \|\| (type2Index < 0 && type1Index >= 0);
	}

	private static boolean isType(String nodeName, String typeName) {
	return ACTIVITY.equals(typeName) ? isActivity(nodeName) : typeName
	.equals(nodeName);
	}

	private static boolean isActivity(String nodeName) {
	return BPELConstants.ND_ASSIGN.equals(nodeName)
	\|\| BPELConstants.ND_COMPENSATE.equals(nodeName)
	\|\| BPELConstants.ND_COMPENSATE_SCOPE.equals(nodeName)
	\|\| BPELConstants.ND_EMPTY.equals(nodeName)
	\|\| BPELConstants.ND_EXIT.equals(nodeName)
	\|\| BPELConstants.ND_EXTENSION_ACTIVITY.equals(nodeName)
	\|\| BPELConstants.ND_FLOW.equals(nodeName)
	\|\| BPELConstants.ND_FOR_EACH.equals(nodeName)
	\|\| BPELConstants.ND_IF.equals(nodeName)
	\|\| BPELConstants.ND_INVOKE.equals(nodeName)
	\|\| BPELConstants.ND_PICK.equals(nodeName)
	\|\| BPELConstants.ND_RECEIVE.equals(nodeName)
	\|\| BPELConstants.ND_REPEAT_UNTIL.equals(nodeName)
	\|\| BPELConstants.ND_REPLY.equals(nodeName)
	\|\| BPELConstants.ND_RETHROW.equals(nodeName)
	\|\| BPELConstants.ND_SCOPE.equals(nodeName)
	\|\| BPELConstants.ND_SEQUENCE.equals(nodeName)
	\|\| BPELConstants.ND_THROW.equals(nodeName)
	\|\| BPELConstants.ND_VALIDATE.equals(nodeName)
	\|\| BPELConstants.ND_WAIT.equals(nodeName)
	\|\| BPELConstants.ND_WHILE.equals(nodeName)
	\|\| BPELConstants.ND_OPAQUEACTIVITY.equals(nodeName);
	}

	public static void niceInsertBefore(WSDLElement parent, Node newChild,
	Node referenceChild) {
	boolean was = ReconciliationHelper.isUpdatingDom(parent);
	Element parentElement = parent.getElement();

	if (parent instanceof ExtensionActivity){
	parentElement = ReconciliationHelper.getExtensionActivityChildElement(parentElement);
	}

	ReconciliationHelper.setUpdatingDom(parent, true);
	Node child = (referenceChild == null) ? parentElement.getLastChild()
	: referenceChild.getPreviousSibling();

	// DO: parentElement has no children ( <tag /> )
	if (child == null) {
	StringBuffer indent = new StringBuffer();
	for (Node ancestor = parentElement.getParentNode(); ancestor != null
	&& ancestor.getNodeType() != Node.DOCUMENT_NODE; ancestor = ancestor
	.getParentNode()) {
	indent.append(" ");
	}
	Text text = parentElement.getOwnerDocument().createTextNode(
	"\n" + indent + " ");
	parentElement.insertBefore(text, referenceChild);
	text = parentElement.getOwnerDocument().createTextNode(
	"\n" + indent);
	referenceChild = parentElement.insertBefore(text, referenceChild);
	parentElement.insertBefore(newChild, referenceChild);
	return;
	}

	while (child != null) {
	short nodeType = child.getNodeType();
	if (nodeType == Node.ELEMENT_NODE)
	break;
	if (nodeType != Node.TEXT_NODE) {
	child = child.getPreviousSibling();
	continue;
	}

	Text text = (Text) child;
	String data = text.getData();
	int index = data.lastIndexOf('\n');
	if (index == -1) {
	child = child.getPreviousSibling();
	continue;
	}

	StringBuffer indent = new StringBuffer();
	for (Node ancestor = parentElement.getParentNode(); ancestor != null
	&& ancestor.getNodeType() != Node.DOCUMENT_NODE; ancestor = ancestor
	.getParentNode()) {
	indent.append(" ");
	}
	if (index + 1 < data.length() && data.charAt(index + 1) == '\r') {
	index++;
	}
	text.replaceData(index + 1, data.length() - index - 1, indent
	+ " ");

	// DO:
	// Format children of the newChild.
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458
	// traverse the child's descendants also, inserting the
	// proper indentation for each
	StringBuffer childIndent = new StringBuffer(indent);
	Node nextNewChild = newChild;
	Node innerChild = newChild.getFirstChild();
	while (innerChild != null) {
	// add "\n" + indent before every child
	Node nextInnerChild = innerChild;
	while (nextInnerChild != null) {
	boolean textNodeIsWhitespaceOnly = false;
	if (nextInnerChild instanceof Text) {
	String content = ((Text)nextInnerChild).getData();
	textNodeIsWhitespaceOnly = (content==null \|\| content.trim().isEmpty());
	}
	if (textNodeIsWhitespaceOnly) {
	// remove an old indentation
	nextNewChild.removeChild(nextInnerChild);
	} else {
	nextNewChild.insertBefore(nextNewChild.getOwnerDocument()
	.createTextNode("\n" + childIndent + " "),
	nextInnerChild);
	}
	nextInnerChild = nextInnerChild.getNextSibling();
	}
	// add "\n" after the last child
	nextNewChild.appendChild(nextNewChild.getOwnerDocument()
	.createTextNode("\n" + childIndent + " "));
	childIndent.append(" ");
	nextNewChild = innerChild;
	innerChild = innerChild.getFirstChild();
	}

	if (referenceChild != null) {
	indent.append(" ");
	}
	text = parentElement.getOwnerDocument().createTextNode(
	"\n" + indent);
	parentElement.insertBefore(text, referenceChild);
	referenceChild = text;
	break;
	}

	parentElement.insertBefore(newChild, referenceChild);
	ReconciliationHelper.setUpdatingDom(parent, was);
	}

	public static void niceAppend(WSDLElement parent, Node child) {
	niceInsertBefore(parent, child, null);
	}

	public static void niceRemoveChild(WSDLElement parent, Node child) {
	boolean was = ReconciliationHelper.isUpdatingDom(parent);
	ReconciliationHelper.setUpdatingDom(parent, true);


	Element parseElement = parent.getElement();

	if (parent instanceof ExtensionActivity) {
	parseElement = ReconciliationHelper.getExtensionActivityChildElement(parseElement);
	}

	boolean done = false;

	Node previous = child.getPreviousSibling();
	if (previous != null && previous.getNodeType() == Node.TEXT_NODE) {
	Text text = (Text) previous;
	String data = text.getData();
	int index = data.lastIndexOf('\n');
	if (index != -1) {
	if (index - 1 > 0 && data.charAt(index - 1) == '\r') {
	text.deleteData(index - 1, data.length() - index + 1);
	} else {
	text.deleteData(index, data.length() - index);
	}
	done = true;
	}
	}

	if (!done) {
	for (Node next = child.getNextSibling(); next != null; next = next
	.getNextSibling()) {
	if (next.getNodeType() == Node.TEXT_NODE) {
	Text text = (Text) next;
	String data = text.getData();
	int index = data.indexOf('\n');
	if (index != -1) {
	if (index + 1 < data.length()
	&& data.charAt(index + 1) == '\r') {
	text.deleteData(0, index + 2);
	} else {
	text.deleteData(0, index + 1);
	}
	break;
	}
	continue;
	}

	if (next.getNodeType() == Node.ELEMENT_NODE) {
	break;
	}
	}
	}

	parseElement.removeChild(child);
	ReconciliationHelper.setUpdatingDom(parent, was);
	}
	}