/*******************************************************************************
* Copyright (c) 2001, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Jens Lukowski/Innoopract - initial renaming/restructuring
*
*******************************************************************************/
package org.eclipse.wst.sse.ui.internal.openon;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.sse.ui.internal.extension.RegistryReader;
/**
* Reads extensions for open on extension point,
* org.eclipse.wst.sse.ui.extensions.openon
*
* @deprecated Use base support for hyperlink navigation
*/
public class OpenOnBuilder extends RegistryReader {
public static final String ATT_CLASS = "class"; //$NON-NLS-1$
public static final String ATT_ID = "id"; //$NON-NLS-1$
private static OpenOnBuilder fInstance;
// extension point ID
public static final String PL_OPENON = "openon"; //$NON-NLS-1$
public static final String PLUGIN_ID = "org.eclipse.wst.sse.ui"; //$NON-NLS-1$
public static final String TAG_CONTENT_TYPE_IDENTIFIER = "contenttypeidentifier"; //$NON-NLS-1$
public static final String TAG_OPENON = "openon"; //$NON-NLS-1$
public static final String TAG_PARTITION_TYPE = "partitiontype"; //$NON-NLS-1$
/**
* returns singleton instance of OpenOnBuilder
*
* @return OpenOnBuilder
*/
public synchronized static OpenOnBuilder getInstance() {
if (fInstance == null) {
fInstance = new OpenOnBuilder();
}
return fInstance;
}
private String fCurrentContentType;
private OpenOnDefinition fCurrentOpenOnDefinition = null;
private List fOpenOnDefs = null;
protected String targetContributionTag;
/**
* Returns the name of the part ID attribute that is expected in the
* target extension.
*
* @param element
* @return String
*/
protected String getId(IConfigurationElement element) {
String value = element.getAttribute(ATT_ID);
return value;
}
protected String getOpenOnClass(IConfigurationElement element) {
String value = element.getAttribute(ATT_CLASS);
return value;
}
/**
* Returns all the open on definition objects
*
* @return
*/
public OpenOnDefinition[] getOpenOnDefinitions() {
initCache();
return (OpenOnDefinition[]) fOpenOnDefs.toArray(new OpenOnDefinition[fOpenOnDefs.size()]);
}
/**
* Returns all the open on definition objects valid for
* contentType/partitionType
*
* @param contentType
* @param partitionType
* @return if either contentType or partitionType is null, null is
* returned
*/
public OpenOnDefinition[] getOpenOnDefinitions(String contentType, String partitionType) {
if (contentType == null || partitionType == null) {
// should not be able to define an openon without a content type
// but if it were possible then would need to search all openon
// definitions for
// definitions with empty contentType list
return null;
}
// entire list of openon definition objects
OpenOnDefinition[] allDefs = getOpenOnDefinitions();
// current list of open on definitions valid for
// contentType/partitionType
List defs = new ArrayList();
// default definitions that should be added to end of list of open on
// definitions
List lastDefs = new ArrayList();
for (int i = 0; i < allDefs.length; ++i) {
// for each one check if it contains contentType
List partitions = (List) allDefs[i].getContentTypes().get(contentType);
if (partitions != null) {
// this openon definition is valid for all partition types for
// this content type
if (partitions.isEmpty()) {
// this will be added to end of list because this is
// considered a default openon
lastDefs.add(allDefs[i]);
} else {
// examine the partition types of this openon
int j = 0; // current index in list of partitions
boolean added = false; // openon has been added to list
while (j < partitions.size() && !added) {
// this openon definition applies to partitionType so
// add to list of valid openons
if (partitionType.equals(partitions.get(j))) {
defs.add(allDefs[i]);
added = true;
} else {
// continue checking to see if this openon
// definition is valid for current partitionType
++j;
}
}
}
}
}
// append the default openon definitions
defs.addAll(lastDefs);
// return the list
return (OpenOnDefinition[]) defs.toArray(new OpenOnDefinition[defs.size()]);
}
private void initCache() {
if (fOpenOnDefs == null) {
fOpenOnDefs = new ArrayList(0);
readContributions(TAG_OPENON, PL_OPENON);
}
}
/**
* Processes element which should be a configuration element specifying a
* content type for the current open on tag. Assumes that there is a valid
* current open on definition object.
*
* @param element
* contenttypeidentifier configuration element
*/
private void processContentTypeTag(IConfigurationElement element) {
// add to current openOnDefinition
String theId = getId(element);
if (theId != null) {
fCurrentContentType = theId;
fCurrentOpenOnDefinition.addContentTypeId(fCurrentContentType);
} else {
fCurrentContentType = null;
}
}
/**
* Processes element which should be a configuration element specifying an
* open on object. Creates a new open on definition object and adds it to
* the list of open on definition objects
*
* @param element
* openon configuration element
*/
private void processOpenOnTag(IConfigurationElement element) {
String theId = getId(element);
String theClass = getOpenOnClass(element);
if (theId != null && theClass != null) {
// start building new OpenOnDefinition
fCurrentOpenOnDefinition = new OpenOnDefinition(theId, theClass, element);
fOpenOnDefs.add(fCurrentOpenOnDefinition);
} else {
fCurrentOpenOnDefinition = null;
}
}
/**
* Processes element which should be a configuration element specifying a
* partition type for the current open on/content type tag. Assumes that
* there is a valid current open on/content type tag.
*
* @param element
* partitiontype configuration element
*/
private void processPartitionTypeTag(IConfigurationElement element) {
// add to current openOnDefinition/contentType
String theId = getId(element);
if (theId != null) {
fCurrentOpenOnDefinition.addPartitionType(fCurrentContentType, theId);
}
}
/**
* Reads the contributions from the registry for the provided workbench
* part and the provided extension point ID.
*
* @param tag
* @param extensionPoint
*/
protected void readContributions(String tag, String extensionPoint) {
targetContributionTag = tag;
IExtensionRegistry registry = Platform.getExtensionRegistry();
readRegistry(registry, PLUGIN_ID, extensionPoint);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.wst.sse.ui.internal.extension.RegistryReader#readElement(org.eclipse.core.runtime.IConfigurationElement)
*/
protected boolean readElement(IConfigurationElement element) {
String tag = element.getName();
if (tag.equals(targetContributionTag)) {
processOpenOnTag(element);
// make sure processing of current open on tag resulted in a
// current open on definition
// before continue reading the children
if (fCurrentOpenOnDefinition != null) {
readElementChildren(element);
}
return true;
} else if (tag.equals(TAG_CONTENT_TYPE_IDENTIFIER)) {
processContentTypeTag(element);
// make sure processing of current content type resulted in a
// valid content type
// before reading the children
if (fCurrentContentType != null) {
readElementChildren(element);
}
return true;
} else if (tag.equals(TAG_PARTITION_TYPE)) {
processPartitionTypeTag(element);
return true;
}
return false;
}
}