package com.swtdesigner;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* Utility class for managing OS resources associated with SWT controls such as colors, fonts, images, etc.
* <p>
* !!! IMPORTANT !!! Application code must explicitly invoke the <code>dispose()</code> method to release the operating
* system resources managed by cached objects when those objects and OS resources are no longer needed (e.g. on
* application shutdown)
* <p>
* This class may be freely distributed as part of any application or plugin.
* <p>
* Copyright (c) 2003 - 2007, Instantiations, Inc. <br>
* All Rights Reserved
*
* @author scheglov_ke
* @author Dan Rubel
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public class SWTResourceManager
{
// //////////////////////////////////////////////////////////////////////////
//
// Color
//
// //////////////////////////////////////////////////////////////////////////
private static Map/* <RGB,Color> */ m_colorMap = new HashMap();
/**
* Returns the system {@link Color} matching the specific ID.
*
* @param systemColorID
* the ID value for the color
* @return the system {@link Color} matching the specific ID
*/
public static Color getColor(int systemColorID)
{
Display display = Display.getCurrent();
return display.getSystemColor(systemColorID);
}
/**
* Returns a {@link Color} given its red, green and blue component values.
*
* @param r
* the red component of the color
* @param g
* the green component of the color
* @param b
* the blue component of the color
* @return the {@link Color} matching the given red, green and blue component values
*/
public static Color getColor(int r, int g, int b)
{
return getColor(new RGB(r, g, b));
}
/**
* Returns a {@link Color} given its RGB value.
*
* @param rgb
* the {@link RGB} value of the color
* @return the {@link Color} matching the RGB value
*/
public static Color getColor(RGB rgb)
{
Color color = (Color)m_colorMap.get(rgb);
if (color == null)
{
Display display = Display.getCurrent();
color = new Color(display, rgb);
m_colorMap.put(rgb, color);
}
return color;
}
/**
* Dispose of all the cached {@link Color}'s.
*/
public static void disposeColors()
{
for (Iterator I = m_colorMap.values().iterator(); I.hasNext();)
{
((Color)I.next()).dispose();
}
m_colorMap.clear();
}
// //////////////////////////////////////////////////////////////////////////
//
// Image
//
// //////////////////////////////////////////////////////////////////////////
/**
* Maps image paths to images.
*/
private static Map/* <String,Image> */ m_imageMap = new HashMap();
/**
* Returns an {@link Image} encoded by the specified {@link InputStream}.
*
* @param stream
* the {@link InputStream} encoding the image data
* @return the {@link Image} encoded by the specified input stream
*/
protected static Image getImage(InputStream stream) throws IOException
{
try
{
Display display = Display.getCurrent();
ImageData data = new ImageData(stream);
if (data.transparentPixel > 0)
{
return new Image(display, data, data.getTransparencyMask());
}
return new Image(display, data);
}
finally
{
stream.close();
}
}
/**
* Returns an {@link Image} stored in the file at the specified path.
*
* @param path
* the path to the image file
* @return the {@link Image} stored in the file at the specified path
*/
public static Image getImage(String path)
{
Image image = (Image)m_imageMap.get(path);
if (image == null)
{
try
{
image = getImage(new FileInputStream(path));
m_imageMap.put(path, image);
}
catch (Exception e)
{
image = getMissingImage();
m_imageMap.put(path, image);
}
}
return image;
}
/**
* Returns an {@link Image} stored in the file at the specified path relative to the specified class.
*
* @param clazz
* the {@link Class} relative to which to find the image
* @param path
* the path to the image file, if starts with <code>'/'</code>
* @return the {@link Image} stored in the file at the specified path
*/
public static Image getImage(Class clazz, String path)
{
String key = clazz.getName() + '|' + path;
Image image = (Image)m_imageMap.get(key);
if (image == null)
{
try
{
image = getImage(clazz.getResourceAsStream(path));
m_imageMap.put(key, image);
}
catch (Exception e)
{
image = getMissingImage();
m_imageMap.put(key, image);
}
}
return image;
}
private static final int MISSING_IMAGE_SIZE = 10;
/**
* @return the small {@link Image} that can be used as placeholder for missing image.
*/
private static Image getMissingImage()
{
Image image = new Image(Display.getCurrent(), MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
GC gc = new GC(image);
gc.setBackground(getColor(SWT.COLOR_RED));
gc.fillRectangle(0, 0, MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
gc.dispose();
return image;
}
/**
* Style constant for placing decorator image in top left corner of base image.
*/
public static final int TOP_LEFT = 1;
/**
* Style constant for placing decorator image in top right corner of base image.
*/
public static final int TOP_RIGHT = 2;
/**
* Style constant for placing decorator image in bottom left corner of base image.
*/
public static final int BOTTOM_LEFT = 3;
/**
* Style constant for placing decorator image in bottom right corner of base image.
*/
public static final int BOTTOM_RIGHT = 4;
/**
* Internal value.
*/
protected static final int LAST_CORNER_KEY = 5;
/**
* Maps images to decorated images.
*/
private static Map[]/* <Image,Map<Image,Image>> */ m_decoratedImageMap = new Map[LAST_CORNER_KEY];
/**
* Returns an {@link Image} composed of a base image decorated by another image.
*
* @param baseImage
* the base {@link Image} that should be decorated
* @param decorator
* the {@link Image} to decorate the base image
* @return {@link Image} The resulting decorated image
*/
public static Image decorateImage(Image baseImage, Image decorator)
{
return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
}
/**
* Returns an {@link Image} composed of a base image decorated by another image.
*
* @param baseImage
* the base {@link Image} that should be decorated
* @param decorator
* the {@link Image} to decorate the base image
* @param corner
* the corner to place decorator image
* @return the resulting decorated {@link Image}
*/
public static Image decorateImage(final Image baseImage, final Image decorator, final int corner)
{
if (corner <= 0 || corner >= LAST_CORNER_KEY)
{
throw new IllegalArgumentException("Wrong decorate corner");
}
Map cornerDecoratedImageMap = m_decoratedImageMap[corner];
if (cornerDecoratedImageMap == null)
{
cornerDecoratedImageMap = new HashMap();
m_decoratedImageMap[corner] = cornerDecoratedImageMap;
}
Map decoratedMap = (Map)cornerDecoratedImageMap.get(baseImage);
if (decoratedMap == null)
{
decoratedMap = new HashMap();
cornerDecoratedImageMap.put(baseImage, decoratedMap);
}
Image result = (Image)decoratedMap.get(decorator);
if (result == null)
{
Rectangle bib = baseImage.getBounds();
Rectangle dib = decorator.getBounds();
result = new Image(Display.getCurrent(), bib.width, bib.height);
GC gc = new GC(result);
gc.drawImage(baseImage, 0, 0);
if (corner == TOP_LEFT)
{
gc.drawImage(decorator, 0, 0);
}
else if (corner == TOP_RIGHT)
{
gc.drawImage(decorator, bib.width - dib.width, 0);
}
else if (corner == BOTTOM_LEFT)
{
gc.drawImage(decorator, 0, bib.height - dib.height);
}
else if (corner == BOTTOM_RIGHT)
{
gc.drawImage(decorator, bib.width - dib.width, bib.height - dib.height);
}
gc.dispose();
decoratedMap.put(decorator, result);
}
return result;
}
/**
* Dispose all of the cached {@link Image}'s.
*/
public static void disposeImages()
{
// dispose loaded images
{
for (Iterator I = m_imageMap.values().iterator(); I.hasNext();)
{
((Image)I.next()).dispose();
}
m_imageMap.clear();
}
// dispose decorated images
for (int i = 0; i < m_decoratedImageMap.length; i++)
{
Map cornerDecoratedImageMap = m_decoratedImageMap[i];
if (cornerDecoratedImageMap != null)
{
for (Iterator I = cornerDecoratedImageMap.values().iterator(); I.hasNext();)
{
Map decoratedMap = (Map)I.next();
for (Iterator J = decoratedMap.values().iterator(); J.hasNext();)
{
Image image = (Image)J.next();
image.dispose();
}
decoratedMap.clear();
}
cornerDecoratedImageMap.clear();
}
}
}
// //////////////////////////////////////////////////////////////////////////
//
// Font
//
// //////////////////////////////////////////////////////////////////////////
/**
* Maps font names to fonts.
*/
private static Map/* <String,Font> */ m_fontMap = new HashMap();
/**
* Maps fonts to their bold versions.
*/
private static Map/* <Font,Font> */ m_fontToBoldFontMap = new HashMap();
/**
* Returns a {@link Font} based on its name, height and style.
*
* @param name
* the name of the font
* @param height
* the height of the font
* @param style
* the style of the font
* @return {@link Font} The font matching the name, height and style
*/
public static Font getFont(String name, int height, int style)
{
return getFont(name, height, style, false, false);
}
/**
* Returns a {@link Font} based on its name, height and style. Windows-specific strikeout and underline flags are also
* supported.
*
* @param name
* the name of the font
* @param size
* the size of the font
* @param style
* the style of the font
* @param strikeout
* the strikeout flag (warning: Windows only)
* @param underline
* the underline flag (warning: Windows only)
* @return {@link Font} The font matching the name, height, style, strikeout and underline
*/
public static Font getFont(String name, int size, int style, boolean strikeout, boolean underline)
{
String fontName = name + '|' + size + '|' + style + '|' + strikeout + '|' + underline;
Font font = (Font)m_fontMap.get(fontName);
if (font == null)
{
FontData fontData = new FontData(name, size, style);
if (strikeout || underline)
{
try
{
Class logFontClass = Class.forName("org.eclipse.swt.internal.win32.LOGFONT"); //$NON-NLS-1$
Object logFont = FontData.class.getField("data").get(fontData); //$NON-NLS-1$
if (logFont != null && logFontClass != null)
{
if (strikeout)
{
logFontClass.getField("lfStrikeOut").set(logFont, new Byte((byte)1)); //$NON-NLS-1$
}
if (underline)
{
logFontClass.getField("lfUnderline").set(logFont, new Byte((byte)1)); //$NON-NLS-1$
}
}
}
catch (Throwable e)
{
IOUtil.ERR().println("Unable to set underline or strikeout" + " (probably on a non-Windows platform). " + e); //$NON-NLS-1$ //$NON-NLS-2$
}
}
font = new Font(Display.getCurrent(), fontData);
m_fontMap.put(fontName, font);
}
return font;
}
/**
* Returns a bold version of the given {@link Font}.
*
* @param baseFont
* the {@link Font} for which a bold version is desired
* @return the bold version of the given {@link Font}
*/
public static Font getBoldFont(Font baseFont)
{
Font font = (Font)m_fontToBoldFontMap.get(baseFont);
if (font == null)
{
FontData fontDatas[] = baseFont.getFontData();
FontData data = fontDatas[0];
font = new Font(Display.getCurrent(), data.getName(), data.getHeight(), SWT.BOLD);
m_fontToBoldFontMap.put(baseFont, font);
}
return font;
}
/**
* Dispose all of the cached {@link Font}'s.
*/
public static void disposeFonts()
{
// clear fonts
for (Iterator iter = m_fontMap.values().iterator(); iter.hasNext();)
{
((Font)iter.next()).dispose();
}
m_fontMap.clear();
// clear bold fonts
for (Iterator iter = m_fontToBoldFontMap.values().iterator(); iter.hasNext();)
{
((Font)iter.next()).dispose();
}
m_fontToBoldFontMap.clear();
}
// //////////////////////////////////////////////////////////////////////////
//
// General
//
// //////////////////////////////////////////////////////////////////////////
/**
* Dispose of cached objects and their underlying OS resources. This should only be called when the cached objects are
* no longer needed (e.g. on application shutdown).
*/
public static void dispose()
{
disposeColors();
disposeImages();
disposeFonts();
}
}