jsf/plugins/org.eclipse.jst.pagedesigner/src/org/eclipse/jst/pagedesigner/commands/range/DesignEdit.java - jsf/webtools.jsf - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 Sybase, Inc. 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:
  *     Sybase, Inc. - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.pagedesigner.commands.range;

 import java.util.Stack;
 import java.util.Vector;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.gef.GraphicalViewer;
 import org.eclipse.gef.dnd.TemplateTransfer;
 import org.eclipse.jst.pagedesigner.IHTMLConstants;
 import org.eclipse.jst.pagedesigner.css2.CSSUtil;
 import org.eclipse.jst.pagedesigner.css2.ICSSStyle;
 import org.eclipse.jst.pagedesigner.dom.DOMRange;
 import org.eclipse.jst.pagedesigner.dom.EditHelper;
 import org.eclipse.jst.pagedesigner.dom.EditModelQuery;
 import org.eclipse.jst.pagedesigner.dom.EditValidateUtil;
 import org.eclipse.jst.pagedesigner.dom.IDOMPosition;
 import org.eclipse.jst.pagedesigner.utils.DOMUtil;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.Text;

 /**
  * @author mengbo
  */
 public abstract class DesignEdit {

     private Stack _selections;

 	private DOMRange _range;

 	private GraphicalViewer _viewer;

 	private IDOMPosition _operationPosition;

 	private final Document _document;

 	private Stack _processedResult;

 	/**
 	 * @param range
 	 * @param viewer
 	 */
 	public DesignEdit(DOMRange range, GraphicalViewer viewer) {
 		setRange(range);
 		_viewer = viewer;
 		_operationPosition = getRange().getStartPosition();
 		_document = ((IDOMNode) _operationPosition.getContainerNode())
 				.getModel().getDocument();
 	}


 	/**
 	 * @return the target document
 	 */
 	protected final Document getDocument() {
         return _document;
     }

     /**
      * @return the result
      */
     protected abstract boolean operate();

 	/**
 	 * @param node
 	 * @return the text
 	 */
 	protected abstract Text processText(WorkNode node);

 	/**
 	 * @param node
 	 * @return the node
 	 */
 	protected abstract Node processNode(WorkNode node);

 	/**
 	 * @param node
 	 * @return the node
 	 */
 	protected abstract Node processContainer(WorkNode node);

 	/**
 	 * @return the dom range
 	 */
 	public DOMRange getRange() {
 		return _range;
 	}

 	void setRange(DOMRange range) {
 		range = EditHelper.normal(range);
 		IDOMPosition start = EditHelper.ensureDOMPosition(range
 				.getStartPosition());
 		IDOMPosition end = EditHelper.ensureDOMPosition(range.getEndPosition());
 		_range = new DOMRange(start, end);
 		EditValidateUtil.validRange(range);
 	}

 	/**
 	 * @return the clipboard
 	 */
 	protected Clipboard getClipboard() {
 		return new Clipboard(_viewer.getControl().getDisplay());
 	}

 	/**
 	 * @return the position
 	 */
 	public IDOMPosition getOperationPosition() {
 		// try
 		// {
 		// Assert.isTrue(_operationPosition != null &&
 		// _operationPosition.getContainerNode() != null &&
 		// _operationPosition.getOffset() > -1);
 		// if (_operationPosition.isText())
 		// {
 		// int length = ((Text)
 		// _operationPosition.getContainerNode()).getLength();
 		// Assert.isTrue(_operationPosition.getOffset() >= 0 &&
 		// _operationPosition.getOffset() <= length);
 		// }
 		// }
 		// catch (Exception e)
 		// {
 		// // "Error", "Error in operation location move"
 		// PDPlugin.getAlerts().confirm("Alert.DesignEdit.opLocationValidTitle",
 		// "Alert.DesignEdit.opLocationValidMessage"); //$NON-NLS-1$
 		// //$NON-NLS-2$
 		// }

 		return _operationPosition;
 	}

 	/**
 	 * @param position
 	 */
 	protected void setOperationPosition(IDOMPosition position) {
 		if (!EditValidateUtil.validPosition(position)) {
 			return;
 		}
 		position = EditHelper.ensureDOMPosition(position);
 		_operationPosition = position;
 	}

 	/**
 	 * @return the result of performing the edit
 	 */
 	public boolean perform() {
 		boolean result = false;

 		result = operate();
 		return result;
 	}

 	/**
 	 * @return Returns the _viewer.
 	 */
 	public GraphicalViewer getViewer() {
 		return _viewer;
 	}

 	private Stack collectNodes() {
 		Node node;
 		Stack result = new Stack();
 		IDOMPosition start = getRange().getStartPosition(), end = getRange()
 				.getEndPosition();
 		int pos[] = new int[] { EditModelQuery.getIndexedRegionLocation(start),
 				EditModelQuery.getIndexedRegionLocation(end), };
 		if (!EditModelQuery.isSame(start, end)) {
 			Node ancestor = EditModelQuery.getInstance().getCommonAncestor(
 					start, end);
 			WorkNode rootWorkNode = new WorkNode(ancestor, pos[0], pos[1]);
 			rootWorkNode.setRoot(true);
 			result.push(rootWorkNode);
 			try {
 				// Loop all the children of the ancestor, and and the result
 				// will be collected
 				if (EditModelQuery.isText(ancestor)) {
 					Stack temp = new Stack();
 					EditHelper.getInstance().collectNodes(ancestor, pos[0],
 							pos[1], ancestor, temp);
 					WorkNode wNode = (WorkNode) temp.remove(0);
 					wNode.setParent(rootWorkNode);
 					result.push(wNode);
 				} else {
 					node = ancestor.getFirstChild();
 					Stack temp = new Stack();
 					while (node != null) {
 						EditHelper.getInstance().collectNodes(node, pos[0],
 								pos[1], ancestor, temp);
 						while (temp.size() > 0) {
 							WorkNode wNode = (WorkNode) temp.remove(0);
 							if (wNode.getNode().getParentNode() == ancestor) {
 								wNode.setParent(rootWorkNode);
 							}
 							result.push(wNode);
 						}
 						node = node.getNextSibling();
 					}
 				}
 			} catch (Exception e) {
 				result.clear();
 			}
 		}
 		return result;
 	}

 	/**
 	 * @return Returns the result.
 	 */
 	public Stack getSelections() {
 		if (_selections == null) {
 			_selections = collectNodes();
 		}
 		return _selections;
 	}

 	/**
 	 * @return the result stack
 	 */
 	public Stack getProcessedResult() {
 		if (_processedResult == null) {
 			_processedResult = new Stack();
 			WorkNode rootNode = getRootWorkNode();
 			if (rootNode != null) {
 				processNodes(rootNode, _processedResult);
 			}
 		}
 		return _processedResult;
 	}

 	/**
 	 * @return the root work node
 	 */
 	protected final WorkNode getRootWorkNode() {
 		WorkNode result = null;
 		if (getSelections().size() > 0) {
 			WorkNode node = (WorkNode) getSelections().get(0);
 			while (node.getParent() != null) {
 				node = node.getParent();
 			}
 			result = node;
 			Assert.isTrue(node.isRoot());
 		}
 		return result;
 	}

 	/**
 	 * @param node
 	 * @param result
 	 * @return true if node
 	 */
 	private final boolean processText(WorkNode node, Stack result) {
 		boolean done = false;
 		if (EditModelQuery.isText(node.getNode())) {
 			Node text = processText(node);
 			if (text != null) {
 				result.add(text);
 			}
 			getSelections().remove(node);
 			done = true;
 		}
 		return done;
 	}

 	/**
 	 * @param node
 	 * @param result
 	 */
 	private final void processContainer(WorkNode node, Stack result) {
 		processContainer(node);
 		getSelections().remove(node);
 	}

 	/**
 	 * @param node
 	 * @param result
 	 * @return true if done
 	 */
 	private final boolean processChildren(WorkNode node, Stack result) {
 		boolean done = false;
 		if (getFirstSelectedChild(node) != null) {
 			Stack myResult = new Stack();
 			{
 				WorkNode child = null;
 				while ((child = getFirstSelectedChild(node)) != null) {
 					{
 						processNodes(child, myResult);
 					}
 				}
 				Node newParent = processContainer(node);
 				newParent = toBeParent(newParent, myResult);
 				result.push(newParent);
 			}
 			getSelections().remove(node);
 			done = true;
 		}
 		return done;
 	}

 	/**
 	 * @param node
 	 * @param result
 	 * @return true if done
 	 */
 	private final boolean processChildren1(WorkNode node, Stack result) {
 		boolean done = false;
 		if (node.getNode().hasChildNodes()) {
 			Stack myResult = new Stack();
 			{
 				Node childNode = node.getNode().getFirstChild();
 				Node next = null;
 				while (childNode != null) {
 					next = childNode.getNextSibling();
 					int x1 = EditModelQuery.getNodeStartIndex(childNode) - 1;
 					int x2 = EditModelQuery.getNodeEndIndex(childNode) + 1;
 					processNodes(new WorkNode(childNode, x1, x2), myResult);
 					childNode = next;
 				}
 				Node newParent = processContainer(node);
 				newParent = toBeParent(newParent, myResult);
 				result.push(newParent);
 			}
 			getSelections().remove(node);
 			done = true;
 		}
 		return done;
 	}

 	/**
 	 * Process the nodes that are selected, the result is a collection of nodes
 	 * that either are clones or the nodes cuted.
 	 *
 	 * @param node
 	 * @param result
 	 */
 	protected final void processNodes(WorkNode node, Stack result) {
 		WorkNode child = null;
 		if (node.isRoot()) {
 			while ((child = getFirstSelectedChild(node)) != null) {
 				processNodes(child, result);
 			}
 		} else {
 			if (node.isWholeSelected()
 					|| //
 					(!EditModelQuery.isText(node.getNode()) && EditModelQuery
 							.getInstance().isSingleRegionNode(node.getNode()))
 					|| //
 					EditModelQuery.isWidget(node.getNode())) {
 				Node temp = processNode(node);
 				if (temp != null) {
 					result.push(temp);
 					getSelections().remove(node);
 				} else {
 					if (!processText(node, result)) {
 						if (!processChildren1(node, result)) {
 							processContainer(node, result);
 						}
 					}
 				}
 			} else {
 				if (!processText(node, result)) {
 					if (!processChildren(node, result)) {
 						processContainer(node, result);
 					}
 				}
 			}
 		}
 	}

 	/**
 	 * @param result
 	 */
 	protected void setClipboard(Stack result) {
 		Node[] nodes = (Node[]) result.toArray(new Node[result.size()]);
 		StringBuffer sb = new StringBuffer();
 		for (int i = 0, size = nodes.length; i < size; i++) {
 			DOMUtil.nodeToString(nodes[i], sb);
 		}
 		getClipboard().setContents(
 				new Object[] { result, sb.toString() },
 				new Transfer[] { TemplateTransfer.getInstance(),
 						TextTransfer.getInstance() });
 	}

 	private Node toBeParent(Node parent, Stack children) {
 		while (children.size() > 0) {
 			parent.appendChild((Node) children.remove(0));
 		}
 		return parent;
 	}

 	private WorkNode getFirstSelectedChild(WorkNode node) {
 		for (int i = 0, n = getSelections().size(); i < n; i++) {
 			WorkNode wNode = (WorkNode) getSelections().get(i);
 			if (wNode.getParent() == node) {
 				return wNode;
 			}
 		}
 		return null;
 	}

 	/**
 	 * @param rootNode
 	 * @param result
 	 * @return the node
 	 */
 	Node collectStyleNodes(Node rootNode, Vector result) {
 		Element element = null;
 		if (rootNode instanceof Element) {
 			element = (Element) rootNode;
 		} else if (rootNode.getParentNode() != null) {
 			element = (Element) rootNode.getParentNode();
 		}
 		ICSSStyle style = CSSUtil.getCSSStyle(element);

 		Node node = EditModelQuery.getDocumentNode(rootNode).createElement(
 				"span"); //$NON-NLS-1$
 		for (int i = 0, n = result.size(); i < n; i++) {
 			node.appendChild((Node) result.elementAt(i));
 		}
 		((Element) node).setAttribute(IHTMLConstants.ATTR_STYLE, CSSUtil
 				.resolveCSSStyle(style));
 		result.removeAllElements();
 		result.add(node);
 		return node;
 	}

 	/**
 	 * @param rootNode
 	 * @param result
 	 * @return the node
 	 */
 	protected final Node collectOtherStyles(Node rootNode, Vector result) {
 		Node cur = rootNode, prev = null, appendPoint = null;
 		if (EditValidateUtil.validNode(rootNode)) {
 			while (!EditModelQuery.isDocument(cur)) {
 				if (!EditValidateUtil.validNode(cur)) {
 					return null;
 				}
 				String name = cur.getNodeName() != null ? cur.getNodeName()
 						.toLowerCase() : ""; //$NON-NLS-1$
 				if (EditModelQuery.HTML_STYLE_NODES.contains(name)) {
 					if (prev != null) {
 						Node newone = cur.cloneNode(false);
 						newone.appendChild(prev);
 						prev = newone;
 					} else {
 						prev = cur.cloneNode(false);
 						appendPoint = prev;
 					}
 				}
 				cur = cur.getParentNode();
 			}
 			if (appendPoint != null) {
 				for (int i = 0, n = result.size(); i < n; i++) {
 					appendPoint.appendChild((Node) result.elementAt(i));
 				}
 				result.removeAllElements();
 				result.add(prev);
 			}
 		}
 		return prev;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2006 Sybase, Inc. 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:
	* Sybase, Inc. - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.pagedesigner.commands.range;

	import java.util.Stack;
	import java.util.Vector;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.gef.GraphicalViewer;
	import org.eclipse.gef.dnd.TemplateTransfer;
	import org.eclipse.jst.pagedesigner.IHTMLConstants;
	import org.eclipse.jst.pagedesigner.css2.CSSUtil;
	import org.eclipse.jst.pagedesigner.css2.ICSSStyle;
	import org.eclipse.jst.pagedesigner.dom.DOMRange;
	import org.eclipse.jst.pagedesigner.dom.EditHelper;
	import org.eclipse.jst.pagedesigner.dom.EditModelQuery;
	import org.eclipse.jst.pagedesigner.dom.EditValidateUtil;
	import org.eclipse.jst.pagedesigner.dom.IDOMPosition;
	import org.eclipse.jst.pagedesigner.utils.DOMUtil;
	import org.eclipse.swt.dnd.Clipboard;
	import org.eclipse.swt.dnd.TextTransfer;
	import org.eclipse.swt.dnd.Transfer;
	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.Text;

	/**
	* @author mengbo
	*/
	public abstract class DesignEdit {

	private Stack _selections;

	private DOMRange _range;

	private GraphicalViewer _viewer;

	private IDOMPosition _operationPosition;

	private final Document _document;

	private Stack _processedResult;

	/**
	* @param range
	* @param viewer
	*/
	public DesignEdit(DOMRange range, GraphicalViewer viewer) {
	setRange(range);
	_viewer = viewer;
	_operationPosition = getRange().getStartPosition();
	_document = ((IDOMNode) _operationPosition.getContainerNode())
	.getModel().getDocument();
	}


	/**
	* @return the target document
	*/
	protected final Document getDocument() {
	return _document;
	}

	/**
	* @return the result
	*/
	protected abstract boolean operate();

	/**
	* @param node
	* @return the text
	*/
	protected abstract Text processText(WorkNode node);

	/**
	* @param node
	* @return the node
	*/
	protected abstract Node processNode(WorkNode node);

	/**
	* @param node
	* @return the node
	*/
	protected abstract Node processContainer(WorkNode node);

	/**
	* @return the dom range
	*/
	public DOMRange getRange() {
	return _range;
	}

	void setRange(DOMRange range) {
	range = EditHelper.normal(range);
	IDOMPosition start = EditHelper.ensureDOMPosition(range
	.getStartPosition());
	IDOMPosition end = EditHelper.ensureDOMPosition(range.getEndPosition());
	_range = new DOMRange(start, end);
	EditValidateUtil.validRange(range);
	}

	/**
	* @return the clipboard
	*/
	protected Clipboard getClipboard() {
	return new Clipboard(_viewer.getControl().getDisplay());
	}

	/**
	* @return the position
	*/
	public IDOMPosition getOperationPosition() {
	// try
	// {
	// Assert.isTrue(_operationPosition != null &&
	// _operationPosition.getContainerNode() != null &&
	// _operationPosition.getOffset() > -1);
	// if (_operationPosition.isText())
	// {
	// int length = ((Text)
	// _operationPosition.getContainerNode()).getLength();
	// Assert.isTrue(_operationPosition.getOffset() >= 0 &&
	// _operationPosition.getOffset() <= length);
	// }
	// }
	// catch (Exception e)
	// {
	// // "Error", "Error in operation location move"
	// PDPlugin.getAlerts().confirm("Alert.DesignEdit.opLocationValidTitle",
	// "Alert.DesignEdit.opLocationValidMessage"); //$NON-NLS-1$
	// //$NON-NLS-2$
	// }

	return _operationPosition;
	}

	/**
	* @param position
	*/
	protected void setOperationPosition(IDOMPosition position) {
	if (!EditValidateUtil.validPosition(position)) {
	return;
	}
	position = EditHelper.ensureDOMPosition(position);
	_operationPosition = position;
	}

	/**
	* @return the result of performing the edit
	*/
	public boolean perform() {
	boolean result = false;

	result = operate();
	return result;
	}

	/**
	* @return Returns the _viewer.
	*/
	public GraphicalViewer getViewer() {
	return _viewer;
	}

	private Stack collectNodes() {
	Node node;
	Stack result = new Stack();
	IDOMPosition start = getRange().getStartPosition(), end = getRange()
	.getEndPosition();
	int pos[] = new int[] { EditModelQuery.getIndexedRegionLocation(start),
	EditModelQuery.getIndexedRegionLocation(end), };
	if (!EditModelQuery.isSame(start, end)) {
	Node ancestor = EditModelQuery.getInstance().getCommonAncestor(
	start, end);
	WorkNode rootWorkNode = new WorkNode(ancestor, pos[0], pos[1]);
	rootWorkNode.setRoot(true);
	result.push(rootWorkNode);
	try {
	// Loop all the children of the ancestor, and and the result
	// will be collected
	if (EditModelQuery.isText(ancestor)) {
	Stack temp = new Stack();
	EditHelper.getInstance().collectNodes(ancestor, pos[0],
	pos[1], ancestor, temp);
	WorkNode wNode = (WorkNode) temp.remove(0);
	wNode.setParent(rootWorkNode);
	result.push(wNode);
	} else {
	node = ancestor.getFirstChild();
	Stack temp = new Stack();
	while (node != null) {
	EditHelper.getInstance().collectNodes(node, pos[0],
	pos[1], ancestor, temp);
	while (temp.size() > 0) {
	WorkNode wNode = (WorkNode) temp.remove(0);
	if (wNode.getNode().getParentNode() == ancestor) {
	wNode.setParent(rootWorkNode);
	}
	result.push(wNode);
	}
	node = node.getNextSibling();
	}
	}
	} catch (Exception e) {
	result.clear();
	}
	}
	return result;
	}

	/**
	* @return Returns the result.
	*/
	public Stack getSelections() {
	if (_selections == null) {
	_selections = collectNodes();
	}
	return _selections;
	}

	/**
	* @return the result stack
	*/
	public Stack getProcessedResult() {
	if (_processedResult == null) {
	_processedResult = new Stack();
	WorkNode rootNode = getRootWorkNode();
	if (rootNode != null) {
	processNodes(rootNode, _processedResult);
	}
	}
	return _processedResult;
	}

	/**
	* @return the root work node
	*/
	protected final WorkNode getRootWorkNode() {
	WorkNode result = null;
	if (getSelections().size() > 0) {
	WorkNode node = (WorkNode) getSelections().get(0);
	while (node.getParent() != null) {
	node = node.getParent();
	}
	result = node;
	Assert.isTrue(node.isRoot());
	}
	return result;
	}

	/**
	* @param node
	* @param result
	* @return true if node
	*/
	private final boolean processText(WorkNode node, Stack result) {
	boolean done = false;
	if (EditModelQuery.isText(node.getNode())) {
	Node text = processText(node);
	if (text != null) {
	result.add(text);
	}
	getSelections().remove(node);
	done = true;
	}
	return done;
	}

	/**
	* @param node
	* @param result
	*/
	private final void processContainer(WorkNode node, Stack result) {
	processContainer(node);
	getSelections().remove(node);
	}

	/**
	* @param node
	* @param result
	* @return true if done
	*/
	private final boolean processChildren(WorkNode node, Stack result) {
	boolean done = false;
	if (getFirstSelectedChild(node) != null) {
	Stack myResult = new Stack();
	{
	WorkNode child = null;
	while ((child = getFirstSelectedChild(node)) != null) {
	{
	processNodes(child, myResult);
	}
	}
	Node newParent = processContainer(node);
	newParent = toBeParent(newParent, myResult);
	result.push(newParent);
	}
	getSelections().remove(node);
	done = true;
	}
	return done;
	}

	/**
	* @param node
	* @param result
	* @return true if done
	*/
	private final boolean processChildren1(WorkNode node, Stack result) {
	boolean done = false;
	if (node.getNode().hasChildNodes()) {
	Stack myResult = new Stack();
	{
	Node childNode = node.getNode().getFirstChild();
	Node next = null;
	while (childNode != null) {
	next = childNode.getNextSibling();
	int x1 = EditModelQuery.getNodeStartIndex(childNode) - 1;
	int x2 = EditModelQuery.getNodeEndIndex(childNode) + 1;
	processNodes(new WorkNode(childNode, x1, x2), myResult);
	childNode = next;
	}
	Node newParent = processContainer(node);
	newParent = toBeParent(newParent, myResult);
	result.push(newParent);
	}
	getSelections().remove(node);
	done = true;
	}
	return done;
	}

	/**
	* Process the nodes that are selected, the result is a collection of nodes
	* that either are clones or the nodes cuted.
	*
	* @param node
	* @param result
	*/
	protected final void processNodes(WorkNode node, Stack result) {
	WorkNode child = null;
	if (node.isRoot()) {
	while ((child = getFirstSelectedChild(node)) != null) {
	processNodes(child, result);
	}
	} else {
	if (node.isWholeSelected()
	\|\| //
	(!EditModelQuery.isText(node.getNode()) && EditModelQuery
	.getInstance().isSingleRegionNode(node.getNode()))
	\|\| //
	EditModelQuery.isWidget(node.getNode())) {
	Node temp = processNode(node);
	if (temp != null) {
	result.push(temp);
	getSelections().remove(node);
	} else {
	if (!processText(node, result)) {
	if (!processChildren1(node, result)) {
	processContainer(node, result);
	}
	}
	}
	} else {
	if (!processText(node, result)) {
	if (!processChildren(node, result)) {
	processContainer(node, result);
	}
	}
	}
	}
	}

	/**
	* @param result
	*/
	protected void setClipboard(Stack result) {
	Node[] nodes = (Node[]) result.toArray(new Node[result.size()]);
	StringBuffer sb = new StringBuffer();
	for (int i = 0, size = nodes.length; i < size; i++) {
	DOMUtil.nodeToString(nodes[i], sb);
	}
	getClipboard().setContents(
	new Object[] { result, sb.toString() },
	new Transfer[] { TemplateTransfer.getInstance(),
	TextTransfer.getInstance() });
	}

	private Node toBeParent(Node parent, Stack children) {
	while (children.size() > 0) {
	parent.appendChild((Node) children.remove(0));
	}
	return parent;
	}

	private WorkNode getFirstSelectedChild(WorkNode node) {
	for (int i = 0, n = getSelections().size(); i < n; i++) {
	WorkNode wNode = (WorkNode) getSelections().get(i);
	if (wNode.getParent() == node) {
	return wNode;
	}
	}
	return null;
	}

	/**
	* @param rootNode
	* @param result
	* @return the node
	*/
	Node collectStyleNodes(Node rootNode, Vector result) {
	Element element = null;
	if (rootNode instanceof Element) {
	element = (Element) rootNode;
	} else if (rootNode.getParentNode() != null) {
	element = (Element) rootNode.getParentNode();
	}
	ICSSStyle style = CSSUtil.getCSSStyle(element);

	Node node = EditModelQuery.getDocumentNode(rootNode).createElement(
	"span"); //$NON-NLS-1$
	for (int i = 0, n = result.size(); i < n; i++) {
	node.appendChild((Node) result.elementAt(i));
	}
	((Element) node).setAttribute(IHTMLConstants.ATTR_STYLE, CSSUtil
	.resolveCSSStyle(style));
	result.removeAllElements();
	result.add(node);
	return node;
	}

	/**
	* @param rootNode
	* @param result
	* @return the node
	*/
	protected final Node collectOtherStyles(Node rootNode, Vector result) {
	Node cur = rootNode, prev = null, appendPoint = null;
	if (EditValidateUtil.validNode(rootNode)) {
	while (!EditModelQuery.isDocument(cur)) {
	if (!EditValidateUtil.validNode(cur)) {
	return null;
	}
	String name = cur.getNodeName() != null ? cur.getNodeName()
	.toLowerCase() : ""; //$NON-NLS-1$
	if (EditModelQuery.HTML_STYLE_NODES.contains(name)) {
	if (prev != null) {
	Node newone = cur.cloneNode(false);
	newone.appendChild(prev);
	prev = newone;
	} else {
	prev = cur.cloneNode(false);
	appendPoint = prev;
	}
	}
	cur = cur.getParentNode();
	}
	if (appendPoint != null) {
	for (int i = 0, n = result.size(); i < n; i++) {
	appendPoint.appendChild((Node) result.elementAt(i));
	}
	result.removeAllElements();
	result.add(prev);
	}
	}
	return prev;
	}
	}