/*

* Copyright (c) 2005 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 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;

import org.eclipse.swt.internal.extension.GraphicsUtil; 

/*

 * ScalableGraphics

 */

public class M2GScalableGraphics

        extends M2GObject

{

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

    // STATIC CONSTANTS

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

    // Exception text

    /* Optimization: static finals changed to local variables

    private static final String ALPHA_OUT_OF_RANGE_ESTR =

        "The alpha is out of range";

    private static final String INVALID_TARGET_ESTR =

        "The target is invalid";

    private static final String MODE_INVALID_ESTR =

        "The mode is invalid";

    private static final String NULL_IMAGE_ESTR =

        "The image is null";

    private static final String NULL_TARGET_ESTR =

        "The target is null";

    private static final String TARGET_ALREADY_BOUND_ESTR =

        "Target is already bound";

    private static final String TARGET_NOT_BOUND_ESTR =

        "Target is not bound";

    */

    // 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;

     int iSurfaceHandle;

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

    // METHODS

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

    /**

     * Constructor

     */

    public M2GScalableGraphics()

    {

        super();

        doConstruct();

    }

    /**

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

     */

    public synchronized void bindTarget(Object target)

    {

    	if (target == null )

    	{

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

    	}

    	if (target instanceof org.eclipse.swt.graphics.GC)

        	{

			final GC finalGc = (GC)target;

        	// Execute in UI thread     

        	Platform.executeInUIThread(

                new M2GRunnableQt() {

                    public void doRun() {

                    	iFinalESWTSurfaceRectangle = GraphicsUtil.startExternalRendering(finalGc);

                    	// Get GCData from GC

                    	/*TODO check for this cahnge GCData gcData = ((org.eclipse.swt.graphics.GC)finalGc).getGCData();    

                    	// Get internalGC (Graphicscontext), WindowSurface and the WindowSurface handle for native access

                        iSurfaceHandle = gcData.internalGc.getWindowSurface().getHandle();*/

                    	iSurfaceHandle = GraphicsUtil.getWindowSurface(finalGc).getHandle();

                        _bind(getHandle(), iSurfaceHandle);

                      }

                      });

                    //  currentTarget = target;

        		iTargetGC = (GC)finalGc;

		    // Handling for LCDUI Graphics

		    //

		    }

//Change accordingly to M3G not as site content.		    

		    else if (target instanceof javax.microedition.lcdui.Graphics)

		    {

		    	Graphics g = (Graphics)target;

		    	final Graphics finalG = g;

		    	iSurfaceRectangle = LCDUIInvoker.startExternalRendering( finalG );

		    	 // Execute in UI thread     

			        Platform.executeInUIThread(

			                new M2GRunnableQt() {

			                    public void doRun() {

                        		iSurfaceHandle = LCDUIInvoker.getWindowSurface(finalG).getHandle();

                        		// Flush Canvas

								            //M2GManager.flushDisplayBuffer();

		                        _bind(getHandle(), iSurfaceHandle);

			                    }

			                  });

			                  iTargetGraphics  = (Graphics)finalG;

		    	}

	         else {

			        throw new IllegalArgumentException();

			    }

    	//TODO Check for : when to give this exception java.lang.IllegalStateException - if target is already bound.

  }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**

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

     */

    public void doConstruct()

    {

      super.doConstruct();

    	 // Execute in UI thread     

	    Platform.executeInUIThread(

            new M2GRunnableQt() {

                public void doRun() {

										        setHandle(_createRenderContext(

										                      getNativeSVGProxyHandle() ));

										        // Add object to the live objects container

										      }

										    });

        register(this);

    }

    /**

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

     */

    public synchronized void doCleanup()

    {

 		    	 // Execute in UI thread     

			        Platform.executeInUIThread(

			                new M2GRunnableQt() {

			                    public void doRun() {  	

																			        _deleteRenderContext(

																			            getHandle() );

																			          }

																			       }

																			    );      

        resetHandles();

        iTargetGC = null;

        iTargetGraphics = null;

    }

    /**

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

     */

    public synchronized void releaseTarget()

    {

      if (iTargetGC != null)

      {

			Platform.executeInUIThread(

            new M2GRunnableQt() {

             public void doRun() {

            	 						   GraphicsUtil.endExternalRendering(iTargetGC);

            	      				      _release(iSurfaceHandle, getHandle());

            	      				    }

            	      				  });

            iTargetGC = null;

        }

			else if (iTargetGraphics != null )

		    {

				final Graphics finalG = iTargetGraphics;

				Platform.executeInUIThread(

	            new M2GRunnableQt() {

	             public void doRun() {

	            			_release(iSurfaceHandle, getHandle());

	            		}

	            	});

				LCDUIInvoker.endExternalRendering( iTargetGraphics );

        iTargetGraphics = null;

        }

      else 

      	{

  		   // check for invalid Graphics TODO this exception is getting trough when we trying to bind.s

            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*/);

        }

       if (iTargetGC != null)

        {

            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;

            }

            // Calculate clip dimensions TODO check the new clipping rect provided from StartExternalRendering API.s

            //Rectangle clipRect = iTargetGC.getClipping();

            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;

            }

						final int finalX = x;            

						final int finalY = y; 

        		    	 // Execute in UI thread   

	        Platform.executeInUIThread(

	                new M2GRunnableQt() {

	                    public void doRun() {         

																			final int[] finalData = _renderESWT(getHandle(),

											                                     finalDoc.getHandle(), finalX, finalY,

											                                     finalClipX, finalClipY, finalClipW, finalClipH, finalSvgW, finalSvgW,

											                                     finalDoc.getRootElement().getCurrentTime(),

											                                     iUseNativeClear);

																				int[] bitmapHandles;

														            bitmapHandles = new int[4];

														            for (int i = 0; i < 4; i++)

														            {

														                bitmapHandles[i] = finalData[i];

														            }

														            int[] renderData;

														            renderData = new int[6];

														            for (int i = 0; i < 6; i++)

														            {

														                renderData[i] = finalData[i+4];

														            }

														            //iTargetGC.internal_drawM2GImage(bitmapHandles, renderData, iUseNativeClear);

																					}});											                                     

        }//if(true)

		else if (iTargetGraphics != null)

		    {

            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;

            }

            //TODO as we are using Surface rectangle provided by StartExternalRendering as Clip Rectangle.

            final int finalClipX = iSurfaceRectangle.x;

            final int finalClipY = iSurfaceRectangle.y;

            final int finalClipW  = iSurfaceRectangle.width;

            final int finalClipH = iSurfaceRectangle.height;

            // Calculate clip dimensions

            /*final int finalClipX = iTargetGraphics.getClipX() + iTargetGraphics.getTranslateX();

            final int finalClipY = iTargetGraphics.getClipY() + iTargetGraphics.getTranslateY();

            final int finalClipW  = iTargetGraphics.getClipWidth();

            final int finalClipH = iTargetGraphics.getClipHeight();*/

            // 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;

            }

				final int finalX = x;            

				final int finalY = y;

      		    	 // Execute in UI thread     

        Platform.executeInUIThread(

                new M2GRunnableQt() {

                    public void doRun() {

								            _renderLCDUI(getHandle(), finalDoc.getHandle(), finalX, finalY,

								                         finalClipX, finalClipY, finalClipW, finalClipH, finalSvgW, finalSvgH,

								                         finalDoc.getRootElement().getCurrentTime());

								                       }});

        }

       else 

        	{

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

                + /*SF*/"Target is not bound"/*SF*/);//TODO for time being commented.s

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

        	}

    }

    /**

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

     */

    public synchronized void setRenderingQuality(int mode)

    {

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

                (mode == ScalableGraphics.RENDERING_QUALITY_HIGH))

        {

        	final int finalMode = mode;

        			    	 // Execute in UI thread     

			        Platform.executeInUIThread(

			                new M2GRunnableQt() {

			                    public void doRun() {

											            _setRenderingQuality(getHandle(), finalMode);

											          }

											        });

        }

        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)

        {

        	final float finalAlpha = alpha;

        			    	 // Execute in UI thread     

			        Platform.executeInUIThread(

			                new M2GRunnableQt() {

			                    public void doRun() {

            															_setTransparency(getHandle(), finalAlpha);

            														}

            													}

            													);

        }

        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(

       int aSurfaceHandle ,int aRenderContextHandle);

    private native int _renderLCDUI(

       int aRenderContextHandle, int aDocumentHandle,

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

        int aSvgW, int aSvgH, float aCurrentTime);

    private native int[] _renderESWT(

       int aRenderContextHandle, int aDocumentHandle,

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

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

    private native void _setRenderingQuality(

       int aRenderContextHandle, int aMode);

    private native void _setTransparency(

       int aRenderContextHandle, float aAlpha);

}