/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package javax.microedition.lcdui;

import java.io.*;

import javax.microedition.lcdui.game.Sprite;

import org.eclipse.swt.graphics.Internal_GfxPackageSupport;

/**

 * Class containing graphical data of image.<br>

 * <br>

 * Image path handling is not implemented correctly, for example "standard"

 * LCDUI accepts path "/TestMIDlets/images/100x100.png" but corresponding path

 * with this image-class must be "/100x100.png".

 */

public class Image

{

    private static Image createImageReturnValue;

    private org.eclipse.swt.graphics.Image eswtImage;

    private int eswtImageWidth;

    private int eswtImageHeight;

    private boolean mutable;

    private com.nokia.mj.impl.rt.support.Finalizer finalizer;

    // buffer has package visibility so that it can be used as

    // a lock in other classes

    ImageBuffer graphicsBuffer;

    // Graphics for transferring instance

    // between application and UI thread

    Graphics tempGraphics;

    /**

     * Constructor.

     */

    Image(org.eclipse.swt.graphics.Image eswtImage, boolean isMutable)

    {

        this.eswtImage = eswtImage;

        this.mutable = isMutable;

        eswtImageWidth = eswtImage.getBounds().width;

        eswtImageHeight = eswtImage.getBounds().height;

        graphicsBuffer = new ImageBuffer(this);

        finalizer = ((finalizer != null) ? finalizer

                     : new com.nokia.mj.impl.rt.support.Finalizer()

        {

            public void finalizeImpl()

            {

                if(finalizer != null)

                {

                    finalizer = null;

                    if(!ESWTUIThreadRunner.isDisposed())

                    {

                        dispose();

                    }

                }

            }

        });

        ESWTUIThreadRunner.update(getClass().getName(), 1);

    }

    /**

     * Called by finalizer when Image is ready to free its resources.

     */

    void dispose()

    {

        ESWTUIThreadRunner.update(getClass().getName(), -1);

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                if(eswtImage != null)

                {

                    eswtImage.dispose();

                    eswtImage = null;

                }

                graphicsBuffer.dispose();

            }

        });

    }

    /**

     * Return eSWT Image object.

     */

    org.eclipse.swt.graphics.Image getESWTImage()

    {

        return eswtImage;

    }

    /**

     * Return eSWT Image object.

     *

     * @param img Image

     * @return eSWT Image

     */

    static org.eclipse.swt.graphics.Image getESWTImage(Image img)

    {

        if(img != null)

        {

            return img.eswtImage;

        }

        return null;

    }

    /**

     * Creates new mutable image where every pixel is white.

     *

     * @param w The width of the image to be created.

     * @param h The height of the image to be created.

     * @return Image created.

     * @throws IllegalArgumentException if width or height are zero or less.

     */

    public static Image createImage(int w, int h)

    {

        if(w <= 0 || h <= 0)

        {

            throw new IllegalArgumentException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_DIMENSIONS);

        }

        final int width = w;

        final int height = h;

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                org.eclipse.swt.graphics.Image eswtImg =

                    eswtCreateImage(width, height);

                if(eswtImg != null)

                {

                    createImageReturnValue = new Image(eswtImg, true);

                }

                else

                {

                    createImageReturnValue = null;

                    throw new OutOfMemoryError();

                }

            }

        });

        return createImageReturnValue;

    }

    /**

     * Creates an immutable image with the specified size from the existing

     * image source.

     *

     * @param srcImage the source of image.

     * @param width the width of the new image.

     * @param height the height of the new image.

     * @return the resized Image.

     * @throws NullPointerException if aImage is null.

     */

    static Image createImage(Image srcImage, int width, int height)

    {

        if(srcImage == null)

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_IS_NULL);

        }

        final Image finalImage = srcImage;

        final int finalWidth = width;

        final int finalHeight = height;

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                org.eclipse.swt.graphics.Image eswtImg =

                    eswtCreateImage(finalImage.eswtImage, finalWidth, finalHeight);

                if(eswtImg != null)

                {

                    createImageReturnValue = new Image(eswtImg, false);

                }

                else

                {

                    createImageReturnValue = null;

                    throw new OutOfMemoryError();

                }

            }

        });

        return createImageReturnValue;

    }

    /**

     * Creates immutable image from existing image source.

     *

     * @param srcImage The source of image.

     * @return Image created.

     * @throws NullPointerException if source image is null.

     */

    public static Image createImage(Image srcImage)

    {

        if(srcImage == null)

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_IS_NULL);

        }

        if(!srcImage.isMutable())

        {

            return srcImage;

        }

        final Image finalImage = srcImage;

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                org.eclipse.swt.graphics.Image eswtImg =

                    eswtCreateImage(finalImage.eswtImage);

                if(eswtImg != null)

                {

                    createImageReturnValue = new Image(eswtImg, false);

                }

                else

                {

                    createImageReturnValue = null;

                    throw new OutOfMemoryError();

                }

            }

        });

        return createImageReturnValue;

    }

    /**

     * Creates an immutable image from named resource.

     *

     * @param name The name of the resource.

     * @return Image created.

     * @throws NullPointerException if name is null.

     * @throws IOException If resource doesn't exist, data cannot be loaded or

     *             data is invalid.

     */

    public static Image createImage(String name) throws IOException

    {

        if(name == null)

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_FILE_NAME_IS_NULL);

        }

        String fileName = name;

        if(!fileName.startsWith("/"))

        {

            fileName = "/" + fileName;

        }

        InputStream stream = Image.class.getResourceAsStream(fileName);

        if(stream == null)

        {

            throw new IOException(MsgRepository.IMAGE_EXCEPTION_IO_ERROR);

        }

        Image image = createImage(stream);

        try

        {

            stream.close();

        }

        catch(IOException e)

        {

            // ignore

        }

        return image;

    }

    /**

     * Creates immutable image from stream. Thread's execution is blocked until

     * this method is finished.

     *

     * @param stream The stream.

     * @return Image created.

     * @throws NullPointerException if stream is null.

     * @throws java.io.IOException If I/O error occurs or data from stream is

     *             invalid.

     */

    public static Image createImage(InputStream stream) throws java.io.IOException

    {

        if(stream == null)

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_FILE_STREAM_IS_NULL);

        }

        final InputStream finalStream = stream;

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                org.eclipse.swt.graphics.Image eswtImg = eswtCreateImage(finalStream);

                if(eswtImg != null)

                {

                    createImageReturnValue = new Image(eswtImg, false);

                }

                else

                {

                    createImageReturnValue = null;

                }

            }

        });

        if(createImageReturnValue == null)

        {

            throw new IOException(MsgRepository.IMAGE_EXCEPTION_IO_ERROR);

        }

        return createImageReturnValue;

    }

    /**

     * Creates new immutable image from image data provided.

     *

     * @param imgData Image data.

     * @param imgOffset Start offset in image data.

     * @param imgLength Length of data used.

     * @return Image created.

     * @throws ArrayIndexOutOfBoundsException if imgOffset and imgLength

     *             specifies invalid range.

     * @throws NullPointerException if imgData is null.

     * @throws IllegalArgumentException if imgData content is invalid.

     */

    public static Image createImage(byte[] imgData, int imgOffset, int imgLength)

    {

        if(imgData == null)

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_DATA_IS_NULL);

        }

        if(imgOffset + imgLength > imgData.length)

        {

            throw new ArrayIndexOutOfBoundsException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_BOUNDS);

        }

        if(imgOffset < 0 || imgLength < 0)

        {

            throw new ArrayIndexOutOfBoundsException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_BOUNDS);

        }

        InputStream inputStream = new ByteArrayInputStream(imgData, imgOffset, imgLength);

        try

        {

            createImageReturnValue = createImage(inputStream);

        }

        catch(IOException e)

        {

            throw new IllegalArgumentException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_DATA);

        }

        finally

        {

            try

            {

                inputStream.close();

            }

            catch(IOException e)

            {

                // ignore

            }

        }

        return createImageReturnValue;

    }

    /**

     * Creates an immutable image from specified region of existing source image

     * with specified transform.

     *

     * @param srcImage Source image.

     * @param x Region's x.

     * @param y Region's y.

     * @param w Regions width.

     * @param h Regions height.

     * @param transform Transform, one of the transforms specified in

     *            Sprite-class.

     * @return Image created.

     * @throws NullPointerException if img is null.

     * @throws IllegalArgumentException if Region specified exceeds the source

     *             image or if w or h is zero or less or if transform is not one

     *             defined in Sprite-class.

     */

    {

        {

            throw new NullPointerException(

                MsgRepository.IMAGE_EXCEPTION_IS_NULL);

        }

        {

            throw new IllegalArgumentException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_DIMENSIONS);

        }

        {

            throw new IllegalArgumentException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_TRANSFORM);

        }

        {

            throw new IllegalArgumentException(

                MsgRepository.IMAGE_EXCEPTION_INVALID_REGION);

        }

        ESWTUIThreadRunner.safeSyncExec(new Runnable()

        {

            public void run()

            {

                org.eclipse.swt.internal.qt.graphics.Image srcCgImage =

                    Internal_GfxPackageSupport.getImage(fImage.getESWTImage());

                org.eclipse.swt.internal.qt.graphics.Image cgImage =

                    new org.eclipse.swt.internal.qt.graphics.Image(

                    srcCgImage, fx, fy, fw, fh);

                cgImage.transform(getCgTransformValue(fTransform));

                org.eclipse.swt.graphics.Image eswtImg =

                    Internal_GfxPackageSupport.new_Image(

                        ESWTUIThreadRunner.getInstance().getDisplay(),

                        cgImage);

                if(eswtImg != null)

                {

                    createImageReturnValue = new Image(eswtImg, false);

                }

                else

                {

                    createImageReturnValue = null;

                    throw new OutOfMemoryError();

                }

            }

        });

        return createImageReturnValue;

    }

    /**

     * Validates that a specified region is fully located within the image

     * bounds. Method is package-private, used by Graphics.drawRegion as well.

     */

    {

    }

    /**

     * Validates if transform has a valid value. Method is package-private, used

     * by Graphics.drawRegion as well.

     */

    static boolean validateTransform(int transform)

    {