/*
* 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 Clipboard class
*
*/


// INTERNAL INCLUDES
#include "com_nokia_mid_ui_Clipboard.h"

// EXTERNAL INCLUDES
#include <CMIDToolkit.h>
#include <jutils.h>
#include <jdebug.h>
#include <txtetext.h>
#include <baclipb.h>
#include <s32mem.h>
#include <s32ucmp.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <txtclipboard.h>
#endif

/**
 * 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 or 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 inserting the text to clipboard.
 *
 * @param aText The text to be copied to the clipboard.
 */
LOCAL_C void CopyToClipboardL(const TDesC* aText)
{
    if (aText == &KNullDesC)
    {
        CClipboard::Clear(CCoeEnv::Static()->FsSession());
    }
    else
    {
        CClipboard* clipboard = CClipboard::NewForWritingLC(
                                    CCoeEnv::Static()->FsSession());

        CPlainText* text = CPlainText::NewL();
        CleanupStack::PushL(text);
        text->InsertL(0, *aText);
        text->CopyToStoreL(clipboard->Store(), clipboard->StreamDictionary(), 0,
                           text->DocumentLength());
        CleanupStack::PopAndDestroy(); // text
        clipboard->CommitL();
        CleanupStack::PopAndDestroy();   // clipboard;
    }
}

/*
 * Class:     com_nokia_mid_ui_Clipboard
 * Method:    _copyToClipboard
 * Signature: (IIZ)I
 */
JNIEXPORT jint JNICALL Java_com_nokia_mid_ui_Clipboard__1copyToClipboard(
    JNIEnv* aJniEnv,
    jclass /* aPeer */,
    jint aToolkitHandle,
    jstring aText)
{
    DEBUG("Clipboard.cpp - copyToClipboard +");
    CMIDToolkit* toolkit = JavaUnhand< CMIDToolkit >(aToolkitHandle);

    // Convert the content to a native descriptor. NULL indicates
    // that an empty string is set as content.
    const RJString content(*aJniEnv, aText);

    const TDesC* nativeContent = (aText ? &content : &KNullDesC);

    jint error = toolkit->ExecuteTrap(&CopyToClipboardL,
                                      nativeContent);
    DEBUG("Clipboard.cpp - copyToClipboard -");
    return error;
}

/**
 * Local helper function for retrieving the text from clipboard.
 *
 * @return The text copied from the clipboard.
 */
LOCAL_C void CopyFromClipboardL(HBufC** aText)
{
    CClipboard* cb = NULL;
    TRAPD(error, (cb = CClipboard::NewForReadingL(
                           CCoeEnv::Static()->FsSession()))); // codescanner::eikonenvstatic
    // Nothing in the clipboard, not an error
    if ((error != KErrPathNotFound) && (error != KErrNotFound))
    {
        TStreamId id(cb->StreamDictionary().At(KClipboardUidTypePlainText));
        if (id != KNullStreamId)
        {
            CleanupStack::PushL(cb);

            RStoreReadStream stream;
            stream.OpenLC(cb->Store(), id);
            TInt length = stream.ReadInt32L();
            CBufFlat* buffer = CBufFlat::NewL(length);
            CleanupStack::PushL(buffer);

            RBufWriteStream bufStream(*buffer);
            CleanupClosePushL(bufStream);
            TMemoryStreamUnicodeSink sink(bufStream);
            TUnicodeExpander e;
            e.ExpandL(sink, stream, length);
            bufStream.CommitL();

            CleanupStack::PopAndDestroy();      // bufStream
            CleanupStack::Pop(buffer);
            CleanupStack::PopAndDestroy(2, cb);   // stream, cb

            CleanupStack::PushL(buffer);

            TPtrC8 ptr8(buffer->Ptr(0));

            TPtr ptr = TPtr16(reinterpret_cast<TText16*>(const_cast<TText8*>(ptr8.Ptr())),
                              length,
                              length);

            if (ptr.Length() != 0)
            {
                *aText = ptr.AllocL();
                CleanupStack::PopAndDestroy(); // ptr;
            }
        }
    }
}

/*
 * Class:     com_nokia_mid_ui_Clipboard
 * Method:    _copyFromClipboard
 * Signature: (II)Z
 */
JNIEXPORT jstring JNICALL Java_com_nokia_mid_ui_Clipboard__1copyFromClipboard(
    JNIEnv* aJniEnv,
    jclass /* aPeer */,
    jint aToolkitHandle,
    jintArray aError)
{
    DEBUG("Clipboard.cpp - copyFromClipboard +");

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

    HBufC* text = NULL;

    jstring content = NULL;

    TInt error = toolkit->ExecuteTrap(
                     &CopyFromClipboardL,
                     &text);
    if (text != NULL)
    {
        // Handle text conversion an errors.
        content = HandleString(*aJniEnv, *text, error, aError);

        // Text is not needed anymore.
        delete text;
    }

    DEBUG("Clipboard.cpp - copyFromClipboard -");
    return content;
}

// End of file