/*

* Copyright (c) 1999 - 2006 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 javax.microedition.lcdui.game.Sprite;

import java.util.Enumeration;

import java.util.Hashtable;

import java.lang.Math;

import com.nokia.mj.impl.rt.legacy.NativeError;

import com.nokia.mid.ui.DirectUtils;

import com.nokia.mj.impl.rt.support.ApplicationInfo;

import com.nokia.mj.impl.rt.support.Finalizer;

/**

 * MIDP LCDUI API class providing methods to draw graphics primitives

 * on a Canvas, CustomItem or Image.

 *

 * Implementation writes commands into a (currently per-MIDlet) global

 * buffer. Each command is of the following form:

 *

 * [header][data]

 *

 * The header is a 32 bit integer divided into two 16 bit fields, the most

 * significant halfword contains the opcode. The opcode is further subdivided

 * into three fields:

 *

 * 15-12  11-10 9-0

 * [clear][mode][op]

 *

 * The top 4 bits are clear, although this may change in future, the top two bits

 * must always remain clear as these bits are used by the buffer itself.

 *

 * Bits 10 and 11 contain a mode identifier which is used by the native layer

 * to try to minimize the number of state changes to the native graphics context.

 *

 * Bits 0 to 9 contains an integer opcode. These must match the opcodes declared in

 * MMIDGraphics in lcdgr.h, and must remain contiguous.

 */

public class Graphics

{

    private static final int TRANS_MIN = javax.microedition.lcdui.game.Sprite.TRANS_NONE;

    private static final int TRANS_MAX = javax.microedition.lcdui.game.Sprite.TRANS_MIRROR_ROT90;

    /**

     * Pixel formats.

     *

     * These must be kept in sync with MMIDGraphics::TPixelType

     *

     * Only TYPE_INT_ARGB_8888 is currently used - in Graphics.drawRGB

     * The others may be useful in the implementation of extension APIs but

     * will require modifications to the MMIDGraphics implementation.

     */

    private static final int TYPE_INT_ARGB_8888       = 0;    // supported

    private static final int TYPE_SHORT_ARGB_4444 = 1;    // not supported yet

    private static final int TYPE_PACKED_ECOLOR_4K    = 2;    // not supported yet

    //

    // Anchor specs

    //

    public static final int HCENTER  = 1;

    public static final int VCENTER  = 2;

    public static final int LEFT     = 4;

    public static final int RIGHT    = 8;

    public static final int TOP      = 16;

    public static final int BOTTOM   = 32;

    public static final int BASELINE = 64;

    //

    // StrokeStyle consts

    //

    public static final int SOLID = 0;

    public static final int DOTTED = 1;

    //

    // Anchor masks

    //

    private static final int STRING_ANCHOR_MASK = HCENTER|LEFT|RIGHT|TOP|BOTTOM|BASELINE;

    private static final int IMAGE_ANCHOR_MASK  = HCENTER|VCENTER|LEFT|RIGHT|TOP|BOTTOM;

    private static final int HMASK              = HCENTER|LEFT|RIGHT;

    private static final int VMASK              = VCENTER|TOP|BOTTOM|BASELINE;

    //

    // These must be kept in sync with MMIDGraphics::TGraphicsOp

    //

    private static final int OP_SET_COLOR    = 0;

    private static final int OP_SET_STROKE   = 1;

    private static final int OP_SET_FONT     = 2;

    private static final int OP_SET_CLIPRECT = 3;

    private static final int OP_TRANSLATE    = 4;

    private static final int OP_RESET      = 5;

    private static final int OP_DRAW_LINE       = 6;

    private static final int OP_DRAW_RECT       = 7;

    private static final int OP_FILL_RECT       = 8;

    private static final int OP_DRAW_ROUNDRECT  = 9;

    private static final int OP_FILL_ROUNDRECT  = 10;

    private static final int OP_DRAW_ARC        = 11;

    private static final int OP_FILL_ARC      = 12;

    private static final int OP_DRAW_STRING     = 13;

    private static final int OP_DRAW_IMAGE      = 14;

    private static final int OP_DRAW_REGION     = 15;

    private static final int OP_COPY_AREA     = 16;

    private static final int OP_FILL_TRIANGLE   = 17;

    private static final int OP_DRAW_PIXELS       = 18;

    /* special ops */

    private static final int OP_FLUSH         = 19;

    private static final int OP_DRAW_BACKGROUND = 20;

    /* NGA specific change */

    private static final int OP_COPY_GRAPHICS   = 21;

    // Default color

    private static final int BLACK = 0xff000000;

    Font          iDefaultFont;

    //

    Toolkit        iToolkit;

    Buffer         iBuffer;

    Object         iTarget;

    Image          iImage;        // target is image

    int            iHandle;

    int            iDirectGraphicsHandle;

    int            iWidth;

    int            iHeight;

    private char[] iChar;     // Buffer for string/character drawing.

    // State

    private int       iTransX;

    private int       iTransY;

    private int       iClipX;

    private int       iClipY;

    private int       iClipWidth;

    private int       iClipHeight;

    private int     iColor;           // color value ARGB with 8 bits each

    private int     iStrokeStyle; // one of (SOLID,DOTTED)

    private Font    iFont;

    private Font    iScalableFont;

    private boolean iFontSet;

    private boolean iScalableFontSet;

    private int iOnScreenWidth;  // width of screen

    private int iOnScreenHeight; // height of screen

    //flag if is original size set in JAD file

    private boolean iIsSetOriginalSize;

    // flag if set target size in JAD file

    private boolean iIsSetTargetSize;

    // size from Nokia-MIDlet-Canvas-Scaling-Orientation-Switch JAD attribute

    private int iTargetHeight;

    private int iTargetWidth;

    // NokiaUI DirectGraphics is stored here in order to allow a proper

    // garbage collection.

    DirectGraphicsImpl iDirectGraphics;

    private Finalizer mFinalizer = new Finalizer()

    {

        public void finalizeImpl()

        {

            doFinalize();

        }

    };

    /*

     * Constructor

     */

    Graphics(Toolkit aToolkit,

             Object aTarget,

             int aDrawable,

             int aWidth,

             int aHeight)

    {

        // saving of given parameters

        iToolkit = aToolkit;

        iBuffer = aToolkit.iBuffer;

        iTarget = aTarget;

        iIsSetTargetSize = false;

        // If a Graphics is drawing to image then a image is saved. Null otherwise

        iImage = (aTarget instanceof Image) ? (Image)aTarget : null;

        // creating of native side graphics

        iHandle = NativeError.check(_create(aToolkit.getHandle(), aDrawable));

        // default values

        iChar = new char[1];

        iIsSetOriginalSize = false;

        iIsSetTargetSize = false;

        iDefaultFont = Font.getDefaultFont();

        // this get a correct iIsSetOriginalSize and iIsSetTargetSize values.

        //

        // getting JAD attributes

        ApplicationInfo appInfo = ApplicationInfo.getInstance();

        if (appInfo.getAttribute("Nokia-MIDlet-Original-Display-Size") != null)

        {

            iIsSetOriginalSize = true;

        }

        String targetSize = appInfo.getAttribute("Nokia-MIDlet-Target-Display-Size");

        if (targetSize != null)

        {

            // setting of iTargetHeight and iTargetWidth

            setTargetSize(targetSize);

        }

        // resenting of state of Graphics

        resetState(aWidth, aHeight);

    }

    /**

     * This method set iTargetHeight and iTargetWidth according to targetSize String.

     * @param targetSize string with Nokia-MIDlet-Target-Display-Size param

     */

    private void setTargetSize(String targetSize)

    {

        iIsSetTargetSize = false;

        String current = "";

        int indexString = 0;

        int indexArray = 0;

        // deleting of leading spaces

        targetSize = targetSize.trim();

        // loading of help string for iTargetWidth

        current += targetSize.charAt(indexString++);

        while ((indexString < targetSize.length()) && (Character.isDigit(targetSize.charAt(indexString))))

        {

            current += (targetSize.charAt(indexString++));

        }

        // If first next non-space char is not ',', input string is wrong.

        while (targetSize.charAt(indexString) == ' ')

        {

            indexString++;

        }

        if (targetSize.charAt(indexString++) != ',')

        {

            return;

        }

        // setting of iTargetWidth

        iTargetWidth = Integer.parseInt(current);

        // set to targetSize String for iTargetHeight without spaces

        targetSize = targetSize.substring(indexString).trim();

        indexString = 0;

        indexArray = 0;

        current = "";

        // loading of help string for iTargetHeight

        current += targetSize.charAt(indexString++);

        while ((indexString < targetSize.length()) && (Character.isDigit(targetSize.charAt(indexString))))

        {

            current += (targetSize.charAt(indexString++));

        }

        // setting of iTargetHeight

        iTargetHeight = Integer.parseInt(current);

        // Set of flag iIsSetTargetSize.

        iIsSetTargetSize = true;

    }

    void dispose()

    {

        final int handle;

        synchronized (iBuffer)

        {

            handle = iHandle;

            iHandle = 0;

        }

        if (0 != handle)

        {

            iToolkit.disposeObject(handle);

        }

    }

    private void doFinalize()

    {

        if (mFinalizer != null)

        {

            registeredFinalize();

            mFinalizer = null;

        }

    }

    void registeredFinalize()

    {

        dispose();

    }

    private void resetState(int aWidth, int aHeight)

    {

        // set of size of iTarget.

        iWidth       = aWidth;

        iHeight      = aHeight;

        // get of size of screen

        iToolkit.getDevice().getDeviceSizeWithoutKeypad();

        iOnScreenWidth = iToolkit.getDevice().iScreenWidth;

        iOnScreenHeight = iToolkit.getDevice().iScreenHeight;

        if (iOnScreenWidth == 0)

        {

            iOnScreenWidth = iWidth;

        }

        if (iOnScreenHeight == 0)

        {

            iOnScreenHeight = iHeight;

        }

        // reset of traslation, clip, color, stroke style and font

        iTransX        = 0;

        iTransY        = 0;

        iClipX         = 0;

        iClipY         = 0;

        iClipWidth   = aWidth;

        iClipHeight  = aHeight;

        iColor         = BLACK;

        iStrokeStyle = SOLID;

        iFont        = iDefaultFont;

        iFontSet   = false;

        iScalableFontSet = false;

        // If target is Canvas in fullscreen mode and

        // MIDlet have set original size and have't set target size,

        // then it is required set correct values of iOnScreenWidth and

        // iOnScreenHeight.

        if ((iTarget instanceof Canvas) &&

                ((Canvas)iTarget).getFullScreenMode() &&

                !iIsSetTargetSize && iIsSetOriginalSize)

        {

            // This code checks if some of measures is

            // bigger of target Canvas is bigger than

            // measure of screen.

            float ratioX = (float)iWidth / iOnScreenWidth;

            float ratioY = (float)iHeight / iOnScreenHeight;

            if (Math.max(ratioX, ratioY) > 1)

            {

                // Canvas has smaller ratio for width to for height than screen.

                if (ratioY > ratioX)

                {

                    // setting correct value of iOnScreenWidth

                    iOnScreenWidth = (iOnScreenHeight * iWidth) / iHeight;

                }

                // Canvas has bigger ratio for width to for height than screen

                // (or the same).

                else

                {

                    // setting correct value of iOnScreenHeight

                    iOnScreenHeight = (iOnScreenWidth * iHeight) / iWidth;

                }

            }

        }

        // setting of target size

        if ((iTarget instanceof Canvas) &&

                ((Canvas)iTarget).getFullScreenMode() &&

                iIsSetTargetSize && iIsSetOriginalSize)

        {

            iOnScreenHeight = iTargetHeight;

            iOnScreenWidth = iTargetWidth;

        }

    }

    void reset(int aWidth, int aHeight)

    {

        synchronized (iBuffer)

        {

            if (iHandle != 0)

            {

                resetState(aWidth, aHeight);

                iBuffer.write(iHandle, OP_RESET, aWidth, aHeight);

            }

        }

    }

    public void translate(int aDx,int aDy)

    {

        synchronized (iBuffer)

        {

            // If is downscaling on, then we change parameters.

            if (isDownscaled())

            {

                aDx = (aDx * iOnScreenWidth) / iWidth;

                aDy = (aDy * iOnScreenHeight) / iHeight;

            }

            // setting of translate in java class Graphics

            iTransX += aDx;

            iTransY += aDy;

            iClipX  -= aDx;

            iClipY  -= aDy;

            // setting of translate in native graphics

            iBuffer.write(iHandle, OP_TRANSLATE, iTransX, iTransY);

        }

    }

    public int getTranslateX()

    {

        // If is downscaling on, then it return downscaled traslate of x.

        if (isDownscaled())

            return (iTransX * iWidth) / iOnScreenWidth;

        // If is downscaling off, then it return non-scaled traslate of x.

        else

            return iTransX;

    }

    public int getTranslateY()

    {

        // If is downscaling on, then it return downscaled traslate of y.

        if (isDownscaled())

            return (iTransY * iHeight) / iOnScreenHeight;

        // If is downscaling off, then it return non-scaled traslate of y.

        else

            return iTransY;

    }

    public int getColor()

    {

        return (iColor & 0x00ffffff);

    }

    public int getRedComponent()

    {

        return (iColor >>> 16) & 0xff;

    }

    public int getGreenComponent()

    {

        return (iColor >>> 8) & 0xff;

    }

    public int getBlueComponent()

    {

        return (iColor & 0xff);

    }

    public int getGrayScale()

    {

        final int color = iColor;

        final int r = (color >>> 16) & 0xff;

        final int g = (color >>> 8) & 0xff;

        final int b = color & 0xff;

        return Math.max(r, Math.max(g,b));

    }

    public void setColor(int aRed,int aGreen,int aBlue)

    {

        /*

         * For all valid arguments, only the least significant

         * byte can contain non-zero bits.

         */

        if (((aRed|aGreen|aBlue)>>>8)!=0)

        {

            throw new IllegalArgumentException();

        }

        setColor((aRed << 16) | (aGreen << 8) | aBlue);

    }

    public void setColor(int aRgb)

    {

        //

        // Drawing colors are fully opaque.

        //

        final int color = (aRgb | 0xff000000);

        synchronized (iBuffer)

        {

            if (iColor != color)

            {

                iColor = color;

                iBuffer.write(iHandle, OP_SET_COLOR, color);

            }

        }

    }

    public void setGrayScale(int aValue)

    {

        setColor(aValue, aValue, aValue);

    }

    public Font getFont()

    {

        return iFont;

    }

    public void setFont(Font aFont)

    {

        if (aFont == null)

        {

            aFont = Font.getDefaultFont();

        }

        synchronized (iBuffer)

        {

            if (iFont != aFont)

            {

                iFont    = aFont;

                iFontSet = false;

                iScalableFontSet = false;

            }

        }

    }

    /**

     * If the downscaling is on, it is created and used the new scaled font.

     */

    private void setScalableFont()

    {

        if (!iScalableFontSet && iFont != null)

        {

            int fontHeight = iFont.getHeight();