/*

* 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.GC;

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.JavaCommandBuffer;

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 RGB_MASK = 0x00FFFFFF;

    static final int COMPONENT_MASK = 0xFF;

    private DirectGraphics directGraphics;

    // Graphics rectangle (off-screen buffer rectangle).

    // private Rectangle graphicsClientArea;

    // Graphics context for drawing to off-screen buffer.

    private GraphicsContext gc;

    // Off-screen buffer.

    //private org.eclipse.swt.internal.qt.graphics.Image frameBuffer;

    // Current font for rendering texts.

    private Font currentFont;

    private int currentColor;

    private int translateX;

    private int translateY;

    private int[] currentClip = new int[4];

    private int currentStrokeSyle;

    // Image owning the Graphics if the Graphics object belongs to an Image.

    private Image parentImage;

    // Flag indicating that we are in Canvas.paint() callback,

    // thus inside UI thread

    private boolean paintCallBack;

    private boolean buffered;

    private JavaCommandBuffer cmdBuffer;

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

    // serialization lock for command buffering and flush

    private final Object flushLock = new Object();

    private Canvas canvasParent;

    private CustomItem customItemParent;

    //Constructor

    Graphics() {

       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();

                                   }

                                });

                            }

                        }

                    }

                });

    }

    /**

     * Set the parent image of this Graphics.

     *

     * @param image an image

     */

    void eswtSetParentImage(final Image image) {

        if(buffered) {

            return;

        }

        if (parentImage != image) {

            parentImage = image;

            if (gc == null) {

                gc = new GraphicsContext();

            }

            else {

                gc.releaseTarget();

            }

            ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                public void run() {

                    org.eclipse.swt.graphics.Image eswtImage = Image.getESWTImage(image);

                    if (eswtImage != null) {

                        gc.bindTarget(Internal_GfxPackageSupport.getImage(eswtImage));

                        Rectangle clipRect = eswtImage.getBounds();

                        setClip(0, 0, clipRect.width, clipRect.height);

                    }

                    reset();

                }});

        }

    }

    /**

     * Initializes this instance of Graphics to use command buffer.

     * 

     * Can be called in a non-UI thread. Not thread-safe. 

     * 

     * @param x The x-coordinate of clip

     * @param y The y-coordinate of clip

     * @param width The width of clip

     * @param height The height of clip

     */

    void initBuffered(final Canvas parent, final int x, final int y, final int width, final int height) {

      ESWTUIThreadRunner.safeSyncExec(new Runnable() {

          public void run() {

              cmdBuffer = new JavaCommandBuffer();

              if (gc == null) {

                  gc = new GraphicsContext();

              }

              gc.bindTarget(cmdBuffer);

              setClip(x, y, width, height);

              reset();

              buffered = true;

              javax.microedition.lcdui.Graphics.this.canvasParent = parent;

          }});

    }

    /**

     * Initializes this instance of Graphics to use command buffer.

     * 

     * Can be called in a non-UI thread. Not thread-safe. 

     * 

     * @param x The x-coordinate of clip

     * @param y The y-coordinate of clip

     * @param width The width of clip

     * @param height The height of clip

     */

    void initBuffered(CustomItem parent, int x, int y, int width, int height) {

        cmdBuffer = new JavaCommandBuffer();

        if (gc == null) {

            gc = new GraphicsContext();

        }

        gc.bindTarget(cmdBuffer);

        setClip(x, y, width, height);

        reset();

        buffered = true;

        this.customItemParent = parent;

    }

	/**

	 * Resets the command buffer contents.

	 * 

	 * This is safe to call only in the UI thread. 

	 */

    void resetCommandBuffer() {

        gc.releaseTarget();

        cmdBuffer.reset();

        gc.bindTarget(cmdBuffer);

        // write settings which were active before flush 

        // if they are not the same as defaults

        gc.setFont(Font.getESWTFont(currentFont).handle);

        gc.setBackgroundColor(currentColor, false);

        gc.setForegroundColor(currentColor, false);

        if ((translateX != 0) || (translateY != 0)) { 

            gc.translate(translateX, translateY);

        }

        // Note that if called in a non-UI thread then the size of the

        // Canvas or CustomItem can change between getting the height and

        // getting the width. Those are modified by the UI thread and there

        // is no synchronization. 

        int w = 0;

        int h = 0;

        if(canvasParent != null) {

            w = canvasParent.getWidth();

            h = canvasParent.getHeight();

        } else {

            w = customItemParent.getContentWidth();

            h = customItemParent.getContentHeight();

        }

        if((currentClip[0] != 0) && (currentClip[1] != 0) && 

           (currentClip[2] != w) && (currentClip[2] != h)) {

            gc.setClip(currentClip[0], currentClip[1], currentClip[2], currentClip[3], false);

        }

        if (currentStrokeSyle != SOLID) {

            gc.setStrokeStyle(GraphicsContext.STROKE_DOT);

        }

    }

    /**

     * Returns the current command buffer or null. 

     * 

     * This method is thread-safe. 

     */

    JavaCommandBuffer getCommandBuffer() {

        return cmdBuffer;

    }

    /**

     * Get the parent image of this Graphics.

     */

    Image getParentImage() {

        return parentImage;

    }

    /**

     * Set Graphics context to a target - the GC is coming from paint event.

     *

     * @param eswtGC

     */

    void eswtSetGC(final GC eswtGC) {

       if(buffered) {

            return;

        }

        gc = eswtGC.getGCData().internalGc;

        ESWTUIThreadRunner.safeSyncExec(new Runnable() {

            public void run() {

                Rectangle clipRect = eswtGC.getClipping();

                setClip(clipRect.x, clipRect.y, clipRect.width, clipRect.height);

                reset();

            }});

    }

    /**

     * Disposes Graphics context resources.

     */

    void dispose() {

        if (parentImage != null) {

            parentImage = null;

        }

        if(gc != null) {

            ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                public void run() {

                    gc.dispose();

                }});

          gc = null;

        }

        if (cmdBuffer != null) {

          cmdBuffer = null;

        }

    }

    /**

     * Resets Graphics state to initial.

     */

    void reset() {

        setColor(0, 0, 0);

        setFont(Font.getDefaultFont());

        setStrokeStyle(Graphics.SOLID);

        this.translateX = 0;

        this.translateY = 0;

    }

    /**

     * 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 flag indicating that we are in Canvas.paint() callback

     */

    void beginPaint() {

        paintCallBack = true;

    }

    /**

     * Sets flag indicating that we are exiting Canvas.paint() callback

     */

    void endPaint() {

        paintCallBack = false;

    }

    /**

     * Provides the serialization lock for buffer writing and flushing

     * @return lock used for synchronizing command buffer access

     */

    Object getLock() {

        return flushLock;

    }

    /**

     * 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(flushLock) {

            if(!buffered) { 

                final int xDelta_ = xDelta;

                final int yDelta_ = yDelta;

                ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                    public void run() {

                        gc.translate(xDelta_, yDelta_);

                    }});

            } else {

                gc.translate(xDelta, yDelta);

            }

        }

        translateX += xDelta;

        translateY += yDelta;

    }

    /**

     * Returns current X-shift of coordinate translation.

     *

     * @return Current X-shift of coordinate translation.

     */

    public int getTranslateX() {

        return translateX;

    }

    /**

     * Returns current Y-shift of coordinate translation.

     *

     * @return current Y-shift of coordinate translation.

     */

    public int getTranslateY() {

        return translateY;

    }

    /**

     * Returns current color in 0x00RRGGBB format.

     *

     * @return Current color in 0x00RRGGBB format.

     */

    public int getColor() {

        return currentColor;

    }

    /**

     * Returns red component of current color.

     *

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

     */

    public int getRedComponent() {

        return currentColor >> 16;

    }

    /**

     * Returns green component of current color.

     *

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

     */

    public int getGreenComponent() {

        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() {

        return currentColor & COMPONENT_MASK;

    }

    /**

     * Returns current grayscale color.

     *

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

     */

    public int getGrayScale() {

        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(flushLock) {

            if(!buffered) { 

                final int r_ = r;

                final int g_ = g;

                final int b_ = b;

                ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                    public void run() {

                        gc.setForegroundColor(r_, g_, b_);

                        gc.setBackgroundColor(r_, g_, b_);

                    }});

            } else {

                gc.setForegroundColor(r, g, b);

                gc.setBackgroundColor(r, g, b);

            }

        }

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

    }

    /**

     * 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(flushLock) {

            if(!buffered) { 

                ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                    public void run() {

                        gc.setForegroundColor(r, g, b);

                        gc.setBackgroundColor(r, g, b);

                    }});

            } else {

                gc.setForegroundColor(r, g, b);

                gc.setBackgroundColor(r, g, b);

            }

        }

        currentColor = 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(flushLock) {

            if(!buffered) { 

                ESWTUIThreadRunner.safeSyncExec(new Runnable() {

                    public void run() {

                        gc.setForegroundColor(col, col, col);

                        gc.setBackgroundColor(col, col, col);

                    }});

            } else {

                gc.setForegroundColor(col, col, col);

                gc.setBackgroundColor(col, col, col);

            }

        }

        currentColor = ((col << 16) | (col << 8) | col) & RGB_MASK;

    }

    /**

     * Returns the current font.