gt: 				gc.drawImage(decorator, bid.width - did.width - 1, 0);
context: /*******************************************************************************
   * Copyright (c) 2011 McCOMSoft. All rights reserved.
   *******************************************************************************/
  package com.swtdesigner;
  
  import java.io.BufferedInputStream;
  import java.io.FileInputStream;
  import java.io.InputStream;
  import java.util.HashMap;
  import java.util.Iterator;
  
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.graphics.Color;
  import org.eclipse.swt.graphics.Cursor;
  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.Point;
  import org.eclipse.swt.graphics.RGB;
  import org.eclipse.swt.graphics.Rectangle;
  import org.eclipse.swt.widgets.Canvas;
  import org.eclipse.swt.widgets.Control;
  import org.eclipse.swt.widgets.CoolBar;
  import org.eclipse.swt.widgets.CoolItem;
  import org.eclipse.swt.widgets.Display;
  
  /**
   * Utility class for managing OS resources associated with SWT controls such as
   * colors, fonts, images, etc.
   * 
   * !!! 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)
   * 
   * This class may be freely distributed as part of any application or plugin.
   * <p>
   * Copyright (c) 2003 - 2005, Instantiations, Inc. <br>
   * All Rights Reserved
   * 
   * @author scheglov_ke
   * @author Dan Rubel
   */
  public class SWTResourceManager {
  
  	/**
  	 * 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();
  		disposeFonts();
  		disposeImages();
  		disposeCursors();
  	}
  
  	// ////////////////////////////
  	// Color support
  	// ////////////////////////////
  
  	/**
  	 * Maps RGB values to colors
  	 */
  	private static HashMap<RGB, Color> m_ColorMap = new HashMap<RGB, Color>();
  
  	/**
  	 * Returns the system color matching the specific ID
  	 * 
  	 * @param systemColorID
  	 *            int The ID value for the color
  	 * @return Color The system color matching the specific ID
  	 */
  	public static Color getColor(int systemColorID) {
  		Display display = Display.getCurrent();
  		return display.getSystemColor(systemColorID);
  	}
  
  	/**
  	 * Returns a color given its red, green and blue component values
  	 * 
  	 * @param r
  	 *            int The red component of the color
  	 * @param g
  	 *            int The green component of the color
  	 * @param b
  	 *            int The blue component of the color
  	 * @return Color The color matching the given red, green and blue componet
  	 *         values
  	 */
  	public static Color getColor(int r, int g, int b) {
  		return getColor(new RGB(r, g, b));
  	}
  
  	/**
  	 * Returns a color given its RGB value
  	 * 
  	 * @param rgb
  	 *            RGB The RGB value of the color
  	 * @return Color The color matching the RGB value
  	 */
  	public static Color getColor(RGB rgb) {
  		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 colors
  	 */
  	public static void disposeColors() {
  		for (Iterator<Color> iter = m_ColorMap.values().iterator(); iter
  				.hasNext();)
  			iter.next().dispose();
  		m_ColorMap.clear();
  	}
  
  	// ////////////////////////////
  	// Image support
  	// ////////////////////////////
  
  	/**
  	 * Maps image names to images
  	 */
  	private static HashMap<String, Image> m_ClassImageMap = new HashMap<String, Image>();
  
  	/**
  	 * Maps images to image decorators
  	 */
  	private static HashMap<Image, HashMap<Image, Image>> m_ImageToDecoratorMap = new HashMap<Image, HashMap<Image, Image>>();
  
  	/**
  	 * Returns an image encoded by the specified input stream
  	 * 
  	 * @param is
  	 *            InputStream The input stream encoding the image data
  	 * @return Image The image encoded by the specified input stream
  	 */
  	protected static Image getImage(InputStream is) {
  		Display display = Display.getCurrent();
  		ImageData data = new ImageData(is);
  		if (data.transparentPixel > 0)
  			return new Image(display, data, data.getTransparencyMask());
  		return new Image(display, data);
  	}
  
  	/**
  	 * Returns an image stored in the file at the specified path
  	 * 
  	 * @param path
  	 *            String The path to the image file
  	 * @return Image The image stored in the file at the specified path
  	 */
  	public static Image getImage(String path) {
  		return getImage("default", path); //$NON-NLS-1$
  	}
  
  	/**
  	 * Returns an image stored in the file at the specified path
  	 * 
  	 * @param section
  	 *            The section to which belongs specified image
  	 * @param path
  	 *            String The path to the image file
  	 * @return Image The image stored in the file at the specified path
  	 */
  	public static Image getImage(String section, String path) {
  		String key = section + '|' + SWTResourceManager.class.getName() + '|'
  				+ path;
  		Image image = m_ClassImageMap.get(key);
  		if (image == null) {
  			try {
  				FileInputStream fis = new FileInputStream(path);
  				image = getImage(fis);
  				m_ClassImageMap.put(key, image);
  				fis.close();
  			} catch (Exception e) {
  				image = getMissingImage();
  				m_ClassImageMap.put(key, image);
  			}
  		}
  		return image;
  	}
  
  	/**
  	 * Returns an image stored in the file at the specified path relative to the
  	 * specified class
  	 * 
  	 * @param clazz
  	 *            Class The class relative to which to find the image
  	 * @param path
  	 *            String The path to the image file
  	 * @return Image The image stored in the file at the specified path
  	 */
  	public static Image getImage(Class<?> clazz, String path) {
  		String key = clazz.getName() + '|' + path;
  		Image image = m_ClassImageMap.get(key);
  		if (image == null) {
  			try {
  				if (path.length() > 0 && path.charAt(0) == '/') {
  					String newPath = path.substring(1, path.length());
  					image = getImage(new BufferedInputStream(clazz
  							.getClassLoader().getResourceAsStream(newPath)));
  				} else {
  					image = getImage(clazz.getResourceAsStream(path));
  				}
  				m_ClassImageMap.put(key, image);
  			} catch (Exception e) {
  				image = getMissingImage();
  				m_ClassImageMap.put(key, image);
  			}
  		}
  		return image;
  	}
  
  	private static final int MISSING_IMAGE_SIZE = 10;
  
  	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;
  
  	/**
  	 * Returns an image composed of a base image decorated by another image
  	 * 
  	 * @param baseImage
  	 *            Image The base image that should be decorated
  	 * @param decorator
  	 *            Image The image to decorate the base image
  	 * @return Image The resulting decorated image
  	 */
  	public static Image decorateImage(Image baseImage, Image decorator) {
  		return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
  	}
  
  	/**
  	 * Returns an image composed of a base image decorated by another image
  	 * 
  	 * @param baseImage
  	 *            Image The base image that should be decorated
  	 * @param decorator
  	 *            Image The image to decorate the base image
  	 * @param corner
  	 *            The corner to place decorator image
  	 * @return Image The resulting decorated image
  	 */
  	public static Image decorateImage(final Image baseImage,
  			final Image decorator, final int corner) {
  		HashMap<Image, Image> decoratedMap = m_ImageToDecoratorMap
  				.get(baseImage);
  		if (decoratedMap == null) {
  			decoratedMap = new HashMap<Image, Image>();
  			m_ImageToDecoratorMap.put(baseImage, decoratedMap);
  		}
  		Image result = decoratedMap.get(decorator);
  		if (result == null) {
  			Rectangle bid = baseImage.getBounds();
  			Rectangle did = decorator.getBounds();
  			result = new Image(Display.getCurrent(), bid.width, bid.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) {
  