ResourceManager.java

/*******************************************************************************
 * Copyright (c) 2011 Google, Inc.
 * 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:
 *    Google, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.wb.swt;
 
import java.io.File;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.resource.CompositeImageDescriptor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.osgi.framework.Bundle;
 
public class ResourceManager extends SWTResourceManager {
    //
    // Image
    //
    private static Map<ImageDescriptor, Image> m_descriptorImageMap = new HashMap<ImageDescriptor, Image>();
    public static ImageDescriptor getImageDescriptor(Class<?> clazz, String path) {
        return ImageDescriptor.createFromFile(clazz, path);
    }
    public static ImageDescriptor getImageDescriptor(String path) {
        try {
            return ImageDescriptor.createFromURL(new File(path).toURI().toURL());
        } catch (MalformedURLException e) {
            return null;
        }
    }
    public static Image getImage(ImageDescriptor descriptor) {
        if (descriptor == null) {
            return null;
        }
        Image image = m_descriptorImageMap.get(descriptor);
        if (image == null) {
            image = descriptor.createImage();
            m_descriptorImageMap.put(descriptor, image);
        }
        return image;
    }
    @SuppressWarnings("unchecked")
    private static Map<Image, Map<Image, Image>>[] m_decoratedImageMap = new Map[LAST_CORNER_KEY];
    public static Image decorateImage(Image baseImage, Image decorator) {
        return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
    }
    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<Image, Map<Image, Image>> cornerDecoratedImageMap = m_decoratedImageMap[corner];
        if (cornerDecoratedImageMap == null) {
            cornerDecoratedImageMap = new HashMap<Image, Map<Image, Image>>();
            m_decoratedImageMap[corner] = cornerDecoratedImageMap;
        }
        Map<Image, Image> decoratedMap = cornerDecoratedImageMap.get(baseImage);
        if (decoratedMap == null) {
            decoratedMap = new HashMap<Image, Image>();
            cornerDecoratedImageMap.put(baseImage, decoratedMap);
        }
        //
        Image result = decoratedMap.get(decorator);
        if (result == null) {
            final Rectangle bib = baseImage.getBounds();
            final Rectangle dib = decorator.getBounds();
            final Point baseImageSize = new Point(bib.width, bib.height);
            CompositeImageDescriptor compositImageDesc = new CompositeImageDescriptor() {
                @Override
                protected void drawCompositeImage(int width, int height) {
                    drawImage(baseImage.getImageData(), 0, 0);
                    if (corner == TOP_LEFT) {
                        drawImage(decorator.getImageData(), 0, 0);
                    } else if (corner == TOP_RIGHT) {
                        drawImage(decorator.getImageData(), bib.width - dib.width, 0);
                    } else if (corner == BOTTOM_LEFT) {
                        drawImage(decorator.getImageData(), 0, bib.height - dib.height);
                    } else if (corner == BOTTOM_RIGHT) {
                        drawImage(decorator.getImageData(), bib.width - dib.width, bib.height - dib.height);
                    }
                }
                @Override
                protected Point getSize() {
                    return baseImageSize;
                }
            };
            //
            result = compositImageDesc.createImage();
            decoratedMap.put(decorator, result);
        }
        return result;
    }
    public static void disposeImages() {
        SWTResourceManager.disposeImages();
        // dispose ImageDescriptor images
        {
            for (Iterator<Image> I = m_descriptorImageMap.values().iterator(); I.hasNext();) {
                I.next().dispose();
            }
            m_descriptorImageMap.clear();
        }
        // dispose decorated images
        for (int i = 0; i < m_decoratedImageMap.length; i++) {
            Map<Image, Map<Image, Image>> cornerDecoratedImageMap = m_decoratedImageMap[i];
            if (cornerDecoratedImageMap != null) {
                for (Map<Image, Image> decoratedMap : cornerDecoratedImageMap.values()) {
                    for (Image image : decoratedMap.values()) {
                        image.dispose();
                    }
                    decoratedMap.clear();
                }
                cornerDecoratedImageMap.clear();
            }
        }
        // dispose plugin images
        {
            for (Iterator<Image> I = m_URLImageMap.values().iterator(); I.hasNext();) {
                I.next().dispose();
            }
            m_URLImageMap.clear();
        }
    }
    //
    // Plugin images support
    //
 
    private static Map<String, Image> m_URLImageMap = new HashMap<String, Image>();
    public interface PluginResourceProvider {
        URL getEntry(String symbolicName, String path);
    }
    private static PluginResourceProvider m_designTimePluginResourceProvider = null;
    @Deprecated
    public static Image getPluginImage(Object plugin, String name) {
        try {
            URL url = getPluginImageURL(plugin, name);
            if (url != null) {
                return getPluginImageFromUrl(url);
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        return null;
    }
    public static Image getPluginImage(String symbolicName, String path) {
        try {
            URL url = getPluginImageURL(symbolicName, path);
            if (url != null) {
                return getPluginImageFromUrl(url);
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        return null;
    }
    private static Image getPluginImageFromUrl(URL url) {
        try {
            try {
                String key = url.toExternalForm();
                Image image = m_URLImageMap.get(key);
                if (image == null) {
                    InputStream stream = url.openStream();
                    try {
                        image = getImage(stream);
                        m_URLImageMap.put(key, image);
                    } finally {
                        stream.close();
                    }
                }
                return image;
            } catch (Throwable e) {
                // Ignore any exceptions
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        return null;
    }
    @Deprecated
    public static ImageDescriptor getPluginImageDescriptor(Object plugin, String name) {
        try {
            try {
                URL url = getPluginImageURL(plugin, name);
                return ImageDescriptor.createFromURL(url);
            } catch (Throwable e) {
                // Ignore any exceptions
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        return null;
    }
    public static ImageDescriptor getPluginImageDescriptor(String symbolicName, String path) {
        try {
            URL url = getPluginImageURL(symbolicName, path);
            if (url != null) {
                return ImageDescriptor.createFromURL(url);
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        return null;
    }
    private static URL getPluginImageURL(String symbolicName, String path) {
        // try runtime plugins
        {
            Bundle bundle = Platform.getBundle(symbolicName);
            if (bundle != null) {
                return bundle.getEntry(path);
            }
        }
        // try design time provider
        if (m_designTimePluginResourceProvider != null) {
            return m_designTimePluginResourceProvider.getEntry(symbolicName, path);
        }
        // no such resource
        return null;
    }
    private static URL getPluginImageURL(Object plugin, String name) throws Exception {
        // try to work with 'plugin' as with OSGI BundleContext
        try {
            Class<?> BundleClass = Class.forName("org.osgi.framework.Bundle"); //$NON-NLS-1$
            Class<?> BundleContextClass = Class.forName("org.osgi.framework.BundleContext"); //$NON-NLS-1$
            if (BundleContextClass.isAssignableFrom(plugin.getClass())) {
                Method getBundleMethod = BundleContextClass.getMethod("getBundle", new Class[0]); //$NON-NLS-1$
                Object bundle = getBundleMethod.invoke(plugin, new Object[0]);
                //
                Class<?> PathClass = Class.forName("org.eclipse.core.runtime.Path"); //$NON-NLS-1$
                Constructor<?> pathConstructor = PathClass.getConstructor(new Class[]{String.class});
                Object path = pathConstructor.newInstance(new Object[]{name});
                //
                Class<?> IPathClass = Class.forName("org.eclipse.core.runtime.IPath"); //$NON-NLS-1$
                Class<?> PlatformClass = Class.forName("org.eclipse.core.runtime.Platform"); //$NON-NLS-1$
                Method findMethod = PlatformClass.getMethod("find", new Class[]{BundleClass, IPathClass}); //$NON-NLS-1$
                return (URL) findMethod.invoke(null, new Object[]{bundle, path});
            }
        } catch (Throwable e) {
            // Ignore any exceptions
        }
        // else work with 'plugin' as with usual Eclipse plugin
        {
            Class<?> PluginClass = Class.forName("org.eclipse.core.runtime.Plugin"); //$NON-NLS-1$
            if (PluginClass.isAssignableFrom(plugin.getClass())) {
                //
                Class<?> PathClass = Class.forName("org.eclipse.core.runtime.Path"); //$NON-NLS-1$
                Constructor<?> pathConstructor = PathClass.getConstructor(new Class[]{String.class});
                Object path = pathConstructor.newInstance(new Object[]{name});
                //
                Class<?> IPathClass = Class.forName("org.eclipse.core.runtime.IPath"); //$NON-NLS-1$
                Method findMethod = PluginClass.getMethod("find", new Class[]{IPathClass}); //$NON-NLS-1$
                return (URL) findMethod.invoke(plugin, new Object[]{path});
            }
        }
        return null;
    }
    //
    // General
    //
 
    public static void dispose() {
        disposeColors();
        disposeFonts();
        disposeImages();
    }
}