root/dwt/graphics/Image.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.graphics.Image;

import dwt.DWT;
import dwt.DWTError;
import dwt.DWTException;
import dwt.internal.gdip.Gdip;
import dwt.internal.win32.OS;

import dwt.graphics.Color;
import dwt.graphics.Device;
import dwt.graphics.Drawable;
import dwt.graphics.GC;
import dwt.graphics.GCData;
import dwt.graphics.ImageData;
import dwt.graphics.PaletteData;
import dwt.graphics.RGB;
import dwt.graphics.Rectangle;
import dwt.graphics.Resource;


import dwt.dwthelper.InputStream;
import dwt.dwthelper.utils;

import tango.text.convert.Format;
//import tango.stdc.string;
//import tango.stdc.stringz;

/**
 * Instances of this class are graphics which have been prepared
 * for display on a specific device. That is, they are ready
 * to paint using methods such as <code>GC.drawImage()</code>
 * and display on widgets with, for example, <code>Button.setImage()</code>.
 * <p>
 * If loaded from a file format that supports it, an
 * <code>Image</code> may have transparency, meaning that certain
 * pixels are specified as being transparent when drawn. Examples
 * of file formats that support transparency are GIF and PNG.
 * </p><p>
 * There are two primary ways to use <code>Images</code>.
 * The first is to load a graphic file from disk and create an
 * <code>Image</code> from it. This is done using an <code>Image</code>
 * constructor, for example:
 * <pre>
 *    Image i = new Image(device, "C:\\graphic.bmp");
 * </pre>
 * A graphic file may contain a color table specifying which
 * colors the image was intended to possess. In the above example,
 * these colors will be mapped to the closest available color in
 * DWT. It is possible to get more control over the mapping of
 * colors as the image is being created, using code of the form:
 * <pre>
 *    ImageData data = new ImageData("C:\\graphic.bmp");
 *    RGB[] rgbs = data.getRGBs();
 *    // At this point, rgbs contains specifications of all
 *    // the colors contained within this image. You may
 *    // allocate as many of these colors as you wish by
 *    // using the Color constructor Color(RGB), then
 *    // create the image:
 *    Image i = new Image(device, data);
 * </pre>
 * <p>
 * Applications which require even greater control over the image
 * loading process should use the support provided in class
 * <code>ImageLoader</code>.
 * </p><p>
 * Application code must explicitly invoke the <code>Image.dispose()</code>
 * method to release the operating system resources managed by each instance
 * when those instances are no longer required.
 * </p>
 *
 * @see Color
 * @see ImageData
 * @see ImageLoader
 * @see <a href="http://www.eclipse.org/swt/snippets/#image">Image snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Examples: GraphicsExample, ImageAnalyzer</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public final class Image : Resource, Drawable {

    alias Resource.init_ init_;

    /**
     * specifies whether the receiver is a bitmap or an icon
     * (one of <code>DWT.BITMAP</code>, <code>DWT.ICON</code>)
     * <p>
     * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT
     * public API. It is marked public only so that it can be shared
     * within the packages provided by DWT. It is not available on all
     * platforms and should never be accessed from application code.
     * </p>
     */
    public int type;

    /**
     * the handle to the OS image resource
     * (Warning: This field is platform dependent)
     * <p>
     * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT
     * public API. It is marked public only so that it can be shared
     * within the packages provided by DWT. It is not available on all
     * platforms and should never be accessed from application code.
     * </p>
     */
    public HGDIOBJ handle;

    /**
     * specifies the transparent pixel
     */
    int transparentPixel = -1, transparentColor = -1;

    /**
     * the GC which is drawing on the image
     */
    GC memGC;

    /**
     * the alpha data for the image
     */
    byte[] alphaData;

    /**
     * the global alpha value to be used for every pixel
     */
    int alpha = -1;

    /**
     * the image data used to create this image if it is a
     * icon. Used only in WinCE
     */
    ImageData data;

    /**
     * width of the image
     */
    int width = -1;

    /**
     * height of the image
     */
    int height = -1;

    /**
     * specifies the default scanline padding
     */
    static const int DEFAULT_SCANLINE_PAD = 4;

/**
 * Prevents uninitialized instances from being created outside the package.
 */
this (Device device) {
    super(device);
}

/**
 * Constructs an empty instance of this class with the
 * specified width and height. The result may be drawn upon
 * by creating a GC and using any of its drawing operations,
 * as shown in the following example:
 * <pre>
 *    Image i = new Image(device, width, height);
 *    GC gc = new GC(i);
 *    gc.drawRectangle(0, 0, 50, 50);
 *    gc.dispose();
 * </pre>
 * <p>
 * Note: Some platforms may have a limitation on the size
 * of image that can be created (size depends on width, height,
 * and depth). For example, Windows 95, 98, and ME do not allow
 * images larger than 16M.
 * </p>
 *
 * @param device the device on which to create the image
 * @param width the width of the new image
 * @param height the height of the new image
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_INVALID_ARGUMENT - if either the width or height is negative or zero</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, int width, int height) {
    super(device);
    init_(width, height);
    init_();
}

/**
 * Constructs a new instance of this class based on the
 * provided image, with an appearance that varies depending
 * on the value of the flag. The possible flag values are:
 * <dl>
 * <dt><b>{@link DWT#IMAGE_COPY}</b></dt>
 * <dd>the result is an identical copy of srcImage</dd>
 * <dt><b>{@link DWT#IMAGE_DISABLE}</b></dt>
 * <dd>the result is a copy of srcImage which has a <em>disabled</em> look</dd>
 * <dt><b>{@link DWT#IMAGE_GRAY}</b></dt>
 * <dd>the result is a copy of srcImage which has a <em>gray scale</em> look</dd>
 * </dl>
 *
 * @param device the device on which to create the image
 * @param srcImage the image to use as the source
 * @param flag the style, either <code>IMAGE_COPY</code>, <code>IMAGE_DISABLE</code> or <code>IMAGE_GRAY</code>
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if srcImage is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if the flag is not one of <code>IMAGE_COPY</code>, <code>IMAGE_DISABLE</code> or <code>IMAGE_GRAY</code></li>
 *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_INVALID_IMAGE - if the image is not a bitmap or an icon, or is otherwise in an invalid state</li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the depth of the image is not supported</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, Image srcImage, int flag) {
    super(device);
    device = this.device;
    if (srcImage is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    if (srcImage.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
    Rectangle rect = srcImage.getBounds();
    this.type = srcImage.type;
    switch (flag) {
        case DWT.IMAGE_COPY: {
            switch (type) {
                case DWT.BITMAP:
                    /* Get the HDC for the device */
                    auto hDC = device.internal_new_GC(null);

                    /* Copy the bitmap */
                    auto hdcSource = OS.CreateCompatibleDC(hDC);
                    auto hdcDest = OS.CreateCompatibleDC(hDC);
                    auto hOldSrc = OS.SelectObject(hdcSource, srcImage.handle);
                    BITMAP bm;
                    OS.GetObject(srcImage.handle, BITMAP.sizeof, &bm);
                    handle = OS.CreateCompatibleBitmap(hdcSource, rect.width, bm.bmBits !is null ? -rect.height : rect.height);
                    if (handle is null) DWT.error(DWT.ERROR_NO_HANDLES);
                    auto hOldDest = OS.SelectObject(hdcDest, handle);
                    OS.BitBlt(hdcDest, 0, 0, rect.width, rect.height, hdcSource, 0, 0, OS.SRCCOPY);
                    OS.SelectObject(hdcSource, hOldSrc);
                    OS.SelectObject(hdcDest, hOldDest);
                    OS.DeleteDC(hdcSource);
                    OS.DeleteDC(hdcDest);

                    /* Release the HDC for the device */
                    device.internal_dispose_GC(hDC, null);

                    transparentPixel = srcImage.transparentPixel;
                    alpha = srcImage.alpha;
                    if (srcImage.alphaData !is null) {
                        alphaData = new byte[srcImage.alphaData.length];
                        System.arraycopy(srcImage.alphaData, 0, alphaData, 0, alphaData.length);
                    }
                    break;
                case DWT.ICON:
                    static if (OS.IsWinCE) {
                        init_(srcImage.data);
                    } else {
                        handle = OS.CopyImage(srcImage.handle, OS.IMAGE_ICON, rect.width, rect.height, 0);
                        if (handle is null) DWT.error(DWT.ERROR_NO_HANDLES);
                    }
                    break;
                default:
                    DWT.error(DWT.ERROR_INVALID_IMAGE);
            }
            break;
        }
        case DWT.IMAGE_DISABLE: {
            ImageData data = srcImage.getImageData();
            PaletteData palette = data.palette;
            RGB[] rgbs = new RGB[3];
            rgbs[0] = device.getSystemColor(DWT.COLOR_BLACK).getRGB();
            rgbs[1] = device.getSystemColor(DWT.COLOR_WIDGET_NORMAL_SHADOW).getRGB();
            rgbs[2] = device.getSystemColor(DWT.COLOR_WIDGET_BACKGROUND).getRGB();
            ImageData newData = new ImageData(rect.width, rect.height, 8, new PaletteData(rgbs));
            newData.alpha = data.alpha;
            newData.alphaData = data.alphaData;
            newData.maskData = data.maskData;
            newData.maskPad = data.maskPad;
            if (data.transparentPixel !is -1) newData.transparentPixel = 0;

            /* Convert the pixels. */
            int[] scanline = new int[rect.width];
            int[] maskScanline = null;
            ImageData mask = null;
            if (data.maskData !is null) mask = data.getTransparencyMask();
            if (mask !is null) maskScanline = new int[rect.width];
            int redMask = palette.redMask;
            int greenMask = palette.greenMask;
            int blueMask = palette.blueMask;
            int redShift = palette.redShift;
            int greenShift = palette.greenShift;
            int blueShift = palette.blueShift;
            for (int y=0; y<rect.height; y++) {
                int offset = y * newData.bytesPerLine;
                data.getPixels(0, y, rect.width, scanline, 0);
                if (mask !is null) mask.getPixels(0, y, rect.width, maskScanline, 0);
                for (int x=0; x<rect.width; x++) {
                    int pixel = scanline[x];
                    if (!((data.transparentPixel !is -1 && pixel is data.transparentPixel) || (mask !is null && maskScanline[x] is 0))) {
                        int red, green, blue;
                        if (palette.isDirect) {
                            red = pixel & redMask;
                            red = (redShift < 0) ? red >>> -redShift : red << redShift;
                            green = pixel & greenMask;
                            green = (greenShift < 0) ? green >>> -greenShift : green << greenShift;
                            blue = pixel & blueMask;
                            blue = (blueShift < 0) ? blue >>> -blueShift : blue << blueShift;
                        } else {
                            red = palette.colors[pixel].red;
                            green = palette.colors[pixel].green;
                            blue = palette.colors[pixel].blue;
                        }
                        int intensity = red * red + green * green + blue * blue;
                        if (intensity < 98304) {
                            newData.data[offset] = cast(byte)1;
                        } else {
                            newData.data[offset] = cast(byte)2;
                        }
                    }
                    offset++;
                }
            }
            init_ (newData);
            break;
        }
        case DWT.IMAGE_GRAY: {
            ImageData data = srcImage.getImageData();
            PaletteData palette = data.palette;
            ImageData newData = data;
            if (!palette.isDirect) {
                /* Convert the palette entries to gray. */
                RGB [] rgbs = palette.getRGBs();
                for (int i=0; i<rgbs.length; i++) {
                    if (data.transparentPixel !is i) {
                        RGB color = rgbs [i];
                        int red = color.red;
                        int green = color.green;
                        int blue = color.blue;
                        int intensity = (red+red+green+green+green+green+green+blue) >> 3;
                        color.red = color.green = color.blue = intensity;
                    }
                }
                newData.palette = new PaletteData(rgbs);
            } else {
                /* Create a 8 bit depth image data with a gray palette. */
                RGB[] rgbs = new RGB[256];
                for (int i=0; i<rgbs.length; i++) {
                    rgbs[i] = new RGB(i, i, i);
                }
                newData = new ImageData(rect.width, rect.height, 8, new PaletteData(rgbs));
                newData.alpha = data.alpha;
                newData.alphaData = data.alphaData;
                newData.maskData = data.maskData;
                newData.maskPad = data.maskPad;
                if (data.transparentPixel !is -1) newData.transparentPixel = 254;

                /* Convert the pixels. */
                int[] scanline = new int[rect.width];
                int redMask = palette.redMask;
                int greenMask = palette.greenMask;
                int blueMask = palette.blueMask;
                int redShift = palette.redShift;
                int greenShift = palette.greenShift;
                int blueShift = palette.blueShift;
                for (int y=0; y<rect.height; y++) {
                    int offset = y * newData.bytesPerLine;
                    data.getPixels(0, y, rect.width, scanline, 0);
                    for (int x=0; x<rect.width; x++) {
                        int pixel = scanline[x];
                        if (pixel !is data.transparentPixel) {
                            int red = pixel & redMask;
                            red = (redShift < 0) ? red >>> -redShift : red << redShift;
                            int green = pixel & greenMask;
                            green = (greenShift < 0) ? green >>> -greenShift : green << greenShift;
                            int blue = pixel & blueMask;
                            blue = (blueShift < 0) ? blue >>> -blueShift : blue << blueShift;
                            int intensity = (red+red+green+green+green+green+green+blue) >> 3;
                            if (newData.transparentPixel is intensity) intensity = 255;
                            newData.data[offset] = cast(byte)intensity;
                        } else {
                            newData.data[offset] = cast(byte)254;
                        }
                        offset++;
                    }
                }
            }
            init_ (newData);
            break;
        }
        default:
            DWT.error(DWT.ERROR_INVALID_ARGUMENT);
    }
    init_();
}

/**
 * Constructs an empty instance of this class with the
 * width and height of the specified rectangle. The result
 * may be drawn upon by creating a GC and using any of its
 * drawing operations, as shown in the following example:
 * <pre>
 *    Image i = new Image(device, boundsRectangle);
 *    GC gc = new GC(i);
 *    gc.drawRectangle(0, 0, 50, 50);
 *    gc.dispose();
 * </pre>
 * <p>
 * Note: Some platforms may have a limitation on the size
 * of image that can be created (size depends on width, height,
 * and depth). For example, Windows 95, 98, and ME do not allow
 * images larger than 16M.
 * </p>
 *
 * @param device the device on which to create the image
 * @param bounds a rectangle specifying the image's width and height (must not be null)
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the bounds rectangle is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if either the rectangle's width or height is negative</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, Rectangle bounds) {
    super(device);
    if (bounds is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    init_(bounds.width, bounds.height);
    init_();
}

/**
 * Constructs an instance of this class from the given
 * <code>ImageData</code>.
 *
 * @param device the device on which to create the image
 * @param data the image data to create the image from (must not be null)
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the image data is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the depth of the ImageData is not supported</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, ImageData data) {
    super(device);
    init_(data);
    init_();
}

/**
 * Constructs an instance of this class, whose type is
 * <code>DWT.ICON</code>, from the two given <code>ImageData</code>
 * objects. The two images must be the same size. Pixel transparency
 * in either image will be ignored.
 * <p>
 * The mask image should contain white wherever the icon is to be visible,
 * and black wherever the icon is to be transparent. In addition,
 * the source image should contain black wherever the icon is to be
 * transparent.
 * </p>
 *
 * @param device the device on which to create the icon
 * @param source the color data for the icon
 * @param mask the mask data for the icon
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if either the source or mask is null </li>
 *    <li>ERROR_INVALID_ARGUMENT - if source and mask are different sizes</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, ImageData source, ImageData mask) {
    super(device);
    if (source is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    if (mask is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    if (source.width !is mask.width || source.height !is mask.height) {
        DWT.error(DWT.ERROR_INVALID_ARGUMENT);
    }
    mask = ImageData.convertMask(mask);
    init_(this.device, this, source, mask);
    init_();
}

/**
 * Constructs an instance of this class by loading its representation
 * from the specified input stream. Throws an error if an error
 * occurs while loading the image, or if the result is an image
 * of an unsupported type.  Application code is still responsible
 * for closing the input stream.
 * <p>
 * This constructor is provided for convenience when loading a single
 * image only. If the stream contains multiple images, only the first
 * one will be loaded. To load multiple images, use
 * <code>ImageLoader.load()</code>.
 * </p><p>
 * This constructor may be used to load a resource as follows:
 * </p>
 * <pre>
 *     static Image loadImage (Display display, Class clazz, String string) {
 *          InputStream stream = clazz.getResourceAsStream (string);
 *          if (stream is null) return null;
 *          Image image = null;
 *          try {
 *               image = new Image (display, stream);
 *          } catch (DWTException ex) {
 *          } finally {
 *               try {
 *                    stream.close ();
 *               } catch (IOException ex) {}
 *          }
 *          return image;
 *     }
 * </pre>
 *
 * @param device the device on which to create the image
 * @param stream the input stream to load the image from
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the stream is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_IO - if an IO error occurs while reading from the stream</li>
 *    <li>ERROR_INVALID_IMAGE - if the image stream contains invalid data </li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the image stream describes an image with an unsupported depth</li>
 *    <li>ERROR_UNSUPPORTED_FORMAT - if the image stream contains an unrecognized format</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this (Device device, InputStream stream) {
    super(device);
    init_(new ImageData(stream));
    init_();
}

/**
 * Constructs an instance of this class by loading its representation
 * from the file with the specified name. Throws an error if an error
 * occurs while loading the image, or if the result is an image
 * of an unsupported type.
 * <p>
 * This constructor is provided for convenience when loading
 * a single image only. If the specified file contains
 * multiple images, only the first one will be used.
 *
 * @param device the device on which to create the image
 * @param filename the name of the file to load the image from
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the file name is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_IO - if an IO error occurs while reading from the file</li>
 *    <li>ERROR_INVALID_IMAGE - if the image file contains invalid data </li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the image file describes an image with an unsupported depth</li>
 *    <li>ERROR_UNSUPPORTED_FORMAT - if the image file contains an unrecognized format</li>
 * </ul>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this (Device device, String filename) {
    super(device);
    device = this.device;
    if (filename is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
    bool gdip = true;
    try {
        device.