/*******************************************************************************
* 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.utils;
import java.util.ArrayList;
import java.util.Comparator;
import javax.xml.namespace.QName;
import org.eclipse.jst.jsf.core.internal.tld.CMUtil;
import org.eclipse.jst.jsf.core.internal.tld.ITLDConstants;
import org.eclipse.jst.pagedesigner.adapters.IBodyInfo;
import org.eclipse.jst.pagedesigner.adapters.internal.BodyInfo;
import org.eclipse.jst.pagedesigner.dom.DOMPosition;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition2;
import org.eclipse.jst.pagedesigner.dom.IDOMPosition;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMText;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* This class helps location insertion position to inside correct body or doc
* prefix. NOTE: this class only doing limited support on doc level position
* validation. Element specific position validation will be done in other
* places.
*
* @author mengbo
*/
public class BodyHelper {
// bit flags used for child skipping.
/**
* Bit flag for empty text node
*/
public static final int EMPTY_TEXT = 1;
/**
* Bit flag for comment node
*/
public static final int COMMENT = 2;
/**
* Bit flag for HEAD node
*/
public static final int HEADER = 3;
/**
*
* @param child
* @return boolean
*/
private static boolean isSkippableChild(Node parent, Node child, int flag) {
if ((flag & COMMENT) != 0 && child.getNodeType() == Node.COMMENT_NODE)
return true;
if ((flag & EMPTY_TEXT) != 0 && child instanceof IDOMText
&& ((IDOMText) child).isElementContentWhitespace())
return true;
if ((flag & HEADER) != 0 && child.getNodeType() == Node.ELEMENT_NODE) {
String uri = CMUtil.getElementNamespaceURI((Element) child);
IBodyInfo parentInfo = getBodyInfo((IDOMNode) parent);
if (parentInfo != null
&& parentInfo.isBodyHeader((IDOMNode) parent, uri,
((Element) child).getLocalName()))
return true;
}
return false;
}
/**
* check whether uri/tag should be header of any body container that is
* ancester of the start node.
*
* @param start
* @param uri
* @param tag
* @return IDOMNode
*/
public static IDOMNode findHeaderContainer(IDOMNode start, String uri,
String tag) {
while (start != null) {
IBodyInfo designInfo = getBodyInfo(start);
if (designInfo != null && designInfo.isBodyContainer(start)) {
if (designInfo.isBodyHeader(start, uri, tag))
return start;
}
start = (IDOMNode) start.getParentNode();
}
return null;
}
/**
* find the closest body insertion point, to make it as deep as possible.
* (Move into as more body as possible)
* @param position
* @return IDOMPosition
*/
public static IDOMPosition findBodyInsertLocation(IDOMPosition position) {
// forward first.
Node reference = position.getNextSiblingNode();
Node container = position.getContainerNode();
while (reference != null) {
IBodyInfo info = getBodyInfo((IDOMNode) reference);
if (info != null && info.isBodyContainer((IDOMNode) reference)) {
// good, we find a body!
position = new DOMPosition(reference, 0);
return findBodyInsertLocation(position);
}
if (isSkippableChild(container, reference, EMPTY_TEXT | COMMENT
| HEADER)) {
reference = reference.getNextSibling();
continue;
}
break;
}
// backward
reference = position.getPreviousSiblingNode();
while (reference != null) {
IBodyInfo info = getBodyInfo((IDOMNode) reference);
if (info != null && info.isBodyContainer((IDOMNode) reference)) {
// good, we find a body!
position = new DOMPosition(reference, reference.getChildNodes()
.getLength());
return findBodyInsertLocation(position);
}
// XXX: not skip header here. So if there is some header with wrong
// location, we will respect user.
if (isSkippableChild(container, reference, EMPTY_TEXT | COMMENT)) {
reference = reference.getPreviousSibling();
continue;
}
break;
}
// not find any body at same level as the insertion point.
return position;
}
/**
* The element type identified by "uri" and "tag" is going to be inserted
* into the document. This method is used to adjust the insert position so
* it can be put into correct body or header section.
* @param uri
* @param tag
* @param position
* @return IDOMPosition
*
*/
public static IDOMPosition adjustInsertPosition(String uri, String tag,
IDOMPosition position) {
IDOMNode parent = (IDOMNode) position.getContainerNode();
IBodyInfo designInfo = getBodyInfo(parent);
if (designInfo == null) {
return position; // should not happen.
}
IDOMNode headerContainer = findHeaderContainer(parent, uri, tag);
if (headerContainer == null) {
// the new node is not header.
if (shouldIgnoreAdjust(uri, tag)) {
return position;
}
// new node is not body header. So should place inside the inner most
// body.
if (!designInfo.isBodyContainer(parent)) {
return position; // it's parent is not body, so we suggest
// it's parent already correctly located, and respect user's
// choice.
}
// ok, we are inside some body, but we don't know whether we are in
// the inner most body.
// try to find a body container at same level and see whether we can
// move into that body.
return findBodyInsertLocation(position);
}
// good, we find a body container and the new node should be header
// of it.
Node child = headerContainer.getFirstChild();
// if parent is different from headerContainer, then
// child!=referenceHolder[0] will always be true
while (child != null) // && child != refNode)
{
Comparator comp = NodeLocationComparator.getInstance();
// Currently the comparator deels with tags like taglib and
// loadbundle particularly, comparasion result 0
// means it didn't compare the tags.
if (comp.compare(child, tag) < 0
|| (comp.compare(child, tag) == 0 && isSkippableChild(
headerContainer, child, COMMENT | EMPTY_TEXT
| HEADER))) {
child = child.getNextSibling();
} else {
break;
}
}
if (child != null) {
return new DOMRefPosition(child, false);
}
return new DOMPosition(parent, parent.getChildNodes()
.getLength());
}
/**
* Find the position to insert a header element into the specified parent.
*
* @param uri
* @param tag
* @param parent
* @param ref
*/
public static void findHeaderInsertPosition(String uri, String tag,
Node parent, Node[] ref) {
Node child = parent.getFirstChild();
while (child != null) {
Comparator comp = NodeLocationComparator.getInstance();
if (comp.compare(child, tag) < 0
|| (comp.compare(child, tag) == 0 && isSkippableChild(
parent, child, COMMENT | EMPTY_TEXT | HEADER))) {
child = child.getNextSibling();
} else {
break;
}
}
ref[0] = child;
return;
}
/**
* @param position
* @param body
* @param defaultPrefix
* @return the new dom position based on the insert. May return null if
* insert fails.
*/
public static IDOMPosition insertBody(IDOMPosition position, QName body,
String defaultPrefix) {
IBodyInfo bodyInfo = getBodyInfo((IDOMNode) position.getContainerNode());
Node node = position.getContainerNode();
final Node originalContainer = node;
final Node nextSibling = position.getNextSiblingNode();
// create the body element first.
Document ownerDoc;
if (node instanceof Document) {
ownerDoc = (Document) node;
} else {
ownerDoc = node.getOwnerDocument();
}
if (ownerDoc == null) {
return null; // should not happen
}
final String prefix = JSPUtil.getOrCreatePrefix(((IDOMNode) node).getModel(),
body.getNamespaceURI(), defaultPrefix);
final Element ele = ownerDoc.createElement((prefix == null ? "" //$NON-NLS-1$
: (prefix + ":")) //$NON-NLS-1$
+ body.getLocalPart());
// need to find out the insertion point
while (node instanceof IDOMNode) {
if (bodyInfo.isBodyContainer((IDOMNode) node)) {
// ok, node is a body container.
// we could create the new node as child of node and move all
// node's none header children
// as children of the new node.
NodeList nl = node.getChildNodes();
ArrayList list = new ArrayList();
for (int i = 0; i < nl.getLength(); i++) {
Node child = nl.item(i);
if (isSkippableChild(node, child, HEADER | COMMENT
| EMPTY_TEXT)) {
continue;
}
list.add(nl.item(i));
}
for (int i = 0; i < list.size(); i++) {
ele.appendChild((Node) list.get(i));
}
node.appendChild(ele);
if (node == originalContainer) {
if (nextSibling == null) {
return new DOMRefPosition2(ele, true);
} else if (nextSibling.getParentNode() == ele) {
// next sibling is not in header part
return new DOMRefPosition(nextSibling, false);
} else {
return new DOMPosition(ele, 0);
}
}
return position;
}
node = node.getParentNode();
}
// should not happen, because document and documentfragment node will
// always be body node
// so if reach here, means the position is not in document.
return null;
}
/**
* For certain special tags, do not following the "header"/"body" separation
* and can't fit into the relocation process.
*
* @param uri
* @param tag
* @return true if tag is an element that should be moved in response to
* body insert.
*/
public static boolean shouldIgnoreAdjust(String uri, String tag) {
// FIXME:
return (ITLDConstants.URI_HTML.equalsIgnoreCase(uri) && "script" //$NON-NLS-1$
.equalsIgnoreCase(tag))
|| (ITLDConstants.URI_JSP.equals(uri));
}
/**
* @param node
* @return the body info corresponding to node (should we use a node adapter?)
*/
public static IBodyInfo getBodyInfo(IDOMNode node) {
// TODO: in the future, when bodyinfo is no longer singleton, we'll use
// adapter mechanism.
return BodyInfo.getInstance();
}
}