android-4.1.1_r1/s

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.ddmuilib;

import com.android.ddmlib.Log;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;

import java.io.InputStream;
import java.net.URL;
import java.util.HashMap;

/**
 * Class to load images stored in a jar file.
 * All images are loaded from /images/<var>filename</var>
 *
 * Because Java requires to know the jar file in which to load the image from, a class is required
 * when getting the instance. Instances are cached and associated to the class passed to
 * {@link #getLoader(Class)}.
 *
 * {@link #getDdmUiLibLoader()} use {@link ImageLoader#getClass()} as the class. This is to be used
 * to load images from ddmuilib.
 *
 * Loaded images are stored so that 2 calls with the same filename will return the same object.
 * This also means that {@link Image} object returned by the loader should never be disposed.
 *
 */
public class ImageLoader {

    private static final String PATH = "/images/"; //$NON-NLS-1$

    private final HashMap<String, Image> mLoadedImages = new HashMap<String, Image>();
    private static final HashMap<Class<?>, ImageLoader> mInstances =
            new HashMap<Class<?>, ImageLoader>();
    private final Class<?> mClass;

    /**
     * Private constructor, creating an instance associated with a class.
     * The class is used to identify which jar file the images are loaded from.
     */
    private ImageLoader(Class<?> theClass) {
        if (theClass == null) {
            theClass = ImageLoader.class;
        }
        mClass = theClass;
    }

    /**
     * Returns the {@link ImageLoader} instance to load images from ddmuilib.jar
     */
    public static ImageLoader getDdmUiLibLoader() {
        return getLoader(null);
    }

    /**
     * Returns an {@link ImageLoader} to load images based on a given class.
     *
     * The loader will load images from the jar from which the class was loaded. using
     * {@link Class#getResource(String)} and {@link Class#getResourceAsStream(String)}.
     *
     * Since all images are loaded using the path /images/<var>filename</var>, any class from the
     * jar will work. However since the loader is cached and reused when the query provides the same
     * class instance, and since the loader will also cache the loaded images, it is recommended
     * to always use the same class for a given Jar file.
     *
     */
    public static ImageLoader getLoader(Class<?> theClass) {
        ImageLoader instance = mInstances.get(theClass);
        if (instance == null) {
            instance = new ImageLoader(theClass);
            mInstances.put(theClass, instance);
        }

        return instance;
    }

    /**
     * Disposes all images for all instances.
     * This should only be called when the program exits.
     */
    public static void dispose() {
        for (ImageLoader loader : mInstances.values()) {
            loader.doDispose();
        }
    }

    private synchronized void doDispose() {
        for (Image image : mLoadedImages.values()) {
            image.dispose();
        }

        mLoadedImages.clear();
    }

    /**
     * Returns an {@link ImageDescriptor} for a given filename.
     *
     * This searches for an image located at /images/<var>filename</var>.
     *
     * @param filename the filename of the image to load.
     */
    public ImageDescriptor loadDescriptor(String filename) {
        URL url = mClass.getResource(PATH + filename);
        // TODO cache in a map
        return ImageDescriptor.createFromURL(url);
    }

    /**
     * Returns an {@link Image} for a given filename.
     *
     * This searches for an image located at /images/<var>filename</var>.
     *
     * @param filename the filename of the image to load.
     * @param display the Display object
     */
    public synchronized Image loadImage(String filename, Display display) {
        Image img = mLoadedImages.get(filename);
        if (img == null) {
            String tmp = PATH + filename;
            InputStream imageStream = mClass.getResourceAsStream(tmp);

            if (imageStream != null) {
                img = new Image(display, imageStream);
                mLoadedImages.put(filename, img);
            }

            if (img == null) {
                throw new RuntimeException("Failed to load " + tmp);
            }
        }

        return img;
    }

    /**
     * Loads an image from a resource. This method used a class to locate the
     * resources, and then load the filename from /images inside the resources.<br>
     * Extra parameters allows for creation of a replacement image of the
     * loading failed.
     *
     * @param display the Display object
     * @param fileName the file name
     * @param width optional width to create replacement Image. If -1, null be
     *            be returned if the loading fails.
     * @param height optional height to create replacement Image. If -1, null be
     *            be returned if the loading fails.
     * @param phColor optional color to create replacement Image. If null, Blue
     *            color will be used.
     * @return a new Image or null if the loading failed and the optional
     *         replacement size was -1
     */
    public Image loadImage(Display display, String fileName, int width, int height,
            Color phColor) {

        Image img = loadImage(fileName, display);

        if (img == null) {
            Log.w("ddms", "Couldn't load " + fileName);
            // if we had the extra parameter to create replacement image then we
            // create and return it.
            if (width != -1 && height != -1) {
                return createPlaceHolderArt(display, width, height,
                        phColor != null ? phColor : display
                                .getSystemColor(SWT.COLOR_BLUE));
            }

            // otherwise, just return null
            return null;
        }

        return img;
    }

    /**
     * Create place-holder art with the specified color.
     */
    public static Image createPlaceHolderArt(Display display, int width,
            int height, Color color) {
        Image img = new Image(display, width, height);
        GC gc = new GC(img);
        gc.setForeground(color);
        gc.drawLine(0, 0, width, height);
        gc.drawLine(0, height - 1, width, -1);
        gc.dispose();
        return img;
    }
}