/*

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

*

*/

// INCLUDE FILES

#include "CM2GEventSource.h"

#include "com_nokia_microedition_m2g_M2GManager.h"

#include "CM2GSVGProxy.h"

#include "CM2GEventSource.h"

#include <swtcliententry.h>

M2G_NS_START

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// CLASS DECLARATION

// ================================ FUNCTIONS ==================================

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

// Java_com_nokia_microedition_m2g_M2GManager::_createSvgEngine

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

/**

 * Calls MM2GSVGProxy::CreateSvgEngineL method.

 * @since Series S60 3.0

 * @param aProxy Proxy instance.

 * @param aHandle Svg engine handle

 */

LOCAL_C void DoCreateSvgEngineL(MM2GSVGProxy* aProxy, TInt* aHandle)

{

    aProxy->CreateSvgEngineL(*aHandle);

}

/**

 * JNI method

 */

JNIEXPORT jint JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1createSvgEngine(

    JNIEnv* aJni,

    jclass,

    jint aEventSourceHandle,

    jint aSvgProxyHandle,

    jboolean /*aUiToolkit*/)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _createSvgEngine - begin");

    CM2GEventSource* eventSource = JavaUnhand< CM2GEventSource >(aEventSourceHandle);

    // Execute native engine method

    TInt handle = M2G_INVALID_HANDLE;

    if (eventSource && aSvgProxyHandle)

    {

        TInt err = eventSource->ExecuteTrap(

                       &DoCreateSvgEngineL,

                       JavaUnhand<MM2GSVGProxy>(aSvgProxyHandle),

                       &handle);

        handle = M2GGeneral::CheckErrorCodeAndHandle(

                     aJni, err, handle, M2G_INVALID_HANDLE);

    }

    M2G_DEBUG_1("M2G_DEBUG: JNI ( M2GManager ) _createSvgEngine: %d - end", handle);

    return handle;

}

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

// Java_com_nokia_microedition_m2g_M2GManager::_createSvgProxy

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

/**

 * Creates an svg proxy.

 * @since Series S60 3.0

 * @param Svg proxy handle

 */

LOCAL_C void DoCreateSvgProxyL(TInt* aHandle)

{

    MM2GSVGProxy* proxy = CM2GSVGProxy::NewL();

    *aHandle = JavaMakeHandle(proxy);

}

/**

 * JNI method

 */

JNIEXPORT jint JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1createSvgProxy(

    JNIEnv* aJni,

    jclass,

    jint aEventSourceHandle,

    jboolean aUiToolkit)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _createSvgProxy - begin");

    TInt handle = M2G_INVALID_HANDLE;

    TInt    err = KM2GNotOk;

    if (aUiToolkit)

    {

        MSwtClient* client = reinterpret_cast< MSwtClient* >(aEventSourceHandle);

        if (client)

        {

            typedef void (*pDoCreateSvgProxyL)(TInt* aHandle);

            pDoCreateSvgProxyL lDoCreateSvgProxyL = DoCreateSvgProxyL;

            TSwtM2gMethodWrapper1<TInt> DoCreateSvgProxy(

                lDoCreateSvgProxyL,

                &handle

            );

            err = client->Execute(DoCreateSvgProxy);

        }

    }

    else

    {

        CM2GEventSource* eventSource = JavaUnhand< CM2GEventSource >(aEventSourceHandle);

        if (eventSource)

        {

            err = eventSource->ExecuteTrap(&DoCreateSvgProxyL, &handle);

        }

    }

    handle = M2GGeneral::CheckErrorCodeAndHandle(aJni, err, handle, err);

    M2G_DEBUG_1("M2G_DEBUG: JNI ( M2GManager ) _createSvgProxy: %d - end", handle);

    return handle;

}

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

// Java_com_nokia_microedition_m2g_M2GManager::_deleteSvgEngine

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

/**

 * Calls MM2GSVGProxy::DeleteSvgEnginedL method.

 * @since Series S60 3.0

 * @param aProxy Proxy instance.

 */

LOCAL_C void DoDeleteSvgEngineL(MM2GSVGProxy* aProxy, TInt aSvgEngineHandle)

{

    aProxy->DeleteSvgEngineL(

        STATIC_CAST(TM2GSvgEngineHandle, aSvgEngineHandle));

}

/**

 * JNI method

 */

JNIEXPORT void JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1deleteSvgEngine(

    JNIEnv* aJni,

    jclass,

    jint aEventSourceHandle,

    jint aSvgProxyHandle,

    jint aSvgEngineHandle,

    jboolean /*aUiToolkit*/)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _deleteSvgEngine - begin");

    CM2GEventSource* eventSource = JavaUnhand< CM2GEventSource >(aEventSourceHandle);

    if (eventSource && aSvgProxyHandle && aSvgEngineHandle)

    {

        TInt err = eventSource->ExecuteTrap(

                       &DoDeleteSvgEngineL,

                       JavaUnhand<MM2GSVGProxy>(aSvgProxyHandle),

                       aSvgEngineHandle);

        M2GGeneral::CheckErrorCode(aJni, err);

    }

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _deleteSvgEngine: - end");

}

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

// Java_com_nokia_microedition_m2g_M2GManager::_deleteSvgProxy

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

/**

 * Deletes a proxy object. NOTE: The proxy object has to be deleted inside same

 * thread as it was created, otherwice there will be problem to delete a CFbsBitmap

 * server object inside the SVGTopt componenet see KATA-6KYA9T (SVGEngineJI: SVGTopt

 * crashes when deleting svg document object that contains external resource)

 * @since Series S60 3.0

 * @param aProxy Proxy instance.

 */

LOCAL_C void DoDeleteSvgProxyL(MM2GSVGProxy* aProxy)

{

    delete aProxy;

}

/**

 * JNI method

 */

JNIEXPORT void JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1deleteSvgProxy(

    JNIEnv* aJni,

    jclass,

    jint aEventSourceHandle,

    jint aSvgProxyHandle,

    jboolean aUiToolkit)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _deleteSvgProxy - begin");

    TInt            err = KM2GNotOk;

    if (aUiToolkit)

    {

        MM2GSVGProxy* proxy = JavaUnhand<MM2GSVGProxy>(aSvgProxyHandle);

        MSwtClient* client  = reinterpret_cast< MSwtClient* >(aEventSourceHandle);

        if (client && proxy)

        {

            typedef void (*pDoDeleteSvgProxyL)(MM2GSVGProxy* aProxy);

            pDoDeleteSvgProxyL lDoDeleteSvgProxyL = DoDeleteSvgProxyL;

            TSwtM2gMethodWrapper1<MM2GSVGProxy> DoDeleteSvgProxy(

                lDoDeleteSvgProxyL,

                proxy

            );

            err = client->Execute(DoDeleteSvgProxy);

        }

    }

    else

    {

        MM2GSVGProxy* proxy = JavaUnhand<MM2GSVGProxy>(aSvgProxyHandle);

        CM2GEventSource* eventSource = JavaUnhand< CM2GEventSource >(aEventSourceHandle);

        if (eventSource && proxy)

        {

            err = eventSource->ExecuteTrap(&DoDeleteSvgProxyL, proxy);

        }

    }

    M2GGeneral::CheckErrorCode(aJni, err);

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _deleteSvgProxy: - end");

}

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

// Java_com_nokia_microedition_m2g_M2GManager::_finalizeEventSource

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

/**

 * JNI method

 */

JNIEXPORT void JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1finalizeEventSource(

    JNIEnv *aJni, jclass, jint aEventSourceHandle, jboolean aUiToolkit)

{

    M2G_DEBUG_1("M2G_DEBUG: JNI ( M2GManager ) _finalizeEventSource: %d", aEventSourceHandle);

    if (aUiToolkit)

    {

        MSwtClient* client  = reinterpret_cast< MSwtClient* >(aEventSourceHandle);

        if (client)

        {

            delete client;

            client = NULL;

        }

    }

    else

    {

        CM2GEventSource* eventSource = JavaUnhand< CM2GEventSource >(aEventSourceHandle);

        if (eventSource)

        {

            eventSource->Dispose(*aJni);

        }

        eventSource = NULL;

    }

}

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

// Java_com_nokia_microedition_m2g_M2GManager::_initEventSource

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

/**

 * JNI method

 */

JNIEXPORT jint JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1initEventSource(

    JNIEnv *aJni,

    jclass aPeer,

    jint aServer)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _initEventSource - begin");

    TRAPD(eventSourceHandle, eventSourceHandle = CM2GEventSource::NewL(

                *aJni, aPeer, aServer));

    M2GGeneral::CheckHandle(aJni, eventSourceHandle);

    M2G_DEBUG_1("M2G_DEBUG: JNI ( M2GManager ) _initEventSource - end: %d", eventSourceHandle);

    return eventSourceHandle;

}

JNIEXPORT jint JNICALL

Java_com_nokia_microedition_m2g_M2GManager__1initSwtEventSource(

    JNIEnv *aJni,

    jclass /*aPeer*/)

{

    M2G_DEBUG_0("M2G_DEBUG: JNI ( M2GManager ) _initEventSource - begin");

    MSwtClient* client = NULL;

    TRAP_IGNORE(client = SWT::CreateClientL());

    if (!client)

    {

        return KErrNotFound;

    }

    M2GGeneral::CheckHandle(aJni, (int)client);

    M2G_DEBUG_1("M2G_DEBUG: JNI ( M2GManager ) _initEventSource - end: %d", eventSourceHandle);

    return (int)client;

}

M2G_NS_END