/*******************************************************************************

 * Copyright (c) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - initial API and implementation

 *******************************************************************************/

#include <QFont>

#include <QFontMetrics>

#include <QSharedDataPointer>

#include <org_eclipse_swt_internal_qt_graphics_OS.h>

#include "graphics.h"

#include "gfxlog.h"

#include "jniutils.h"

#include "swtapplication.h"

#include "autorelease.h"

#include "gfxutils.h"

using namespace Java::GFX;

#define POINTER_TO_HANDLE(pointer) reinterpret_cast<jint>( pointer )

#define HANDLE_TO_POINTER(type, variable, handle) type variable = reinterpret_cast<type>( handle )

#define ARRAY_CAST(type, variable) reinterpret_cast<type>( variable )

#define GFX_TRY try

#define GFX_CATCH \

catch(std::bad_alloc const&) \

    { \

        GfxException e(EGfxErrorNoMemory, "Bad alloc"); \

        swtApp->jniUtils().Throw(aJniEnv, e); \

    } \

catch(GfxException e) \

    { \

        swtApp->jniUtils().Throw(aJniEnv, e); \

    }

jint JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1get_1windowsurface

  (JNIEnv* aJniEnv, jclass, jint aHandle) 

{   

    WindowSurface* ws = NULL;

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        ws = gc->getWindowSurface();

    }

    GFX_CATCH

    return POINTER_TO_HANDLE(ws);

}

// Creates a new instance of native graphics context (gc)

jint JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1init

  (JNIEnv* aJniEnv , jclass)

{

    GraphicsContext* gc = 0;

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        gc = GraphicsFactory::createGraphicsContext();

    }

    GFX_CATCH

    return POINTER_TO_HANDLE(gc);

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1dispose

  (JNIEnv* aJniEnv , jclass, jint aHandle) 

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);  

        gc->dispose();

        gc = NULL;

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1bindTarget

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aTarget, jint aType, jint aBufferFlushTargetHandle)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->bindTarget(aTarget, (TTargetType)aType, static_cast<int>(aBufferFlushTargetHandle));

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1render

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aBufferHandle)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        HANDLE_TO_POINTER(Buffer*, buffer, aBufferHandle);

        gc->render(buffer);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1releaseTarget

  (JNIEnv* aJniEnv , jclass, jint aHandle) 

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->releaseTarget();

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1copyArea__IIII

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aTargetHandle, jint aX, jint aY)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        HANDLE_TO_POINTER(Image*, image, aTargetHandle);

        gc->copyArea(image, aX, aY);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1copyArea__IIIIIIIZ

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aSrcX, jint aSrcY, jint aWidth, jint aHeight, jint aDestX, jint aDestY, jboolean aPaint)

{   

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->copyArea(aSrcX, aSrcY, aWidth, aHeight, aDestX, aDestY, aPaint == JNI_TRUE ? true : false);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawArc

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight, jint aStartAngle, jint aArcAngle)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawArc(aX, aY, aWidth, aHeight, aStartAngle, aArcAngle);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawEllipse

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawEllipse(aX, aY, aWidth, aHeight);

    }

    GFX_CATCH

}

JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawFocus

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawFocus(aX, aY, aWidth, aHeight);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawImage__IIII

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aImageHandle, jint aX, jint aY)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        HANDLE_TO_POINTER(Image*, image, aImageHandle);

        gc->drawImage(image, aX, aY);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawImage__IIIIIIIIIII

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aImageHandle, jint aTx, jint aTy, jint aTw, jint aTh, 

  jint aSx, jint aSy, jint aSw, jint aSh, jint aManipulation)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        HANDLE_TO_POINTER(Image*, image, aImageHandle);

        gc->drawImage(image, aManipulation, aTx, aTy, aTw, aTh, aSx, aSy, aSw, aSh);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawLine

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX1, jint aY1, jint aX2, jint aY2)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawLine(aX1, aY1, aX2, aY2);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawPoint

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawPoint(aX, aY);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawPolygon

  (JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aPointArray)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int length = aJniEnv->GetArrayLength(aPointArray);

        int* buffer = new int[length]; // might throw bad_alloc

        AutoRelease<int> release(buffer, true);

        swtApp->jniUtils().GetJavaIntArrayRegionToIntArray(aJniEnv, aPointArray, 0, length, buffer); // might throw bad_alloc

        gc->drawPolygon(buffer, length);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawPolyline

  (JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aPointArray)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int length = aJniEnv->GetArrayLength(aPointArray);

        int* buffer = new int[length]; // might throw bad_alloc

        AutoRelease<int> release(buffer, true);

        swtApp->jniUtils().GetJavaIntArrayRegionToIntArray(aJniEnv, aPointArray, 0, length, buffer); // might throw bad_alloc

        gc->drawPolyline(buffer, length);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawRect

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawRect(aX, aY, aWidth, aHeight);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawRGB__I_3IIIIIIIZI

  (JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aRgbData, jint aOffset, jint aScanlength, 

    jint aX, jint aY, jint aWidth, jint aHeight, jboolean aProcessAlpha, jint aManipulation)

{

    GFX_TRY 

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int length = aJniEnv->GetArrayLength(aRgbData);

        int* buffer = new int[length]; // might throw bad_alloc

        AutoRelease<int> release(buffer, true);

        swtApp->jniUtils().GetJavaIntArrayRegionToIntArray(aJniEnv, aRgbData, 0, length, buffer); // might throw bad_alloc

        gc->drawRGB(buffer, length, aOffset, aScanlength, aX, aY, aWidth, aHeight, aProcessAlpha, aManipulation);

    } 

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawRGB__I_3B_3BIIIIIIII

  (JNIEnv *aJniEnv, jclass, jint aHandle, jbyteArray aRgbData, jbyteArray aTransparencyMask, 

  jint aOffset, jint aScanLength, jint aX, jint aY, jint aWidth, jint aHeight, jint aTransform, jint aFormat)

  {

    GFX_TRY 

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int dataLength = aJniEnv->GetArrayLength(aRgbData);

        int maskLength = aJniEnv->GetArrayLength(aTransparencyMask);

        char* dataBuffer = new char[dataLength]; // might throw bad_alloc

        AutoRelease<char> releaseData(dataBuffer, true);

        swtApp->jniUtils().GetJavaByteArrayRegionToCharArray(aJniEnv, aRgbData, 0, dataLength, dataBuffer); // might throw bad_alloc

        char* maskBuffer = NULL;

        AutoRelease<char> releaseMask(NULL, true); // Will delete mask or NULL if there's no mask

        if(aTransparencyMask)

        {

            maskBuffer = new char[maskLength]; // might throw bad_alloc

            releaseMask.reset(maskBuffer);

            swtApp->jniUtils().GetJavaByteArrayRegionToCharArray(aJniEnv, aTransparencyMask, 0, maskLength, maskBuffer); // might throw bad_alloc        

        }

        gc->drawRGB(dataBuffer, maskBuffer, dataLength, aOffset, aScanLength, aX, aY, aWidth, aHeight, aTransform, aFormat);

    }

    GFX_CATCH

  }

 void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawRGB__I_3SIIIIIIZII

  (JNIEnv * aJniEnv, jclass, jint aImageHandle, jshortArray aRgbData, jint aOffset, jint aScanlength,

   jint aX, jint aY, jint aWidth, jint aHeight, jboolean aProcessAlpha, jint aManipulation, jint aFormat)

 {

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aImageHandle);

        int length = aJniEnv->GetArrayLength(aRgbData);

        short* buffer = new short[length];

        AutoRelease<short> release(buffer, true);

        ::memset(buffer, 0, sizeof(short)*length);

        swtApp->jniUtils().GetJavaShortArrayRegionToShortArray(aJniEnv, aRgbData, 0, length, buffer); // might throw bad_alloc

        gc->drawRGB(buffer, length, aOffset, aScanlength, aX, aY, aWidth, aHeight, aProcessAlpha, aManipulation, aFormat);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawRoundRect

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight, jint aArcWidth, jint aArcHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawRoundRect(aX, aY, aWidth, aHeight, aArcWidth, aArcHeight);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1drawString

  (JNIEnv* aJniEnv, jclass, jint aHandle, jstring aText, jint aX, jint aY, jint aWidth, jint aHeight,

  jint aAlignments, jint aFlags, jboolean aIsTransparent) 

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        const jchar* chars; // unsigned short (2 bytes) 

        int length;

        length = aJniEnv->GetStringLength(aText);

        chars = aJniEnv->GetStringChars(aText, NULL);

        AutoReleaseStringChars release(aJniEnv, aText, chars);

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->drawString(

            (const unsigned short*)chars, 

            aX, 

            aY,

            aWidth,

            aHeight,

            length, 

            aAlignments,

            aFlags,

            aIsTransparent);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillArc

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight, jint aStartAngle, jint aArcAngle)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->fillArc(aX, aY, aWidth, aHeight, aStartAngle, aArcAngle);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillEllipse

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight) 

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->fillEllipse(aX, aY, aWidth, aHeight);   

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillGradientRect

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight, jboolean aVertical, jboolean aSwapColors)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->fillGradientRect(aX, aY, aWidth, aHeight, aVertical, aSwapColors);  

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillPolygon

  (JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aPointArray)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int length = aJniEnv->GetArrayLength(aPointArray);

        int* buffer = new int[length]; // might throw bad_alloc

        AutoRelease<int> release(buffer, true);

        swtApp->jniUtils().GetJavaIntArrayRegionToIntArray(aJniEnv, aPointArray, 0, length, buffer); // might throw bad_alloc

        gc->fillPolygon(buffer, length);

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillRect

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->fillRect(aX, aY, aWidth, aHeight);  

    }

    GFX_CATCH

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1fillRoundRect

  (JNIEnv* aJniEnv , jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight, jint aArcWidth, jint aArcHeight)

{

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        gc->fillRoundRect(aX, aY, aWidth, aHeight, aArcWidth, aArcHeight);

    }

    GFX_CATCH

}

jint JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1getBackgroundAlpha

  (JNIEnv* aJniEnv , jclass, jint aHandle)

{

    jint bgAlpha = 0;

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        bgAlpha = static_cast<jint>( gc->getBackgroundAlpha() );

    }

    GFX_CATCH

    return bgAlpha;

}

jint JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1getBackgroundColor

  (JNIEnv* aJniEnv , jclass, jint aHandle)

{

    jint bgColor = 0;

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        bgColor = static_cast<jint>( gc->getBackgroundColor() );

    }

    GFX_CATCH

    return bgColor;

}

jint JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1getCharacterWidth

  (JNIEnv* aJniEnv , jclass, jint aHandle, jchar aCh, jboolean aIsAdvanced)

{

    jint charWidth = 0;

    GFX_TRY

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        charWidth = static_cast<jint>( gc->getCharacterWidth(aCh, aIsAdvanced) );

    }

    GFX_CATCH

    return charWidth;

}

void JNICALL Java_org_eclipse_swt_internal_qt_graphics_OS_graphicsContext_1getFontMetricsData

  (JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aDataArray, jint aFontHandle)

{

    GFX_TRY 

    {

        GFX_LOG_JNI_CALL();

        HANDLE_TO_POINTER(GraphicsContext*, gc, aHandle);

        int length = aJniEnv->GetArrayLength(aDataArray);

        int* buffer = new int[length]; // might throw bad_alloc

        AutoRelease<int> release(buffer, true);

        ::memset(buffer, 0, sizeof(int)*length);

        if (aFontHandle)

        {

            HANDLE_TO_POINTER(QFont*, font, aFontHandle);

            gc->getFontMetricsData(buffer, *font);