/*

* Copyright (c) 2002 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:

*

*/

#include "CMIDToolkit.h"

#include "MIDUtils.h"

#include "javax_microedition_lcdui_Canvas.h"

#ifdef LCDUI_DEBUG_ON

#include <jdebug.h>

#define LCDUI_DEBUG_INT2(msg, x, y) DEBUG_INT2(msg, x, y)

#else

#define LCDUI_DEBUG_INT2(msg, x, y)

#endif

struct TCanvasCreate

{

    jweak       iRef;

    jint        iDisplayable;

    jboolean    iIsGameCanvas;

};

struct TCanvasAttribs

{

    TInt  iHandle;

    TSize iSize;

    TBool iFrameBuffer;

    TBool iHasBackground;

};

LOCAL_C void CreateCanvasL(CMIDToolkit* aToolkit, TCanvasCreate* aCreate, TCanvasAttribs* aAttribs)

{

    MMIDDisplayable* container = MIDUnhand<MMIDDisplayable>(aCreate->iDisplayable);

    // Create a new MMIDCanvas object

    MMIDCanvas* canvas = aToolkit->ComponentFactory()->CreateCanvasL(

                             *container,

                             (aCreate->iIsGameCanvas ? MMIDComponent::EGameCanvas : MMIDComponent::ECanvas));

    CleanupDisposePushL(canvas);

    aAttribs->iHandle = aToolkit->RegisterComponentL(canvas, aCreate->iRef);

    container->SetComponentL(*canvas);

    CleanupPopComponent(canvas);

    aCreate->iRef = 0;

    aAttribs->iSize = canvas->ContentSize();

    aAttribs->iFrameBuffer = static_cast< TBool >(canvas->FrameBuffer() != NULL);

    // Check from a MMIDEnv object if the canvas object has a background or not

    aAttribs->iHasBackground = aToolkit->Env()->CanvasHasBackground(*canvas);

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1create

(

    JNIEnv*   aJni,

    jobject   aCanvas,

    jint      aToolkit,

    jint      aDisplayable,

    jboolean  aIsGameCanvas,

    jintArray aAttribsReturn

)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    TCanvasCreate create;

    create.iDisplayable=aDisplayable;

    create.iRef= aJni->NewWeakGlobalRef(aCanvas);

    create.iIsGameCanvas = aIsGameCanvas;

    TCanvasAttribs attribs;

    attribs.iFrameBuffer=EFalse;

    attribs.iHasBackground = EFalse;

    jint error;

    if (create.iRef)

    {

        error = toolkit->ExecuteTrap(&CreateCanvasL, toolkit, &create, &attribs);

    }

    else

    {

        error = KErrNoMemory;

    }

    if (create.iRef)

    {

        // should be cleared in CreateCanvasL if no error

        aJni->DeleteWeakGlobalRef(create.iRef);

    }

    ASSERT(aJni->GetArrayLength(aAttribsReturn) == 5);

    jint attribsArray[5];

    attribsArray[0] = static_cast< jint >(attribs.iHandle);

    attribsArray[1] = static_cast< jint >(attribs.iSize.iWidth);

    attribsArray[2] = static_cast< jint >(attribs.iSize.iHeight);

    attribsArray[3] = static_cast< jint >(attribs.iFrameBuffer);

    attribsArray[4] = static_cast< jint >(attribs.iHasBackground);

    aJni->SetIntArrayRegion(aAttribsReturn, 0, 5, &attribsArray[0]);

    LCDUI_DEBUG_INT2("Canvas_create(%x == %x)", handle, (TInt)MIDUnhandObject<MMIDCanvas>(handle));

    return error;

}

LOCAL_C TInt GetKeyCode(MMIDUtils* aUtils,TInt aGameAction)

{

    return aUtils->GetKeyCode(aGameAction);

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1getKeyCode

(JNIEnv *,jobject,jint aToolkit,jint aGameAction)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    jint keyCode = toolkit->Execute(&GetKeyCode, toolkit->Utils(),(TInt)aGameAction);

    return keyCode;

}

LOCAL_C void GetKeyName(MMIDUtils* aUtils,TDes* aText,TInt aKeyCode)

{

    aUtils->GetKeyName(*aText,aKeyCode);

}

JNIEXPORT jstring JNICALL Java_javax_microedition_lcdui_Canvas__1getKeyName

(JNIEnv* aJni,jobject,jint aToolkit,jint aKeyCode)

{

    TBuf<KMaxName> keyName;

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    toolkit->ExecuteV(&GetKeyName,toolkit->Utils(),(TDes*)&keyName,(TInt)aKeyCode);

    jstring str = CreateJavaString(*aJni,keyName);

    return str;

}

LOCAL_C TInt GetGameAction(MMIDUtils* aUtils,TInt aKeyCode)

{

    return aUtils->GetGameAction(aKeyCode);

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1getGameAction

(JNIEnv*, jclass, jint aToolkit, jint aKeyCode)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    jint gameAction = toolkit->Execute(&GetGameAction, toolkit->Utils(), (TInt)aKeyCode);

    LCDUI_DEBUG_INT2("getGameAction(%d) -> %d", aKeyCode, gameAction);

    return gameAction;

}

LOCAL_C void InvokeGetCanvasSize(MMIDCanvas* aCanvas, TSize* aSize)

{

    *aSize = aCanvas->ContentSize();

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1getCanvasSize

(

    JNIEnv*,

    jobject,

    jint aToolkit,

    jint aCanvas

)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    MMIDCanvas* canvas = MIDUnhand<MMIDCanvas>(aCanvas);

    TSize size;

    toolkit->ExecuteV(&InvokeGetCanvasSize, canvas, &size);

    return (size.iWidth << 16) | (size.iHeight & 0x0000ffff);

}

LOCAL_C void InvokeSuppressKeys(MMIDCanvas* aCanvas)

{

    ASSERT(aCanvas);

    aCanvas->SuppressKeys();

}

JNIEXPORT void JNICALL Java_javax_microedition_lcdui_Canvas__1suppressKeyEvents

(JNIEnv*,jobject,jint aToolkit,jint aCanvas)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    MMIDCanvas*  canvas  = MIDUnhand<MMIDCanvas>(aCanvas);

    toolkit->ExecuteV(&InvokeSuppressKeys, canvas);

}

LOCAL_C TInt InvokeGameActions(MMIDCanvas* aCanvas)

{

    ASSERT(aCanvas);

    return TInt(aCanvas->GameActions());

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1getKeyStates

(JNIEnv *,jobject,jint aToolkit, jint aCanvas)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    MMIDCanvas*  canvas  = MIDUnhand<MMIDCanvas>(aCanvas);

    TInt actions = toolkit->Execute(&InvokeGameActions, canvas);

    return actions;

}

LOCAL_C void InvokeSetFullScreenModeL(jint aDisplayable,jboolean aFullScreen, jint* aSizeArray)

{

    MMIDDisplayable* displayable = MIDUnhandObject<MMIDDisplayable>(aDisplayable);

    MMIDCanvas* canvas = (MMIDCanvas*)displayable->Component();

    displayable->SetFullScreenModeL(aFullScreen);

    TSize size = canvas->ContentSize();

    aSizeArray[0]=size.iWidth;

    aSizeArray[1]=size.iHeight;

}

JNIEXPORT jint JNICALL Java_javax_microedition_lcdui_Canvas__1setFullScreenMode

(JNIEnv* aEnv,jobject,jint aToolkit,jint aDisplayable,jboolean aFullScreen, jintArray aSizeReturn)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    jint sizeArray[2];

    jint err = toolkit->ExecuteTrap(&InvokeSetFullScreenModeL, aDisplayable, aFullScreen, sizeArray);

    aEnv->SetIntArrayRegion(aSizeReturn, 0, 2, sizeArray);

    return err;

}

LOCAL_C jboolean InvokeNetworkIndicatorLocation(MMIDCanvas* aCanvas, jint* aPositionArray, jint* aSizeArray)

{

    TSize size;

    TPoint position;

    TBool indicatorExists = aCanvas->NetworkIndicatorLocation(position, size);

    aPositionArray[0] = position.iX;

    aPositionArray[1] = position.iY;

    aSizeArray[0] = size.iWidth;

    aSizeArray[1] = size.iHeight;

    return indicatorExists;

}

JNIEXPORT jboolean JNICALL Java_javax_microedition_lcdui_Canvas__1getNetworkIndicatorLocation

(JNIEnv* aEnv,jobject, jint aToolkit, jint aCanvas, jintArray aPosition, jintArray aSize)

{

    CMIDToolkit* toolkit = JavaUnhand<CMIDToolkit>(aToolkit);

    MMIDCanvas*  canvas  = MIDUnhand<MMIDCanvas>(aCanvas);

    jint positionArray[2];

    jint sizeArray[2];

    jboolean indicatorExists = toolkit->Execute(&InvokeNetworkIndicatorLocation, canvas, positionArray, sizeArray);

    aEnv->SetIntArrayRegion(aPosition, 0, 2, positionArray);

    aEnv->SetIntArrayRegion(aSize,     0, 2, sizeArray);

    return indicatorExists;

}