/*******************************************************************************
* Copyright (c) 2001, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.editor.search;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.ui.progress.UIJob;
import org.eclipse.wst.common.core.search.SearchEngine;
import org.eclipse.wst.common.core.search.SearchMatch;
import org.eclipse.wst.common.core.search.SearchParticipant;
import org.eclipse.wst.common.core.search.SearchPlugin;
import org.eclipse.wst.common.core.search.SearchRequestor;
import org.eclipse.wst.common.core.search.pattern.QualifiedName;
import org.eclipse.wst.common.core.search.pattern.SearchPattern;
import org.eclipse.wst.common.core.search.scope.SearchScope;
import org.eclipse.wst.common.ui.internal.search.dialogs.IComponentList;
import org.eclipse.wst.common.ui.internal.search.dialogs.IComponentSearchListProvider;
import org.eclipse.wst.xml.core.internal.search.XMLComponentDeclarationPattern;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.search.IXSDSearchConstants;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDImport;
import org.eclipse.xsd.XSDInclude;
import org.eclipse.xsd.XSDRedefine;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaContent;
import org.eclipse.xsd.XSDSchemaDirective;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTypeDefinition;
public abstract class XSDSearchListProvider implements IComponentSearchListProvider
{
protected XSDSchema[] schemas;
protected IFile currentFile;
// TODO (cs) remove these and use proper search scopes!
//
public static final int ENCLOSING_PROJECT_SCOPE = 0;
public static final int ENTIRE_WORKSPACE_SCOPE = 1;
public XSDSearchListProvider(IFile currentFile, XSDSchema[] schemas)
{
this.schemas = schemas;
this.currentFile = currentFile;
try
{
IProject[] refs = currentFile.getProject().getReferencedProjects();
for (int i=0; i < refs.length; i++)
{
System.out.println("dep " + refs[i].getName());
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
class ComponentCollectingXSDVisitor
{
protected List visitedSchemas = new ArrayList();
IComponentList list;
QualifiedName searchKind;
ComponentCollectingXSDVisitor(IComponentList list, QualifiedName searchKind)
{
this.list = list;
this.searchKind = searchKind;
}
public void visitSchema(final XSDSchema schema, boolean visitImportedSchema)
{
visitedSchemas.add(schema);
for (Iterator contents = schema.getContents().iterator(); contents.hasNext();)
{
XSDSchemaContent content = (XSDSchemaContent) contents.next();
if (content instanceof XSDSchemaDirective)
{
final XSDSchemaDirective schemaDirective = (XSDSchemaDirective) content;
XSDSchema extSchema = schemaDirective.getResolvedSchema();
if (extSchema == null && schemaDirective instanceof XSDImport && visitImportedSchema)
{
// Force the import declaration to resolve. The work must be done in the UI thread
// because there are UI components listening to changes in the schema content.
UIJob loadImportJob = new UIJob(XSDEditorPlugin.getResourceString("_UI_LABEL_LOADING_XML_SCHEMA")) //$NON-NLS-1$
{
public IStatus runInUIThread(IProgressMonitor monitor)
{
// The schema model will load the import when trying to resolve any component
// in the imported schema's namespace.
XSDImport xsdImport = (XSDImport)schemaDirective;
String importNamespace = xsdImport.getNamespace();
schema.resolveAttributeDeclaration(importNamespace, ""); //$NON-NLS-1$
return Status.OK_STATUS;
}
};
loadImportJob.setSystem(true);
loadImportJob.schedule();
try
{
loadImportJob.join();
}
catch (InterruptedException e)
{
// Nothing to do about it.
}
extSchema = schemaDirective.getResolvedSchema();
}
if (extSchema != null && !visitedSchemas.contains(extSchema))
{
if (schemaDirective instanceof XSDImport && visitImportedSchema)
{
visitSchema(extSchema, false);
}
else if (schemaDirective instanceof XSDInclude || schemaDirective instanceof XSDRedefine)
{
visitSchema(extSchema, false);
}
}
}
else if (content instanceof XSDElementDeclaration && searchKind == IXSDSearchConstants.ELEMENT_META_NAME)
{
list.add(content);
}
else if (content instanceof XSDAttributeDeclaration && searchKind == IXSDSearchConstants.ATTRIBUTE_META_NAME)
{
list.add(content);
}
else if (content instanceof XSDSimpleTypeDefinition && searchKind == IXSDSearchConstants.SIMPLE_TYPE_META_NAME)
{
// in this case we only want to show simple types
list.add(content);
}
else if (content instanceof XSDTypeDefinition && searchKind == IXSDSearchConstants.TYPE_META_NAME)
{
// in this case we want to show all types
list.add(content);
}
}
}
public List getVisitedSchemas()
{
return visitedSchemas;
}
}
class InternalSearchRequestor extends SearchRequestor
{
IComponentList componentList;
HashMap files;
InternalSearchRequestor(IComponentList componentList, HashMap files)
{
this.componentList = componentList;
this.files = files;
}
public void acceptSearchMatch(SearchMatch match) throws CoreException
{
// we filter out the matches from the current file since we assume the
// info derived from our schema models is more update to date
// (in the event that we haven't saved our latest modifications)
//
if (files.get(match.getFile()) == null)
{
// TODO... this ugly qualified name stashing will go away soon
//
QualifiedName qualifiedName = null;
Object o = match.map.get("name");
if (o != null && o instanceof QualifiedName)
{
qualifiedName = (QualifiedName)o;
}
if (qualifiedName != null && qualifiedName.getLocalName() != null)
{
componentList.add(match);
}
}
}
}
protected void findMatches(SearchEngine searchEngine, SearchRequestor requestor, SearchScope scope, QualifiedName metaName)
{
try
{
XMLComponentDeclarationPattern pattern = new XMLComponentDeclarationPattern(new QualifiedName("*", "*"), metaName, SearchPattern.R_PATTERN_MATCH);
// TODO (cs) revist this... we shouldn't be needing to hard-code partipant id's
// All we're really doing here is trying to avoid finding matches in
// wsdl's since we don't ever want to import/include a wsdl from a schema!
// Maybe we should just scope out any file types that aren't xsd's using a
// custom SearchScope?
//
SearchParticipant particpant = SearchPlugin.getDefault().getSearchParticipant("org.eclipse.wst.xsd.search.XSDSearchParticipant");
Assert.isNotNull(particpant);
SearchParticipant[] participants = {particpant};
searchEngine.search(pattern, requestor, participants, scope, null, new NullProgressMonitor());
}
catch (CoreException e)
{
e.printStackTrace();
}
}
protected HashMap createFileMap(List visitedSchemas)
{
HashMap fileMap = new HashMap();
for (Iterator i = visitedSchemas.iterator(); i.hasNext(); )
{
XSDSchema theSchema = (XSDSchema)i.next();
String location = theSchema.getSchemaLocation();
IFile file = computeFile(location);
if (file != null)
{
fileMap.put(file, Boolean.TRUE);
}
}
return fileMap;
}
private IFile computeFile(String baseLocation)
{
IFile file = null;
if (baseLocation != null)
{
String fileScheme = "file:"; //$NON-NLS-1$
String platformResourceScheme = "platform:/resource";
if (baseLocation.startsWith(fileScheme))
{
baseLocation = baseLocation.substring(fileScheme.length());
baseLocation = removeLeading(baseLocation, "/");
IPath path = new Path(baseLocation);
file = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(path);
}
else if (baseLocation.startsWith(platformResourceScheme))
{
baseLocation = baseLocation.substring(platformResourceScheme.length());
baseLocation = removeLeading(baseLocation, "/");
IPath path = new Path(baseLocation);
file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
}
}
return file;
}
private String removeLeading(String path, String pattern)
{
while (path.startsWith(pattern))
{
path = path.substring(pattern.length());
}
return path;
}
}