public URL getResource(final String name) {
URL url = null;
if (this.isParentFirst(name)) {
url = ((this.parent == null) ? super.getResource(name) : this.parent.getResource(name));
}
if (url != null) {
this.log("Resource " + name + " loaded from parent loader", 4);
} else {
final Enumeration<File> e = this.pathComponents.elements();
while (e.hasMoreElements() && url == null) {
final File pathComponent = e.nextElement();
url = this.getResourceURL(pathComponent, name);
if (url != null) {
this.log("Resource " + name + " loaded from ant loader", 4);
}
}
}
if (url == null && !this.isParentFirst(name)) {
if (this.ignoreBase) {
url = ((this.getRootLoader() == null) ? null : this.getRootLoader().getResource(name));
} else {
url = ((this.parent == null) ? super.getResource(name) : this.parent.getResource(name));
}
if (url != null) {
this.log("Resource " + name + " loaded from parent loader", 4);
}
}
if (url == null) {
this.log("Couldn't load Resource " + name, 4);
}
return url;
}
protected void unpackComponents() throws IOException, FileNotFoundException {
File applicationPackage = new File(getApplication().getPackageResourcePath());
File componentsDir = new File(sGREDir, "components");
if (componentsDir.lastModified() == applicationPackage.lastModified()) return;
componentsDir.mkdir();
componentsDir.setLastModified(applicationPackage.lastModified());
GeckoAppShell.killAnyZombies();
ZipFile zip = new ZipFile(applicationPackage);
byte[] buf = new byte[32768];
try {
if (unpackFile(zip, buf, null, "removed-files")) removeFiles();
} catch (Exception ex) {
// This file may not be there, so just log any errors and move on
Log.w(LOG_FILE_NAME, "error removing files", ex);
}
// copy any .xpi file into an extensions/ directory
Enumeration<? extends ZipEntry> zipEntries = zip.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = zipEntries.nextElement();
if (entry.getName().startsWith("extensions/") && entry.getName().endsWith(".xpi")) {
Log.i("GeckoAppJava", "installing extension : " + entry.getName());
unpackFile(zip, buf, entry, entry.getName());
}
}
}
protected void load(ZipFile zipfile) throws IOException {
Enumeration entries = zipfile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
fireBeginFile(entry.getName());
Logger.getLogger(getClass())
.debug("Starting file " + entry.getName() + " (" + entry.getSize() + " bytes)");
byte[] bytes = null;
InputStream in = null;
try {
in = zipfile.getInputStream(entry);
bytes = readBytes(in);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ex) {
// Ignore
}
}
}
Logger.getLogger(getClass())
.debug("Passing up file " + entry.getName() + " (" + bytes.length + " bytes)");
getLoader().load(entry.getName(), new ByteArrayInputStream(bytes));
fireEndFile(entry.getName());
}
}
private Class<?> findClassInComponents(final String name) throws ClassNotFoundException {
final String classFilename = this.getClassFilename(name);
final Enumeration<File> e = this.pathComponents.elements();
while (e.hasMoreElements()) {
final File pathComponent = e.nextElement();
InputStream stream = null;
try {
stream = this.getResourceStream(pathComponent, classFilename);
if (stream != null) {
this.log("Loaded from " + pathComponent + " " + classFilename, 4);
return this.getClassFromStream(stream, name, pathComponent);
}
continue;
} catch (SecurityException se) {
throw se;
} catch (IOException ioe) {
this.log(
"Exception reading component " + pathComponent + " (reason: " + ioe.getMessage() + ")",
3);
} finally {
FileUtils.close(stream);
}
}
throw new ClassNotFoundException(name);
}
/** Lists contents of JAR file, via ZipFile. */
void list(String fname, String files[]) throws IOException {
ZipFile zf = new ZipFile(fname);
Enumeration<? extends ZipEntry> zes = zf.entries();
while (zes.hasMoreElements()) {
printEntry(zes.nextElement(), files);
}
zf.close();
}
public void addJavaLibraries() {
final Vector<String> packages = JavaEnvUtils.getJrePackages();
final Enumeration<String> e = packages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
this.addSystemPackageRoot(packageName);
}
}
private InputStream loadResource(final String name) {
InputStream stream = null;
File pathComponent;
for (Enumeration<File> e = this.pathComponents.elements();
e.hasMoreElements() && stream == null;
stream = this.getResourceStream(pathComponent, name)) {
pathComponent = e.nextElement();
}
return stream;
}
private void index() throws IOException {
Enumeration entries = _jar.entries();
_nameToEntryMap = new HashMap();
_crcToEntryMap = new HashMap();
_entries = new ArrayList();
if (_debug) {
System.out.println("indexing: " + _jar.getName());
}
if (entries != null) {
while (entries.hasMoreElements()) {
JarEntry entry = (JarEntry) entries.nextElement();
long crc = entry.getCrc();
Long crcL = new Long(crc);
if (_debug) {
System.out.println("\t" + entry.getName() + " CRC " + crc);
}
_nameToEntryMap.put(entry.getName(), entry);
_entries.add(entry);
// generate the CRC to entries map
if (_crcToEntryMap.containsKey(crcL)) {
// key exist, add the entry to the correcponding
// linked list
// get the linked list
LinkedList ll = (LinkedList) _crcToEntryMap.get(crcL);
// put in the new entry
ll.add(entry);
// put it back in the hash map
_crcToEntryMap.put(crcL, ll);
} else {
// create a new entry in the hashmap for the new key
// first create the linked list and put in the new
// entry
LinkedList ll = new LinkedList();
ll.add(entry);
// create the new entry in the hashmap
_crcToEntryMap.put(crcL, ll);
}
}
}
}
public String getClasspath() {
final StringBuilder sb = new StringBuilder();
boolean firstPass = true;
final Enumeration<File> componentEnum = this.pathComponents.elements();
while (componentEnum.hasMoreElements()) {
if (!firstPass) {
sb.append(System.getProperty("path.separator"));
} else {
firstPass = false;
}
sb.append(componentEnum.nextElement().getAbsolutePath());
}
return sb.toString();
}
// Take a tree of files starting in a directory in a zip file
// and copy them to a disk directory, recreating the tree.
private int unpackZipFile(
File inZipFile, String directory, String parent, boolean suppressFirstPathElement) {
int count = 0;
if (!inZipFile.exists()) return count;
parent = parent.trim();
if (!parent.endsWith(File.separator)) parent += File.separator;
if (!directory.endsWith(File.separator)) directory += File.separator;
File outFile = null;
try {
ZipFile zipFile = new ZipFile(inZipFile);
Enumeration zipEntries = zipFile.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) zipEntries.nextElement();
String name = entry.getName().replace('/', File.separatorChar);
if (name.startsWith(directory)) {
if (suppressFirstPathElement) name = name.substring(directory.length());
outFile = new File(parent + name);
// Create the directory, just in case
if (name.indexOf(File.separatorChar) >= 0) {
String p = name.substring(0, name.lastIndexOf(File.separatorChar) + 1);
File dirFile = new File(parent + p);
dirFile.mkdirs();
}
if (!entry.isDirectory()) {
System.out.println("Installing " + outFile);
// Copy the file
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFile));
BufferedInputStream in = new BufferedInputStream(zipFile.getInputStream(entry));
int size = 1024;
int n = 0;
byte[] b = new byte[size];
while ((n = in.read(b, 0, size)) != -1) out.write(b, 0, n);
in.close();
out.flush();
out.close();
// Count the file
count++;
}
}
}
zipFile.close();
} catch (Exception e) {
System.err.println("...an error occured while installing " + outFile);
e.printStackTrace();
System.err.println("Error copying " + outFile.getName() + "\n" + e.getMessage());
return -count;
}
System.out.println(count + " files were installed.");
return count;
}
public synchronized void cleanup() {
final Enumeration<JarFile> e = this.jarFiles.elements();
while (e.hasMoreElements()) {
final JarFile jarFile = e.nextElement();
try {
jarFile.close();
} catch (IOException ex) {
}
}
this.jarFiles = new Hashtable<File, JarFile>();
if (this.project != null) {
this.project.removeBuildListener(this);
}
this.project = null;
}
public static String[] getZipList(String zipFile) throws ZipException, IOException {
File file = new File(zipFile);
ZipFile zip = new ZipFile(file);
Enumeration<? extends ZipEntry> zipFileEntries = zip.entries();
ArrayList<String> files = new ArrayList<String>();
// Process each entry
while (zipFileEntries.hasMoreElements()) {
// grab a zip file entry
ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
String currentEntry = entry.getName();
files.add(currentEntry);
}
return files.toArray(new String[files.size()]);
}
private boolean isParentFirst(final String resourceName) {
boolean useParentFirst = this.parentFirst;
Enumeration<String> e = this.systemPackages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
if (resourceName.startsWith(packageName)) {
useParentFirst = true;
break;
}
}
e = this.loaderPackages.elements();
while (e.hasMoreElements()) {
final String packageName = e.nextElement();
if (resourceName.startsWith(packageName)) {
useParentFirst = false;
break;
}
}
return useParentFirst;
}
public static void extract(String zipFile, String newPath, boolean overwrite)
throws ZipException, IOException {
File file = new File(zipFile);
ZipFile zip = new ZipFile(file);
new File(newPath).mkdir();
Enumeration<? extends ZipEntry> zipFileEntries = zip.entries();
// Process each entry
while (zipFileEntries.hasMoreElements()) {
// grab a zip file entry
ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
String currentEntry = entry.getName();
File destFile = new File(newPath, currentEntry);
// destFile = new File(newPath, destFile.getName());
File destinationParent = destFile.getParentFile();
// create the parent directory structure if needed
destinationParent.mkdirs();
if (!entry.isDirectory()) {
if (!overwrite && destFile.exists()) continue;
BufferedInputStream is = new BufferedInputStream(zip.getInputStream(entry));
int currentByte;
// establish buffer for writing file
byte data[] = new byte[BUFFER];
// write the current file to disk
FileOutputStream fos = new FileOutputStream(destFile);
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
// read and write until last byte is encountered
while ((currentByte = is.read(data, 0, BUFFER)) != -1) {
dest.write(data, 0, currentByte);
}
close(dest);
close(is);
}
}
}
public void init(FilterConfig filterConfig) {
this.config = filterConfig;
this.encoding = config.getInitParameter("encoding");
if (encoding == null || encoding.length() == 0) {
encoding = "GBK";
}
expiresMap = new HashMap();
Enumeration names = config.getInitParameterNames();
while (names.hasMoreElements()) {
String paramName = (String) names.nextElement();
if (!"encoding".equals(paramName)) {
String paramValue = config.getInitParameter(paramName);
try {
Integer expires = Integer.valueOf(config.getInitParameter(paramName));
expiresMap.put(paramName, expires);
} catch (Exception ex) {
// LogUtil.logError( "Filter."+paramValue+"="+paramValue);
}
}
}
}
protected void loadAirspacesFromPath(String path, Collection<Airspace> airspaces) {
File file = ExampleUtil.saveResourceToTempFile(path, ".zip");
if (file == null) return;
try {
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = null;
for (Enumeration<? extends ZipEntry> e = zipFile.entries();
e.hasMoreElements();
entry = e.nextElement()) {
if (entry == null) continue;
String name = WWIO.getFilename(entry.getName());
if (!(name.startsWith("gov.nasa.worldwind.render.airspaces") && name.endsWith(".xml")))
continue;
String[] tokens = name.split("-");
try {
Class c = Class.forName(tokens[0]);
Airspace airspace = (Airspace) c.newInstance();
BufferedReader input =
new BufferedReader(new InputStreamReader(zipFile.getInputStream(entry)));
String s = input.readLine();
airspace.restoreState(s);
airspaces.add(airspace);
if (tokens.length >= 2) {
airspace.setValue(AVKey.DISPLAY_NAME, tokens[1]);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
/** Extracts specified entries from JAR file, via ZipFile. */
void extract(String fname, String files[]) throws IOException {
ZipFile zf = new ZipFile(fname);
Set<ZipEntry> dirs = newDirSet();
Enumeration<? extends ZipEntry> zes = zf.entries();
while (zes.hasMoreElements()) {
ZipEntry e = zes.nextElement();
InputStream is;
if (files == null) {
dirs.add(extractFile(zf.getInputStream(e), e));
} else {
String name = e.getName();
for (String file : files) {
if (name.startsWith(file)) {
dirs.add(extractFile(zf.getInputStream(e), e));
break;
}
}
}
}
zf.close();
updateLastModifiedTime(dirs);
}
/**
* Unzips the transferred file. Returns <code>true</code> if the unzip was successful, and <code>
* false</code> otherwise. In case of failure, this method handles setting an appropriate
* response.
*/
private boolean completeUnzip(HttpServletRequest req, HttpServletResponse resp)
throws ServletException {
IPath destPath = new Path(getPath());
try {
ZipFile source = new ZipFile(new File(getStorageDirectory(), FILE_DATA));
IFileStore destinationRoot = NewFileServlet.getFileStore(destPath);
Enumeration<? extends ZipEntry> entries = source.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
IFileStore destination = destinationRoot.getChild(entry.getName());
if (entry.isDirectory()) destination.mkdir(EFS.NONE, null);
else {
destination.getParent().mkdir(EFS.NONE, null);
IOUtilities.pipe(
source.getInputStream(entry),
destination.openOutputStream(EFS.NONE, null),
false,
true);
}
}
source.close();
} catch (ZipException e) {
// zip exception implies client sent us invalid input
String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString());
statusHandler.handleRequest(
req, resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, e));
return false;
} catch (Exception e) {
// other failures should be considered server errors
String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString());
statusHandler.handleRequest(
req,
resp,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, e));
return false;
}
return true;
}
// =============================================================================
/** initializes internal hash tables with Jar file resources. */
private byte[] read(String name) {
try {
// extracts just sizes only.
ZipFile zf = new ZipFile(jarFileName);
Enumeration e = zf.entries();
while (e.hasMoreElements()) {
ZipEntry ze = (ZipEntry) e.nextElement();
if (debugOn) {
System.out.println(dumpZipEntry(ze));
}
htSizes.put(ze.getName(), new Integer((int) ze.getSize()));
}
zf.close();
// extract resources and put them into the hashtable.
FileInputStream fis = new FileInputStream(jarFileName);
BufferedInputStream bis = new BufferedInputStream(fis);
ZipInputStream zis = new ZipInputStream(bis);
ZipEntry ze = null;
while ((ze = zis.getNextEntry()) != null) {
if (ze.isDirectory()) {
continue;
}
if (debugOn) {
System.out.println("ze.getName()=" + ze.getName() + "," + "getSize()=" + ze.getSize());
}
int size = (int) ze.getSize();
// -1 means unknown size.
if (size == -1) {
size = ((Integer) htSizes.get(ze.getName())).intValue();
}
byte[] b = new byte[(int) size];
int rb = 0;
int chunk = 0;
while (((int) size - rb) > 0) {
chunk = zis.read(b, rb, (int) size - rb);
if (chunk == -1) {
break;
}
rb += chunk;
}
if (debugOn) {
System.out.println(
ze.getName() + " rb=" + rb + ",size=" + size + ",csize=" + ze.getCompressedSize());
}
if (ze.getName().equals(name)) {
return b;
}
}
} catch (NullPointerException e) {
System.out.println("done.");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private void prepareToDraw() {
if (forwardSlot0 != null) {
forwardSlot0.setCgview(p);
forwardSlot0.setFeatureThickness(featureThickness);
}
if (forwardSlot1 != null) {
forwardSlot1.setCgview(p);
forwardSlot1.setFeatureThickness(featureThickness);
}
if (forwardSlot2 != null) {
forwardSlot2.setCgview(p);
forwardSlot2.setFeatureThickness(featureThickness);
}
if (forwardSlot3 != null) {
forwardSlot3.setCgview(p);
forwardSlot3.setFeatureThickness(featureThickness);
}
if (forwardSlot4 != null) {
forwardSlot4.setCgview(p);
forwardSlot4.setFeatureThickness(featureThickness);
}
if (forwardSlot5 != null) {
forwardSlot5.setCgview(p);
forwardSlot5.setFeatureThickness(featureThickness);
}
if (forwardSlot6 != null) {
forwardSlot6.setCgview(p);
forwardSlot6.setFeatureThickness(featureThickness);
}
if (forwardSlot7 != null) {
forwardSlot7.setCgview(p);
forwardSlot7.setFeatureThickness(featureThickness);
}
if (reverseSlot0 != null) {
reverseSlot0.setCgview(p);
reverseSlot0.setFeatureThickness(featureThickness);
}
if (reverseSlot1 != null) {
reverseSlot1.setCgview(p);
reverseSlot1.setFeatureThickness(featureThickness);
}
if (reverseSlot2 != null) {
reverseSlot2.setCgview(p);
reverseSlot2.setFeatureThickness(featureThickness);
}
if (reverseSlot3 != null) {
reverseSlot3.setCgview(p);
reverseSlot3.setFeatureThickness(featureThickness);
}
if (reverseSlot4 != null) {
reverseSlot4.setCgview(p);
reverseSlot4.setFeatureThickness(featureThickness);
}
if (reverseSlot5 != null) {
reverseSlot5.setCgview(p);
reverseSlot5.setFeatureThickness(featureThickness);
}
if (reverseSlot6 != null) {
reverseSlot6.setCgview(p);
reverseSlot6.setFeatureThickness(featureThickness);
}
if (reverseSlot7 != null) {
reverseSlot7.setCgview(p);
reverseSlot7.setFeatureThickness(featureThickness);
}
if (restrictionSlot != null) {
restrictionSlot.setCgview(p);
restrictionSlot.setFeatureThickness(featureThickness);
}
// send settings to p
if (showTitle) {
p.setTitle(title);
}
p.setWidth(imageWidth);
p.setHeight(imageHeight);
p.setLabelsToKeep(MAXLABELS);
p.setDrawTickMarks(drawTickMarks);
p.setTitleFont(titleFont);
p.setLabelFont(labelFont);
p.setFeatureThickness(featureThickness);
p.setBackboneThickness(backboneThickness);
p.setFeatureSlotSpacing(featureSpacing);
p.setLegendFont(legendFont);
p.setTickLength(tickLength);
p.setLabelLineLength(labelLineLength);
p.setLabelPlacementQuality(labelPlacementQuality);
p.setUseColoredLabelBackgrounds(useColoredLabelBackground);
p.setShowBorder(showBorder);
p.setShowShading(showShading);
p.setShadingProportion(shadingProportion);
p.setUseInnerLabels(useInnerLabels);
p.setMoveInnerLabelsToOuter(moveInnerLabelsToOuter);
p.setWarningFont(rulerFont);
p.setRulerFont(rulerFont);
// if not drawing labels, don't show message.
if (!(showLabels)) {
p.setShowWarning(false);
}
// set backboneRadius based on smallest image dimension
int smallestDimension = Math.min(imageWidth, imageHeight);
if (smallestDimension <= 750) {
p.setBackboneRadius(0.50d * (double) smallestDimension / 2.0d);
} else {
p.setBackboneRadius(0.50d * 750.0d / 2.0d);
}
// check coloredLabels
if (!(useColoredLabels)) {
if (colorScheme == REGULAR) {
p.setGlobalLabelColor((Color) MAP_ITEM_COLORS.get("titleFont"));
} else if (colorScheme == INVERSE) {
p.setGlobalLabelColor((Color) MAP_ITEM_COLORS_INVERSE.get("titleFont"));
}
}
// set map item colors
if (colorScheme == REGULAR) {
p.setLongTickColor((Color) MAP_ITEM_COLORS.get("tick"));
p.setShortTickColor((Color) MAP_ITEM_COLORS.get("partialTick"));
p.setZeroTickColor((Color) MAP_ITEM_COLORS.get("zeroLine"));
p.setRulerFontColor((Color) MAP_ITEM_COLORS.get("rulerFont"));
p.setBackboneColor((Color) MAP_ITEM_COLORS.get("backbone"));
p.setTitleFontColor((Color) MAP_ITEM_COLORS.get("titleFont"));
p.setWarningFontColor((Color) MAP_ITEM_COLORS.get("titleFont"));
p.setBackgroundColor((Color) MAP_ITEM_COLORS.get("background"));
} else if (colorScheme == INVERSE) {
p.setLongTickColor((Color) MAP_ITEM_COLORS_INVERSE.get("tick"));
p.setShortTickColor((Color) MAP_ITEM_COLORS_INVERSE.get("partialTick"));
p.setZeroTickColor((Color) MAP_ITEM_COLORS_INVERSE.get("zeroLine"));
p.setRulerFontColor((Color) MAP_ITEM_COLORS_INVERSE.get("rulerFont"));
p.setBackboneColor((Color) MAP_ITEM_COLORS_INVERSE.get("backbone"));
p.setTitleFontColor((Color) MAP_ITEM_COLORS_INVERSE.get("titleFont"));
p.setWarningFontColor((Color) MAP_ITEM_COLORS_INVERSE.get("titleFont"));
p.setBackgroundColor((Color) MAP_ITEM_COLORS_INVERSE.get("background"));
}
// build legend
if ((showLegend) && (DRAW_LEGEND_ITEMS.size() > 0)) {
// create legend
legend = new Legend(p);
legend.setAllowLabelClash(allowLabelClashLegend);
legend.setBackgroundOpacity(0.5f);
legend.setFont(legendFont);
legend.setPosition(legendPosition);
if (colorScheme == REGULAR) {
legend.setBackgroundColor((Color) MAP_ITEM_COLORS.get("background"));
legend.setFontColor((Color) MAP_ITEM_COLORS.get("titleFont"));
} else if (colorScheme == INVERSE) {
legend.setBackgroundColor((Color) MAP_ITEM_COLORS_INVERSE.get("background"));
legend.setFontColor((Color) MAP_ITEM_COLORS_INVERSE.get("titleFont"));
}
LegendItem legendItem;
Enumeration legendEntries = DRAW_LEGEND_ITEMS.keys();
ArrayList list = new ArrayList();
while (legendEntries.hasMoreElements()) {
list.add(legendEntries.nextElement());
}
Collections.sort(list);
Iterator i = list.iterator();
while (i.hasNext()) {
String key = (String) i.next();
legendItem = new LegendItem(legend);
legendItem.setDrawSwatch(SWATCH_SHOW);
legendItem.setLabel((String) LEGEND_ITEM_NAMES.get(key));
if (colorScheme == REGULAR) {
legendItem.setSwatchColor((Color) FEATURE_COLORS.get(key));
} else if (colorScheme == INVERSE) {
legendItem.setSwatchColor((Color) FEATURE_COLORS_INVERSE.get(key));
}
}
}
// set message
if (showMessage) {
legend = new Legend(p);
legend.setAllowLabelClash(false);
legend.setBackgroundOpacity(0.5f);
legend.setFont(messageFont);
legend.setPosition(LEGEND_LOWER_RIGHT);
LegendItem legendItem;
if (colorScheme == REGULAR) {
legend.setBackgroundColor((Color) MAP_ITEM_COLORS.get("background"));
legend.setFontColor((Color) MAP_ITEM_COLORS.get("titleFont"));
legendItem = new LegendItem(legend);
legendItem.setLabel(message);
legendItem.setDrawSwatch(SWATCH_NO_SHOW);
} else if (colorScheme == INVERSE) {
legend.setBackgroundColor((Color) MAP_ITEM_COLORS_INVERSE.get("background"));
legend.setFontColor((Color) MAP_ITEM_COLORS_INVERSE.get("titleFont"));
legendItem = new LegendItem(legend);
legendItem.setLabel(message);
legendItem.setDrawSwatch(SWATCH_NO_SHOW);
}
}
}
