/*

* 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: JNI implementation of CanvasGraphicsItem class

*

*/

// INTERNAL INCLUDES

#include "com_nokia_mid_ui_CanvasGraphicsItem.h"

#include "CMIDCanvas.h" // userinclude in nokialcdui.component

// EXTERNAL INCLUDES

#include <MMIDCanvasGraphicsItem.h>

#include <MMIDCanvasGraphicsItemPainter.h>

#include <CMIDToolkit.h>

#include <jutils.h>

#include <jdebug.h>

/**

 * Local helper function for creating the native side peer object for

 * CanvasGraphicsItem.

 *

 * @param aNativePeerHandle On return, contains the native peer's handle

 */

LOCAL_C void CreateNativePeerL(

    CMIDToolkit* aToolkit,

    jobject aPeer,

    TInt* aNativePeerHandle,

    MMIDCanvasGraphicsItemPainter* aItemPainter)

{

    // Get LCDUI component factory.

    MMIDComponentFactory* factory = aToolkit->ComponentFactory();

    // Create new graphics item component.

    MMIDCanvasGraphicsItem* graphicsItem = factory->CreateCanvasGraphicsItemL(

                                               aItemPainter);

    // Put the component to cleanup stack during the register operation.

    CleanupDisposePushL(graphicsItem);

    // Register component to the LCDUI.

    *aNativePeerHandle = aToolkit->RegisterComponentL(graphicsItem, aPeer);

    // Component can be popped from the cleanup stack.

    CleanupPopComponent(graphicsItem);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _createNativePeer

 * Signature: (I)I

 */

JNIEXPORT jint JNICALL

Java_com_nokia_mid_ui_CanvasGraphicsItem__1createNativePeer(

    JNIEnv* aJniEnv,

    jobject aPeer,

    jint aToolkitHandle,

    jint aPainterHandle,

    jint /* aWidth */,

    jint /* aHeight */)

{

    DEBUG("CanvasGraphicsItem.cpp - createNativePeer +");

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

    MMIDCanvasGraphicsItemPainter* itemPainter =

        MIDUnhandObject<MMIDCanvasGraphicsItemPainter>(aPainterHandle);

    jobject peer = aJniEnv->NewWeakGlobalRef(aPeer);

    TInt handle = -1;

    TSize size;

    TInt error = toolkit->ExecuteTrap(

                     &CreateNativePeerL,

                     toolkit,

                     peer,

                     &handle,

                     itemPainter);

    if (error == KErrNone)

    {

        DEBUG(

            "CanvasGraphicsItem.cpp - createNativePeer");

    }

    else

    {

        // Global reference must be removed at this point if construction

        // failed for some reason.

        aJniEnv->DeleteWeakGlobalRef(static_cast< jweak >(peer));

    }

    DEBUG_INT("CanvasGraphicsItem.cpp - createNativePeer, error = %d", error);

    return (error != KErrNone ? error : handle);

}

/**

 * Local helper function for setting the size of a graphics item

 *

 * @param aGraphicsItem The graphics item object to be modified.

 * @param aWidth The width of the graphics item.

 * @param aHeight The height of the graphics item.

 * @param aHeightInRows Indicates if the height is presented in rows.

 */

LOCAL_C void SetSizeL(

    MMIDCanvasGraphicsItem* aGraphicsItem,

    TInt aWidth,

    TInt aHeight)

{

    aGraphicsItem->SetSizeL(aWidth, aHeight);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _setSize

 * Signature: (IIII)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1setSize(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aWidth,

    jint aHeight)

{

    DEBUG("CanvasGraphicsItem.cpp - setSize +");

    CMIDToolkit* toolkit =

        JavaUnhand< CMIDToolkit >(aToolkitHandle);

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject< MMIDCanvasGraphicsItem >(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(

                     &SetSizeL,

                     item,

                     aWidth,

                     aHeight);

    DEBUG("CanvasGraphicsItem.cpp - setSize -");

    return error;

}

/**

 * Local helper function for setting the parent of a graphics item

 *

 * @param aGraphicsItem The graphics item object to be modified.

 * @param aParent The parent to be set.

 */

LOCAL_C void SetParentL(

    MMIDCanvasGraphicsItem* aGraphicsItem, MMIDComponent* aParent)

{

    MMIDCustomComponentContainer* container = NULL;

    MDirectContainer* directContainer = NULL;

    if (aParent)

    {

        MMIDComponent::TType type(aParent->Type());

        __ASSERT_DEBUG(type == MMIDComponent::ECanvas ||

                       type == MMIDComponent::ECustomItem,

                       User::Invariant());

        // Use static cast instead of reinterpret_cast because

        // reinterpret_cast does not preform the conversion correctly.

        // static_cast is OK eventhough CMIDCanvas is non-sharable class.

        // We don't use its methods.

        container = static_cast< CMIDCanvas* >(aParent);

        directContainer = static_cast< CMIDCanvas* >(aParent);

    }

    aGraphicsItem->SetParentL(container);

    aGraphicsItem->SetDirectContainerL(directContainer);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _setParent

 * Signature: (III)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1setParent(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aParentHandle)

{

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

    MMIDComponent* parent = NULL;

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    if (aParentHandle)

    {

        parent = MIDUnhandObject< MMIDComponent >(aParentHandle);

    }

    TInt error = toolkit->ExecuteTrap(

                     &SetParentL,

                     item,

                     parent);

    DEBUG_INT("CanvasGraphicsItem.cpp - setParent, error = %d", error);

    return error;

}

/**

 * Local helper function for setting a graphics item visible.

 *

 * @param aItem The graphics item to set visible.

 */

LOCAL_C void SetVisibleL(MMIDCanvasGraphicsItem* aItem, TBool aVisible)

{

    aItem->SetVisibleL(aVisible);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _show

 * Signature: (II)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1setVisible(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jboolean aVisible)

{

    DEBUG_INT("CanvasGraphicsItem.cpp - setVisible +, aVisible=%d", aVisible);

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

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(

                     &SetVisibleL,

                     item,

                     (TBool)aVisible);

    DEBUG_INT("CanvasGraphicsItem.cpp - setVisible -, error=%d", error);

    return error;

}

/**

 * Local helper function for setting a graphics item's position.

 *

 * @param aItem The graphics item.

 * @param aX The x coordinate of the anchor point.

 * @param aY The y coordinate of the anchor point.

 */

LOCAL_C void SetPosition(MMIDCanvasGraphicsItem* aItem, TInt aX, TInt aY)

{

    aItem->SetPosition(aX, aY);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _setPosition

 * Signature: (IIII)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1setPosition(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aX,

    jint aY)

{

    DEBUG("CanvasGraphicsItem.cpp - setPosition +");

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

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    toolkit->ExecuteV(&SetPosition, item, aX, aY);

    DEBUG("CanvasGraphicsItem.cpp - setPosition -");

    return KErrNone;

}

/**

 * Local helper function for setting the elevation of a graphics item.

 *

 * @param aGraphicsItem The graphics item object to be modified.

 * @param aZ The z-position defining the elevation.

 */

LOCAL_C void SetElevationL(MMIDCanvasGraphicsItem* aGraphicsItem, TInt aZ)

{

    aGraphicsItem->SetElevationL(aZ);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _setZPosition

 * Signature: (III)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1setZPosition(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aZ)

{

    DEBUG("CanvasGraphicsItem.cpp - setZPosition +");

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

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(

                     &SetElevationL,

                     item,

                     aZ);

    DEBUG_INT("CanvasGraphicsItem.cpp - setZPosition -, error=%d", error);

    return error;

}

/**

 * Local helper function for getting the elevation of a graphics item.

 *

 * @param aItem The graphics item.

 * @return The elevation of the graphics item's content.

 */

LOCAL_C TInt Elevation(MMIDCanvasGraphicsItem* aItem)

{

    return aItem->Elevation();

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _getZPosition

 * Signature: (II)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1getZPosition(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle)

{

    DEBUG("CanvasGraphicsItem.cpp - getZPosition +");

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

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    TInt position = toolkit->Execute(&Elevation, item);

    DEBUG_INT("CanvasGraphicsItem.cpp - getZPosition -, position=%d",

              position);

    return position;

}

/**

 * Local helper function for dispoisng graphics item native side component.

 *

 * @param aItem The graphics item to be destroyed.

 */

LOCAL_C void Dispose(CMIDToolkit* aToolkit, MMIDCanvasGraphicsItem* aItem)

{

    aToolkit->DisposeObject(aItem);

}

/*

 * Class:     com_nokia_mid_ui_CanvasGraphicsItem

 * Method:    _dispose

 * Signature: (II)V

 */

JNIEXPORT void JNICALL Java_com_nokia_mid_ui_CanvasGraphicsItem__1dispose(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle)

{

    DEBUG("CanvasGraphicsItem.cpp - dispose +");

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

    MMIDCanvasGraphicsItem* item =

        MIDUnhandObject<MMIDCanvasGraphicsItem>(aNativePeerHandle);

    toolkit->ExecuteV(&Dispose, toolkit, item);

    DEBUG("CanvasGraphicsItem.cpp - dispose -");

}