/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.designtime.internal.view;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
import org.eclipse.jst.jsf.designtime.context.DTFacesContext;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* A component tree construction strategy based on XML view definition
*
* @author cbateman
*
*/
public class XMLComponentTreeConstructionStrategy extends
ComponentTreeConstructionStrategy<Node, IDocument>
{
private final XMLViewDefnAdapter _adapter;
// private final XMLViewObjectConstructionStrategy
// _objectConstructionStrategy;
private final IProject _project;
/**
* @param adapter
* @param project
*/
public XMLComponentTreeConstructionStrategy(
final XMLViewDefnAdapter adapter, final IProject project)
{
_adapter = adapter;
_project = project;
}
@Override
public ComponentInfo createComponentTree(final DTFacesContext context,
final DTUIViewRoot viewRoot)
{
final IDocument container = _adapter.getContainer(context, viewRoot
.getViewId());
final List<Node> roots = _adapter.getViewDefnRoots(container);
if (roots.size() > 0)
{
final IAdaptable adaptable = viewRoot.getServices();
XMLViewObjectMappingService tagMappingService = null;
if (adaptable != null)
{
tagMappingService = (XMLViewObjectMappingService) adaptable
.getAdapter(XMLViewObjectMappingService.class);
}
final XMLViewObjectConstructionStrategy objectConstructionStrategy =
new XMLViewObjectConstructionStrategy(
_adapter, new ComponentConstructionData(0, null, _project,
container), tagMappingService);
objectConstructionStrategy.getConstructionData().setIdCounter(0);
// can only handle a single root for XML; should be the DOM root
return buildComponentTree(roots.get(0), viewRoot, container,
objectConstructionStrategy);
}
return viewRoot;
}
private ComponentInfo buildComponentTree(final Node root,
final DTUIViewRoot viewRoot, final IDocument document,
final XMLViewObjectConstructionStrategy objectConstructionStrategy)
{
final ComponentInfo dummyRoot = ComponentFactory.createComponentInfo(
null, null, null, true);
// populate the dummy root
recurseDOMModel(root, dummyRoot, document, objectConstructionStrategy);
// try to extract the view defined root from the dummyRoot and update
// 'root' with its children.
populateViewRoot(viewRoot, dummyRoot.getChildren());
return viewRoot;
}
/**
* Tries to find the view defined view root in children and use it populate
* viewRoot. Children may sub-class to a different algorithm or, in some
* cases create an implicit (i.e. Facelets does this) view root if one is
* not explicitly created by the view definition.
*
* Regardless of the strategy, the following post-conditions must be true
*
* To the extend that children represent the top-level objects in the view
* under the presumed root, viewRoot must be populated with them either
* directly if the creation of a view root is implicit (i.e. Facelets) or
* through a valid view root declaration found in the view definition (i.e.
* f:view in JSP) found the children list.
*
* The default behaviour assumes the JSP case.
*
* TODO: add validation cases for missing view roots in JSP.
*
* @param viewRoot
* @param children
*/
protected void populateViewRoot(final DTUIViewRoot viewRoot,
final List children)
{
ComponentInfo foundRoot = null;
// TODO: additional cases:
// 1) Valid case: view is a fragment and has one or more non-view root
// children
// 2) Invalid case: not a fragment and has no view root
// 3) Invalid case: any definition and has more than one view root
// 4) Invalid case: any definition and has component siblings to the
// view root
FIND_VIEWROOT: for (final Iterator it = children.iterator(); it
.hasNext();)
{
final ComponentInfo topLevelChild = (ComponentInfo) it.next();
if ("javax.faces.ViewRoot".equals(topLevelChild //$NON-NLS-1$
.getComponentTypeInfo().getComponentType()))
{
foundRoot = topLevelChild;
break FIND_VIEWROOT;
}
}
if (foundRoot != null)
{
for (final Iterator it = foundRoot.getChildren().iterator(); it
.hasNext();)
{
final ComponentInfo child = (ComponentInfo) it.next();
final String facetName = foundRoot.getFacetName(child);
// if not a facet, add as a normal child
if (facetName == null)
{
viewRoot.addChild(child);
}
// if it is a facet, add as a facet
else
{
viewRoot.addFacet(facetName, child);
}
}
}
}
private void recurseDOMModel(final Node node, final ComponentInfo parent,
final IDocument document,
XMLViewObjectConstructionStrategy objectConstructionStrategy)
{
ViewObject mappedObject = null;
objectConstructionStrategy.getConstructionData().setParent(parent);
mappedObject = _adapter.mapToViewObject(node,
objectConstructionStrategy, document);
ComponentInfo newParent = parent;
if (mappedObject instanceof ComponentInfo)
{
parent.addChild((ComponentInfo) mappedObject);
newParent = (ComponentInfo) mappedObject;
}
final NodeList children = node.getChildNodes();
final int numChildren = children.getLength();
for (int i = 0; i < numChildren; i++)
{
recurseDOMModel(children.item(i), newParent, document,
objectConstructionStrategy);
}
}
}