bundles/org.eclipse.wst.dtd.ui/src/org/eclipse/wst/dtd/ui/views/contentoutline/DTDTreeContentProvider.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * 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);
 					}
 				}
 			}
 		});
 	}
 }
	/*******************************************************************************
	* 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);
	}
	}
	}
	});
	}
	}