/*******************************************************************************
* Copyright (c) 2005, 2011 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Code 9 - Additional function and fixes
* EclipseSource - ongoing development
* Felix Riegger (SAP AG) - consolidation of publishers for PDE formats (bug 331974)
*******************************************************************************/
package org.eclipse.equinox.internal.p2.publisher.eclipse;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.equinox.frameworkadmin.BundleInfo;
import org.eclipse.equinox.internal.p2.core.helpers.CollectionUtils;
import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper;
import org.eclipse.equinox.internal.p2.core.helpers.URLUtil;
import org.eclipse.equinox.p2.metadata.IVersionedId;
import org.eclipse.equinox.p2.metadata.VersionedId;
import org.eclipse.equinox.p2.publisher.eclipse.FeatureEntry;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.publishing.Activator;
import org.eclipse.pde.internal.publishing.Messages;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
* Used to parse a .product file.
*/
public class ProductFile extends DefaultHandler implements IProductDescriptor {
public final static String GENERIC_VERSION_NUMBER = "0.0.0"; //$NON-NLS-1$
private static final String ATTRIBUTE_PATH = "path"; //$NON-NLS-1$
private static final String ATTRIBUTE_ICON = "icon"; //$NON-NLS-1$
protected static final String ATTRIBUTE_FRAGMENT = "fragment"; //$NON-NLS-1$
private static final String ATTRIBUTE_APPLICATION = "application"; //$NON-NLS-1$
private static final String ATTRIBUTE_INCLUDE_LAUNCHERS = "includeLaunchers"; //$NON-NLS-1$
private static final String ATTRIBUTE_NAME = "name"; //$NON-NLS-1$
private static final String ATTRIBUTE_VALUE = "value"; //$NON-NLS-1$
private static final String ATTRIBUTE_LOCATION = "location"; //$NON-NLS-1$
private static final String ATTRIBUTE_AUTO_START = "autoStart"; //$NON-NLS-1$
private static final String ATTRIBUTE_START_LEVEL = "startLevel"; //$NON-NLS-1$
protected static final String ATTRIBUTE_VERSION = "version"; //$NON-NLS-1$
protected static final String ATTRIBUTE_ID = "id"; //$NON-NLS-1$
private static final String ATTRIBUTE_UID = "uid"; //$NON-NLS-1$
private static final String PROPERTY_ECLIPSE_APPLICATION = "eclipse.application"; //$NON-NLS-1$
private static final String PROPERTY_ECLIPSE_PRODUCT = "eclipse.product"; //$NON-NLS-1$
private final static SAXParserFactory parserFactory = SAXParserFactory.newInstance();
private static final String PROGRAM_ARGS = "programArgs"; //$NON-NLS-1$
private static final String PROGRAM_ARGS_LINUX = "programArgsLin"; //$NON-NLS-1$
private static final String PROGRAM_ARGS_MAC = "programArgsMac"; //$NON-NLS-1$
private static final String PROGRAM_ARGS_SOLARIS = "programArgsSol"; //$NON-NLS-1$
private static final String PROGRAM_ARGS_WIN = "programArgsWin"; //$NON-NLS-1$
private static final String VM_ARGS = "vmArgs"; //$NON-NLS-1$
private static final String VM_ARGS_LINUX = "vmArgsLin"; //$NON-NLS-1$
private static final String VM_ARGS_MAC = "vmArgsMac"; //$NON-NLS-1$
private static final String VM_ARGS_SOLARIS = "vmArgsSol"; //$NON-NLS-1$
private static final String VM_ARGS_WIN = "vmArgsWin"; //$NON-NLS-1$
private static final String SOLARIS_LARGE = "solarisLarge"; //$NON-NLS-1$
private static final String SOLARIS_MEDIUM = "solarisMedium"; //$NON-NLS-1$
private static final String SOLARIS_SMALL = "solarisSmall"; //$NON-NLS-1$
private static final String SOLARIS_TINY = "solarisTiny"; //$NON-NLS-1$
private static final String WIN32_16_LOW = "winSmallLow"; //$NON-NLS-1$
private static final String WIN32_16_HIGH = "winSmallHigh"; //$NON-NLS-1$
private static final String WIN32_24_LOW = "win24Low"; //$NON-NLS-1$
private static final String WIN32_32_LOW = "winMediumLow"; //$NON-NLS-1$
private static final String WIN32_32_HIGH = "winMediumHigh"; //$NON-NLS-1$
private static final String WIN32_48_LOW = "winLargeLow"; //$NON-NLS-1$
private static final String WIN32_48_HIGH = "winLargeHigh"; //$NON-NLS-1$
private static final String OS_WIN32 = "win32";//$NON-NLS-1$
private static final String OS_LINUX = "linux";//$NON-NLS-1$
private static final String OS_SOLARIS = "solaris";//$NON-NLS-1$
private static final String OS_MACOSX = "macosx";//$NON-NLS-1$
//element names
private static final String EL_FEATURES = "features"; //$NON-NLS-1$
private static final String EL_FEATURE = "feature"; //$NON-NLS-1$
private static final String EL_PLUGINS = "plugins"; //$NON-NLS-1$
private static final String EL_PLUGIN = "plugin"; //$NON-NLS-1$
private static final String EL_PRODUCT = "product"; //$NON-NLS-1$
private static final String EL_PROPERTY = "property"; //$NON-NLS-1$
private static final String EL_CONFIG_INI = "configIni"; //$NON-NLS-1$
private static final String EL_LAUNCHER = "launcher"; //$NON-NLS-1$
private static final String EL_LAUNCHER_ARGS = "launcherArgs"; //$NON-NLS-1$
private static final String EL_SPLASH = "splash"; //$NON-NLS-1$
private static final String EL_CONFIGURATIONS = "configurations"; //$NON-NLS-1$
private static final String EL_LICENSE = "license"; //$NON-NLS-1$
private static final String EL_URL = "url"; //$NON-NLS-1$
private static final String EL_TEXT = "text"; //$NON-NLS-1$
//These constants form a small state machine to parse the .product file
private static final int STATE_START = 0;
private static final int STATE_PRODUCT = 1;
private static final int STATE_LAUNCHER = 2;
private static final int STATE_LAUNCHER_ARGS = 3;
private static final int STATE_PLUGINS = 4;
private static final int STATE_FEATURES = 5;
private static final int STATE_PROGRAM_ARGS = 6;
private static final int STATE_PROGRAM_ARGS_LINUX = 7;
private static final int STATE_PROGRAM_ARGS_MAC = 8;
private static final int STATE_PROGRAM_ARGS_SOLARIS = 9;
private static final int STATE_PROGRAM_ARGS_WIN = 10;
private static final int STATE_VM_ARGS = 11;
private static final int STATE_VM_ARGS_LINUX = 12;
private static final int STATE_VM_ARGS_MAC = 13;
private static final int STATE_VM_ARGS_SOLARIS = 14;
private static final int STATE_VM_ARGS_WIN = 15;
private static final int STATE_CONFIG_INI = 16;
private static final int STATE_CONFIGURATIONS = 17;
private static final int STATE_LICENSE = 18;
private static final int STATE_LICENSE_URL = 19;
private static final int STATE_LICENSE_TEXT = 20;
private static final String PI_PDEBUILD = "org.eclipse.pde.build"; //$NON-NLS-1$
private final static int EXCEPTION_PRODUCT_FORMAT = 23;
private final static int EXCEPTION_PRODUCT_FILE = 24;
private int state = STATE_START;
private SAXParser parser;
private String launcherName = null;
// private boolean useIco = false;
private final Map<String, Collection<String>> icons = new HashMap<String, Collection<String>>(6);
private String configPath = null;
private final Map<String, String> platformSpecificConfigPaths = new HashMap<String, String>();
private String configPlatform = null;
private String platformConfigPath = null;
private String id = null;
private String uid = null;
private boolean useFeatures = false;
protected List<FeatureEntry> plugins = new ArrayList<FeatureEntry>();
protected List<FeatureEntry> fragments = new ArrayList<FeatureEntry>();
private final List<FeatureEntry> features = new ArrayList<FeatureEntry>();
private String splashLocation = null;
private String productName = null;
private String application = null;
private String version = null;
private Properties launcherArgs = new Properties();
private final File location;
private List<BundleInfo> bundleInfos;
private Map<String, String> properties;
private boolean includeLaunchers = true;
private String licenseURL;
private String licenseText = null;
private String currentOS;
private static String normalize(String text) {
if (text == null || text.trim().length() == 0)
return ""; //$NON-NLS-1$
StringBuffer result = new StringBuffer(text.length());
boolean haveSpace = false;
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (Character.isWhitespace(c)) {
if (haveSpace)
continue;
haveSpace = true;
result.append(" "); //$NON-NLS-1$
} else {
haveSpace = false;
result.append(c);
}
}
return result.toString();
}
public ProductFile(String location, String os) throws CoreException {
super();
this.currentOS = os;
this.location = new File(location);
try {
parserFactory.setNamespaceAware(true);
parser = parserFactory.newSAXParser();
InputStream in = new BufferedInputStream(new FileInputStream(location));
try {
parser.parse(new InputSource(in), this);
} finally {
try {
in.close();
} catch (IOException e) {
// ignore exception on close (as it was done by Utils.close() before)
}
}
} catch (ParserConfigurationException e) {
throw new CoreException(new Status(IStatus.ERROR, PI_PDEBUILD, EXCEPTION_PRODUCT_FORMAT, NLS.bind(Messages.exception_productParse, location), e));
} catch (SAXException e) {
throw new CoreException(new Status(IStatus.ERROR, PI_PDEBUILD, EXCEPTION_PRODUCT_FORMAT, NLS.bind(Messages.exception_productParse, location), e));
} catch (FileNotFoundException e) {
throw new CoreException(new Status(IStatus.ERROR, PI_PDEBUILD, EXCEPTION_PRODUCT_FILE, NLS.bind(Messages.exception_missingElement, location), null));
} catch (IOException e) {
throw new CoreException(new Status(IStatus.ERROR, PI_PDEBUILD, EXCEPTION_PRODUCT_FORMAT, NLS.bind(Messages.exception_productParse, location), e));
}
}
/**
* Constructs a product file parser.
*/
public ProductFile(String location) throws Exception {
super();
this.location = new File(location);
parserFactory.setNamespaceAware(true);
parser = parserFactory.newSAXParser();
InputStream in = new BufferedInputStream(new FileInputStream(location));
try {
parser.parse(new InputSource(in), this);
} finally {
in.close();
}
parser = null;
}
/**
* Gets the name of the launcher specified in the .product file.
*/
public String getLauncherName() {
return launcherName;
}
/**
* Gets the location of the .product file.
*/
public File getLocation() {
return location;
}
/**
* Returns the properties found in .product file. Properties
* are located in the <configurations> block of the file
*/
public Map<String, String> getConfigurationProperties() {
Map<String, String> result = properties != null ? properties : new HashMap<String, String>();
if (application != null && !result.containsKey(PROPERTY_ECLIPSE_APPLICATION))
result.put(PROPERTY_ECLIPSE_APPLICATION, application);
if (id != null && !result.containsKey(PROPERTY_ECLIPSE_PRODUCT))
result.put(PROPERTY_ECLIPSE_PRODUCT, id);
return result;
}
/**
* Returns a List<VersionedName> for each bundle that makes up this product.
* @param includeFragments Indicates whether or not fragments should
* be included in the list
*/
public List<IVersionedId> getBundles(boolean includeFragments) {
List<IVersionedId> result = new LinkedList<IVersionedId>();
for (FeatureEntry plugin : plugins) {
result.add(new VersionedId(plugin.getId(), plugin.getVersion()));
}
if (includeFragments) {
for (FeatureEntry fragment : fragments) {
result.add(new VersionedId(fragment.getId(), fragment.getVersion()));
}
}
return result;
}
private List<FeatureEntry> getBundleEntries(boolean includeFragments) {
List<FeatureEntry> result = new LinkedList<FeatureEntry>();
result.addAll(plugins);
if (includeFragments)
result.addAll(fragments);
return result;
}
/**
* Returns a List<BundleInfo> for each bundle that has custom configuration data
* in the product file.
* @return A List<BundleInfo>
*/
public List<BundleInfo> getBundleInfos() {
return bundleInfos != null ? bundleInfos : CollectionUtils.<BundleInfo> emptyList();
}
/**
* Returns a list<VersionedName> of fragments that constitute this product.
*/
public List<IVersionedId> getFragments() {
List<IVersionedId> result = new LinkedList<IVersionedId>();
for (FeatureEntry fragment : fragments) {
result.add(new VersionedId(fragment.getId(), fragment.getVersion()));
}
return result;
}
/**
* Returns a List<VersionedName> of features that constitute this product.
*/
public List<IVersionedId> getFeatures() {
List<IVersionedId> result = new LinkedList<IVersionedId>();
for (FeatureEntry feature : features) {
result.add(new VersionedId(feature.getId(), feature.getVersion()));
}
return result;
}
public List<FeatureEntry> getProductEntries() {
if (useFeatures()) {
return features;
}
return getBundleEntries(true);
}
public boolean containsPlugin(String plugin) {
return getBundles(true).contains(plugin);
}
public String[] getIcons() {
return getIcons(currentOS);
}
public String[] getIcons(String os) {
Collection<String> result = icons.get(os);
if (result == null)
return new String[0];
return result.toArray(new String[result.size()]);
}
public String getConfigIniPath(String os) {
String specific = platformSpecificConfigPaths.get(os);
return specific == null ? configPath : specific;
}
public String getConfigIniPath() {
return configPath;
}
public boolean haveCustomConfig() {
return configPath != null || platformSpecificConfigPaths.size() > 0;
}
/**
* Returns the ID for this product.
*/
public String getId() {
if (uid != null)
return uid;
return id;
}
public String getProductId() {
return id;
}
/**
* Returns the location (the bundle) that defines the splash screen
*/
public String getSplashLocation() {
return splashLocation;
}
/**
* Returns the product name.
*/
public String getProductName() {
return productName;
}
/**
* Returns the application identifier for this product.
*/
public String getApplication() {
return application;
}
/**
* Returns true if this product is built using feature,
* false otherwise.
*/
public boolean useFeatures() {
return useFeatures;
}
/**
* Returns the version of the product
*/
public String getVersion() {
return (version == null || version.length() == 0) ? "0.0.0" : version; //$NON-NLS-1$
}
public boolean includeLaunchers() {
return includeLaunchers;
}
public Map<String, BundleInfo> getConfigurationInfo() {
Map<String, BundleInfo> result = new HashMap<String, BundleInfo>();
for (BundleInfo info : getBundleInfos()) {
result.put(info.getSymbolicName(), info);
}
return result;
}
public Properties getConfigProperties() {
Properties props = new Properties();
for (Entry<String, String> property : getConfigurationProperties().entrySet()) {
props.setProperty(property.getKey(), property.getValue());
}
return props;
}
/**
* Returns the VM arguments for a specific platform.
* If the empty string is used for the OS, this returns
* the default VM arguments
*/
public String getVMArguments(String os) {
os = os == null ? "" : os; //$NON-NLS-1$
String key = null;
if (os.equals(OS_WIN32)) {
key = VM_ARGS_WIN;
} else if (os.equals(OS_LINUX)) {
key = VM_ARGS_LINUX;
} else if (os.equals(OS_MACOSX)) {
key = VM_ARGS_MAC;
} else if (os.equals(OS_SOLARIS)) {
key = VM_ARGS_SOLARIS;
}
String prefix = launcherArgs.getProperty(VM_ARGS);
String platform = null, args = null;
if (key != null)
platform = launcherArgs.getProperty(key);
if (prefix != null)
args = platform != null ? prefix + " " + platform : prefix; //$NON-NLS-1$
else
args = platform != null ? platform : ""; //$NON-NLS-1$
return normalize(args);
}
/**
* Returns the program arguments for a specific platform.
* If the empty string is used for the OS, this returns
* the default program arguments
*/
public String getProgramArguments(String os) {
os = os == null ? "" : os; //$NON-NLS-1$
String key = null;
if (os.equals(OS_WIN32)) {
key = PROGRAM_ARGS_WIN;
} else if (os.equals(OS_LINUX)) {
key = PROGRAM_ARGS_LINUX;
} else if (os.equals(OS_MACOSX)) {
key = PROGRAM_ARGS_MAC;
} else if (os.equals(OS_SOLARIS)) {
key = PROGRAM_ARGS_SOLARIS;
}
String prefix = launcherArgs.getProperty(PROGRAM_ARGS);
String platform = null, args = null;
if (key != null)
platform = launcherArgs.getProperty(key);
if (prefix != null)
args = platform != null ? prefix + " " + platform : prefix; //$NON-NLS-1$
else
args = platform != null ? platform : ""; //$NON-NLS-1$
return normalize(args);
}
public String getLicenseText() {
return licenseText;
}
public String getLicenseURL() {
return licenseURL;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) {
switch (state) {
case STATE_START :
if (EL_PRODUCT.equals(localName)) {
processProduct(attributes);
state = STATE_PRODUCT;
}
break;
case STATE_PRODUCT :
if (EL_CONFIG_INI.equals(localName)) {
processConfigIni(attributes);
state = STATE_CONFIG_INI;
} else if (EL_LAUNCHER.equals(localName)) {
processLauncher(attributes);
state = STATE_LAUNCHER;
} else if (EL_PLUGINS.equals(localName)) {
state = STATE_PLUGINS;
} else if (EL_FEATURES.equals(localName)) {
state = STATE_FEATURES;
} else if (EL_LAUNCHER_ARGS.equals(localName)) {
state = STATE_LAUNCHER_ARGS;
} else if (EL_SPLASH.equals(localName)) {
splashLocation = attributes.getValue(ATTRIBUTE_LOCATION);
} else if (EL_CONFIGURATIONS.equals(localName)) {
state = STATE_CONFIGURATIONS;
} else if (EL_LICENSE.equals(localName)) {
state = STATE_LICENSE;
}
break;
case STATE_CONFIG_INI :
processConfigIniPlatform(localName, true);
break;
case STATE_LAUNCHER :
if (OS_SOLARIS.equals(localName)) {
processSolaris(attributes);
} else if ("win".equals(localName)) { //$NON-NLS-1$
processWin(attributes);
} else if (OS_LINUX.equals(localName)) {
processLinux(attributes);
} else if (OS_MACOSX.equals(localName)) {
processMac(attributes);
}
if ("ico".equals(localName)) { //$NON-NLS-1$
processIco(attributes);
} else if ("bmp".equals(localName)) { //$NON-NLS-1$
processBmp(attributes);
}
break;
case STATE_LAUNCHER_ARGS :
if (PROGRAM_ARGS.equals(localName)) {
state = STATE_PROGRAM_ARGS;
} else if (PROGRAM_ARGS_LINUX.equals(localName)) {
state = STATE_PROGRAM_ARGS_LINUX;
} else if (PROGRAM_ARGS_MAC.equals(localName)) {
state = STATE_PROGRAM_ARGS_MAC;
} else if (PROGRAM_ARGS_SOLARIS.equals(localName)) {
state = STATE_PROGRAM_ARGS_SOLARIS;
} else if (PROGRAM_ARGS_WIN.equals(localName)) {
state = STATE_PROGRAM_ARGS_WIN;
} else if (VM_ARGS.equals(localName)) {
state = STATE_VM_ARGS;
} else if (VM_ARGS_LINUX.equals(localName)) {
state = STATE_VM_ARGS_LINUX;
} else if (VM_ARGS_MAC.equals(localName)) {
state = STATE_VM_ARGS_MAC;
} else if (VM_ARGS_SOLARIS.equals(localName)) {
state = STATE_VM_ARGS_SOLARIS;
} else if (VM_ARGS_WIN.equals(localName)) {
state = STATE_VM_ARGS_WIN;
}
break;
case STATE_PLUGINS :
if (EL_PLUGIN.equals(localName)) {
processPlugin(attributes);
}
break;
case STATE_LICENSE :
if (EL_URL.equals(localName)) {
state = STATE_LICENSE_URL;
} else if (EL_TEXT.equals(localName)) {
licenseText = ""; //$NON-NLS-1$
state = STATE_LICENSE_TEXT;
}
break;
case STATE_FEATURES :
if (EL_FEATURE.equals(localName)) {
processFeature(attributes);
}
break;
case STATE_CONFIGURATIONS :
if (EL_PLUGIN.equals(localName)) {
processPluginConfiguration(attributes);
} else if (EL_PROPERTY.equals(localName)) {
processPropertyConfiguration(attributes);
}
break;
}
}
/**
* Processes the property tag in the .product file. These tags contain
* a Name and Value pair. For each tag (with a non-null name), a property
* is created.
*/
private void processPropertyConfiguration(Attributes attributes) {
String name = attributes.getValue(ATTRIBUTE_NAME);
String value = attributes.getValue(ATTRIBUTE_VALUE);
if (name == null)
return;
if (value == null)
value = ""; //$NON-NLS-1$
if (properties == null)
properties = new HashMap<String, String>();
properties.put(name, value);
}
private void processPluginConfiguration(Attributes attributes) {
BundleInfo info = new BundleInfo();
info.setSymbolicName(attributes.getValue(ATTRIBUTE_ID));
info.setVersion(attributes.getValue(ATTRIBUTE_VERSION));
String value = attributes.getValue(ATTRIBUTE_START_LEVEL);
if (value != null) {
int startLevel = Integer.parseInt(value);
if (startLevel > 0)
info.setStartLevel(startLevel);
}
value = attributes.getValue(ATTRIBUTE_AUTO_START);
if (value != null)
info.setMarkedAsStarted(Boolean.valueOf(value).booleanValue());
if (bundleInfos == null)
bundleInfos = new ArrayList<BundleInfo>();
bundleInfos.add(info);
}
@Override
public void endElement(String uri, String localName, String qName) {
switch (state) {
case STATE_PLUGINS :
if (EL_PLUGINS.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_FEATURES :
if (EL_FEATURES.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_LAUNCHER_ARGS :
if (EL_LAUNCHER_ARGS.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_LAUNCHER :
if (EL_LAUNCHER.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_CONFIGURATIONS :
if (EL_CONFIGURATIONS.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_LICENSE :
if (EL_LICENSE.equals(localName))
state = STATE_PRODUCT;
break;
case STATE_PROGRAM_ARGS :
case STATE_PROGRAM_ARGS_LINUX :
case STATE_PROGRAM_ARGS_MAC :
case STATE_PROGRAM_ARGS_SOLARIS :
case STATE_PROGRAM_ARGS_WIN :
case STATE_VM_ARGS :
case STATE_VM_ARGS_LINUX :
case STATE_VM_ARGS_MAC :
case STATE_VM_ARGS_SOLARIS :
case STATE_VM_ARGS_WIN :
state = STATE_LAUNCHER_ARGS;
break;
case STATE_LICENSE_URL :
case STATE_LICENSE_TEXT :
state = STATE_LICENSE;
break;
case STATE_CONFIG_INI :
if (EL_CONFIG_INI.equals(localName))
state = STATE_PRODUCT;
else
processConfigIniPlatform(localName, false);
break;
}
}
@Override
public void characters(char[] ch, int start, int length) {
switch (state) {
case STATE_PROGRAM_ARGS :
addLaunchArgumentToMap(PROGRAM_ARGS, String.valueOf(ch, start, length));
break;
case STATE_PROGRAM_ARGS_LINUX :
addLaunchArgumentToMap(PROGRAM_ARGS_LINUX, String.valueOf(ch, start, length));
break;
case STATE_PROGRAM_ARGS_MAC :
addLaunchArgumentToMap(PROGRAM_ARGS_MAC, String.valueOf(ch, start, length));
break;
case STATE_PROGRAM_ARGS_SOLARIS :
addLaunchArgumentToMap(PROGRAM_ARGS_SOLARIS, String.valueOf(ch, start, length));
break;
case STATE_PROGRAM_ARGS_WIN :
addLaunchArgumentToMap(PROGRAM_ARGS_WIN, String.valueOf(ch, start, length));
break;
case STATE_VM_ARGS :
addLaunchArgumentToMap(VM_ARGS, String.valueOf(ch, start, length));
break;
case STATE_VM_ARGS_LINUX :
addLaunchArgumentToMap(VM_ARGS_LINUX, String.valueOf(ch, start, length));
break;
case STATE_VM_ARGS_MAC :
addLaunchArgumentToMap(VM_ARGS_MAC, String.valueOf(ch, start, length));
break;
case STATE_VM_ARGS_SOLARIS :
addLaunchArgumentToMap(VM_ARGS_SOLARIS, String.valueOf(ch, start, length));
break;
case STATE_VM_ARGS_WIN :
addLaunchArgumentToMap(VM_ARGS_WIN, String.valueOf(ch, start, length));
break;
case STATE_CONFIG_INI :
if (platformConfigPath != null)
platformConfigPath += String.valueOf(ch, start, length);
break;
case STATE_LICENSE_URL :
licenseURL = String.valueOf(ch, start, length);
break;
case STATE_LICENSE_TEXT :
if (licenseText != null)
licenseText += String.valueOf(ch, start, length);
break;
}
}
private void addLaunchArgumentToMap(String key, String value) {
if (launcherArgs == null)
launcherArgs = new Properties();
String oldValue = launcherArgs.getProperty(key);
if (oldValue != null)
launcherArgs.setProperty(key, oldValue + value);
else
launcherArgs.setProperty(key, value);
}
protected void processPlugin(Attributes attributes) {
String fragment = attributes.getValue(ATTRIBUTE_FRAGMENT);
String pluginId = attributes.getValue(ATTRIBUTE_ID);
String pluginVersion = attributes.getValue(ATTRIBUTE_VERSION);
FeatureEntry entry = new FeatureEntry(pluginId, pluginVersion != null ? pluginVersion : GENERIC_VERSION_NUMBER, true);
entry.setFragment(Boolean.valueOf(fragment).booleanValue());
if (fragment != null && new Boolean(fragment).booleanValue()) {
fragments.add(entry);
} else {
plugins.add(entry);
}
}
private void processFeature(Attributes attributes) {
String featureId = attributes.getValue(ATTRIBUTE_ID);
String featureVersion = attributes.getValue(ATTRIBUTE_VERSION);
FeatureEntry featureEntry = new FeatureEntry(featureId, featureVersion != null ? featureVersion : GENERIC_VERSION_NUMBER, false);
features.add(featureEntry);
}
private void processProduct(Attributes attributes) {
id = attributes.getValue(ATTRIBUTE_ID);
uid = attributes.getValue(ATTRIBUTE_UID);
productName = attributes.getValue(ATTRIBUTE_NAME);
application = attributes.getValue(ATTRIBUTE_APPLICATION);
if (attributes.getIndex(ATTRIBUTE_INCLUDE_LAUNCHERS) >= 0)
includeLaunchers = Boolean.valueOf(attributes.getValue(ATTRIBUTE_INCLUDE_LAUNCHERS));
String use = attributes.getValue("useFeatures"); //$NON-NLS-1$
if (use != null)
useFeatures = Boolean.valueOf(use).booleanValue();
version = attributes.getValue(ATTRIBUTE_VERSION);
}
private void processConfigIni(Attributes attributes) {
String path = null;
if ("custom".equals(attributes.getValue("use"))) { //$NON-NLS-1$//$NON-NLS-2$
path = attributes.getValue(ATTRIBUTE_PATH);
}
String os = attributes.getValue("os"); //$NON-NLS-1$
if (os != null && os.length() > 0) {
// TODO should we allow a platform-specific default to over-ride a custom generic path?
if (path != null)
platformSpecificConfigPaths.put(os, path);
} else if (path != null) {
configPath = path;
}
}
private void processConfigIniPlatform(String key, boolean begin) {
if (begin) {
configPlatform = key;
platformConfigPath = ""; //$NON-NLS-1$
} else if (configPlatform.equals(key) && platformConfigPath.length() > 0) {
platformSpecificConfigPaths.put(key, platformConfigPath);
platformConfigPath = null;
}
}
private void processLauncher(Attributes attributes) {
launcherName = attributes.getValue(ATTRIBUTE_NAME);
}
private void addIcon(String os, String value) {
if (value == null)
return;
File iconFile = new File(value);
if (!iconFile.isFile()) {
//workspace
Location instanceLocation = (Location) ServiceHelper.getService(Activator.getContext(), Location.class.getName(), Location.INSTANCE_FILTER);
if (instanceLocation != null && instanceLocation.getURL() != null) {
File workspace = URLUtil.toFile(instanceLocation.getURL());
if (workspace != null)
iconFile = new File(workspace, value);
}
}
if (!iconFile.isFile())
iconFile = new File(location.getParentFile(), value);
Collection<String> list = icons.get(os);
if (list == null) {
list = new ArrayList<String>(6);
icons.put(os, list);
}
list.add(iconFile.getAbsolutePath());
}
private void processSolaris(Attributes attributes) {
addIcon(OS_SOLARIS, attributes.getValue(SOLARIS_LARGE));
addIcon(OS_SOLARIS, attributes.getValue(SOLARIS_MEDIUM));
addIcon(OS_SOLARIS, attributes.getValue(SOLARIS_SMALL));
addIcon(OS_SOLARIS, attributes.getValue(SOLARIS_TINY));
}
private void processWin(Attributes attributes) {
// useIco = Boolean.valueOf(attributes.getValue(P_USE_ICO)).booleanValue();
}
private void processIco(Attributes attributes) {
addIcon(OS_WIN32, attributes.getValue(ATTRIBUTE_PATH));
}
private void processBmp(Attributes attributes) {
addIcon(OS_WIN32, attributes.getValue(WIN32_16_HIGH));
addIcon(OS_WIN32, attributes.getValue(WIN32_16_LOW));
addIcon(OS_WIN32, attributes.getValue(WIN32_24_LOW));
addIcon(OS_WIN32, attributes.getValue(WIN32_32_HIGH));
addIcon(OS_WIN32, attributes.getValue(WIN32_32_LOW));
addIcon(OS_WIN32, attributes.getValue(WIN32_48_HIGH));
addIcon(OS_WIN32, attributes.getValue(WIN32_48_LOW));
}
private void processLinux(Attributes attributes) {
addIcon(OS_LINUX, attributes.getValue(ATTRIBUTE_ICON));
}
private void processMac(Attributes attributes) {
addIcon(OS_MACOSX, attributes.getValue(ATTRIBUTE_ICON));
}
}