/*

* 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 TextEditor class

*

*/

// INTERNAL INCLUDES

#include "com_nokia_mid_ui_TextEditor.h"

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

// EXTERNAL INCLUDES

#include <MMIDTextEditor.h>

#include <CMIDToolkit.h>

#include <jutils.h>

#include <jdebug.h>

// UNNAMED LOCAL NAMESPACE

namespace

{

// The number of colors (r,g,b,a)

const TInt KNumColors       = 4;

const TInt KColorIndexRed   = 0;

const TInt KColorIndexGreen = 1;

const TInt KColorIndexBlue  = 2;

const TInt KColorIndexAlpha = 3;

}

/**

 * Local helper method for handling native strings and converting them to

 * Java strings.

 *

 * Error is set also in this method.

 *

 * @param aJniEnv A valid reference JNI environment.

 * @param aText The native descriptor to be converted.

 * @param aError The return value from ExecuteTrap.

 * @param aReturnError On return, contains an error code.

 * @return The converted Java string of NULL if the conversion failed.

 */

LOCAL_C jstring HandleString(

    JNIEnv& aJniEnv,

    const TDesC& aText,

    TInt aError,

    jintArray aReturnError)

{

    DEBUG("TextEditor.cpp - HandleString +");

    jstring javaText = NULL;

    // Create Java string if the operation was successful.

    if (aError == KErrNone)

    {

        javaText = CreateJavaString(aJniEnv, aText);

        // If NULL is returned, it indicates that the creation failed.

        if (!javaText)

        {

            aError = KErrNoMemory;

        }

    }

    jint errorArray[ 1 ] = { aError };

    aJniEnv.SetIntArrayRegion(aReturnError, 0, 1, errorArray);

    DEBUG_INT("TextEditor.cpp - HandleString -, aError=%d", aError);

    return javaText;

}

/**

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

 * TextEditor.

 *

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

 */

LOCAL_C void CreateNativePeerL(

    CMIDToolkit* aToolkit,

    jobject aPeer,

    TInt* aNativePeerHandle,

    TInt aMaxSize,

    TInt aWidth,

    TInt aHeight,

    TBool aHeightInRows,

    TSize* aSize)

{

    // Get LCDUI component factory.

    MMIDComponentFactory* factory = aToolkit->ComponentFactory();

    // Create new text editor component.

    MMIDTextEditor* textEditor = factory->CreateTextEditorL(

                                     aMaxSize, aWidth, aHeight, aHeightInRows);

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

    CleanupDisposePushL(textEditor);

    // Register component to the LCDUI.

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

    // Component can be popped from the cleanup stack.

    CleanupPopComponent(textEditor);

    // Store the size of the text editor.

    *aSize = textEditor->EditorSize();

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _createNativePeer

 * Signature: (I)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1createNativePeer(

    JNIEnv* aJniEnv,

    jobject aPeer,

    jint aToolkitHandle,

    jint aMaxSize,

    jint aWidth,

    jint aHeight,

    jboolean aHeightInRows,

    jintArray aSize)

{

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

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

    jobject peer = aJniEnv->NewWeakGlobalRef(aPeer);

    TInt handle = -1;

    TSize size;

    TInt error = toolkit->ExecuteTrap(

                     &CreateNativePeerL,

                     toolkit,

                     peer,

                     &handle,

                     aMaxSize,

                     aWidth,

                     aHeight,

                     (TBool)aHeightInRows,

                     &size);

    // Store returned size.

    if (error == KErrNone)

    {

        jint sizeArray[ 2 ] = { size.iWidth, size.iHeight };

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

        DEBUG_INT2("TextEditor.cpp - createNativePeer -, width=%d height=%d",

                   size.iWidth, size.iHeight);

    }

    else

    {

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

        // failed for some reason.

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

    }

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

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

}

/**

 * Local helper function for setting the multiline status of text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @param aMultiline The multiline status of the text editor to be set.

 */

LOCAL_C void SetMultilineL(

    MMIDTextEditor* aTextEditor,

    TBool aMultiline)

{

    aTextEditor->SetMultilineL(aMultiline);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setMultiline

 * Signature: (IIZ)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setMultiline(

    JNIEnv* /*aJniEnv*/,

    jobject /*aPeer*/,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jboolean aMultiline)

{

    DEBUG("TextEditor.cpp - setMultiline +");

    CMIDToolkit* toolkit =

        JavaUnhand<CMIDToolkit>(aToolkitHandle);

    MMIDTextEditor* editor =

        MIDUnhandObject<MMIDTextEditor>(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(&SetMultilineL, editor,

                                      (TBool)aMultiline);

    DEBUG_INT("TextEditor.cpp - setMultiline -, error=%d", error);

    return error;

}

/**

 * Local helper function for getting of multiline state of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @return The multiline state of the text editor.

 */

LOCAL_C TBool IsMultiline(MMIDTextEditor* aTextEditor)

{

    return aTextEditor->IsMultiline();

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _isMultiline

 * Signature: (IIZ)I

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mid_ui_TextEditor__1isMultiline(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle)

{

    DEBUG("TextEditor.cpp - isMultiline +");

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

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    TBool multiline = toolkit->Execute(&IsMultiline, editor);

    DEBUG_INT("TextEditor.cpp - isMultiline -, multiline=%d", multiline);

    return multiline;

}

/**

 * Local helper function for setting the size of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @param aWidth The width of the editor.

 * @param aHeight The height of the editor.

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

 */

LOCAL_C void SetSize(

    MMIDTextEditor* aTextEditor,

    TInt aWidth,

    TInt aHeight)

{

    aTextEditor->SetEditorSize(aWidth, aHeight);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setSize

 * Signature: (IIII)I

 */

JNIEXPORT int JNICALL Java_com_nokia_mid_ui_TextEditor__1setSize(

    JNIEnv* /*aJniEnv*/,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aWidth,

    jint aHeight)

{

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

    CMIDToolkit* toolkit =

        JavaUnhand< CMIDToolkit >(aToolkitHandle);

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    toolkit->ExecuteV(

        &SetSize,

        editor,

        aWidth,

        aHeight);

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

    return KErrNone;

}

/**

 * Local helper function for setting the parent of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @param aParent The parent to be set.

 */

LOCAL_C void SetParentL(MMIDTextEditor* aTextEditor, 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);

    }

    aTextEditor->SetParentL(container);

    aTextEditor->SetDirectContainerL(directContainer);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setParent

 * Signature: (III)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setParent(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aParentHandle)

{

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

    MMIDComponent* parent = NULL;

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    if (aParentHandle)

    {

        parent = MIDUnhandObject< MMIDComponent >(aParentHandle);

    }

    TInt error = toolkit->ExecuteTrap(

                     &SetParentL,

                     editor,

                     parent);

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

    return error;

}

/**

 * Local helper function for setting a text editor visible.

 *

 * @param aEditor The editor to set visible.

 */

LOCAL_C void SetVisibleL(MMIDTextEditor* aEditor, TBool aVisible)

{

    aEditor->SetVisibleL(aVisible);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _show

 * Signature: (II)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setVisible(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jboolean aVisible)

{

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

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

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(

                     &SetVisibleL,

                     editor,

                     (TBool)aVisible);

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

    return error;

}

/**

 * Local helper function for setting a text editor's position.

 *

 * @param aEditor The editor.

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

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

 */

LOCAL_C void SetPosition(MMIDTextEditor* aEditor, TInt aX, TInt aY)

{

    aEditor->SetPosition(aX, aY);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setPosition

 * Signature: (IIII)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setPosition(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jint aX,

    jint aY)

{

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

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

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

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

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

    return KErrNone;

}

/**

 * Local helper function for setting the touch enabled state of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @param aEnabled The touch enabled status of the text editor to be set.

 */

LOCAL_C void SetTouchEnabled(

    MMIDTextEditor* aTextEditor,

    TBool aEnabled)

{

    aTextEditor->SetTouchEnabled(aEnabled);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setTouchEnabled

 * Signature: (IIZ)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setTouchEnabled(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jboolean aEnabled)

{

    DEBUG("TextEditor.cpp - setTouchEnabled +");

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

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    toolkit->ExecuteV(&SetTouchEnabled, editor, (TBool)aEnabled);

    DEBUG("TextEditor.cpp - setTouchEnabled -");

    return KErrNone;

}

/**

 * Local helper function for setting the focus state of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @param aFocused The focus status of the text editor to be set.

 */

LOCAL_C void SetFocusStateL(

    MMIDTextEditor* aTextEditor,

    TBool aFocusState)

{

    aTextEditor->SetFocusStateL(aFocusState);

}

/*

 * Class:     com_nokia_mid_ui_TextEditor

 * Method:    _setFocusState

 * Signature: (IIZ)I

 */

JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_TextEditor__1setFocusState(

    JNIEnv* /* aJniEnv */,

    jobject /* aPeer */,

    jint aToolkitHandle,

    jint aNativePeerHandle,

    jboolean aFocusState)

{

    DEBUG("TextEditor.cpp - setFocusState +");

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

    MMIDTextEditor* editor =

        MIDUnhandObject< MMIDTextEditor >(aNativePeerHandle);

    TInt error = toolkit->ExecuteTrap(

                     &SetFocusStateL,

                     editor,

                     (TBool)aFocusState);

    DEBUG_INT("TextEditor.cpp - setFocusState -, error=%d", error);

    return error;

}

/**

 * Local helper function for getting of focus state of a text editor

 *

 * @param aTextEditor The text editor object to be modified.

 * @return The focus state of the text editor.

 */

LOCAL_C TBool GetFocusState(MMIDTextEditor* aTextEditor)

{

    return aTextEditor->GetFocusState();

}