/*

* 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 com.nokia.microedition.m2g;

import com.nokia.microedition.m2g.M2GRunnableQt;

import javax.microedition.m2g.*;

import javax.microedition.m2g.ScalableGraphics;

import javax.microedition.lcdui.Graphics;

import java.lang.StringBuffer;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Rectangle;

import com.nokia.mj.impl.utils.Logger;

import com.nokia.mj.impl.nokialcdui.LCDUIInvoker;

import org.eclipse.swt.internal.qt.GCData;

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

/*

 * ScalableGraphics

 */

public class M2GScalableGraphics

        extends M2GObject

{

    //--------------------------------------------------

    // STATIC CONSTANTS

    //--------------------------------------------------

    // Transparency alpha max and min limits

    private static final float MAX_TRANSPARENCY_ALPHA = 1.0f;

    private static final float MIN_TRANSPARENCY_ALPHA = 0.0f;

    //--------------------------------------------------

    // VARIABLES

    //--------------------------------------------------

    private GC        iTargetGC      = null;

    private int iUseNativeClear = 0;

    private Graphics iTargetGraphics;

    private Rectangle iSurfaceRectangle;

    private Rectangle iFinalESWTSurfaceRectangle;

    //--------------------------------------------------

    // METHODS

    //--------------------------------------------------

    /**

     * Constructor

     */

    public M2GScalableGraphics()

    {

        super();

        doConstruct();

    }

    /**

     * @see javax.microedition.m2g.ScalableGraphics#bindTarget()

     */

    public synchronized void bindTarget(Object target)

    {

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doConstruct()

     */

    public void doConstruct()

    {

        register(this);

    }

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doCleanup()

     */

    public synchronized void doCleanup()

    {

        resetHandles();

        iTargetGC = null;

        iTargetGraphics = null;

    }

    /**

     * @see javax.microedition.m2g.ScalableGraphics#releaseTarget()

     */

    public synchronized void releaseTarget()

    {

            iTargetGC = null;

        }

        }

            throw new IllegalStateException(/*SF*/"Target is not bound"/*SF*/);

    }

    public synchronized void render(

        int x, int y, ScalableImage image, boolean aUseNativeClear)

    {

        iUseNativeClear = aUseNativeClear ? 1 : 0;

        render(x, y, image);

        iUseNativeClear = 0;

    }

    /**

     * @see javax.microedition.m2g.ScalableGraphics#render()

     */

    public synchronized void render(int x, int y, ScalableImage image)

    {

        if (image == null)

        {

            Logger.ELOG(Logger.EJavaUI, "render() - exception: "

                        + /*SF*/"The target is null"/*SF*/);

            throw new NullPointerException(/*SF*/"The target is null"/*SF*/);

        }

        {

            final M2GDocument finalDoc = (M2GDocument)((SVGImage)image).getDocument();

            // Get synchronized svg image data

            final int finalSvgW  = image.getViewportWidth();

            final int finalSvgH = image.getViewportHeight();

            if ((finalSvgW == 0) || (finalSvgW == 0))

            {

                return;

            }

            Rectangle clipRect = iFinalESWTSurfaceRectangle;

            final int finalClipX = clipRect.x;

            final int finalClipY = clipRect.y;

            final int finalClipW = clipRect.width;

            final int finalClipH = clipRect.height;

            // if none of the svg image is visible due to clipping then don't

            // bother to call render

            if ((x >= (finalClipX + finalClipW)) || (y >= (finalClipY + finalClipH)))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "render() - svg image isn't visible due to clipping");

                return;

            }

            if (((x + finalSvgW) < finalClipX) || ((y + finalSvgW) < finalClipY))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "render() - svg image isn't visible due to clipping");

                return;

            }

        }//if(true)

            final M2GDocument finalDoc = (M2GDocument)((SVGImage)image).getDocument();

            // Get synchronized svg image data

            final int finalSvgW  = image.getViewportWidth();

            final int finalSvgH = image.getViewportHeight();

            if ((finalSvgW == 0) || (finalSvgH == 0))

                return;

            }

            final int finalClipX = iSurfaceRectangle.x;

            final int finalClipY = iSurfaceRectangle.y;

            final int finalClipW  = iSurfaceRectangle.width;

            final int finalClipH = iSurfaceRectangle.height;

            // if none of the svg image is visible due to clipping then don't

            // bother to call render

            if ((x >= (finalClipX + finalClipW)) || (y >= (finalClipY + finalClipH)))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "render() - svg image isn't visible due to clipping");

                return;

            }

            if (((x + finalSvgW) < finalClipX) || ((y + finalSvgH) < finalClipY))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "render() - svg image isn't visible due to clipping");

                return;

            }

        }

    }

    /**

     * @see javax.microedition.m2g.ScalableGraphics#setRenderingQuality(int)

     */

    public synchronized void setRenderingQuality(int mode)

    {

        if ((mode == ScalableGraphics.RENDERING_QUALITY_LOW) ||

                (mode == ScalableGraphics.RENDERING_QUALITY_HIGH))

        {

        }

        else

        {

            Logger.ELOG(Logger.EJavaUI,

                        "setRenderingQuality() - exception: " + /*SF*/"The mode is invalid"/*SF*/);

            throw new IllegalArgumentException(/*SF*/"The mode is invalid"/*SF*/);

        }

    }

    /**

     * @see javax.microedition.m2g.ScalableGraphics#setTransparency(float)

     */

    public synchronized void setTransparency(float alpha)

    {

        if (alpha >= MIN_TRANSPARENCY_ALPHA && alpha <= MAX_TRANSPARENCY_ALPHA)

        {

        }

        else

        {

            Logger.ELOG(Logger.EJavaUI,

                        "setTransparency() - exception: " + /*SF*/"The alpha is out of range"/*SF*/);

            throw new IllegalArgumentException(/*SF*/"The alpha is out of range"/*SF*/);

        }

    }

    //--------------------------------------------------

    // NATIVE METHODS

    //--------------------------------------------------

    private native int _bind(

        int aRenderContextHandle, int aTargetHandle);

    private native int _createRenderContext(

        int aSVGProxyHandle);

    private native void _deleteRenderContext(

        int aRenderContextHandle);

    private native int _release(

    private native int _renderLCDUI(

        int aX, int aY, int aClipX, int aClipY, int aClipW, int aClipH,

        int aSvgW, int aSvgH, float aCurrentTime);

    private native int[] _renderESWT(

        int aX, int aY, int aClipX, int aClipY, int aClipW, int aClipH,

        int aSvgW, int aSvgH, float aCurrentTime, int iUseNativeClear);

    private native void _setRenderingQuality(

    private native void _setTransparency(

}