/*

 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include "awt.h"

#include "awt_DataTransferer.h"

#include "awt_DnDDT.h"

#include "awt_TextComponent.h"

#include <shlobj.h>

#include <shellapi.h>

#include <sun_awt_windows_WDataTransferer.h>

#include "locale_str.h"

#define GALLOCFLG (GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT)

#define WIN_TO_JAVA_PIXEL(r, g, b) (0xFF000000 | (r) << 16 | (g) << 8  | (b) << 0)

DECLARE_JAVA_CLASS(dataTransfererClazz, "sun/awt/datatransfer/DataTransferer");

jobject

AwtDataTransferer::GetDataTransferer(JNIEnv* env) {

    DECLARE_STATIC_OBJECT_JAVA_METHOD(getInstanceMethodID, dataTransfererClazz,

                                      "getInstance",

                                      "()Lsun/awt/datatransfer/DataTransferer;");

    return env->CallStaticObjectMethod(clazz, getInstanceMethodID);

}

jbyteArray

AwtDataTransferer::ConvertData(JNIEnv* env, jobject source, jobject contents,

                               jlong format, jobject formatMap) {

    jobject transferer = GetDataTransferer(env);

    if (!JNU_IsNull(env, transferer)) {

        jbyteArray ret = NULL;

        DECLARE_OBJECT_JAVA_METHOD(convertDataMethodID, dataTransfererClazz,

                                   "convertData",

                                   "(Ljava/lang/Object;Ljava/awt/datatransfer/Transferable;JLjava/util/Map;Z)[B");

        ret = (jbyteArray)env->CallObjectMethod(transferer, convertDataMethodID,

                                                source, contents, format,

                                                formatMap, AwtToolkit::IsMainThread());

        if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

            env->ExceptionDescribe();

            env->ExceptionClear();

        }

        env->DeleteLocalRef(transferer);

        return ret;

    } else {

        return NULL;

    }

}

jobject

AwtDataTransferer::ConcatData(JNIEnv* env, jobject obj1, jobject obj2) {

    jobject transferer = GetDataTransferer(env);

    if (!JNU_IsNull(env, transferer)) {

        jobject ret = NULL;

        DECLARE_OBJECT_JAVA_METHOD(concatDataMethodID, dataTransfererClazz,

                                   "concatData",

                                   "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");

        ret = env->CallObjectMethod(transferer, concatDataMethodID, obj1, obj2);

        if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

            env->ExceptionDescribe();

            env->ExceptionClear();

        }

        env->DeleteLocalRef(transferer);

        return ret;

    } else {

        return NULL;

    }

}

/**

 * This routine retrieves palette entries from enhanced metafile or

 * a logical color palette, builds appropriate LOGPALETTE structure,

 * writes it into a created Java byte array and returns a local

 * reference to the array.

 * This routine is used for image data transfer.

 *

 * @param hGdiObj - a handle to the GDI object to retrieve palette entries from,

 *        it can be a handle to either a logical color palette (OBJ_PAL type)

 *        or an enhanced metafile (OBJ_ENHMETAFILE). If it is neither of these

 *        types the routine fails(see bFailSafe).

 * @param dwGdiObjType - a type of the passed GDI object. It should be specified

 *        if the type of the passed GDI object is known to the caller. Otherwise

 *        pass 0.

 * @param bFailSafe - if FALSE, the routine will return NULL in case of failure,

 *        otherwise it will return an array with empty LOGPALETTE structure

 *        in case of failure.

 * @return a local reference to Java byte array which contains LOGPALETTE

 *        structure which defines a logical color palette or a palette of

 *        an enhanced metafile.

 */

jbyteArray

AwtDataTransferer::GetPaletteBytes(HGDIOBJ hGdiObj, DWORD dwGdiObjType,

                                   BOOL bFailSafe) {

    if (hGdiObj == NULL) {

        dwGdiObjType = 0;

    } else if (dwGdiObjType == 0) {

        dwGdiObjType = ::GetObjectType(hGdiObj);

    } else {

        DASSERT(::GetObjectType(hGdiObj) == dwGdiObjType);

    }

    if (!bFailSafe && dwGdiObjType == 0) {

        return NULL;

    }

    UINT nEntries = 0;

    switch (dwGdiObjType) {

    case OBJ_PAL:

        nEntries =

            ::GetPaletteEntries((HPALETTE)hGdiObj, 0, 0, NULL);

        break;

    case OBJ_ENHMETAFILE:

        nEntries =

            ::GetEnhMetaFilePaletteEntries((HENHMETAFILE)hGdiObj, 0, NULL);

        break;

    }

    if (!bFailSafe && (nEntries == 0 || nEntries == GDI_ERROR)) {

        return NULL;

    }

    JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

    jsize size = sizeof(LOGPALETTE) + nEntries * sizeof(PALETTEENTRY);

    jbyteArray paletteBytes = env->NewByteArray(size);

    if (JNU_IsNull(env, paletteBytes)) {

        throw std::bad_alloc();

    }

    LOGPALETTE* pLogPalette =

        (LOGPALETTE*)env->GetPrimitiveArrayCritical(paletteBytes, NULL);

    PALETTEENTRY* pPalEntries = (PALETTEENTRY*)pLogPalette->palPalEntry;

    pLogPalette->palVersion = 0x300;

    pLogPalette->palNumEntries = nEntries;

    switch (dwGdiObjType) {

    case OBJ_PAL:

        VERIFY(::GetPaletteEntries((HPALETTE)hGdiObj, 0, nEntries,

                                   pPalEntries) == nEntries);

        break;

    case OBJ_ENHMETAFILE:

        VERIFY(::GetEnhMetaFilePaletteEntries((HENHMETAFILE)hGdiObj, nEntries,

                                              pPalEntries) == nEntries);

        break;

    }

    env->ReleasePrimitiveArrayCritical(paletteBytes, pLogPalette, 0);

    return paletteBytes;

}

jbyteArray

AwtDataTransferer::LCIDToTextEncoding(JNIEnv *env, LCID lcid) {

    LANGID langID = LANGIDFROMLCID(lcid);

    const char *encoding = getEncodingFromLangID(langID);

    // Warning C4244.

    // Cast SIZE_T (__int64 on 64-bit/unsigned int on 32-bit)

    // to jsize (long).

    // We assume that the encoding name length cannot exceed INT_MAX.

    jsize length = (jsize)strlen(encoding);

    jbyteArray retval = env->NewByteArray(length);

    if (retval == NULL) {

        throw std::bad_alloc();

    }

    env->SetByteArrayRegion(retval, 0, length, (jbyte *)encoding);

    free((void *)encoding);

    return retval;

}

static VOID CALLBACK

IdleFunc() {

    /*

     * Fix for 4485987 and 4669873.

     * If IdleFunc is a noop, the secondary message pump occasionally occupies

     * all processor time and causes drag freezes. GetQueueStatus is needed to

     * mark all messages that are currently in the queue as old, otherwise

     * WaitMessage will return immediatelly as we selectively get messages from

     * the queue.

     */

    ::WaitMessage();

    ::GetQueueStatus(QS_ALLINPUT);

}

static BOOL CALLBACK

PeekMessageFunc(MSG& msg) {

    return ::PeekMessage(&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE) ||

           ::PeekMessage(&msg, NULL, WM_AWT_INVOKE_METHOD, WM_AWT_INVOKE_METHOD, PM_REMOVE) ||

           ::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_REMOVE);

}

void

AwtDataTransferer::SecondaryMessageLoop() {

    DASSERT(AwtToolkit::MainThread() == ::GetCurrentThreadId());

    AwtToolkit::GetInstance().MessageLoop(IdleFunc,

                                          PeekMessageFunc);

}

extern "C" {

/*

 * Class:     sun_awt_datatransfer_DataTransferer

 * Method:    draqQueryFile

 * Signature: ([B)[Ljava/lang/String;

 */

JNIEXPORT jobjectArray JNICALL

Java_sun_awt_windows_WDataTransferer_dragQueryFile

    (JNIEnv *env, jobject obj, jbyteArray bytes)

{

    TRY;

    /*

     * Fix for the BugTraq ID 4327064 - inter-jvm DnD crashes the droping jvm.

     * On Win9X DragQueryFile() doesn't accept a pointer to the local help as the first

     * argument, so we should dump the bits into global memory.

     */

    UINT size = env->GetArrayLength(bytes);

    HGLOBAL hglobal = NULL;

    jbyte *bBytes = NULL;

    HDROP hdrop = NULL;

    LPTSTR buffer = NULL;

    hglobal = ::GlobalAlloc(GALLOCFLG, size);

    if (hglobal == NULL) {

        throw std::bad_alloc();

    }

    try {

        bBytes = (jbyte*)::GlobalLock(hglobal);

        env->GetByteArrayRegion(bytes, 0, size, bBytes);

        hdrop = (HDROP)bBytes;

        UINT nFilenames = ::DragQueryFile(hdrop, 0xFFFFFFFF, NULL, 0);

        jclass str_clazz = env->FindClass("java/lang/String");

        DASSERT(str_clazz != NULL);

        jobjectArray filenames = env->NewObjectArray(nFilenames, str_clazz,

                                                     NULL);

        if (filenames == NULL) {

            throw std::bad_alloc();

        }

        UINT bufsize = 512; // in characters, not in bytes

        buffer = (LPTSTR)safe_Malloc(bufsize*sizeof(TCHAR));

        for (UINT i = 0; i < nFilenames; i++) {

            UINT size = ::DragQueryFile(hdrop, i, NULL, 0);

            if (size > bufsize) {

                bufsize = size;

                buffer = (LPTSTR)safe_Realloc(buffer, bufsize*sizeof(TCHAR));

            }

            ::DragQueryFile(hdrop, i, buffer, bufsize);

            jstring name = JNU_NewStringPlatform(env, buffer);

            if (name == NULL) {

                throw std::bad_alloc();

            }

            env->SetObjectArrayElement(filenames, i, name);

        }

        free(buffer);

        ::GlobalUnlock(hglobal);

        ::GlobalFree(hglobal);

        return filenames;

    } catch (std::bad_alloc&) {

        free(buffer);

        ::GlobalUnlock(hglobal);

        ::GlobalFree(hglobal);

        throw;

    }

    CATCH_BAD_ALLOC_RET(NULL);

}

/*

 * Class:     sun_awt_windows_WDataTransferer

 * Method:    platformImageBytesToImageData

 * Signature: ([BI)[I

 */

JNIEXPORT jintArray JNICALL

Java_sun_awt_windows_WDataTransferer_platformImageBytesToImageData(

    JNIEnv *env, jobject self, jbyteArray bytes, jlong format) {

    TRY;

    HDC hdc = NULL;

    LOGPALETTE* pLogPalette = NULL;

    WORD uPaletteEntries = 0;

    SIZE_T uOffset = 0;

    HPALETTE hPalette = NULL;

    HPALETTE hOldPalette = NULL;

    BITMAPINFO* pSrcBmi = NULL;

    BITMAPINFOHEADER* pSrcBmih = NULL;

    LPVOID pSrcBits = NULL;

    BITMAPINFO* pDstBmi = NULL;

    BITMAPINFOHEADER* pDstBmih = NULL;

    LPVOID pDstBits = NULL;

    LPBYTE lpEnhMetaFileBits = NULL;

    HENHMETAFILE hEnhMetaFile = NULL;

    HBITMAP hDibSection = NULL;

    HBITMAP hOldBitmap = NULL;

    jintArray buffer = NULL;

    LONG width = 0;

    LONG height = 0;

    int numPixels = 0;

    if (JNU_IsNull(env, bytes)) {

        return NULL;

    }

    jsize size = env->GetArrayLength(bytes);

    if (size == 0) {

        return NULL;

    }

    jbyte* bBytes = (jbyte*)safe_Malloc(size * sizeof(jbyte));

    try {

        env->GetByteArrayRegion(bytes, 0, size, bBytes);

        pLogPalette = (LOGPALETTE*)bBytes;

        uPaletteEntries = pLogPalette->palNumEntries;

        uOffset = sizeof(LOGPALETTE) + uPaletteEntries * sizeof(PALETTEENTRY);

        DASSERT(uOffset < (SIZE_T)size);

        if (uPaletteEntries == 0) {

            pLogPalette = NULL;

        }

        hdc = ::CreateCompatibleDC(NULL);

        if (hdc == NULL) {

            free(bBytes);

            return NULL;

        }

        switch (format) {

        case CF_DIB:

            pSrcBmi = (BITMAPINFO*)((LPSTR)bBytes + uOffset);

            pSrcBmih = &pSrcBmi->bmiHeader;

            width = pSrcBmih->biWidth;

            height = abs(pSrcBmih->biHeight);

            {

                DWORD nColorEntries = 0;

                switch (pSrcBmih->biBitCount) {

                case  0: nColorEntries = 0; break;

                case  1: nColorEntries = 2; break;

                case  4:

                case  8:

                    nColorEntries = (pSrcBmih->biClrUsed != 0) ?

                        pSrcBmih->biClrUsed : (1 << pSrcBmih->biBitCount);

                    break;

                case 16:

                case 24:

                case 32:

                    nColorEntries = pSrcBmih->biClrUsed;

                    // If biBitCount is 16 or 32 and biCompression is

                    // BI_BITFIELDS the color table will be prefixed with

                    // three DWORD color masks.

                    if (pSrcBmih->biCompression == BI_BITFIELDS &&

                        (pSrcBmih->biBitCount == 16 ||

                         pSrcBmih->biBitCount == 32)) {

                        nColorEntries += 3;

                    }

                    break;

                default:

                    // The header is probably corrupted.

                    // Fail immediatelly to avoid memory access violation.

                    free(bBytes);

                    ::DeleteDC(hdc);

                    return NULL;

                }

                pSrcBits = (LPSTR)pSrcBmi + pSrcBmih->biSize

                    + nColorEntries * sizeof(RGBQUAD);

            }

            break;

        case CF_ENHMETAFILE:

        case CF_METAFILEPICT:

            lpEnhMetaFileBits = (BYTE*)bBytes + uOffset;

            // Warning C4244. size is jsize, uOffset is SIZE_T.

            // We assert that size > uOffset, so it is safe to cast to jsize.

            hEnhMetaFile = ::SetEnhMetaFileBits(size - (jsize)uOffset,

                                                lpEnhMetaFileBits);

            DASSERT(hEnhMetaFile != NULL);

            {

                UINT uHeaderSize =

                    ::GetEnhMetaFileHeader(hEnhMetaFile, 0, NULL);

                DASSERT(uHeaderSize != 0);

                ENHMETAHEADER* lpemh = (ENHMETAHEADER*)safe_Malloc(uHeaderSize);

                VERIFY(::GetEnhMetaFileHeader(hEnhMetaFile, uHeaderSize,

                                              lpemh) == uHeaderSize);

                LPRECTL lpFrame = &lpemh->rclFrame;

                POINT p = { abs(lpFrame->right - lpFrame->left),

                            abs(lpFrame->bottom - lpFrame->top) };

                VERIFY(::SaveDC(hdc));

                VERIFY(::SetMapMode(hdc, MM_HIMETRIC));

                VERIFY(::LPtoDP(hdc, &p, 1));

                VERIFY(::RestoreDC(hdc, -1));

                width = p.x;

                height = -p.y;

                free(lpemh);

            }

            break;

        default:

            DASSERT(FALSE); // Other formats are not supported yet.

            free(bBytes);

            ::DeleteDC(hdc);

            return NULL;

        }

        // JNI doesn't allow to store more than INT_MAX in a single array.

        // We report conversion failure in this case.

        if (width * height > INT_MAX) {

            free(bBytes);

            ::DeleteDC(hdc);

            return NULL;

        }

        numPixels = width * height;

        if (pLogPalette != NULL) {

            hPalette = ::CreatePalette(pLogPalette);

            if (hPalette == NULL) {

                free(bBytes);

                ::DeleteDC(hdc);

                return NULL;

            }

            hOldPalette = ::SelectPalette(hdc, hPalette, FALSE);

            ::RealizePalette(hdc);

        }

        // allocate memory for BITMAPINFO

        pDstBmi = (BITMAPINFO *)safe_Calloc(1, sizeof(BITMAPINFO));

        pDstBmih = &pDstBmi->bmiHeader;

        static const int BITS_PER_PIXEL = 32;

        // prepare BITMAPINFO for a 32-bit RGB bitmap

        pDstBmih->biSize = sizeof(BITMAPINFOHEADER);

        pDstBmih->biWidth = width;

        pDstBmih->biHeight = -height; // negative height means a top-down DIB

        pDstBmih->biPlanes = 1;

        pDstBmih->biBitCount = BITS_PER_PIXEL;

        pDstBmih->biCompression = BI_RGB;

        // NOTE: MSDN says that biSizeImage may be set to 0 for BI_RGB bitmaps,

        // but this causes CreateDIBSection to allocate zero-size memory block

        // for DIB data. It works okay when biSizeImage is explicitly specified.

        pDstBmih->biSizeImage = width * height * (BITS_PER_PIXEL >> 3);

        hDibSection = ::CreateDIBSection(hdc, (BITMAPINFO*)pDstBmi,

                                         DIB_RGB_COLORS, &pDstBits,

                                         NULL, 0);

        if (hDibSection == NULL) {

            free(pDstBmi); pDstBmi = NULL;

            if (hPalette != NULL) {

                VERIFY(::SelectPalette(hdc, hOldPalette, FALSE) != NULL);

                hOldPalette = NULL;

                VERIFY(::DeleteObject(hPalette)); hPalette = NULL;

            }

            VERIFY(::DeleteDC(hdc)); hdc = NULL;

            free(bBytes); bBytes = NULL;

            JNU_ThrowIOException(env, "failed to get drop data");

            return NULL;

        }

        hOldBitmap = (HBITMAP)::SelectObject(hdc, hDibSection);

        DASSERT(hOldBitmap != NULL);

        switch (format) {

        case CF_DIB:

            VERIFY(::StretchDIBits(hdc,