/*

* 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 org.eclipse.swt.graphics.Internal_GfxPackageSupport;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.internal.qt.graphics.GraphicsContext;

import org.eclipse.swt.internal.qt.graphics.FontUtils;

import com.nokia.mid.ui.DirectGraphics;

/**

 * Implementation of LCDUI <code>Graphics</code> class.

 */

public class Graphics

{

    /**

     * Constant for horizontal center alignment of the text.

     */

    public static final int HCENTER = 1;

    /**

     * Constant for vertical alignment of the image.

     */

    public static final int VCENTER = 2;

    /**

     * Constant for horizontal left alignment of the text.

     */

    public static final int LEFT = 4;

    /**

     * Constant for horizontal right alignment of the text.

     */

    public static final int RIGHT = 8;

    /**

     * Constant for vertical top alignment of the text.

     */

    public static final int TOP = 16;

    /**

     * Constant for vertical bottom alignment of the text.

     */

    public static final int BOTTOM = 32;

    /**

     * Constant for vertical baseline alignment of the text.

     */

    public static final int BASELINE = 64;

    /**

     * Constant for solid stroke style.

     */

    public static final int SOLID = 0;

    /**

     * Constant for dotted stroke style.

     */

    public static final int DOTTED = 1;

    static final int INVALID_STROKE_STYLE = -1;

    static final int RGB_MASK = 0x00FFFFFF;

    static final int OPAQUE_ALPHA = 0xff000000;

    static final int COMPONENT_MASK = 0xFF;

    /**

     * Constants for sync strategy

     */

    static final int SYNC_LEAVE_SURFACE_SESSION_CLOSED = 10;

    static final int SYNC_LEAVE_SURFACE_SESSION_OPEN = 11;

    // Set default sync strategy as closed

    private int syncStrategy = SYNC_LEAVE_SURFACE_SESSION_CLOSED; 

    private DirectGraphics directGraphics;

    private Buffer graphicsBuffer;

    Font currentFont;

    int currentColor;

    int translateX;

    int translateY;

    int[] currentClip = new int[4];

    int currentStrokeStyle;

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

    //Constructor

    Graphics(Buffer buffer, Rectangle clipRect)

    {

        finalizer = ((finalizer != null) ? finalizer

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

        {

            public void finalizeImpl()

            {

                if(finalizer != null)

                {

                    finalizer = null;

                    if(!ESWTUIThreadRunner.isDisposed())

                    {

                        ESWTUIThreadRunner.safeSyncExec(new Runnable()

                        {

                            public void run()

                            {

                                dispose();

                            }

                        });

                    }

                }

            }

        });

        currentClip[0] = clipRect.x;

        currentClip[1] = clipRect.y;

        currentClip[2] = clipRect.width;

        currentClip[3] = clipRect.height;

        graphicsBuffer = buffer;

    }

    /**

     * Disposes objects with native counterparts

     */

    void dispose()

    {

        synchronized(graphicsBuffer)

        {

            graphicsBuffer.removeRef();

        }

    }

    /**

     * Resets Graphics state to initial.

     */

    void reset()

    {

        currentFont = Buffer.defaultFont;

        currentColor = Buffer.defaultColor;

        currentStrokeStyle = Buffer.defaultStrokeStyle;

        translateX = Buffer.defaultTranslateX;

        translateY = Buffer.defaultTranslateY;

    }

    /**

     * Cleans the Canvas background.

     */

    void cleanBackground(Rectangle area)

    {

        int savedColor = currentColor;

        setColor(255, 255, 255);

        fillRect(area.x, area.y, area.width, area.height);

        setColor(savedColor);

    }

    /**

     * Cleans the Canvas background.

     */

    void cleanBackground(int x, int y, int w, int h)

    {

        int savedColor = currentColor;

        setColor(255, 255, 255);

        fillRect(x, y, w, h);

        setColor(savedColor);

    }

    /**

     * Sets the sync strategy for this instance.

     * This affects on the behavior of the sync method of this class

     * which is called via LCDUIInvoker

     */

    void setSyncStrategy(int strategy)

    {

    }

    /**

     * Sets coordinate translation. Translations are cumulative.

     *

     * @param xDelta x-shift for coordinates.

     * @param yDelta y-shift for coordinates.

     */

    public void translate(int xDelta, int yDelta)

    {

        synchronized(graphicsBuffer)

        {

            graphicsBuffer.translate(xDelta, yDelta, this);

            translateX += xDelta;

            translateY += yDelta;

        }

    }

    /**

     * Returns current X-shift of coordinate translation.

     *

     * @return Current X-shift of coordinate translation.

     */

    public int getTranslateX()

    {

        synchronized(graphicsBuffer)

        {

            return translateX;

        }

    }

    /**

     * Returns current Y-shift of coordinate translation.

     *

     * @return current Y-shift of coordinate translation.

     */

    public int getTranslateY()

    {

        synchronized(graphicsBuffer)

        {

            return translateY;

        }

    }

    /**

     * Returns current color in 0x00RRGGBB format.

     *

     * @return Current color in 0x00RRGGBB format.

     */

    public int getColor()

    {

        synchronized(graphicsBuffer)

        {

            return (currentColor & RGB_MASK);

        }

    }

    /**

     * Returns red component of current color.

     *

     * @return Red component of current color in the range of 0-255.

     */

    public int getRedComponent()

    {

        synchronized(graphicsBuffer)

        {

        }

    }

    /**

     * Returns green component of current color.

     *

     * @return Green component of current color in the range of 0-255.

     */

    public int getGreenComponent()

    {

        synchronized(graphicsBuffer)

        {

            return (currentColor >> 8) & COMPONENT_MASK;

        }

    }

    /**

     * Returns blue component of current color.

     *

     * @return Blue component of current color in the range of 0-255.

     */

    public int getBlueComponent()

    {

        synchronized(graphicsBuffer)

        {

            return currentColor & COMPONENT_MASK;

        }

    }

    /**

     * Returns current grayscale color.

     *

     * @return Returns current grayscale color in the range 0-255.

     */

    public int getGrayScale()

    {

        synchronized(graphicsBuffer)

        {

            return (getRedComponent() + getGreenComponent() + getBlueComponent()) / 3;

        }

    }

    /**

     * Sets the current color by color components for red, green and blue.

     *

     * @param r - red component of the color to be set.

     * @param g - green component of the color to be set.

     * @param b - blue component of the color to be set.

     */

    public void setColor(int r, int g, int b)

    {

        if(r < 0 || r > 255 ||

                g < 0 || g > 255 ||

                b < 0 || b > 255)

        {

            throw new IllegalArgumentException();

        }

        synchronized(graphicsBuffer)

        {

            graphicsBuffer.setColor(r, g, b, this);

            currentColor = (OPAQUE_ALPHA | (r << 16) | (g << 8) | b);

        }

    }

    /**

     * Sets the current color.

     *

     * @param RGB - color to be set in the form of 0x00RRGGBB.

     */

    public void setColor(int RGB)

    {

        int maskedRGB = RGB & RGB_MASK;

        final int r = maskedRGB >> 16;

        final int g = (maskedRGB >> 8) & COMPONENT_MASK;

        final int b = maskedRGB & COMPONENT_MASK;

        synchronized(graphicsBuffer)

        {

            graphicsBuffer.setColor(r, g, b, this);

            currentColor = (OPAQUE_ALPHA | maskedRGB);

        }

    }

    /**

     * Sets gray-scale color.

     *

     * @param val - gray-scale value to be set in the range of 0-255.

     */

    public void setGrayScale(int val)

    {

        if((val < 0) || (val > 255))

        {

            throw new IllegalArgumentException();

        }

        final int col = val & COMPONENT_MASK;

        synchronized(graphicsBuffer)

        {

            graphicsBuffer.setColor(col, col, col, this);

            currentColor = (OPAQUE_ALPHA | (col << 16) | (col << 8) | col);

        }

    }

    /**

     * Returns the current font.

     *

     * @return Current font.

     */

    public Font getFont()

    {

        synchronized(graphicsBuffer)

        {

            return currentFont;

        }

    }

    /**

     * Sets the font to be used for string rendering.

     *

     * @param newFont - the font to be used for string rendering.

     */

    public void setFont(Font newFont)

    {

        synchronized(graphicsBuffer)

        {

            if(newFont == null)

            {

                newFont = Font.getDefaultFont();

            }

            graphicsBuffer.setFont(Font.getESWTFont(newFont).handle, this);

            currentFont = newFont;

        }

    }

    /**

     * Returns left bound of clip rectangle.

     *

     * @return Left bound of clip rectangle.

     */

    public int getClipX()

    {

        synchronized(graphicsBuffer)

        {

            return currentClip[0];

        }

    }

    /**

     * Returns top bound of clip rectangle.

     *

     * @return Top bound of clip rectangle.

     */

    public int getClipY()

    {

        synchronized(graphicsBuffer)

        {

            return currentClip[1];

        }

    }

    /**

     * Returns width of clip rectangle.

     *

     * @return Width of clip rectangle.

     */

    public int getClipWidth()

    {

        synchronized(graphicsBuffer)

        {

            return currentClip[2];

        }

    }

    /**

     * Returns height of clip rectangle.

     *

     * @return Height of clip rectangle.

     */

    public int getClipHeight()

    {

        synchronized(graphicsBuffer)

        {

            return currentClip[3];

        }

    }

    /**

     * Intersects current clip rectangle with the specified one.

     *

     * @param x - left bound of the clip rectangle to intersect with the

     *            current one.

     * @param y - top bound of the clip rectangle to intersect with the

     *            current one.

     * @param w - width of the clip rectangle to intersect with the current one.

     * @param h - height of the clip rectangle to intersect with the current

     *            one.

     */

    public void clipRect(int x, int y, int w, int h)

    {

        synchronized(graphicsBuffer)

        {

            final int cx2 = Math.min(currentClip[0] + currentClip[2], x + w);

            final int cy2 = Math.min(currentClip[1] + currentClip[3], y + h);

            // setting of clip to Java Graphics

            currentClip[0] = Math.max(x, currentClip[0]);

            currentClip[1] = Math.max(y, currentClip[1]);

            currentClip[2] = cx2 - currentClip[0];

            currentClip[3] = cy2 - currentClip[1];

            graphicsBuffer.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], this);

        }

    }

    /**

     * Sets the clip rectangle.

     *

     * @param x - left bound of the new clip rectangle.

     * @param y - top bound of the new clip rectangle.

     * @param w - width of the new clip rectangle.