Attachment #63991 for bug #182506

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 182506
Collapse All | Expand All

Lines 25-33 Link Here

(-)src/org/eclipse/mylar/java/tests/xml/XmlSearchPluginTest.java (-1 / +1 lines)
25	import org.eclipse.mylar.internal.context.core.CompositeContext;	25	import org.eclipse.mylar.internal.context.core.CompositeContext;
26	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;	26	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;
27	import org.eclipse.mylar.internal.context.core.MylarContext;	27	import org.eclipse.mylar.internal.context.core.MylarContext;
28	import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
29	import org.eclipse.mylar.internal.java.JavaStructureBridge;	28	import org.eclipse.mylar.internal.java.JavaStructureBridge;
30	import org.eclipse.mylar.internal.java.search.XmlJavaRelationProvider;	29	import org.eclipse.mylar.internal.java.search.XmlJavaRelationProvider;
		30	import org.eclipse.mylar.internal.pde.PdeStructureBridge;
31	import org.eclipse.mylar.internal.resources.ResourceStructureBridge;	31	import org.eclipse.mylar.internal.resources.ResourceStructureBridge;
32	import org.eclipse.mylar.java.tests.search.ActiveSearchNotifier;	32	import org.eclipse.mylar.java.tests.search.ActiveSearchNotifier;
33	import org.eclipse.mylar.java.tests.search.SearchPluginTestHelper;	33	import org.eclipse.mylar.java.tests.search.SearchPluginTestHelper;

Lines 14-22 Link Here

(-)src/org/eclipse/mylar/java/tests/xml/XmlTestActiveSearchListener.java (-1 / +1 lines)
14	import java.util.List;	14	import java.util.List;
15		15
16	import org.eclipse.core.internal.resources.File;	16	import org.eclipse.core.internal.resources.File;
		17	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
17	import org.eclipse.mylar.context.core.AbstractRelationProvider;	18	import org.eclipse.mylar.context.core.AbstractRelationProvider;
18	import org.eclipse.mylar.context.core.ContextCorePlugin;	19	import org.eclipse.mylar.context.core.ContextCorePlugin;
19	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
20	import org.eclipse.mylar.context.tests.support.search.TestActiveSearchListener;	20	import org.eclipse.mylar.context.tests.support.search.TestActiveSearchListener;
21	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;	21	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
22	import org.eclipse.search.internal.ui.text.FileSearchResult;	22	import org.eclipse.search.internal.ui.text.FileSearchResult;




import java.util.Map;

import org.eclipse.core.internal.resources.File;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.AbstractRelationProvider;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.tests.support.search.TestActiveSearchListener;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
import org.eclipse.mylar.internal.java.search.XmlJavaRelationProvider;
import org.eclipse.mylar.internal.pde.PdeStructureBridge;
import org.eclipse.mylar.monitor.core.InteractionEvent;
import org.eclipse.search.internal.ui.text.FileSearchResult;
import org.eclipse.search.ui.text.Match;

Lines 27-35 Link Here

(-)src/org/eclipse/mylar/java/tests/search/JavaReferencesSearchTest.java (-1 / +1 lines)
27	import org.eclipse.mylar.internal.context.core.CompositeContext;	27	import org.eclipse.mylar.internal.context.core.CompositeContext;
28	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;	28	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;
29	import org.eclipse.mylar.internal.context.core.MylarContext;	29	import org.eclipse.mylar.internal.context.core.MylarContext;
30	import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
31	import org.eclipse.mylar.internal.java.JavaStructureBridge;	30	import org.eclipse.mylar.internal.java.JavaStructureBridge;
32	import org.eclipse.mylar.internal.java.search.JavaReferencesProvider;	31	import org.eclipse.mylar.internal.java.search.JavaReferencesProvider;
		32	import org.eclipse.mylar.internal.pde.PdeStructureBridge;
33		33
34	/**	34	/**
35	* @author Shawn Minto	35	* @author Shawn Minto

Lines 34-40 Link Here

(-)META-INF/MANIFEST.MF (-1 / +3 lines)
34	org.eclipse.mylar.monitor.ui,	34	org.eclipse.mylar.monitor.ui,
35	org.eclipse.search,	35	org.eclipse.search,
36	org.eclipse.mylar.resources.tests,	36	org.eclipse.mylar.resources.tests,
37	org.eclipse.mylar.monitor.core	37	org.eclipse.mylar.monitor.core,
		38	org.eclipse.mylar.pde,
		39	org.eclipse.mylar.ant
38	Eclipse-AutoStart: true	40	Eclipse-AutoStart: true
39	Bundle-ClassPath: mylar-java-tests.jar	41	Bundle-ClassPath: mylar-java-tests.jar
40	Export-Package: org.eclipse.mylar.java.tests,	42	Export-Package: org.eclipse.mylar.java.tests,




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.ide.xml.pde;

import java.util.Collections;
import java.util.List;

import org.eclipse.core.internal.resources.File;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.pde.internal.core.text.build.BuildEntry;
import org.eclipse.pde.internal.core.text.plugin.PluginNode;
import org.eclipse.pde.internal.core.text.plugin.PluginObjectNode;
import org.eclipse.pde.internal.ui.editor.PDEFormPage;
import org.eclipse.pde.internal.ui.editor.plugin.ManifestEditor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.views.markers.internal.ProblemMarker;

/**
 * @author Mik Kersten
 * 
 */
public class PdeStructureBridge extends AbstractContextStructureBridge {

	public final static String CONTENT_TYPE = "plugin.xml";

	@Override
	public String getContentType() {
		return CONTENT_TYPE;
	}

	@Override
	public String getContentType(String elementHandle) {
		if (elementHandle.endsWith(".xml")) {
			return parentContentType;
//			return parentBridge.getContentType();
		} else {
			return CONTENT_TYPE;
		}
	}

	@Override
	public List<String> getChildHandles(String handle) {
		return Collections.emptyList();
	}

	@Override
	public String getParentHandle(String handle) {
		// we can only get the parent if we have a PluginObjectNode

		Object object = getObjectForHandle(handle);
		if (object instanceof PluginObjectNode) {
			PluginObjectNode parent = (PluginObjectNode) ((PluginObjectNode) object).getParentNode();
			if (parent != null) {
				return getHandleIdentifier(parent);
			} else {
				// the parent is the plugin.xml file, so return that handle
				int delimeterIndex = handle.indexOf(";");
				if (delimeterIndex != -1) {
					String parentHandle = handle.substring(0, delimeterIndex);
					return parentHandle;
				} else {
					return null;
				}
			}
		} else if (object instanceof PluginNode) {
			PluginNode parent = (PluginNode) ((PluginNode) object).getParentNode();
			if (parent != null) {
				return getHandleIdentifier(parent);
			} else {
				// the parent is the plugin.xml file, so return that handle
				int delimeterIndex = handle.indexOf(";");
				if (delimeterIndex != -1) {
					String parentHandle = handle.substring(0, delimeterIndex);
					return parentHandle;
				} else {
					return null;
				}
			}
		} else if (object instanceof IFile) {
			// String fileHandle = parentBridge.getParentHandle(handle);
			AbstractContextStructureBridge parentBridge = ContextCorePlugin.getDefault().getStructureBridge(parentContentType);
			return parentBridge.getParentHandle(handle);
		} else {
			return null;
		}
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getObjectForHandle(java.lang.String)
	 */
	@Override
	public Object getObjectForHandle(String handle) {
		if (handle == null)
			return null;
		int first = handle.indexOf(";");
		String filename = "";
		if (first == -1) {
			AbstractContextStructureBridge parentBridge = ContextCorePlugin.getDefault().getStructureBridge(parentContentType);
			return parentBridge.getObjectForHandle(handle);
		} else {
			// extract the filename from the handle since it represents a node
			filename = handle.substring(0, first);
		}

		try {
			// get the file and create a FileEditorInput
			IPath path = new Path(filename);
			IFile f = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);

			// get the start line for the element
			int start = Integer.parseInt(handle.substring(first + 1));

			// // get the content and the document so that we can get the offset
			// String content = XmlNodeHelper.getContents(f.getContents());
			// IDocument d = new Document(content);

			// get the offsets for the element
			// make sure that we are on a character and not whitespace
			// int offset = d.getLineOffset(start);
			// while(d.getChar(offset) == ' ')
			// offset++;

			// get the current editor which should be the ManifestEditor so that
			// we can get the element that we want
			IEditorPart editorPart = null;
			try {
				editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
			} catch (NullPointerException e) {
				// do nothing, this just means that there is no active page
			}
			if (editorPart != null && editorPart instanceof ManifestEditor) {
				PluginObjectNode node = PdeEditingMonitor.getNode((ManifestEditor) editorPart, start, true);
				// get the element based on the offset
				return node;
			} else {
				String content = XmlNodeHelper.getContents(f.getContents());
				IDocument d = new Document(content);
				PluginObjectNode node = PdeEditingMonitor.getNode(d, f, start, true);
				return node;
			}
		} catch (Exception e) {
			// ignore, means file doesn't exist
			// ContextCorePlugin.log(e, "handle failed");
		}
		return null;
	}

	/**
	 * Handle is filename;hashcodeOfElementAndAttributes
	 * 
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getHandleIdentifier(java.lang.Object)
	 */
	@Override
	public String getHandleIdentifier(Object object) {
		// we can only create handles for PluginObjectNodes and plugin.xml files
		if (object instanceof XmlNodeHelper) {
			return ((XmlNodeHelper) object).getHandle();
		} else if (object instanceof PluginObjectNode) {
			PluginObjectNode node = (PluginObjectNode) object;
			try {
				// get the handle for the PluginObjectNode
				if (node.getModel() == null || node.getModel().getUnderlyingResource() == null
						|| node.getModel().getUnderlyingResource().getFullPath() == null) {
					// ContextCorePlugin.log("PDE xml node's resource or model is
					// null: " + node.getName(), this);
					return null;
				}
				IPath path = new Path(node.getModel().getUnderlyingResource().getFullPath().toString());
				IFile file = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
				String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor
						.getStringOfNode(node).hashCode()).getHandle();
				return handle;
			} catch (Exception e) {
				MylarStatusHandler.log(e, "pde handle failed");
			}
		} else if (object instanceof PluginNode) {
			PluginNode node = (PluginNode) object;
			try {
				if (node.getModel() == null || node.getModel().getUnderlyingResource() == null
						|| node.getModel().getUnderlyingResource().getFullPath() == null) {
					// ContextCorePlugin.log("PDE xml node's resource or model is
					// null: " + node.getName(), this);
					return null;
				}
				IPath path = new Path(node.getModel().getUnderlyingResource().getFullPath().toString());
				IFile file = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
				String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor
						.getStringOfNode(node).hashCode()).getHandle();
				return handle;
			} catch (Exception e) {
				MylarStatusHandler.log(e, "pde handle failed");
			}

		} else if (object instanceof File) {
			// get the handle for the file if it is plugin.xml
			File file = (File) object;
			if (file.getFullPath().toString().endsWith("plugin.xml"))
				return file.getFullPath().toString();
		}
		return null;
	}

	@Override
	public String getName(Object object) {
		if (object instanceof PluginObjectNode) {
			PluginObjectNode node = (PluginObjectNode) object;
			String name = node.getXMLAttributeValue("name");
			if (name == null)
				name = node.getXMLTagName();
			name = node.getModel().getUnderlyingResource().getName() + ": " + name;
			return name;
		} else if (object instanceof File) {
			File file = (File) object;
			if (file.getFullPath().toString().endsWith("plugin.xml"))
				return "plugin.xml";
		}
		return "";
	}

	/**
	 * TODO: make a non-handle based test
	 */
	@Override
	public boolean canBeLandmark(String handle) {
		if (handle == null) {
			return false;
		} else {
			return handle.indexOf(';') == -1;
		}
	}

	@Override
	public boolean acceptsObject(Object object) {
		// we only accept PluginObjectNodes and plugin.xml Files
		if (object instanceof PluginNode || object instanceof PluginObjectNode || object instanceof BuildEntry || object instanceof PDEFormPage) {
			return true;
		} else if (object instanceof XmlNodeHelper) {
			if (((XmlNodeHelper) object).getFilename().endsWith("plugin.xml"))
				return true;
		} else if (object instanceof File) {
			File file = (File) object;
			if (file.getFullPath().toString().endsWith("plugin.xml"))
				return true;
		}
		return false;
	}

	@Override
	public boolean canFilter(Object element) {
		return true;
	}

	@Override
	public boolean isDocument(String handle) {
		return handle.indexOf(';') == -1;
	}

	@Override
	public String getHandleForOffsetInObject(Object resource, int offset) {
		if (resource == null)
			return null;
		if (resource instanceof ProblemMarker) {
			ProblemMarker marker = (ProblemMarker) resource;

			// we can only get a handle for a marker with the resource
			// plugin.xml
			try {
				IResource res = marker.getResource();

				if (res instanceof IFile) {
					IFile file = (IFile) res;
					if (file.getFullPath().toString().endsWith("plugin.xml")) {
						return file.getFullPath().toString();
					} else {
						return null;
					}
				}
				return null;
			} catch (Throwable t) {
				MylarStatusHandler.log(t, "Could not find element for: " + marker);
				return null;
			}
		} else if (resource instanceof IFile) {
			try {
				IFile file = (IFile) resource;
				if (file.getFullPath().toString().endsWith("plugin.xml")) {
					String content = XmlNodeHelper.getContents(file.getContents());
					IDocument d = new Document(content);
					PluginObjectNode node = PdeEditingMonitor.getNode(d, file, offset, false);
					String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor.getStringOfNode(
							node).hashCode()).getHandle();
					return handle;
				}
			} catch (Exception e) {
				MylarStatusHandler.log(e, "Unable to get handle for offset in object");
			}
		}
		return null;
	}

//	public IProject getProjectForObject(Object object) {
//		while (!(object instanceof IFile)) {
//			String handle = getParentHandle(getHandleIdentifier(object));
//			if (handle == null)
//				break;
//			object = getObjectForHandle(handle);
//		}
//		if (object instanceof IFile && acceptsObject(object)) {
//			return ((IFile) object).getProject();
//		}
//		return null;
//	}

	public boolean containsProblem(IMylarElement node) {
		// TODO Auto-generated method stub
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.ide.xml.pde;

import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.core.IMylarRelation;
import org.eclipse.mylar.internal.context.ui.AbstractContextLabelProvider;
import org.eclipse.mylar.internal.context.ui.ContextUiImages;
import org.eclipse.mylar.internal.ide.MylarIdePlugin;
import org.eclipse.swt.graphics.Image;

/**
 * @author Mik Kersten
 */
public class PdeContextLabelProvider extends AbstractContextLabelProvider {

	public static final String LABEL_RELATION = "referenced by";
	
	@Override
	protected Image getImage(IMylarElement node) {
		return ContextUiImages.getImage(ContextUiImages.FILE_XML);
	}

	@Override
	protected Image getImage(IMylarRelation edge) {
		return ContextUiImages.getImage(MylarIdePlugin.EDGE_REF_XML);
	}

	@Override
	protected String getText(IMylarElement node) {
		AbstractContextStructureBridge bridge = ContextCorePlugin.getDefault().getStructureBridge(PdeStructureBridge.CONTENT_TYPE);
		return bridge.getName(bridge.getObjectForHandle(node.getHandleIdentifier()));
	}

	@Override
	protected String getText(IMylarRelation edge) {
		return LABEL_RELATION;
	}

	@Override
	protected Image getImageForObject(Object object) {
		return ContextUiImages.getImage(ContextUiImages.FILE_XML);
	}

	@Override
	protected String getTextForObject(Object object) {
		AbstractContextStructureBridge bridge = ContextCorePlugin.getDefault().getStructureBridge(PdeStructureBridge.CONTENT_TYPE);
		return bridge.getName(object);
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
/*
 * Created on Apr 1, 2005
 */
package org.eclipse.mylar.internal.ide.xml.pde;

import java.util.Locale;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.mylar.monitor.ui.AbstractUserInteractionMonitor;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.IPluginObject;
import org.eclipse.pde.internal.core.plugin.ImportObject;
import org.eclipse.pde.internal.core.text.IDocumentAttribute;
import org.eclipse.pde.internal.core.text.IDocumentNode;
import org.eclipse.pde.internal.core.text.plugin.PluginModel;
import org.eclipse.pde.internal.core.text.plugin.PluginObjectNode;
import org.eclipse.pde.internal.ui.editor.plugin.ManifestEditor;
import org.eclipse.pde.internal.ui.editor.plugin.ManifestSourcePage;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.FileEditorInput;

public class PdeEditingMonitor extends AbstractUserInteractionMonitor {

	public PdeEditingMonitor() {
		super();
	}

	@Override
	protected void handleWorkbenchPartSelection(IWorkbenchPart part, ISelection selection, boolean contributeToContext) {
		if (part instanceof ManifestEditor) {
			TextSelection textSelection = null;
			IEditorInput in = null;

			// assume that we are editing an xml file due to the editor used
			// this is the plugin.xml editor

			ManifestEditor editor = (ManifestEditor) part;

			// fix bug when user is looking in the cvs repository since the
			// input
			// is not a FileEditorInput
			if (!(editor.getEditorInput() instanceof FileEditorInput))
				return;

			// make sure that the selection is a text selection
			if (!(editor.getSelection() instanceof TextSelection || editor.getSelection() instanceof StructuredSelection)) {
				return;
			} else if (editor.getSelection() instanceof StructuredSelection) {
				StructuredSelection s = (StructuredSelection) editor.getSelection();
				if (s.getFirstElement() instanceof PluginObjectNode) {
					PluginObjectNode n = (PluginObjectNode) s.getFirstElement();
					textSelection = new TextSelection(n.getOffset(), n.getLength());
				} else if (s.getFirstElement() instanceof ImportObject) {
					ImportObject io = (ImportObject) s.getFirstElement();
					if (io.getImport() instanceof PluginObjectNode) {
						PluginObjectNode n = (PluginObjectNode) io.getImport();
						textSelection = new TextSelection(n.getOffset(), n.getLength());
					}
				} else {
					return;
				}
			} else {
				// get the selection and the editor input
				textSelection = (TextSelection) editor.getSelection();
			}
			in = editor.getEditorInput();

			// check if we have a text selection
			if (textSelection != null) {
				try {

					// get the node for the selection
					int offset = textSelection.getOffset();
					PluginObjectNode node = getNode(editor, offset, false);

					if (node != null) {
						FileEditorInput fei = (FileEditorInput) in;

						// fix a bug when there is a selection and the editor
						// input is the manifest.mf file
						// not the plugin.xml
						if (fei.getFile().getFullPath().toString().toLowerCase(Locale.ENGLISH).endsWith("/manifest.mf")) {
							return;
						}

						String nodeString = getStringOfNode(node);
						if (nodeString == null)
							return;

						// create the helper to get the handle for the node
						XmlNodeHelper xnode = new XmlNodeHelper(fei.getFile().getFullPath().toString(), nodeString
								.hashCode());

						// get the name for the node
//						String name = node.getXMLAttributeValue("name");
//						if (name == null)
//							name = node.getXMLTagName();
						super.handleElementSelection(part, xnode, contributeToContext);
					}
				} catch (Exception e) {
					MylarStatusHandler.log(e, "couldn't resolve selection");
				}
			}
		}
	}

	public static String getStringOfNode(IDocumentNode node) {
		if (node == null)
			return null;
		String s = node.getXMLTagName();
		for (IDocumentAttribute a : node.getNodeAttributes()) {
			s += a.getAttributeName() + "=" + a.getAttributeValue();
		}
		return s;
	}

	/**
	 * COPIED FROM ManifestSourcePage - from a getRangeElement body
	 */
	public static PluginObjectNode getNode(ManifestEditor editor, int offset, boolean hashCode) {
		ManifestSourcePage page = (ManifestSourcePage) editor.findPage("plugin-context");
		if (page != null) {
			IPluginModelBase model = (IPluginModelBase) page.getInputContext().getModel();
			PluginObjectNode node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getLibraries(),
					offset, hashCode);
			if (node == null)
				node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getImports(), offset,
						hashCode);
			if (node == null)
				node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getExtensionPoints(),
						offset, hashCode);
			if (node == null)
				node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getExtensions(), offset,
						hashCode);
			if (node == null) {
				node = (PluginObjectNode) PdeEditingMonitor.findNode(new IPluginObject[] { model.getPluginBase() },
						offset, hashCode);
			}
			return node;
		}
		return null;
	}

	public static PluginObjectNode getNode(IDocument d, IFile f, int num, boolean hashCode) throws CoreException {
		PluginModel model = new PluginModel(d, true);
		model.setUnderlyingResource(f);
		if (!model.isLoaded()) {
			model.load();
			model.setEnabled(true);
		}

		PluginObjectNode node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getLibraries(),
				num, hashCode);
		if (node == null)
			node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getImports(), num, hashCode);
		if (node == null)
			node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getExtensionPoints(), num,
					hashCode);
		if (node == null)
			node = (PluginObjectNode) PdeEditingMonitor.findNode(model.getPluginBase().getExtensions(), num, hashCode);
		if (node == null) {
			node = (PluginObjectNode) PdeEditingMonitor.findNode(new IPluginObject[] { model.getPluginBase() }, num,
					hashCode);
		}
		return node;
	}

	/**
	 * COPIED FROM ManifestSourcePage
	 */
	private static IDocumentNode findNode(IPluginObject[] nodes, int offset, boolean hashCode) {
		for (int i = 0; i < nodes.length; i++) {
			IDocumentNode node = (IDocumentNode) nodes[i];
			IDocumentNode[] children = node.getChildNodes();

			// changed region - added to check the children to make it work
			// properly
			IDocumentNode node2 = null;
			if (children.length > 0)
				node2 = PdeEditingMonitor.findNode(children, offset, hashCode);
			// end changed region

			if (node2 != null && node2 instanceof IPluginObject)
				return node2;

			if (!hashCode) {
				if (offset >= node.getOffset() && offset < node.getOffset() + node.getLength()) {
					return node;
				}
			} else {
				if (getStringOfNode(node).hashCode() == offset)
					return node;
			}
		}
		return null;
	}

	/**
	 * Copy of previous, taking different arguments
	 */
	private static IDocumentNode findNode(IDocumentNode[] nodes, int offset, boolean hashCode) {
		for (int i = 0; i < nodes.length; i++) {
			IDocumentNode node = nodes[i];
			IDocumentNode[] children = node.getChildNodes();
			IDocumentNode node2 = null;
			if (children.length > 0)
				node2 = PdeEditingMonitor.findNode(children, offset, hashCode);
			if (node2 != null)
				return node2;

			if (!hashCode) {
				if (offset >= node.getOffset() && offset < node.getOffset() + node.getLength()) {
					return node;
				}
			} else {
				if (getStringOfNode(node).hashCode() == offset)
					return node;
			}
		}
		return null;
	}
}

// XXX used if we support the xmen editor
// if (part instanceof XMLTextEditor) {
// XMLTextEditor editor = (XMLTextEditor)part;
// TextSelection textSelection =
// (TextSelection)editor.getSelectionProvider().getSelection();
// if (textSelection != null) {
//
// try{
// // get the model for the xml elements
// XMLReconciler rec = editor.getModel();
//                    
// int start = textSelection.getStartLine();
// int end = textSelection.getEndLine();
//                    
// // get the node that was selected
// XMLNode node = rec.getNodeFromLine(start);
//                    
// ContextCorePlugin.getTaskscapeManager().handleElementSelected(
// node.getHandle(), node.getCanName(),
// IDegreeOfInterest.Value.Selections,
// ITaskscapeNode.Kind.XML);
//                              
// }catch(Exception e){
// //handle properly
// }
// }




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
/*
 * Created on Apr 6, 2005
 */
package org.eclipse.mylar.internal.ide.xml.pde;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ITreeViewerListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.ui.AbstractContextUiBridge;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.resources.MylarResourcesPlugin;
import org.eclipse.pde.internal.core.text.plugin.PluginObjectNode;
import org.eclipse.pde.internal.ui.editor.FormOutlinePage;
import org.eclipse.pde.internal.ui.editor.ISortableContentOutlinePage;
import org.eclipse.pde.internal.ui.editor.PDEFormEditor;
import org.eclipse.pde.internal.ui.editor.PDESourcePage;
import org.eclipse.pde.internal.ui.editor.SourceOutlinePage;
import org.eclipse.pde.internal.ui.editor.plugin.ManifestEditor;
import org.eclipse.pde.internal.ui.editor.plugin.PluginInputContext;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.texteditor.AbstractTextEditor;

/**
 * @author Mik Kersten
 * @author Shawn Minto
 */
public class PdeUiBridge extends AbstractContextUiBridge {
	
	private TreeViewerListener treeSelectionChangedListener;

	public PdeUiBridge() {
		treeSelectionChangedListener = new TreeViewerListener();
	}

	/**
	 * @see org.eclipse.mylar.context.ui.AbstractContextUiBridge#open(org.eclipse.mylar.context.core.IMylarElement)
	 */
	@Override
	public void open(IMylarElement node) {
		// get the handle of the node
		String handle = node.getHandleIdentifier();

		int first = handle.indexOf(";");
		String filename = "";
		if (first == -1)
			filename = handle;
		else
			filename = handle.substring(0, first);

		try {
			// get the file
			IPath path = new Path(filename);
			IFile f = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);

			// open the xml file looking at the proper line
			IEditorPart editor = openInEditor(f, true);

			// if the editor is null, we had a problem and should return
			if (editor == null) {
				MylarStatusHandler.log("Unable to open editor for file: " + filename, this);
				return;
			}

			// get the contents and create a new document so that we can get
			// the offsets to highlight
			// String content = XmlNodeHelper.getContents(f.getContents());
			//            
			// IDocument d = new Document(content);

			// if(first != -1){
			// int start = Integer.parseInt(handle.substring(first + 1));
			//                
			// // get the offsets for the element
			// int startOffset = d.getLineOffset(start);
			// int length = 0;
			//                
			// // set the selection if the selection provider is not null
			// ISelectionProvider selectionProvider =
			// editor.getEditorSite().getSelectionProvider();
			// if(selectionProvider != null)
			// selectionProvider.setSelection(new TextSelection(startOffset,
			// length));
			// }

		} catch (Exception e) {
			// ContextCorePlugin.log(e, "ERROR OPENING XML EDITOR\n" +
			// e.getMessage());
		}
	}

	/**
	 * Open a file in the appropriate editor
	 * 
	 * @param file
	 *            The IFile to open
	 * @param activate
	 *            Whether to activate the editor or not
	 * @return The IEditorPart that the file opened in
	 * @throws PartInitException
	 */
	private IEditorPart openInEditor(IFile file, boolean activate) throws PartInitException {
		if (file != null) {
			IWorkbenchPage p = MylarResourcesPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage();
			if (p != null && file.exists()) {
				IEditorPart editorPart = IDE.openEditor(p, file, activate);
				// initializeHighlightRange(editorPart);
				return editorPart;
			}
		}
		return null;
	}

	@Override
	public void close(IMylarElement node) {
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		if (page != null) {
			IEditorReference[] references = page.getEditorReferences();
			for (int i = 0; i < references.length; i++) {
				IEditorPart part = references[i].getEditor(false);
				if (part != null) {
					// HACK find better way to get the filename other than the
					// tooltip
					if (("/" + part.getTitleToolTip()).equals(node.getHandleIdentifier())) {
						if (part instanceof FormEditor) {
							((FormEditor) part).close(true);
						} else if (part instanceof AbstractTextEditor) {
							((AbstractTextEditor) part).close(true);
						}
					}
					// if (part.getEditorInput() instanceof IFileEditorInput) {
					// IFileEditorInput input =
					// (IFileEditorInput)part.getEditorInput();
					// if (input.getFile().getName().endsWith(".xml")) {
					// if (part instanceof FormEditor) {
					// ((FormEditor)part).close(true);
					// } else if (part instanceof AbstractTextEditor) {
					// ((AbstractTextEditor)part).close(true);
					// }
					// }
					// }
				}
			}
		}
	}

	@Override
	public boolean acceptsEditor(IEditorPart editorPart) {
		return editorPart instanceof ManifestEditor;
	}

	/**
	 * HACK: use a lot of reflection to get the TreeViewer
	 */
	@Override
	public List<TreeViewer> getContentOutlineViewers(IEditorPart editor) {
		if (editor instanceof PDEFormEditor) {
			PDESourcePage sp = null;
			List<TreeViewer> viewers = new ArrayList<TreeViewer>(2);
			if ((sp = (PDESourcePage) ((PDEFormEditor) editor).findPage(PluginInputContext.CONTEXT_ID)) != null) {
				ISortableContentOutlinePage p = sp.getContentOutline();
				if (p != null && p.getControl() != null) {
					try {
						if (p != null && p instanceof SourceOutlinePage) {
							// get the tree viewer for the outline
							Class<?> clazz2 = p.getClass();
							Field field2 = clazz2.getDeclaredField("viewer");
							field2.setAccessible(true);
							Object f2 = field2.get(p);
							if (f2 != null && f2 instanceof TreeViewer) {
								viewers.add((TreeViewer) f2);
							}
						}
					} catch (Exception e) {
						MylarStatusHandler.log(e, "failed to get tree viewers");
						return null;
					}
				}
			}

			try {
				// get the current page of the outline
				Class<?> clazz = PDEFormEditor.class;
				Field field = null;
				try {
					field = clazz.getDeclaredField("formOutline");
				} catch (NoSuchFieldException e) {
					field = clazz.getDeclaredField("fFormOutline");
				}
				field.setAccessible(true);
				Object f = field.get(editor);
				if (f != null && f instanceof FormOutlinePage) {
					// get the tree viewer for the outline
					Class<?> clazz2 = FormOutlinePage.class;
					Field field2 = null;
					try {
						field2 = clazz2.getDeclaredField("treeViewer");
					} catch (NoSuchFieldException e) {
						field2 = clazz2.getDeclaredField("fTreeViewer");
					}
					field2.setAccessible(true);
					Object f2 = field2.get(f);
					if (f2 != null && f2 instanceof TreeViewer) {
						TreeViewer treeViewer = (TreeViewer) f2;
						viewers.add(treeViewer);
					}
				}
			} catch (Exception e) {
				MylarStatusHandler.fail(e, "could not get PDE outline", false);
				return Collections.emptyList();
			}

			// add a listener so that when the selection changes, the view is
			// refreshed to attempt to keep the ui model the same as the
			// taskscape one
			for (TreeViewer viewer : viewers) {
				viewer.addSelectionChangedListener(treeSelectionChangedListener);
				viewer.addTreeListener(treeSelectionChangedListener);
			}

			return viewers;
		}
		return Collections.emptyList();
	}

	public void refreshOutline(Object element, boolean updateLabels, boolean setSelection) {
		IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		List<TreeViewer> treeViewers = getContentOutlineViewers(editorPart);
		for (TreeViewer treeViewer : treeViewers) {
			if (treeViewer != null) {
				if (element == null) {
					treeViewer.getControl().setRedraw(false);
					treeViewer.refresh(true);
					treeViewer.getControl().setRedraw(true);
					treeViewer.expandAll();
				} else if (element instanceof PluginObjectNode) {
					treeViewer.getControl().setRedraw(false);
					treeViewer.refresh(element, true);
					treeViewer.getControl().setRedraw(true);
					treeViewer.expandAll();
				}
			}
		}

	}

	/**
	 * Class to listen to the tree views to attempt to refresh them more
	 * frequently to keep the ui model consistant with the user selections
	 * 
	 * @author Shawn Minto
	 */
	private class TreeViewerListener implements ISelectionChangedListener, ITreeViewerListener {
		public void selectionChanged(SelectionChangedEvent event) {
			Object o = event.getSource();
			if (o instanceof TreeViewer) {
				((TreeViewer) o).refresh();
				((TreeViewer) o).expandAll();
			}
		}

		public void treeCollapsed(TreeExpansionEvent event) {
			Object o = event.getSource();
			if (o instanceof TreeViewer) {
				((TreeViewer) o).refresh();
			}

		}

		public void treeExpanded(TreeExpansionEvent event) {
			Object o = event.getSource();
			if (o instanceof TreeViewer) {
				((TreeViewer) o).refresh();
			}
		}
	}

	@Override
	public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) {
		return null;
	}

	@Override
	public void restoreEditor(IMylarElement document) {
		open(document);
	}
	
	@Override
	public IMylarElement getElement(IEditorInput input) {
		return null;
	}

	@Override
	public String getContentType() {
		return PdeStructureBridge.CONTENT_TYPE;
	}
}

Lines 30-36 Link Here

(-)META-INF/MANIFEST.MF (-3 / +1 lines)
30	Export-Package: org.eclipse.mylar.internal.ide,	30	Export-Package: org.eclipse.mylar.internal.ide,
31	org.eclipse.mylar.internal.ide.ui,	31	org.eclipse.mylar.internal.ide.ui,
32	org.eclipse.mylar.internal.ide.ui.actions,	32	org.eclipse.mylar.internal.ide.ui.actions,
33	org.eclipse.mylar.internal.ide.xml,	33	org.eclipse.mylar.internal.ide.xml
34	org.eclipse.mylar.internal.ide.xml.ant,
35	org.eclipse.mylar.internal.ide.xml.pde
36	Bundle-RequiredExecutionEnvironment: J2SE-1.5	34	Bundle-RequiredExecutionEnvironment: J2SE-1.5




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
/*
 * Created on Apr 1, 2005
 */
package org.eclipse.mylar.internal.ide.xml.ant;

//import java.lang.reflect.InvocationTargetException;
//import java.lang.reflect.Method;

import org.eclipse.ant.internal.ui.editor.AntEditor;
import org.eclipse.ant.internal.ui.model.AntElementNode;
import org.eclipse.ant.internal.ui.model.AntModel;
import org.eclipse.ant.internal.ui.model.AntProjectNode;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.mylar.monitor.ui.AbstractUserInteractionMonitor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.FileEditorInput;

/**
 * @author Mik Kersten
 */
public class AntEditingMonitor extends AbstractUserInteractionMonitor {

	public AntEditingMonitor() {
		super();
	}

	@Override
	protected void handleWorkbenchPartSelection(IWorkbenchPart part, ISelection selection, boolean contributeToContext) {
		if (part instanceof AntEditor) {

			TextSelection textSelection = null;
			IEditorInput in = null;

			// assume that we are editing an xml file due to the editor used
			// this is the build.xml and other ant file editor
			AntEditor editor = (AntEditor) part;

			if (!(editor.getSelectionProvider().getSelection() instanceof TextSelection))
				return;

			textSelection = (TextSelection) editor.getSelectionProvider().getSelection();
			in = editor.getEditorInput();

			// check if we have a text selection
			if (textSelection != null && editor != null && editor.getAntModel() != null) {
				try {
					AntElementNode node = editor.getAntModel().getNode(textSelection.getOffset(), false);
					if (node == null) {
						return;
					}

					FileEditorInput fei = (FileEditorInput) in;
//					Method method = AntElementNode.class.getDeclaredMethod("getElementPath", new Class[] {});
//					method.setAccessible(true);
//					String path = (String) method.invoke(node, new Object[] {});
					String path = node.getElementPath();
					if (path == null) {
						return;
					}
					XmlNodeHelper xnode = new XmlNodeHelper(fei.getFile().getFullPath().toString(), path);
					super.handleElementSelection(part, xnode, contributeToContext);
				} catch (Exception e) {
					MylarStatusHandler.log(e, "selection resolve failed");
				}
			}
		}
		return;
	}

	public static AntElementNode getNode(AntModel antModel, String elementPath) throws SecurityException,
			NoSuchMethodException {
		AntProjectNode topNode;
		try {
			topNode = antModel.getProjectNode();
			return getNode(topNode, elementPath);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * HACK: using reflection to gain accessibility
	 */
	private static AntElementNode getNode(AntElementNode topNode, String elementPath) throws NoSuchMethodException,
			IllegalAccessException {
		if (topNode == null)
			return null;

//		Method method = AntElementNode.class.getDeclaredMethod("getElementPath", new Class[] {});
//		method.setAccessible(true);
//		String path = (String) method.invoke(topNode, new Object[] {});
		String path = topNode.getElementPath();
		if (path.compareTo(elementPath) == 0) {
			return topNode;
		}

		if (topNode.getChildNodes() == null)
			return null;

		for (Object obj : topNode.getChildNodes()) {
			if (obj instanceof AntElementNode) {
				AntElementNode node = (AntElementNode) obj;
//				path = (String) method.invoke(node, new Object[] {});
				path = node.getElementPath();
				if (path.compareTo(elementPath) == 0) {
					return node;
				} else {
					AntElementNode node2 = getNode(node, elementPath);
					if (node2 != null)
						return node2;
				}
			}
		}
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
/*
 * Created on Apr 6, 2005
 */
package org.eclipse.mylar.internal.ide.xml.ant;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.ant.internal.ui.editor.AntEditor;
import org.eclipse.ant.internal.ui.editor.outline.AntEditorContentOutlinePage;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.ui.AbstractContextUiBridge;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.MylarIdePlugin;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.texteditor.AbstractTextEditor;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

/**
 * @author Mik Kersten
 */
public class AntUiBridge extends AbstractContextUiBridge {

	/**
	 * @see org.eclipse.mylar.context.ui.AbstractContextUiBridge#open(org.eclipse.mylar.context.core.IMylarElement)
	 */
	@Override
	public void open(IMylarElement node) {
		// get the handle of the node
		String handle = node.getHandleIdentifier();

		int first = handle.indexOf(";");
		String filename = "";
		if (first == -1)
			filename = handle;
		else
			filename = handle.substring(0, first);

		try {
			// get the file
			IPath path = new Path(filename);
			IFile f = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);

			// open the xml file looking at the proper line
			IEditorPart editor = openInEditor(f, true);

			// if the editor is null, we had a problem and should return
			if (editor == null) {
				MylarStatusHandler.log("Unable to open editor for file: " + filename, this);
				return;
			}

			// get the contents and create a new document so that we can get
			// the offsets to highlight
			// String content = XmlNodeHelper.getContents(f.getContents());

			// IDocument d = new Document(content);

			// if(first != -1){
			// int start = Integer.parseInt(handle.substring(first + 1));
			//
			// // get the offsets for the element
			// int startOffset = d.getLineOffset(start);
			// int length = 0;
			//                
			// // set the selection if the selection provider is not null
			// ISelectionProvider selectionProvider =
			// editor.getEditorSite().getSelectionProvider();
			// if(selectionProvider != null)
			// selectionProvider.setSelection(new TextSelection(startOffset,
			// length));
			// }

		} catch (Exception e) {
			MylarStatusHandler.fail(e, "ERROR OPENING XML EDITOR\n" + e.getMessage(), false);
		}
	}

	/**
	 * Open a file in the appropriate editor
	 * 
	 * @param file
	 *            The IFile to open
	 * @param activate
	 *            Whether to activate the editor or not
	 * @return The IEditorPart that the file opened in
	 * @throws PartInitException
	 */
	private IEditorPart openInEditor(IFile file, boolean activate) throws PartInitException {
		if (file != null) {
			IWorkbenchPage p = MylarIdePlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage();
			if (p != null && file.exists()) {
				try {
					IEditorPart editorPart = IDE.openEditor(p, file, activate);
					return editorPart;
				} catch (Exception e) {
					// ignore this
				}
				// initializeHighlightRange(editorPart);
			}
		}
		return null;
	}

	@Override
	public void close(IMylarElement node) {
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		if (page != null) {
			IEditorReference[] references = page.getEditorReferences();
			for (int i = 0; i < references.length; i++) {
				IEditorPart part = references[i].getEditor(false);
				if (part != null) {
					if (part.getEditorInput() instanceof IFileEditorInput) {
						IFileEditorInput input = (IFileEditorInput) part.getEditorInput();
						if ((input.getFile().getFullPath().toString()).equals(node.getHandleIdentifier())) {
							if (part instanceof FormEditor) {
								((FormEditor) part).close(true);
							} else if (part instanceof AbstractTextEditor) {
								((AbstractTextEditor) part).close(true);
							}
						}
					}
				}
			}
		}
	}

	@Override
	public boolean acceptsEditor(IEditorPart editorPart) {
		return editorPart instanceof AntEditor;
	}

	/**
	 * HACK: use reflection to get the TreeViewer
	 */
	@Override
	public List<TreeViewer> getContentOutlineViewers(IEditorPart editor) {
		List<TreeViewer> viewers = new ArrayList<TreeViewer>();
		if (editor instanceof AntEditor) {
			try {
				AntEditor ae = (AntEditor) editor;
				AntEditorContentOutlinePage outline = (AntEditorContentOutlinePage) ae
						.getAdapter(IContentOutlinePage.class);
				Class<?> clazz = ContentOutlinePage.class;
				Method method = clazz.getDeclaredMethod("getTreeViewer", new Class[] {});
				method.setAccessible(true);
				viewers.add((TreeViewer) method.invoke(outline, new Object[] {}));
			} catch (Exception e) {
				MylarStatusHandler.log(e, "couldn't get outline");
			}
		}
		return viewers;
	}

	@Override
	public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) {
		return null;
	}

	@Override
	public void restoreEditor(IMylarElement document) {
		open(document);
	}
	
	@Override
	public IMylarElement getElement(IEditorInput input) {
		return null;
	}

	@Override
	public String getContentType() {
		return AntStructureBridge.CONTENT_TYPE;
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.ide.xml.ant;

import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.core.IMylarRelation;
import org.eclipse.mylar.internal.context.ui.AbstractContextLabelProvider;
import org.eclipse.mylar.internal.context.ui.ContextUiImages;
import org.eclipse.mylar.internal.ide.MylarIdePlugin;
import org.eclipse.swt.graphics.Image;

/**
 * @author Mik Kersten
 */
public class AntContextLabelProvider extends AbstractContextLabelProvider {

	public static final String LABEL_RELATION = "referenced by";
	
	@Override
	protected Image getImage(IMylarElement node) {
		return ContextUiImages.getImage(ContextUiImages.FILE_XML);
	}

	@Override
	protected Image getImage(IMylarRelation edge) {
		return ContextUiImages.getImage(MylarIdePlugin.EDGE_REF_XML);
	}

	@Override
	protected String getText(IMylarElement node) {
		AbstractContextStructureBridge bridge = ContextCorePlugin.getDefault().getStructureBridge(AntStructureBridge.CONTENT_TYPE);
		return bridge.getName(bridge.getObjectForHandle(node.getHandleIdentifier()));
	}

	@Override
	protected String getText(IMylarRelation edge) {
		return LABEL_RELATION;
	}

	@Override
	protected Image getImageForObject(Object object) {
		return ContextUiImages.getImage(ContextUiImages.FILE_XML);
	}

	@Override
	protected String getTextForObject(Object object) {
		AbstractContextStructureBridge bridge = ContextCorePlugin.getDefault().getStructureBridge(AntStructureBridge.CONTENT_TYPE);
		return bridge.getName(object);
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
/*
 * Created on Apr 20, 2005
 */
package org.eclipse.mylar.internal.ide.xml.ant;

//import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;

import org.eclipse.ant.internal.ui.editor.AntEditor;
import org.eclipse.ant.internal.ui.editor.text.AntAnnotationModel;
import org.eclipse.ant.internal.ui.model.AntElementNode;
import org.eclipse.ant.internal.ui.model.AntModel;
import org.eclipse.ant.internal.ui.model.IProblemRequestor;
import org.eclipse.ant.internal.ui.model.LocationProvider;
import org.eclipse.core.internal.resources.File;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.views.markers.internal.ProblemMarker;

/**
 * @author Mik Kersten
 */
public class AntStructureBridge extends AbstractContextStructureBridge {

	public final static String CONTENT_TYPE = "build.xml";

	private static final char HANDLE_PATH_SEPARATOR = ';';

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getContentType()
	 */
	@Override
	public String getContentType() {
		return CONTENT_TYPE;
	}

	@Override
	public String getContentType(String elementHandle) {
		if (elementHandle.endsWith(".xml")) {
			return parentContentType;
		} else {
			return CONTENT_TYPE;
		}
	}

	@Override
	public List<String> getChildHandles(String handle) {
		return Collections.emptyList();
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getParentHandle(java.lang.String)
	 */
	@Override
	public String getParentHandle(String handle) {
		Object o = getObjectForHandle(handle);

		// we can only get the parent if the element is an AntElementNode
		if (o instanceof AntElementNode) {

			// try to get the parent node
			AntElementNode parent = ((AntElementNode) o).getParentNode();

			if (parent != null) {
				// get the handle for the parent node
				return getHandleIdentifier(parent);
			} else {
				// if the parent is null, we just need to return the handle for
				// the file
				int delimeterIndex = handle.indexOf(";");
				if (delimeterIndex != -1) {
					String parentHandle = handle.substring(0, delimeterIndex);
					return parentHandle;
				} else {
					return null;
				}
			}
		} else if (o instanceof IFile) {
			AbstractContextStructureBridge parentBridge = ContextCorePlugin.getDefault().getStructureBridge(parentContentType);
			return parentBridge.getParentHandle(handle);
		} else {
			// return null if we can't get a parents
			return null;
		}
	}

	/**
	 * TODO: performance issue?
	 */
	@Override
	public Object getObjectForHandle(String handle) {
		try {
			if (handle == null)
				return null;
			int first = handle.indexOf(HANDLE_PATH_SEPARATOR);
			String filename = "";
			if (first == -1) {
				// we have just the filename, so return the IFile for this
				// filename
				filename = handle;
				IPath path = new Path(filename);
				IFile f = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
				return f;
			} else {
				// we have an element since there is a line number
				// get the filename from the handle
				filename = handle.substring(0, first);
			}

			// get the file and create a new FileEditorInput
			IPath path = new Path(filename);
			IFile file = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
			FileEditorInput fei = new FileEditorInput(file);

			// get the line number that the element is on
			String elementPath = handle.substring(first + 1);
			if (elementPath.equals("")) {
				return file;
			} else {
				// XXX needed if the editor is the only way to get the model
				// get the active editor, which should be the ant editor so we
				// can get the AntModel
				IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
						.getActiveEditor();
				if (editorPart instanceof AntEditor) {
					AntModel antModel = ((AntEditor) editorPart).getAntModel();
					if (antModel != null)
						return AntEditingMonitor.getNode(antModel, elementPath);
				} else {
					String content = XmlNodeHelper.getContents(file.getContents());
					IDocument d = new Document(content);
					// create the ant model and get the element from it
					IProblemRequestor p = new AntAnnotationModel(file);
					AntModel am = new AntModel(d, p, new LocationProvider(fei));
					am.reconcile();
					return AntEditingMonitor.getNode(am, elementPath);
				}
			}
		} catch (Throwable t) {
			// ignore this, means that the file or node doesn't exist
		}
		return null;
	}

	/**
	 * Handle is filename;XPath
	 * 
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getHandleIdentifier(java.lang.Object)
	 */
	@Override
	public String getHandleIdentifier(Object object) {
		// we can only create handles for AntElementNodes and build.xml Files
		if (object instanceof XmlNodeHelper) {
			return ((XmlNodeHelper) object).getHandle();
		} else if (object instanceof AntElementNode) {
			AntElementNode node = (AntElementNode) object;
				String path = node.getElementPath();
				if (path == null || node == null || node.getIFile() == null) {
					return null;
				}
				XmlNodeHelper helper = new XmlNodeHelper(node.getIFile().getFullPath().toString(), path);
				if (helper != null) {
					return helper.getHandle();
				}
		} else if (object instanceof File) {
			File file = (File) object;
			// get the handle for the build.xml file
			if (file.getFullPath().toString().endsWith("build.xml"))
				return file.getFullPath().toString();
		}
		return null;
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getName(java.lang.Object)
	 */
	@Override
	public String getName(Object object) {
		if (object instanceof AntElementNode) {
			AntElementNode n = (AntElementNode) object;
			String name = n.getIFile().getName() + ": " + n.getName();
			return name;
		} else if (object instanceof File) {
			File file = (File) object;
			if (file.getFullPath().toString().endsWith("build.xml"))
				return "build.xml";
		}
		return "";
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#canBeLandmark(Object)
	 * 
	 * TODO: make a non-handle based test
	 */
	@Override
	public boolean canBeLandmark(String handle) {
		if (handle != null) {
			return handle.indexOf(';') == -1;
		} else {
			return false;
		}
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#acceptsObject(java.lang.Object)
	 */
	@Override
	public boolean acceptsObject(Object object) {
		// we accept AntElementNode and build.xml File objects
		if (object instanceof AntElementNode) {
			return true;
		} else if (object instanceof XmlNodeHelper) {
			if (((XmlNodeHelper) object).getFilename().endsWith("build.xml"))
				return true;
		} else if (object instanceof File) {
			File file = (File) object;
			if (file.getFullPath().toString().endsWith("build.xml"))
				return true;
		}
		return false;
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#canFilter(java.lang.Object)
	 */
	@Override
	public boolean canFilter(Object element) {
		return true;
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#isDocument(java.lang.String)
	 */
	@Override
	public boolean isDocument(String handle) {
		return handle.indexOf(';') == -1;
	}

	/**
	 * @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getHandleForOffsetInObject(Object,
	 *      int)
	 */
	@Override
	public String getHandleForOffsetInObject(Object resource, int offset) {
		if (resource == null)
			return null;
		if (resource instanceof ProblemMarker) {
			ProblemMarker marker = (ProblemMarker) resource;

			// we can only return a handle if the resource is build.xml
			try {
				IResource res = marker.getResource();

				if (res instanceof IFile) {
					IFile file = (IFile) res;
					if (file.getFullPath().toString().endsWith("build.xml")) {
						return file.getFullPath().toString();
					} else {
						return null;
					}
				}
				return null;
			} catch (Throwable t) {
				MylarStatusHandler.fail(t, "Could not find element for: " + marker, false);
				return null;
			}
		} else if (resource instanceof IFile) {
			try {
				IFile file = (IFile) resource;
				if (file.getFullPath().toString().endsWith("build.xml")) {
					FileEditorInput fei = new FileEditorInput(file);
					String content = XmlNodeHelper.getContents(file.getContents());
					IDocument d = new Document(content);
					// create the ant model and get the element from it
					IProblemRequestor p = new AntAnnotationModel(file);
					AntModel am = new AntModel(d, p, new LocationProvider(fei));
					am.reconcile();

					AntElementNode node = am.getNode(offset, false);
//					Method method = AntElementNode.class.getDeclaredMethod("getElementPath", new Class[] {});
//					method.setAccessible(true);
//					String path = (String) method.invoke(node, new Object[] {});
					String path = node.getElementPath();
					if (path == null) {
						return null;
					}
					String handle = new XmlNodeHelper(file.getFullPath().toString(), path).getHandle();
					return handle;
				}
			} catch (Exception e) {
				MylarStatusHandler.log(e, "Unable to get handle for offset in object");
			}
		}
		return null;
	}

//	public IProject getProjectForObject(Object object) {
//		while (!(object instanceof IFile)) {
//			String handle = getParentHandle(getHandleIdentifier(object));
//			if (handle == null)
//				break;
//			object = getObjectForHandle(handle);
//		}
//		if (object instanceof IFile && acceptsObject(object)) {
//			return ((IFile) object).getProject();
//		}
//		return null;
//	}
}





import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.ide.xml.ant.AntEditingMonitor;
import org.eclipse.mylar.internal.ide.xml.pde.PdeEditingMonitor;
import org.eclipse.mylar.monitor.ui.MylarMonitorUiPlugin;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

 * @author Mik Kersten
 */
public class MylarIdePlugin extends AbstractUIPlugin {

	public static final String PLUGIN_ID = "org.eclipse.mylar.ide";

	private static MylarIdePlugin INSTANCE;

	public static final ImageDescriptor EDGE_REF_XML = getImageDescriptor("icons/elcl16/edge-ref-xml.gif");

	private PdeEditingMonitor pdeEditingMonitor;

	private AntEditingMonitor antEditingMonitor;
		
	public MylarIdePlugin() {
		INSTANCE = this;
	}

	@Override
	public void start(BundleContext context) throws Exception {
		super.start(context);

		// final IWorkbench workbench = PlatformUI.getWorkbench();
		// workbench.getDisplay().asyncExec(new Runnable() {
		// public void run() {
		// try {
		// pdeEditingMonitor = new PdeEditingMonitor();
		// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(pdeEditingMonitor);
		//
		// antEditingMonitor = new AntEditingMonitor();
		// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(antEditingMonitor);
		// } catch (Exception e) {
		// MylarStatusHandler.fail(e, "Mylar IDE initialization failed", false);
		// }
		// }
		// });
//					MylarMonitorPlugin.getDefault().getSelectionMonitors().add(antEditingMonitor);
//				} catch (Exception e) {
//					MylarStatusHandler.fail(e, "Mylar IDE initialization failed", false);
//				}
//			}
//		});
	}

	@Override

		try {
			super.stop(context);
			INSTANCE = null;
			MylarMonitorUiPlugin.getDefault().getSelectionMonitors().remove(pdeEditingMonitor);
			MylarMonitorUiPlugin.getDefault().getSelectionMonitors().remove(antEditingMonitor);
		} catch (Exception e) {
			MylarStatusHandler.fail(e,
					"Mylar IDE stop failed, Mylar may not have started properly (ensure correct Eclipse version)",




<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.0"?>
<?eclipse version="3.0"?>
<plugin> 
   
   	<extension point="org.eclipse.mylar.context.core.bridges">
		<structureBridge
	        class="org.eclipse.mylar.internal.ide.xml.ant.AntStructureBridge"
	        name="Ant Structure Bridge"
	        parentContentType="*"/>
		<structureBridge
	        class="org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge"
	        name="PDE Structure Bridge"
	        parentContentType="*"/>
	</extension>

   <extension point="org.eclipse.mylar.context.ui.bridges">
    <uiBridge
          class="org.eclipse.mylar.internal.ide.xml.pde.PdeUiBridge"
          contentType="plugin.xml"
          activeSearchIcon="icons/elcl16/edge-ref-xml.gif"
	      activeSearchLabel="XML Search"/>
    <labelProvider
          class="org.eclipse.mylar.internal.ide.xml.pde.PdeContextLabelProvider"
          contentType="plugin.xml"/>
    <uiBridge
          class="org.eclipse.mylar.internal.ide.xml.ant.AntUiBridge"
          contentType="build.xml"
          activeSearchIcon="icons/elcl16/edge-ref-xml.gif"
	      activeSearchLabel="XML Search"/>
    <labelProvider
          class="org.eclipse.mylar.internal.ide.xml.ant.AntContextLabelProvider"
          contentType="build.xml"/>
  </extension>
  
 	<extension point="org.eclipse.ui.preferencePages">
      <page 

Added Link Here

(-).refactorings/2007/4/16/refactorings.index (+2 lines)
1	1176782571643 Delete element
2	1176783488221 Delete element

Added Link Here

(-).refactorings/2007/4/16/refactorings.history (+5 lines)
1	<?xml version="1.0" encoding="utf-8"?>
2	<session version="1.0">
3	<refactoring accessors="true" comment="Delete 1 element(s) from project 'org.eclipse.mylar.ide' - Original project: 'org.eclipse.mylar.ide' - Original element: 'org.eclipse.mylar.ide/src/org.eclipse.mylar.internal.ide.xml.ant'" description="Delete element" element1="/src<org.eclipse.mylar.internal.ide.xml.ant" elements="1" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1176782571643" subPackages="false" version="1.0"/>
4	<refactoring accessors="true" comment="Delete 1 element(s) from project 'org.eclipse.mylar.ide' - Original project: 'org.eclipse.mylar.ide' - Original element: 'org.eclipse.mylar.ide/src/org.eclipse.mylar.internal.ide.xml.pde'" description="Delete element" element1="/src<org.eclipse.mylar.internal.ide.xml.pde" elements="1" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1176783488221" subPackages="false" version="1.0"/>
5	</session>




import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.context.core.AbstractRelationProvider;
import org.eclipse.mylar.context.core.ContextCorePlugin;
import org.eclipse.mylar.context.core.IDegreeOfSeparation;
import org.eclipse.mylar.context.core.IMylarElement;
import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.context.core.DegreeOfSeparation;
import org.eclipse.mylar.internal.context.core.IActiveSearchListener;
import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;
import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
import org.eclipse.mylar.resources.MylarResourcesPlugin;
import org.eclipse.search.core.text.TextSearchScope;
import org.eclipse.search.internal.ui.text.FileSearchQuery;


	public static final Map<Match, XmlNodeHelper> nodeMap = new HashMap<Match, XmlNodeHelper>();

	//TODO: copied from PdeStructure bridge: Pde has a dep on Java but Java should not have a dep on PDE
	protected static final String PDE_CONTENT_TYPE = "plugin.xml";

	public XmlJavaRelationProvider() {
		// TODO: should this be a generic XML extension?
		super(PDE_CONTENT_TYPE, SOURCE_ID);
	}

	@Override

			// create a search scope for the projects of landmarks
			Set<IResource> l = new HashSet<IResource>();
			for (IMylarElement landmark : landmarks) {
				if (landmark.getContentType().equals(PDE_CONTENT_TYPE)) {
					// ||
					// landmark.getContentType().equals(AntStructureBridge.CONTENT_TYPE))
					// {


			IResource[] res = new IResource[l.size()];
			res = l.toArray(res);
			TextSearchScope doiScope = FileTextSearchScope.newSearchScope(res, new String[] {PDE_CONTENT_TYPE}, false);
			return l.isEmpty() ? null : doiScope;
		case 2:
			// create a search scope for the projects of landmarks


			res = new IProject[projectsToSearch.size()];
			res = projectsToSearch.toArray(res);
			TextSearchScope projScope = FileTextSearchScope.newSearchScope(res, new String[] {PDE_CONTENT_TYPE}, false);

			return projectsToSearch.isEmpty() ? null : projScope;
		case 3:
			// create a search scope for the workspace
			return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PDE_CONTENT_TYPE}, false);
		case 4:
			// create a search scope for the workspace
			return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PDE_CONTENT_TYPE}, false);
		default:
			return null;
		}


					for (String handle : nodes.keySet()) {

						incrementInterest(node, PDE_CONTENT_TYPE, handle, degreeOfSeparation);
					}
					gathered = true;
					XmlJavaRelationProvider.this.searchCompleted(node);

Return to bug 182506

Lines 16-29 Link Here

(-)src/org/eclipse/mylar/java/tests/xml/XmlResultUpdaterSearchListener.java (-2 / +2 lines)
16	import java.util.Map;	16	import java.util.Map;
17		17
18	import org.eclipse.core.internal.resources.File;	18	import org.eclipse.core.internal.resources.File;
		19	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
19	import org.eclipse.mylar.context.core.AbstractRelationProvider;	20	import org.eclipse.mylar.context.core.AbstractRelationProvider;
20	import org.eclipse.mylar.context.core.ContextCorePlugin;	21	import org.eclipse.mylar.context.core.ContextCorePlugin;
21	import org.eclipse.mylar.context.core.IMylarElement;	22	import org.eclipse.mylar.context.core.IMylarElement;
22	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
23	import org.eclipse.mylar.context.tests.support.search.TestActiveSearchListener;	23	import org.eclipse.mylar.context.tests.support.search.TestActiveSearchListener;
24	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;	24	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
25	import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
26	import org.eclipse.mylar.internal.java.search.XmlJavaRelationProvider;	25	import org.eclipse.mylar.internal.java.search.XmlJavaRelationProvider;
		26	import org.eclipse.mylar.internal.pde.PdeStructureBridge;
27	import org.eclipse.mylar.monitor.core.InteractionEvent;	27	import org.eclipse.mylar.monitor.core.InteractionEvent;
28	import org.eclipse.search.internal.ui.text.FileSearchResult;	28	import org.eclipse.search.internal.ui.text.FileSearchResult;
29	import org.eclipse.search.ui.text.Match;	29	import org.eclipse.search.ui.text.Match;

Removed Link Here

(-)src/org/eclipse/mylar/internal/ide/xml/pde/PdeStructureBridge.java (-340 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.ide.xml.pde;
13
14	import java.util.Collections;
15	import java.util.List;
16
17	import org.eclipse.core.internal.resources.File;
18	import org.eclipse.core.internal.resources.Workspace;
19	import org.eclipse.core.resources.IFile;
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.resources.ResourcesPlugin;
22	import org.eclipse.core.runtime.IPath;
23	import org.eclipse.core.runtime.Path;
24	import org.eclipse.jface.text.Document;
25	import org.eclipse.jface.text.IDocument;
26	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
27	import org.eclipse.mylar.context.core.ContextCorePlugin;
28	import org.eclipse.mylar.context.core.IMylarElement;
29	import org.eclipse.mylar.core.MylarStatusHandler;
30	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
31	import org.eclipse.pde.internal.core.text.build.BuildEntry;
32	import org.eclipse.pde.internal.core.text.plugin.PluginNode;
33	import org.eclipse.pde.internal.core.text.plugin.PluginObjectNode;
34	import org.eclipse.pde.internal.ui.editor.PDEFormPage;
35	import org.eclipse.pde.internal.ui.editor.plugin.ManifestEditor;
36	import org.eclipse.ui.IEditorPart;
37	import org.eclipse.ui.PlatformUI;
38	import org.eclipse.ui.views.markers.internal.ProblemMarker;
39
40	/**
41	* @author Mik Kersten
42	*
43	*/
44	public class PdeStructureBridge extends AbstractContextStructureBridge {
45
46	public final static String CONTENT_TYPE = "plugin.xml";
47
48	@Override
49	public String getContentType() {
50	return CONTENT_TYPE;
51	}
52
53	@Override
54	public String getContentType(String elementHandle) {
55	if (elementHandle.endsWith(".xml")) {
56	return parentContentType;
57	// return parentBridge.getContentType();
58	} else {
59	return CONTENT_TYPE;
60	}
61	}
62
63	@Override
64	public List<String> getChildHandles(String handle) {
65	return Collections.emptyList();
66	}
67
68	@Override
69	public String getParentHandle(String handle) {
70	// we can only get the parent if we have a PluginObjectNode
71
72	Object object = getObjectForHandle(handle);
73	if (object instanceof PluginObjectNode) {
74	PluginObjectNode parent = (PluginObjectNode) ((PluginObjectNode) object).getParentNode();
75	if (parent != null) {
76	return getHandleIdentifier(parent);
77	} else {
78	// the parent is the plugin.xml file, so return that handle
79	int delimeterIndex = handle.indexOf(";");
80	if (delimeterIndex != -1) {
81	String parentHandle = handle.substring(0, delimeterIndex);
82	return parentHandle;
83	} else {
84	return null;
85	}
86	}
87	} else if (object instanceof PluginNode) {
88	PluginNode parent = (PluginNode) ((PluginNode) object).getParentNode();
89	if (parent != null) {
90	return getHandleIdentifier(parent);
91	} else {
92	// the parent is the plugin.xml file, so return that handle
93	int delimeterIndex = handle.indexOf(";");
94	if (delimeterIndex != -1) {
95	String parentHandle = handle.substring(0, delimeterIndex);
96	return parentHandle;
97	} else {
98	return null;
99	}
100	}
101	} else if (object instanceof IFile) {
102	// String fileHandle = parentBridge.getParentHandle(handle);
103	AbstractContextStructureBridge parentBridge = ContextCorePlugin.getDefault().getStructureBridge(parentContentType);
104	return parentBridge.getParentHandle(handle);
105	} else {
106	return null;
107	}
108	}
109
110	/**
111	* @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getObjectForHandle(java.lang.String)
112	*/
113	@Override
114	public Object getObjectForHandle(String handle) {
115	if (handle == null)
116	return null;
117	int first = handle.indexOf(";");
118	String filename = "";
119	if (first == -1) {
120	AbstractContextStructureBridge parentBridge = ContextCorePlugin.getDefault().getStructureBridge(parentContentType);
121	return parentBridge.getObjectForHandle(handle);
122	} else {
123	// extract the filename from the handle since it represents a node
124	filename = handle.substring(0, first);
125	}
126
127	try {
128	// get the file and create a FileEditorInput
129	IPath path = new Path(filename);
130	IFile f = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
131
132	// get the start line for the element
133	int start = Integer.parseInt(handle.substring(first + 1));
134
135	// // get the content and the document so that we can get the offset
136	// String content = XmlNodeHelper.getContents(f.getContents());
137	// IDocument d = new Document(content);
138
139	// get the offsets for the element
140	// make sure that we are on a character and not whitespace
141	// int offset = d.getLineOffset(start);
142	// while(d.getChar(offset) == ' ')
143	// offset++;
144
145	// get the current editor which should be the ManifestEditor so that
146	// we can get the element that we want
147	IEditorPart editorPart = null;
148	try {
149	editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
150	} catch (NullPointerException e) {
151	// do nothing, this just means that there is no active page
152	}
153	if (editorPart != null && editorPart instanceof ManifestEditor) {
154	PluginObjectNode node = PdeEditingMonitor.getNode((ManifestEditor) editorPart, start, true);
155	// get the element based on the offset
156	return node;
157	} else {
158	String content = XmlNodeHelper.getContents(f.getContents());
159	IDocument d = new Document(content);
160	PluginObjectNode node = PdeEditingMonitor.getNode(d, f, start, true);
161	return node;
162	}
163	} catch (Exception e) {
164	// ignore, means file doesn't exist
165	// ContextCorePlugin.log(e, "handle failed");
166	}
167	return null;
168	}
169
170	/**
171	* Handle is filename;hashcodeOfElementAndAttributes
172	*
173	* @see org.eclipse.mylar.context.core.AbstractContextStructureBridge#getHandleIdentifier(java.lang.Object)
174	*/
175	@Override
176	public String getHandleIdentifier(Object object) {
177	// we can only create handles for PluginObjectNodes and plugin.xml files
178	if (object instanceof XmlNodeHelper) {
179	return ((XmlNodeHelper) object).getHandle();
180	} else if (object instanceof PluginObjectNode) {
181	PluginObjectNode node = (PluginObjectNode) object;
182	try {
183	// get the handle for the PluginObjectNode
184	if (node.getModel() == null \|\| node.getModel().getUnderlyingResource() == null
185	\|\| node.getModel().getUnderlyingResource().getFullPath() == null) {
186	// ContextCorePlugin.log("PDE xml node's resource or model is
187	// null: " + node.getName(), this);
188	return null;
189	}
190	IPath path = new Path(node.getModel().getUnderlyingResource().getFullPath().toString());
191	IFile file = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
192	String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor
193	.getStringOfNode(node).hashCode()).getHandle();
194	return handle;
195	} catch (Exception e) {
196	MylarStatusHandler.log(e, "pde handle failed");
197	}
198	} else if (object instanceof PluginNode) {
199	PluginNode node = (PluginNode) object;
200	try {
201	if (node.getModel() == null \|\| node.getModel().getUnderlyingResource() == null
202	\|\| node.getModel().getUnderlyingResource().getFullPath() == null) {
203	// ContextCorePlugin.log("PDE xml node's resource or model is
204	// null: " + node.getName(), this);
205	return null;
206	}
207	IPath path = new Path(node.getModel().getUnderlyingResource().getFullPath().toString());
208	IFile file = (IFile) ((Workspace) ResourcesPlugin.getWorkspace()).newResource(path, IResource.FILE);
209	String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor
210	.getStringOfNode(node).hashCode()).getHandle();
211	return handle;
212	} catch (Exception e) {
213	MylarStatusHandler.log(e, "pde handle failed");
214	}
215
216	} else if (object instanceof File) {
217	// get the handle for the file if it is plugin.xml
218	File file = (File) object;
219	if (file.getFullPath().toString().endsWith("plugin.xml"))
220	return file.getFullPath().toString();
221	}
222	return null;
223	}
224
225	@Override
226	public String getName(Object object) {
227	if (object instanceof PluginObjectNode) {
228	PluginObjectNode node = (PluginObjectNode) object;
229	String name = node.getXMLAttributeValue("name");
230	if (name == null)
231	name = node.getXMLTagName();
232	name = node.getModel().getUnderlyingResource().getName() + ": " + name;
233	return name;
234	} else if (object instanceof File) {
235	File file = (File) object;
236	if (file.getFullPath().toString().endsWith("plugin.xml"))
237	return "plugin.xml";
238	}
239	return "";
240	}
241
242	/**
243	* TODO: make a non-handle based test
244	*/
245	@Override
246	public boolean canBeLandmark(String handle) {
247	if (handle == null) {
248	return false;
249	} else {
250	return handle.indexOf(';') == -1;
251	}
252	}
253
254	@Override
255	public boolean acceptsObject(Object object) {
256	// we only accept PluginObjectNodes and plugin.xml Files
257	if (object instanceof PluginNode \|\| object instanceof PluginObjectNode \|\| object instanceof BuildEntry \|\| object instanceof PDEFormPage) {
258	return true;
259	} else if (object instanceof XmlNodeHelper) {
260	if (((XmlNodeHelper) object).getFilename().endsWith("plugin.xml"))
261	return true;
262	} else if (object instanceof File) {
263	File file = (File) object;
264	if (file.getFullPath().toString().endsWith("plugin.xml"))
265	return true;
266	}
267	return false;
268	}
269
270	@Override
271	public boolean canFilter(Object element) {
272	return true;
273	}
274
275	@Override
276	public boolean isDocument(String handle) {
277	return handle.indexOf(';') == -1;
278	}
279
280	@Override
281	public String getHandleForOffsetInObject(Object resource, int offset) {
282	if (resource == null)
283	return null;
284	if (resource instanceof ProblemMarker) {
285	ProblemMarker marker = (ProblemMarker) resource;
286
287	// we can only get a handle for a marker with the resource
288	// plugin.xml
289	try {
290	IResource res = marker.getResource();
291
292	if (res instanceof IFile) {
293	IFile file = (IFile) res;
294	if (file.getFullPath().toString().endsWith("plugin.xml")) {
295	return file.getFullPath().toString();
296	} else {
297	return null;
298	}
299	}
300	return null;
301	} catch (Throwable t) {
302	MylarStatusHandler.log(t, "Could not find element for: " + marker);
303	return null;
304	}
305	} else if (resource instanceof IFile) {
306	try {
307	IFile file = (IFile) resource;
308	if (file.getFullPath().toString().endsWith("plugin.xml")) {
309	String content = XmlNodeHelper.getContents(file.getContents());
310	IDocument d = new Document(content);
311	PluginObjectNode node = PdeEditingMonitor.getNode(d, file, offset, false);
312	String handle = new XmlNodeHelper(file.getFullPath().toString(), PdeEditingMonitor.getStringOfNode(
313	node).hashCode()).getHandle();
314	return handle;
315	}
316	} catch (Exception e) {
317	MylarStatusHandler.log(e, "Unable to get handle for offset in object");
318	}
319	}
320	return null;
321	}
322
323	// public IProject getProjectForObject(Object object) {
324	// while (!(object instanceof IFile)) {
325	// String handle = getParentHandle(getHandleIdentifier(object));
326	// if (handle == null)
327	// break;
328	// object = getObjectForHandle(handle);
329	// }
330	// if (object instanceof IFile && acceptsObject(object)) {
331	// return ((IFile) object).getProject();
332	// }
333	// return null;
334	// }
335
336	public boolean containsProblem(IMylarElement node) {
337	// TODO Auto-generated method stub
338	return false;
339	}
340	}

Lines 12-19 Link Here

(-)src/org/eclipse/mylar/internal/ide/MylarIdePlugin.java (-31 / +17 lines)
12		12
13	import org.eclipse.jface.resource.ImageDescriptor;	13	import org.eclipse.jface.resource.ImageDescriptor;
14	import org.eclipse.mylar.core.MylarStatusHandler;	14	import org.eclipse.mylar.core.MylarStatusHandler;
15	import org.eclipse.mylar.internal.ide.xml.ant.AntEditingMonitor;
16	import org.eclipse.mylar.internal.ide.xml.pde.PdeEditingMonitor;
17	import org.eclipse.mylar.monitor.ui.MylarMonitorUiPlugin;	15	import org.eclipse.mylar.monitor.ui.MylarMonitorUiPlugin;
18	import org.eclipse.ui.plugin.AbstractUIPlugin;	16	import org.eclipse.ui.plugin.AbstractUIPlugin;
19	import org.osgi.framework.BundleContext;	17	import org.osgi.framework.BundleContext;
Lines 22-38 Link Here
22	* @author Mik Kersten	20	* @author Mik Kersten
23	*/	21	*/
24	public class MylarIdePlugin extends AbstractUIPlugin {	22	public class MylarIdePlugin extends AbstractUIPlugin {
25		23
26	public static final String PLUGIN_ID = "org.eclipse.mylar.ide";	24	public static final String PLUGIN_ID = "org.eclipse.mylar.ide";
27		25
28	private static MylarIdePlugin INSTANCE;	26	private static MylarIdePlugin INSTANCE;
29		27
30	public static final ImageDescriptor EDGE_REF_XML = getImageDescriptor("icons/elcl16/edge-ref-xml.gif");	28	public static final ImageDescriptor EDGE_REF_XML = getImageDescriptor("icons/elcl16/edge-ref-xml.gif");
31		29
32	private PdeEditingMonitor pdeEditingMonitor;
33
34	private AntEditingMonitor antEditingMonitor;
35
36	public MylarIdePlugin() {	30	public MylarIdePlugin() {
37	INSTANCE = this;	31	INSTANCE = this;
38	}	32	}
Lines 40-66 Link Here
40	@Override	34	@Override
41	public void start(BundleContext context) throws Exception {	35	public void start(BundleContext context) throws Exception {
42	super.start(context);	36	super.start(context);
43		37
44	pdeEditingMonitor = new PdeEditingMonitor();	38	// final IWorkbench workbench = PlatformUI.getWorkbench();
45	MylarMonitorUiPlugin.getDefault().getSelectionMonitors().add(pdeEditingMonitor);	39	// workbench.getDisplay().asyncExec(new Runnable() {
46		40	// public void run() {
47	antEditingMonitor = new AntEditingMonitor();	41	// try {
48	MylarMonitorUiPlugin.getDefault().getSelectionMonitors().add(antEditingMonitor);	42	// pdeEditingMonitor = new PdeEditingMonitor();
49		43	// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(pdeEditingMonitor);
50	// final IWorkbench workbench = PlatformUI.getWorkbench();	44	//
51	// workbench.getDisplay().asyncExec(new Runnable() {	45	// antEditingMonitor = new AntEditingMonitor();
52	// public void run() {	46	// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(antEditingMonitor);
53	// try {	47	// } catch (Exception e) {
54	// pdeEditingMonitor = new PdeEditingMonitor();	48	// MylarStatusHandler.fail(e, "Mylar IDE initialization failed", false);
55	// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(pdeEditingMonitor);	49	// }
56	//	50	// }
57	// antEditingMonitor = new AntEditingMonitor();	51	// });
58	// MylarMonitorPlugin.getDefault().getSelectionMonitors().add(antEditingMonitor);
59	// } catch (Exception e) {
60	// MylarStatusHandler.fail(e, "Mylar IDE initialization failed", false);
61	// }
62	// }
63	// });
64	}	52	}
65		53
66	@Override	54	@Override
Lines 68-75 Link Here
68	try {	56	try {
69	super.stop(context);	57	super.stop(context);
70	INSTANCE = null;	58	INSTANCE = null;
71	MylarMonitorUiPlugin.getDefault().getSelectionMonitors().remove(pdeEditingMonitor);
72	MylarMonitorUiPlugin.getDefault().getSelectionMonitors().remove(antEditingMonitor);
73	} catch (Exception e) {	59	} catch (Exception e) {
74	MylarStatusHandler.fail(e,	60	MylarStatusHandler.fail(e,
75	"Mylar IDE stop failed, Mylar may not have started properly (ensure correct Eclipse version)",	61	"Mylar IDE stop failed, Mylar may not have started properly (ensure correct Eclipse version)",

Lines 1-37 Link Here

(-)plugin.xml (-29 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.0"?>	2	<?eclipse version="3.0"?>
3	<?eclipse version="3.0"?>
4	<plugin>	3	<plugin>
5		4
6	<extension point="org.eclipse.mylar.context.core.bridges">
7	<structureBridge
8	class="org.eclipse.mylar.internal.ide.xml.ant.AntStructureBridge"
9	name="Ant Structure Bridge"
10	parentContentType="*"/>
11	<structureBridge
12	class="org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge"
13	name="PDE Structure Bridge"
14	parentContentType="*"/>
15	</extension>
16		5
17	<extension point="org.eclipse.mylar.context.ui.bridges">
18	<uiBridge
19	class="org.eclipse.mylar.internal.ide.xml.pde.PdeUiBridge"
20	contentType="plugin.xml"
21	activeSearchIcon="icons/elcl16/edge-ref-xml.gif"
22	activeSearchLabel="XML Search"/>
23	<labelProvider
24	class="org.eclipse.mylar.internal.ide.xml.pde.PdeContextLabelProvider"
25	contentType="plugin.xml"/>
26	<uiBridge
27	class="org.eclipse.mylar.internal.ide.xml.ant.AntUiBridge"
28	contentType="build.xml"
29	activeSearchIcon="icons/elcl16/edge-ref-xml.gif"
30	activeSearchLabel="XML Search"/>
31	<labelProvider
32	class="org.eclipse.mylar.internal.ide.xml.ant.AntContextLabelProvider"
33	contentType="build.xml"/>
34	</extension>
35		6
36	<extension point="org.eclipse.ui.preferencePages">	7	<extension point="org.eclipse.ui.preferencePages">
37	<page	8	<page

Lines 37-53 Link Here

(-)src/org/eclipse/mylar/internal/java/search/XmlJavaRelationProvider.java (-9 / +11 lines)
37	import org.eclipse.jdt.core.IMember;	37	import org.eclipse.jdt.core.IMember;
38	import org.eclipse.jdt.core.IType;	38	import org.eclipse.jdt.core.IType;
39	import org.eclipse.jdt.core.JavaCore;	39	import org.eclipse.jdt.core.JavaCore;
		40	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
40	import org.eclipse.mylar.context.core.AbstractRelationProvider;	41	import org.eclipse.mylar.context.core.AbstractRelationProvider;
41	import org.eclipse.mylar.context.core.ContextCorePlugin;	42	import org.eclipse.mylar.context.core.ContextCorePlugin;
42	import org.eclipse.mylar.context.core.IDegreeOfSeparation;	43	import org.eclipse.mylar.context.core.IDegreeOfSeparation;
43	import org.eclipse.mylar.context.core.IMylarElement;	44	import org.eclipse.mylar.context.core.IMylarElement;
44	import org.eclipse.mylar.context.core.AbstractContextStructureBridge;
45	import org.eclipse.mylar.core.MylarStatusHandler;	45	import org.eclipse.mylar.core.MylarStatusHandler;
46	import org.eclipse.mylar.internal.context.core.DegreeOfSeparation;	46	import org.eclipse.mylar.internal.context.core.DegreeOfSeparation;
47	import org.eclipse.mylar.internal.context.core.IActiveSearchListener;	47	import org.eclipse.mylar.internal.context.core.IActiveSearchListener;
48	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;	48	import org.eclipse.mylar.internal.context.core.IMylarSearchOperation;
49	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;	49	import org.eclipse.mylar.internal.ide.xml.XmlNodeHelper;
50	import org.eclipse.mylar.internal.ide.xml.pde.PdeStructureBridge;
51	import org.eclipse.mylar.resources.MylarResourcesPlugin;	50	import org.eclipse.mylar.resources.MylarResourcesPlugin;
52	import org.eclipse.search.core.text.TextSearchScope;	51	import org.eclipse.search.core.text.TextSearchScope;
53	import org.eclipse.search.internal.ui.text.FileSearchQuery;	52	import org.eclipse.search.internal.ui.text.FileSearchQuery;
Lines 72-80 Link Here
72		71
73	public static final Map<Match, XmlNodeHelper> nodeMap = new HashMap<Match, XmlNodeHelper>();	72	public static final Map<Match, XmlNodeHelper> nodeMap = new HashMap<Match, XmlNodeHelper>();
74		73
		74	//TODO: copied from PdeStructure bridge: Pde has a dep on Java but Java should not have a dep on PDE
		75	protected static final String PDE_CONTENT_TYPE = "plugin.xml";
		76
75	public XmlJavaRelationProvider() {	77	public XmlJavaRelationProvider() {
76	// TODO: should this be a generic XML extension?	78	// TODO: should this be a generic XML extension?
77	super(PdeStructureBridge.CONTENT_TYPE, SOURCE_ID);	79	super(PDE_CONTENT_TYPE, SOURCE_ID);
78	}	80	}
79		81
80	@Override	82	@Override
Lines 113-119 Link Here
113	// create a search scope for the projects of landmarks	115	// create a search scope for the projects of landmarks
114	Set<IResource> l = new HashSet<IResource>();	116	Set<IResource> l = new HashSet<IResource>();
115	for (IMylarElement landmark : landmarks) {	117	for (IMylarElement landmark : landmarks) {
116	if (landmark.getContentType().equals(PdeStructureBridge.CONTENT_TYPE)) {	118	if (landmark.getContentType().equals(PDE_CONTENT_TYPE)) {
117	// \|\|	119	// \|\|
118	// landmark.getContentType().equals(AntStructureBridge.CONTENT_TYPE))	120	// landmark.getContentType().equals(AntStructureBridge.CONTENT_TYPE))
119	// {	121	// {
Lines 136-142 Link Here
136		138
137	IResource[] res = new IResource[l.size()];	139	IResource[] res = new IResource[l.size()];
138	res = l.toArray(res);	140	res = l.toArray(res);
139	TextSearchScope doiScope = FileTextSearchScope.newSearchScope(res, new String[] {PdeStructureBridge.CONTENT_TYPE}, false);	141	TextSearchScope doiScope = FileTextSearchScope.newSearchScope(res, new String[] {PDE_CONTENT_TYPE}, false);
140	return l.isEmpty() ? null : doiScope;	142	return l.isEmpty() ? null : doiScope;
141	case 2:	143	case 2:
142	// create a search scope for the projects of landmarks	144	// create a search scope for the projects of landmarks
Lines 160-174 Link Here
160		162
161	res = new IProject[projectsToSearch.size()];	163	res = new IProject[projectsToSearch.size()];
162	res = projectsToSearch.toArray(res);	164	res = projectsToSearch.toArray(res);
163	TextSearchScope projScope = FileTextSearchScope.newSearchScope(res, new String[] {PdeStructureBridge.CONTENT_TYPE}, false);	165	TextSearchScope projScope = FileTextSearchScope.newSearchScope(res, new String[] {PDE_CONTENT_TYPE}, false);
164		166
165	return projectsToSearch.isEmpty() ? null : projScope;	167	return projectsToSearch.isEmpty() ? null : projScope;
166	case 3:	168	case 3:
167	// create a search scope for the workspace	169	// create a search scope for the workspace
168	return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PdeStructureBridge.CONTENT_TYPE}, false);	170	return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PDE_CONTENT_TYPE}, false);
169	case 4:	171	case 4:
170	// create a search scope for the workspace	172	// create a search scope for the workspace
171	return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PdeStructureBridge.CONTENT_TYPE}, false);	173	return FileTextSearchScope.newSearchScope(new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }, new String[] {PDE_CONTENT_TYPE}, false);
172	default:	174	default:
173	return null;	175	return null;
174	}	176	}
Lines 243-249 Link Here
243		245
244	for (String handle : nodes.keySet()) {	246	for (String handle : nodes.keySet()) {
245		247
246	incrementInterest(node, PdeStructureBridge.CONTENT_TYPE, handle, degreeOfSeparation);	248	incrementInterest(node, PDE_CONTENT_TYPE, handle, degreeOfSeparation);
247	}	249	}
248	gathered = true;	250	gathered = true;
249	XmlJavaRelationProvider.this.searchCompleted(node);	251	XmlJavaRelationProvider.this.searchCompleted(node);