/*******************************************************************************
* Copyright (c) 2001, 2011 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
* Jens Lukowski/Innoopract - initial renaming/restructuring
*
*******************************************************************************/
package org.eclipse.wst.dtd.ui.views.contentoutline;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.dtd.core.internal.Attribute;
import org.eclipse.wst.dtd.core.internal.AttributeList;
import org.eclipse.wst.dtd.core.internal.Comment;
import org.eclipse.wst.dtd.core.internal.DTDFile;
import org.eclipse.wst.dtd.core.internal.DTDNode;
import org.eclipse.wst.dtd.core.internal.Element;
import org.eclipse.wst.dtd.core.internal.Entity;
import org.eclipse.wst.dtd.core.internal.NodeList;
import org.eclipse.wst.dtd.core.internal.Notation;
import org.eclipse.wst.dtd.core.internal.ParameterEntityReference;
import org.eclipse.wst.dtd.core.internal.document.DTDModelImpl;
import org.eclipse.wst.dtd.core.internal.event.IDTDFileListener;
import org.eclipse.wst.dtd.core.internal.event.NodesEvent;
class DTDTreeContentProvider implements ITreeContentProvider, IDTDFileListener {
private Object fInputObject;
protected Viewer fViewer;
// A cached set of IndexedNodeLists, required for getParent to return the
// correct instances mapping to TreeItems
protected Object[] logicalNodeLists = null;
private boolean showLogicalOrder = false;
public DTDTreeContentProvider() {
super();
}
public void dispose() {
fViewer = null;
}
private void expandToNode(DTDNode node) {
DTDFile dtdFile = node.getDTDFile();
// first expand the root
AbstractTreeViewer viewer = (AbstractTreeViewer) fViewer;
viewer.expandToLevel(dtdFile, 1);
NodeList listToExpand = null;
if (node instanceof Element || node instanceof ParameterEntityReference) {
listToExpand = dtdFile.getElementsAndParameterEntityReferences();
}
else if (node instanceof Notation) {
listToExpand = dtdFile.getNotations();
}
else if (node instanceof Entity) {
listToExpand = dtdFile.getEntities();
}
else if (node instanceof Comment) {
listToExpand = dtdFile.getComments();
}
if (listToExpand != null) {
viewer.expandToLevel(listToExpand, 1);
}
viewer.expandToLevel(node, 0);
}
public Object[] getChildren(Object parentElement) {
// return the lists of nodes when in logical order mode, all the Nodes
// otherwise
if (parentElement instanceof DTDFile) {
if (isShowLogicalOrder()) {
// return the visible node lists
if (logicalNodeLists == null) {
Iterator nodeLists = ((DTDFile) parentElement).getNodeLists().iterator();
List visibleLists = new ArrayList(7);
while (nodeLists.hasNext()) {
NodeList list = (NodeList) nodeLists.next();
if (isVisibleNodeList(list)) {
visibleLists.add(list);
}
}
logicalNodeLists = visibleLists.toArray();
}
return logicalNodeLists;
}
else {
// return the visible nodes
List allNodes = ((DTDFile) parentElement).getNodes();
List visibleNodes = new ArrayList(allNodes.size());
for (int i = 0; i < allNodes.size(); i++) {
Object o = allNodes.get(i);
if (isVisibleNode(o)) {
visibleNodes.add(o);
}
}
return visibleNodes.toArray();
}
}
else if (parentElement instanceof NodeList) {
return ((NodeList) parentElement).getNodes().toArray();
}
else if (parentElement instanceof Element) {
// always group the attributes directly under the element
Object[] children = ((DTDNode) parentElement).getChildren();
List attributes = ((Element) parentElement).getElementAttributes();
Object[] logicalChildren = new Object[children.length + attributes.size()];
int index = 0;
for (index = 0; index < children.length; index++) {
logicalChildren[index] = children[index];
}
for (Iterator iter = attributes.iterator(); iter.hasNext();) {
logicalChildren[index++] = iter.next();
}
return logicalChildren;
}
else if (parentElement instanceof DTDNode) {
return ((DTDNode) parentElement).getChildren();
}
return Collections.EMPTY_LIST.toArray();
}
public Object[] getElements(java.lang.Object inputElement) {
Object[] elements = null;
// Always show the DTDFile "node"
if (inputElement instanceof DTDModelImpl) {
elements = new Object[]{((DTDModelImpl) inputElement).getDTDFile()};
}
if (elements == null) {
elements = new Object[0];
}
return elements;
}
public Object getParent(Object element) {
List parents = getParents(element);
Object parent = null;
if(parents.size() > 0) {
parent = parents.get(0);
}
return parent;
}
public boolean hasChildren(Object element) {
Object[] children = getChildren(element);
return children.length > 0;
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
fViewer = viewer;
if (fInputObject instanceof DTDModelImpl) {
((DTDModelImpl) fInputObject).getDTDFile().removeDTDFileListener(this);
}
fInputObject = newInput;
if (fInputObject instanceof DTDModelImpl) {
((DTDModelImpl) fInputObject).getDTDFile().addDTDFileListener(this);
}
}
/**
* Get the value of showLogicalOrder.
*
* @return value of showLogicalOrder.
*/
public boolean isShowLogicalOrder() {
return showLogicalOrder;
}
private boolean isVisibleNode(Object o) {
if (o instanceof AttributeList) {
return false;
}
return true;
}
private boolean isVisibleNodeList(NodeList nodeList) {
/*
* All NodesLists should be visible because you can momentarily have
* an ATTLIST (for example) without a corresponding ELEMENT
* declaration
*/
return true;// !nodeList.getListType().equals(DTDRegionTypes.ATTLIST_TAG);
}
/**
* <p>If a node changed then refresh the tree for that node</p>
*
* @see org.eclipse.wst.dtd.core.internal.event.IDTDFileListener#nodeChanged(org.eclipse.wst.dtd.core.internal.DTDNode)
*/
public void nodeChanged(final DTDNode node) {
refreshTree(node);
}
public void nodesAdded(NodesEvent event) {
if (fViewer instanceof AbstractTreeViewer) {
StructuredViewer viewer = (StructuredViewer) fViewer;
ISelection selection = viewer.getSelection();
Object firstObj = (!selection.isEmpty() && selection instanceof IStructuredSelection) ? ((IStructuredSelection) selection).getFirstElement() : null;
DTDNode oldSelectedNode = null;
if (firstObj instanceof DTDNode) {
oldSelectedNode = (DTDNode) firstObj;
}
//update the tree
refreshTree(event);
final List nodes = event.getNodes();
if (!nodes.isEmpty()) {
final DTDNode node = (DTDNode) nodes.get(0);
if (oldSelectedNode == null || node.getStructuredDTDDocumentRegion() != oldSelectedNode.getStructuredDTDDocumentRegion() || node.getStartOffset() != oldSelectedNode.getStartOffset() || node.getEndOffset() != oldSelectedNode.getEndOffset()) {
expandToNode(node);
viewer.setSelection(new StructuredSelection(node));
}
}
}
}
public void nodesRemoved(NodesEvent event) {
if (fViewer instanceof AbstractTreeViewer) {
AbstractTreeViewer abstractTreeViewer = (AbstractTreeViewer) fViewer;
for (Iterator iter = event.getNodes().iterator(); iter.hasNext();) {
abstractTreeViewer.remove(iter.next());
}
}
//update the tree
refreshTree(event);
}
/**
* Set the value of showLogicalOrder.
*
* @param value
* Value to assign to showLogicalOrder.
*/
public void setShowLogicalOrder(boolean value) {
this.showLogicalOrder = value;
if (!value) {
// if not using logical order, lose the cached lists
logicalNodeLists = null;
}
}
/**
* <p>Used to update the tree after a node event such as a node added or removed.</p>
* @param event the {@link NodesEvent} that caused the tree to need updating
*/
private void refreshTree(NodesEvent event) {
for (Iterator it = event.getNodes().iterator(); it.hasNext();) {
Object node = it.next();
this.refreshTree(node);
}
}
/**
* <p>Refreshes the tree from the parents of the given node.</p>
* @param node refresh the tree from the parents of this node
*/
private void refreshTree(Object node) {
List parents = getParents(node);
if(parents.size() > 0) {
for(int p = 0; p < parents.size(); ++p) {
final Object parent = parents.get(p);
// Bug 111100 - If it is a top level node (ie. parent is a
// DTDFile),
// insert the node directly to improve performance
if (parent instanceof DTDFile) {
Object[] objs = getChildren(parent);
for (int i = 0; i < objs.length; i++) {
if (objs[i] == node) {
((AbstractTreeViewer) fViewer).insert(parent, node, i);
break;
}
}
}
this.refreshTreeNode(parent, true);
}
}
}
/**
* @param element get the tree parents of this element
* @return {@link List} of parents of the given element
*/
private List getParents(Object element) {
List parents = new ArrayList();
Object parent = null;
if (element instanceof DTDNode) {
DTDNode node = (DTDNode) element;
if (element instanceof Attribute) {
parent = node.getParentNode();
if (parent != null && parent instanceof AttributeList) {
parents.addAll(getElementParentsOfAttributeList((AttributeList)parent));
}
} else if(element instanceof AttributeList) {
parents.addAll(getElementParentsOfAttributeList((AttributeList)element));
}
// if showing in the logical order, return the IndexedNodeList
// acting as a parent in the tree
if (isShowLogicalOrder()) {
Object[] indexedNodeLists = getChildren(((DTDModelImpl) fInputObject).getDTDFile());
for (int i = 0; i < indexedNodeLists.length && parent == null; i++) {
if (indexedNodeLists[i] instanceof NodeList) {
if (((NodeList) indexedNodeLists[i]).getNodes().contains(element)) {
parents.add(indexedNodeLists[i]);
}
}
}
}
//try and get the simple parent
parent = ((DTDNode) element).getParentNode();
if(parent != null) {
parents.add(parent);
}
//if no parents found must be new nodes so refresh from root
if(parents.size() == 0) {
parents.add(((DTDModelImpl) fInputObject).getDTDFile());
}
}else if (element instanceof NodeList && fInputObject instanceof DTDModelImpl) {
parents.add(((DTDModelImpl) fInputObject).getDTDFile());
}
return parents;
}
/**
* @param attList get the element parents of the given {@link AttributeList}
* @return the element parents of the given {@link AttributeList}, if no parents
* can be found the list contains the DTD file element
*/
private List getElementParentsOfAttributeList(AttributeList attList) {
List parents = new ArrayList();
Iterator iterAttList = attList.getDTDFile().getNodes().iterator();
while (iterAttList.hasNext()) {
DTDNode currentNode = (DTDNode) iterAttList.next();
if (currentNode instanceof Element &&
currentNode.getName().equals(attList.getName())) {
parents.add(currentNode);
}
}
if(parents.size() == 0) {
parents.add(((DTDModelImpl) fInputObject).getDTDFile());
}
return parents;
}
/**
* <p>Executes a refresh on the {@link AbstractTreeViewer} for the given
* node</p>
*
* @param node refresh the tree for this node
* @param updateLabels <code>true</code> to update the labels on the tree,
* <code>false</code> otherwise.
*/
private void refreshTreeNode(final Object node, final boolean updateLabels) {
fViewer.getControl().getDisplay().asyncExec(new Runnable() {
public void run() {
if (!fViewer.getControl().isDisposed()) {
if(node != null) {
((AbstractTreeViewer) fViewer).refresh(node, updateLabels);
} else {
((AbstractTreeViewer) fViewer).refresh(updateLabels);
}
}
}
});
}
}