/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @author Pavel Dolgov */ #include #include #include #include #include #include #include #include #pragma comment(lib, "gdi32.lib") class AtlModule : public CAtlModuleT { } _AtlModule; #include "WinDataTransfer.h" // Data format names static const char * FORMAT_TEXT = "text/plain"; static const char * FORMAT_FILE_LIST = "application/x-java-file-list"; static const char * FORMAT_URL = "application/x-java-url"; static const char * FORMAT_HTML = "text/html"; static const char * FORMAT_IMAGE = "image/x-java-image"; static const wchar_t * FORMAT_SERIALIZED = L"application/x-java-serialized-object"; // Windows clipboard formats UINT WinDataObject::cfShellUrlA = 0; UINT WinDataObject::cfShellUrlW = 0; UINT WinDataObject::cfHTML = 0; FORMATETC WinDataObject::textFormats[] = { { CF_UNICODETEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, { CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } }; FORMATETC WinDataObject::fileListFormat = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; FORMATETC WinDataObject::urlFormats[] = { { 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, { 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } }; FORMATETC WinDataObject::htmlFormat = { 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; FORMATETC WinDataObject::imageFormats[] = { { CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, { CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF } }; // Cached JNI data static JavaVM * jvm = NULL; static jclass classWinDataTransfer = NULL; static jclass classString = NULL; static jclass classDataSnapshot = NULL; static jmethodID methodDataSnapshotGetNativeFormats = NULL; static jmethodID methodDataSnapshotGetText = NULL; static jmethodID methodDataSnapshotGetFileList = NULL; static jmethodID methodDataSnapshotGetURL = NULL; static jmethodID methodDataSnapshotGetHTML = NULL; static jmethodID methodDataSnapshotGetRawBitmapHeader = NULL; static jmethodID methodDataSnapshotGetRawBitmapBuffer8 = NULL; static jmethodID methodDataSnapshotGetRawBitmapBuffer16 = NULL; static jmethodID methodDataSnapshotGetRawBitmapBuffer32 = NULL; static jmethodID methodDataSnapshotGetSerializedObject = NULL; static jclass classWinDropTarget = NULL; static jmethodID methodWinDropTargetDragEnter = NULL; static jmethodID methodWinDropTargetDragLeave = NULL; static jmethodID methodWinDropTargetDragOver = NULL; static jmethodID methodWinDropTargetDrop = NULL; static jclass classWinDragSource = NULL; static jmethodID methodWinDragSourceContinueDrag = NULL; static jmethodID methodWinDragSourceGiveFeedback = NULL; static jmethodID methodWinDragSourceEndDrag = NULL; static const int RAW_BITMAP_HEADER_LENGTH = 7; inline static JNIEnv * getEnv() { JNIEnv* env; jvm->GetEnv((void**)&env, JNI_VERSION_1_2); return env; } JNIEXPORT void JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_init( JNIEnv * env, jclass clazz) { HRESULT hr = OleInitialize(NULL); if (jvm != NULL) { return; } WinDataObject::registerFormats(); env->GetJavaVM(&jvm); classWinDataTransfer = (jclass)env->NewGlobalRef(clazz); classString = env->FindClass("java/lang/String"); classString = (jclass)env->NewGlobalRef(classString); classDataSnapshot = env->FindClass("org/apache/harmony/awt/datatransfer/DataSnapshot"); classDataSnapshot = (jclass)env->NewGlobalRef(classDataSnapshot); methodDataSnapshotGetNativeFormats = env->GetMethodID( classDataSnapshot, "getNativeFormats", "()[Ljava/lang/String;"); methodDataSnapshotGetText = env->GetMethodID( classDataSnapshot, "getText", "()Ljava/lang/String;"); methodDataSnapshotGetFileList = env->GetMethodID( classDataSnapshot, "getFileList", "()[Ljava/lang/String;"); methodDataSnapshotGetURL = env->GetMethodID( classDataSnapshot, "getURL", "()Ljava/lang/String;"); methodDataSnapshotGetHTML = env->GetMethodID( classDataSnapshot, "getHTML", "()Ljava/lang/String;"); methodDataSnapshotGetRawBitmapHeader = env->GetMethodID( classDataSnapshot, "getRawBitmapHeader", "()[I"); methodDataSnapshotGetRawBitmapBuffer8 = env->GetMethodID( classDataSnapshot, "getRawBitmapBuffer8", "()[B"); methodDataSnapshotGetRawBitmapBuffer16 = env->GetMethodID( classDataSnapshot, "getRawBitmapBuffer16", "()[S"); methodDataSnapshotGetRawBitmapBuffer32 = env->GetMethodID( classDataSnapshot, "getRawBitmapBuffer32", "()[I"); methodDataSnapshotGetSerializedObject = env->GetMethodID( classDataSnapshot, "getSerializedObject", "(Ljava/lang/String;)[B"); classWinDropTarget = env->FindClass("org/apache/harmony/awt/datatransfer/windows/WinDropTarget"); classWinDropTarget = (jclass)env->NewGlobalRef(classWinDropTarget); methodWinDropTargetDragEnter = env->GetMethodID( classWinDropTarget, "dragEnter", "(JIIII)I"); methodWinDropTargetDragLeave = env->GetMethodID( classWinDropTarget, "dragLeave", "()V"); methodWinDropTargetDragOver = env->GetMethodID( classWinDropTarget, "dragOver", "(IIII)I"); methodWinDropTargetDrop = env->GetMethodID( classWinDropTarget, "drop", "(JIIII)I"); classWinDragSource = env->FindClass("org/apache/harmony/awt/datatransfer/windows/WinDragSource");; classWinDragSource = (jclass)env->NewGlobalRef(classWinDragSource); methodWinDragSourceContinueDrag = env->GetMethodID( classWinDragSource, "continueDrag", "()V"); methodWinDragSourceGiveFeedback = env->GetMethodID( classWinDragSource, "giveFeedback", "(IZ)V"); methodWinDragSourceEndDrag = env->GetMethodID( classWinDragSource, "endDrag", "(IZ)V"); } JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getOleClipboardDataObject( JNIEnv *, jclass) { IDataObject * dataObject = NULL; HRESULT hr = OleGetClipboard(&dataObject); if (SUCCEEDED(hr)) { return (jlong)dataObject; } return 0; } JNIEXPORT void JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_releaseDataObject( JNIEnv *, jclass, jlong pointer) { if (pointer == 0) { return; } IDataObject * dataObject = (IDataObject *)pointer; dataObject->Release(); } JNIEXPORT jstring JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectText( JNIEnv * env, jclass, jlong pointer) { if (pointer == 0) { return NULL; } return WinDataObject::getText(env, (IDataObject *)pointer); } JNIEXPORT jobjectArray JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectFileList( JNIEnv * env, jclass, jlong pointer) { if (pointer == 0) { return NULL; } return WinDataObject::getFileList(env, (IDataObject *)pointer); } JNIEXPORT jstring JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectURL( JNIEnv * env, jclass, jlong pointer) { if (pointer == 0) { return NULL; } return WinDataObject::getURL(env, (IDataObject *)pointer); } JNIEXPORT jstring JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectHTML( JNIEnv * env, jclass, jlong pointer) { if (pointer == 0) { return NULL; } return WinDataObject::getHTML(env, (IDataObject *)pointer); } JNIEXPORT jobject JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectImage( JNIEnv * env, jclass, jlong pointer, jintArray header) { if (pointer == 0) { return NULL; } return WinDataObject::getBitmap(env, (IDataObject *)pointer, header); } JNIEXPORT jbyteArray JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectSerialized( JNIEnv * env, jclass, jlong pointer, jstring nativeFormat) { if (pointer == 0) { return NULL; } return WinDataObject::getSerialized(env, (IDataObject *)pointer, nativeFormat); } JNIEXPORT jstring JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getSystemDefaultCharset( JNIEnv * env, jclass) { CHARSETINFO charset; UINT_PTR lcid = GetSystemDefaultLCID(); BOOL ok = TranslateCharsetInfo((DWORD*)lcid, &charset, TCI_SRCLOCALE); if (!ok) { return NULL; } CoInitialize(NULL); CComPtr multiLanguage; HRESULT hr = multiLanguage.CoCreateInstance(CLSID_CMultiLanguage); if (FAILED(hr)) { return NULL; } MIMECPINFO info; memset(&info, 0, sizeof(MIMECPINFO)); hr = multiLanguage->GetCodePageInfo(charset.ciACP, &info); if (FAILED(hr)) { return NULL; } return env->NewString((const jchar *)info.wszWebCharset, (jsize)wcslen(info.wszWebCharset)); } JNIEXPORT jobjectArray JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_getDataObjectFormats( JNIEnv * env, jclass, jlong pointer) { if (pointer == 0) { return NULL; } return WinDataObject::enumFormats(env, (IDataObject *)pointer); } JNIEXPORT jboolean JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_isDataObjectFormatAvailable( JNIEnv * env, jclass, jlong pointer, jstring nativeFormat) { if (pointer == 0) { return NULL; } return WinDataObject::queryFormat(env, (IDataObject *)pointer, nativeFormat); } JNIEXPORT void JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_setClipboardContents( JNIEnv * env, jclass, jobject dataSnapshot) { if (dataSnapshot == NULL) { OleSetClipboard(NULL); return; } WinDataObject * winDataObject = WinDataObject::CreateInstance(); winDataObject->init(env, dataSnapshot); OleSetClipboard(winDataObject); OleFlushClipboard(); winDataObject->Release(); } JNIEXPORT void JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_startDrag( JNIEnv * env, jclass, jobject dataSnapshot, jobject dragSource, jint actions) { if (dataSnapshot == NULL || dragSource == NULL || actions == 0) { return; } WinDataObject * winDataObject = WinDataObject::CreateInstance(); winDataObject->init(env, dataSnapshot); WinDragSource * winDragSource = WinDragSource::CreateInstance(); winDragSource->init(env, dragSource); DWORD dwEffect = 0; HRESULT hr = DoDragDrop(winDataObject, winDragSource, (DWORD)actions, &dwEffect); winDataObject->Release(); winDragSource->Release(); getEnv()->CallVoidMethod(dragSource, methodWinDragSourceEndDrag, (jint)dwEffect, (hr == DRAGDROP_S_DROP)); } JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_registerDropTarget( JNIEnv * env, jclass, jlong hWnd, jobject targetObj) { WinDropTarget * target = WinDropTarget::CreateInstance(); target->init((HWND)hWnd, targetObj); HRESULT hr = CoLockObjectExternal(target, TRUE, FALSE); if (SUCCEEDED(hr)) { hr = RegisterDragDrop((HWND)hWnd, target); } if (FAILED(hr)) { target->Release(); return 0; } IDropTarget * pdt = static_cast(target); return (jlong)pdt; } JNIEXPORT void JNICALL Java_org_apache_harmony_awt_nativebridge_windows_WinDataTransfer_revokeDropTarget( JNIEnv * env, jclass, jlong hWnd, jlong target) { RevokeDragDrop((HWND)hWnd); if (target != 0) { IDropTarget * pdt = (IDropTarget *)target; CoLockObjectExternal(pdt, FALSE, TRUE); pdt->Release(); } } void WinDataObject::registerFormats() { cfShellUrlW = RegisterClipboardFormat(CFSTR_INETURLW); cfShellUrlA = RegisterClipboardFormat(CFSTR_INETURLA); cfHTML = RegisterClipboardFormat(TEXT("HTML Format")); htmlFormat.cfFormat = cfHTML; urlFormats[0].cfFormat = cfShellUrlW; urlFormats[1].cfFormat = cfShellUrlA; } jstring WinDataObject::getStringA(JNIEnv * env, const char * cstr) { if (cstr == NULL) { return env->NewString((const jchar *)L"", 0); } jstring jstr = NULL; int len = MultiByteToWideChar(CP_ACP, 0, cstr, -1, NULL, 0); if (len > 0) { wchar_t * wstr = new wchar_t[len]; if (len == MultiByteToWideChar(CP_ACP, 0, cstr, -1, wstr, len)) { jstr = env->NewString((const jchar *)wstr, (jsize)wcslen(wstr)); } delete [] wstr; } return jstr; } jstring WinDataObject::getStringA(JNIEnv * env, HGLOBAL hGlobal) { char * cstr = (char *)GlobalLock(hGlobal); jstring jstr = getStringA(env, cstr); GlobalUnlock(hGlobal); return jstr; } jstring WinDataObject::getStringW(JNIEnv * env, HGLOBAL hGlobal) { wchar_t * wstr = (wchar_t *)GlobalLock(hGlobal); if (wstr == NULL) { return env->NewString((const jchar *)L"", 0); } jstring jstr = env->NewString((const jchar *)wstr, (jsize)wcslen(wstr)); GlobalUnlock(hGlobal); return jstr; } jstring WinDataObject::getStringA(JNIEnv * env, IDataObject * dataObject, UINT format) { FORMATETC fmt = { format, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; STGMEDIUM stgmed; jstring jstr = NULL; if(SUCCEEDED(dataObject->GetData(&fmt, &stgmed))) { jstr = getStringA(env, stgmed.hGlobal); ReleaseStgMedium(&stgmed); } return jstr; } jstring WinDataObject::getStringW(JNIEnv * env, IDataObject * dataObject, UINT format) { FORMATETC fmt = { format, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; STGMEDIUM stgmed; jstring jstr = NULL; if(SUCCEEDED(dataObject->GetData(&fmt, &stgmed))) { jstr = getStringW(env, stgmed.hGlobal); ReleaseStgMedium(&stgmed); } return jstr; } jobjectArray WinDataObject::getFileListA(JNIEnv * env, const char * files) { const char * cstr = files; jsize count = 0; while (*cstr) { cstr += strlen(cstr) + 1; count ++; } jobjectArray result = env->NewObjectArray(count, classString, NULL); cstr = files; for (jsize i=0; *cstr; i++) { jstring jstr = getStringA(env, cstr); cstr += strlen(cstr) + 1; env->SetObjectArrayElement(result, i, jstr); } return result; } jobjectArray WinDataObject::getFileListW(JNIEnv * env, const wchar_t * files) { const wchar_t * wstr = files; jsize count = 0; while (*wstr) { wstr += wcslen(wstr) + 1; count ++; } jobjectArray result = env->NewObjectArray(count, classString, NULL); wstr = files; for (jsize i=0; *wstr; i++) { size_t len = wcslen(wstr); jstring jstr = env->NewString((const jchar *)wstr, (jsize)len); wstr += len + 1; env->SetObjectArrayElement(result, i, jstr); } return result; } jstring WinDataObject::getText(JNIEnv * env, IDataObject * dataObject) { jstring jstr = getStringW(env, dataObject, CF_UNICODETEXT); if (jstr != NULL) { return jstr; } return getStringA(env, dataObject, CF_TEXT); } jobjectArray WinDataObject::getFileList(JNIEnv * env, IDataObject * dataObject) { STGMEDIUM stgmed; if(FAILED(dataObject->GetData(&fileListFormat, &stgmed))) { return NULL; } jobjectArray fileList = NULL; DROPFILES * drop = (DROPFILES *)GlobalLock(stgmed.hGlobal); BYTE * fileNames = (BYTE *)drop + drop->pFiles; if (drop->fWide) { fileList = getFileListW(env, (wchar_t *)fileNames); } else { fileList = getFileListA(env, (char *)fileNames); } GlobalUnlock(stgmed.hGlobal); ReleaseStgMedium(&stgmed); return fileList; } jstring WinDataObject::getURL(JNIEnv * env, IDataObject * dataObject) { jstring jstr = getStringW(env, dataObject, cfShellUrlW); if (jstr != NULL) { return jstr; } return getStringA(env, dataObject, cfShellUrlA); } int WinDataObject::parseCfHtmlTag(const char * cstr, const char * tag) { const char * pos = strstr(cstr, tag); if (pos == NULL) { return -1; } return atoi(pos + strlen(tag)); } jstring WinDataObject::getHTML(JNIEnv * env, IDataObject * dataObject) { STGMEDIUM stgmed; HRESULT hr = dataObject->GetData(&htmlFormat, &stgmed); if(FAILED(hr)) { return NULL; } jstring html = NULL; int length = (int)GlobalSize(stgmed.hGlobal); const char * cstr = (const char *)GlobalLock(stgmed.hGlobal); int start = parseCfHtmlTag(cstr, "StartHTML:"); int end = parseCfHtmlTag(cstr, "EndHTML:"); if (start < 0 || end < 0) { start = parseCfHtmlTag(cstr, "StartFragment:"); end = parseCfHtmlTag(cstr, "EndFragment:"); } if (start > 0 && end > 0 && start < end && end <= length) { char * buffer = new char[end - start + 2]; memcpy(buffer, cstr + start, end - start + 1); buffer[end - start + 1] = 0; html = env->NewStringUTF(buffer); delete [] buffer; } GlobalUnlock(stgmed.hGlobal); ReleaseStgMedium(&stgmed); return html; } jobject WinDataObject::getBitmap(JNIEnv * env, IDataObject * dataObject, jintArray header) { STGMEDIUM stgmed; for (int i = 0; i < sizeof(imageFormats)/sizeof(FORMATETC); i++) { if(SUCCEEDED(dataObject->GetData(&imageFormats[i], &stgmed))) { jobject result = NULL; switch (imageFormats[i].cfFormat) { case CF_DIB: { LPVOID data = (LPVOID)GlobalLock(stgmed.hGlobal); result = getDIB(env, (BITMAPINFO *)data, header); GlobalUnlock(stgmed.hGlobal); break; } case CF_ENHMETAFILE: { result = getEnhMetaFile(env, stgmed.hEnhMetaFile, header); break; } } ReleaseStgMedium(&stgmed); if (result != NULL) { return result; } } } return NULL; } jobject WinDataObject::getDIB(JNIEnv * env, BITMAPINFO * info, jintArray header) { BITMAPINFOHEADER & hdr = info->bmiHeader; BYTE * colors = (BYTE *)info + hdr.biSize; BYTE * buffer = colors + hdr.biClrUsed * sizeof(RGBQUAD); jint rMask = 0, gMask = 0, bMask = 0; jint bitCount = hdr.biBitCount; jint stride = hdr.biWidth; jsize height = labs(hdr.biHeight); jobject result = NULL; switch(hdr.biCompression) { case BI_RGB: if (bitCount == 32 || bitCount == 24) { rMask = 0xFF; gMask = 0xFF00; bMask = 0xFF0000; } else if (bitCount == 16) { rMask = 0x7C00; gMask = 0x3E0; bMask = 0x1F; } break; case BI_BITFIELDS: rMask = ((jint*)colors)[0]; gMask = ((jint*)colors)[1]; bMask = ((jint*)colors)[2]; buffer += 3 * sizeof(RGBQUAD); break; default: // TODO: convert to 24 or 32 bit RGB bitmap return NULL; } switch (hdr.biBitCount) { case 32: { jsize length = stride * height; jintArray array = env->NewIntArray(length); jint * pixels = (jint *)buffer; if (hdr.biHeight > 0) { pixels += stride * (hdr.biHeight - 1); for (jsize i = 0; i < hdr.biHeight; i++, pixels -= stride) { env->SetIntArrayRegion(array, i * stride, hdr.biWidth, pixels); } } else { env->SetIntArrayRegion(array, 0, length, pixels); } result = array; break; } case 24: { stride = hdr.biWidth * 3; if (stride % 4 > 0) { stride += 4 - stride % 4; } jsize length = stride * height; jbyteArray array = env->NewByteArray(length); jbyte * pixels = (jbyte *)buffer; if (hdr.biHeight > 0) { pixels += stride * (hdr.biHeight - 1); for (jsize i = 0; i < hdr.biHeight; i++, pixels -= stride) { env->SetByteArrayRegion(array, i * stride, hdr.biWidth * 3, pixels); } } else { env->SetByteArrayRegion(array, 0, length, pixels); } result = array; break; } case 16: case 15: { stride = hdr.biWidth + hdr.biWidth % 2; jsize length = stride * height; jshortArray array = env->NewShortArray(length); jshort * pixels = (jshort *)buffer; if (hdr.biHeight > 0) { pixels += stride * (hdr.biHeight - 1); for (jsize i = 0; i < hdr.biHeight; i++, pixels -= stride) { env->SetShortArrayRegion(array, i * stride, hdr.biWidth, pixels); } } else { env->SetShortArrayRegion(array, 0, length, pixels); } result = array; break; } case 8: { bitCount = 32; const jint opaque = 0xFF000000; rMask = 0xFF0000; gMask = 0xFF00; bMask = 0xFF; if (stride % 4 > 0) { stride += 4 - stride % 4; } jsize length = hdr.biWidth * height; jintArray array = env->NewIntArray(length); BYTE * pixels = buffer; jint * palette = (jint *)colors; jint * line = new jint[hdr.biWidth]; jint step = stride; if (hdr.biHeight > 0) { pixels += stride * (hdr.biHeight - 1); step = -stride; } for (jsize i = 0; i < height; i++, pixels += step) { for (int j = 0; j < hdr.biWidth; j++) { BYTE c = pixels[j]; line[j] = (c < hdr.biClrUsed) ? (palette[c] | opaque) : opaque; } env->SetIntArrayRegion(array, i * hdr.biWidth, hdr.biWidth, line); } delete [] line; stride = hdr.biWidth; result = array; break; } default: // TODO: convert to 24 or 32 bit RGB bitmap return NULL; } jint rawHeader[] = { hdr.biWidth, height, stride, bitCount, rMask, gMask, bMask }; env->SetIntArrayRegion(header, 0, RAW_BITMAP_HEADER_LENGTH, rawHeader); return result; } jobject WinDataObject::getEnhMetaFile(JNIEnv * env, HENHMETAFILE hEMF, jintArray header) { const float screenResulutionUnit = 0.01f; // in millimetres ENHMETAHEADER hemf; memset(&hemf, 0, sizeof(ENHMETAHEADER)); hemf.iType = EMR_HEADER; hemf.nSize = sizeof(ENHMETAHEADER); hemf.dSignature = ENHMETA_SIGNATURE; if (GetEnhMetaFileHeader(hEMF, sizeof(ENHMETAHEADER), &hemf) == 0) { return NULL; } HDC screenDC = GetDC(NULL); int width = hemf.rclFrame.right - hemf.rclFrame.left; int height = hemf.rclFrame.bottom - hemf.rclFrame.top; float hRes = (float)GetDeviceCaps(screenDC, HORZRES) / (float)GetDeviceCaps(screenDC, HORZSIZE); float vRes = (float)GetDeviceCaps(screenDC, VERTRES) / (float)GetDeviceCaps(screenDC, VERTSIZE); width = (int)(width * screenResulutionUnit * hRes); height = (int)(height * screenResulutionUnit * vRes); int screenBits = GetDeviceCaps(screenDC, BITSPIXEL); HDC memoryDC = CreateCompatibleDC(screenDC); HBITMAP hBitmap = CreateCompatibleBitmap(memoryDC, width, height); SelectObject(memoryDC, hBitmap); ReleaseDC(NULL, screenDC); jobject result = NULL; RECT rc = {0, 0, width, height }; HBRUSH hbr = CreateSolidBrush(0xFFFFFFFF); FillRect(memoryDC, &rc, hbr); DeleteObject(hbr); BOOL ok = PlayEnhMetaFile(memoryDC, hEMF, &rc); BITMAPINFO info; memset(&info, 0, sizeof(BITMAPINFO)); info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); info.bmiHeader.biPlanes = 1; info.bmiHeader.biWidth = width; info.bmiHeader.biHeight = -height; info.bmiHeader.biBitCount = (screenBits > 16) ? 32 : 16; info.bmiHeader.biCompression = BI_RGB; if (ok) { ok = GetDIBits(memoryDC, hBitmap, 0, 0, NULL, &info, DIB_RGB_COLORS); } int stride = 0; if (ok) { switch (info.bmiHeader.biBitCount) { case 32: stride = info.bmiHeader.biWidth * 4; break; case 16: stride = (info.bmiHeader.biWidth + info.bmiHeader.biWidth % 2) * 2; break; default: ok = FALSE; } } BYTE * bitmap = NULL; if (ok) { bitmap = new BYTE[sizeof(BITMAPINFOHEADER) + stride * height]; BYTE * buffer = bitmap + sizeof(BITMAPINFOHEADER); memcpy(bitmap, &info.bmiHeader, sizeof(BITMAPINFOHEADER)); ok = GetDIBits(memoryDC, hBitmap, 0, height, buffer, (BITMAPINFO *)bitmap, DIB_RGB_COLORS); } if (ok) { result = getDIB(env, (BITMAPINFO *)bitmap, header); } if (bitmap != NULL) { delete [] bitmap; } DeleteObject(hBitmap); DeleteDC(memoryDC); return result; } jobjectArray WinDataObject::enumFormats(JNIEnv * env, IDataObject * dataObject) { CComPtr enumFormats; HRESULT hr = dataObject->EnumFormatEtc(DATADIR_GET, &enumFormats); if (FAILED(hr)) { return NULL; } enum { maskText = 1, maskFileList = 2, maskUrl = 4, maskHtml = 8, maskImage = 16 }; DWORD formatsMask = 0; CSimpleArray formatList; FORMATETC format; DWORD count = 0; while (enumFormats->Next(1, &format, &count) == S_OK) { if (format.ptd != NULL) { CoTaskMemFree(format.ptd); } if (format.dwAspect != DVASPECT_CONTENT) { continue; } if ((format.tymed & TYMED_ENHMF) != 0 && format.cfFormat == CF_ENHMETAFILE) { jstring jstr = env->NewStringUTF(FORMAT_IMAGE); formatList.Add(jstr); continue; } if ((format.tymed & TYMED_HGLOBAL) == 0) { continue; } if (format.cfFormat == CF_UNICODETEXT || format.cfFormat == CF_TEXT) { jstring jstr = env->NewStringUTF(FORMAT_TEXT); formatList.Add(jstr); continue; } if (format.cfFormat == CF_HDROP) { jstring jstr = env->NewStringUTF(FORMAT_FILE_LIST); formatList.Add(jstr); continue; } if (format.cfFormat == CF_DIB) { jstring jstr = env->NewStringUTF(FORMAT_IMAGE); formatList.Add(jstr); continue; } if (format.cfFormat == cfShellUrlA || format.cfFormat == cfShellUrlW) { jstring jstr = env->NewStringUTF(FORMAT_URL); formatList.Add(jstr); continue; } if (format.cfFormat == cfHTML) { jstring jstr = env->NewStringUTF(FORMAT_HTML); formatList.Add(jstr); continue; } jstring jstr = getSerializedFormatName(env, format.cfFormat); if (jstr != NULL) { formatList.Add(jstr); } } enumFormats.Release(); jobjectArray result = env->NewObjectArray((jsize)formatList.GetSize(), classString, NULL); for (jsize i = 0; i < (jsize)formatList.GetSize(); i++) { env->SetObjectArrayElement(result, i, formatList[i]); } return result; } jbyteArray WinDataObject::getSerialized(JNIEnv * env, IDataObject * dataObject, jstring nativeFormat) { FORMATETC format = { 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; jboolean isCopy; const jchar * name = env->GetStringChars(nativeFormat, &isCopy); format.cfFormat = RegisterClipboardFormatW((LPCWSTR)name); env->ReleaseStringChars(nativeFormat, name); STGMEDIUM stgmed; if(FAILED(dataObject->GetData(&format, &stgmed))) { return NULL; } jsize length = (jsize)GlobalSize(stgmed.hGlobal); jbyte * bytes = (jbyte *)GlobalLock(stgmed.hGlobal); jbyteArray array = env->NewByteArray(length); env->SetByteArrayRegion(array, 0, length, bytes); GlobalUnlock(stgmed.hGlobal); ReleaseStgMedium(&stgmed); return array; } jboolean WinDataObject::queryFormat(IDataObject * dataObject, UINT format, DWORD tymed) { FORMATETC fmt = { format, 0, DVASPECT_CONTENT, -1, tymed }; return (SUCCEEDED(dataObject->QueryGetData(&fmt))) ? JNI_TRUE : JNI_FALSE; } jboolean WinDataObject::queryFormat(JNIEnv * env, IDataObject * dataObject, jstring nativeFormat) { const char * formatNameA = (const char *)env->GetStringUTFChars(nativeFormat, NULL); BOOL found = FALSE; jboolean result = JNI_FALSE; if (strcmp(formatNameA, FORMAT_TEXT) == 0) { found = TRUE; result = queryFormat(dataObject, CF_TEXT) || queryFormat(dataObject, CF_UNICODETEXT); } else if (strcmp(formatNameA, FORMAT_FILE_LIST) == 0) { found = TRUE; result = queryFormat(dataObject, CF_HDROP); } else if (strcmp(formatNameA, FORMAT_URL) == 0) { found = TRUE; result = queryFormat(dataObject, cfShellUrlW) || queryFormat(dataObject, cfShellUrlA); } else if (strcmp(formatNameA, FORMAT_HTML) == 0) { found = TRUE; result = queryFormat(dataObject, cfHTML); } else if (strcmp(formatNameA, FORMAT_IMAGE) == 0) { found = TRUE; result = queryFormat(dataObject, CF_DIB) || queryFormat(dataObject, CF_ENHMETAFILE, TYMED_ENHMF); } env->ReleaseStringUTFChars(nativeFormat, formatNameA); if (found) { return result; } const jchar * formatNameW = env->GetStringChars(nativeFormat, NULL); if (wcsstr((const wchar_t *)formatNameW, FORMAT_SERIALIZED) != NULL) { UINT format = RegisterClipboardFormatW((LPCWSTR)formatNameW); if (format != 0) { result = queryFormat(dataObject, format); } } env->ReleaseStringChars(nativeFormat, formatNameW); return result; } jstring WinDataObject::getSerializedFormatName(JNIEnv * env, UINT format) { const int formatNameLength = 512; wchar_t formatName[formatNameLength]; if (0 != GetClipboardFormatNameW(format, formatName, formatNameLength) ) { if (wcsstr(formatName, FORMAT_SERIALIZED) != NULL) { return env->NewString((const jchar *)formatName, (jsize)wcslen(formatName)); } } return NULL; } WinDataObject::WinDataObject() { dataSnapshotGlobalRef = NULL; } WinDataObject::~WinDataObject() { if (dataSnapshotGlobalRef != NULL) { getEnv()->DeleteGlobalRef(dataSnapshotGlobalRef); } } int WinDataObject::getFormatsForName(const char * formatName, FORMATETC ** formats) { if (strcmp(formatName, FORMAT_TEXT) == 0) { *formats = textFormats; return sizeof(textFormats)/sizeof(FORMATETC); } if (strcmp(formatName, FORMAT_FILE_LIST) == 0) { *formats = &fileListFormat; return 1; } if (strcmp(formatName, FORMAT_URL) == 0) { *formats = urlFormats; return sizeof(urlFormats)/sizeof(FORMATETC); } if (strcmp(formatName, FORMAT_HTML) == 0) { *formats = &htmlFormat; return 1; } if (strcmp(formatName, FORMAT_IMAGE) == 0) { *formats = imageFormats; return sizeof(imageFormats)/sizeof(FORMATETC); } return 0; } int WinDataObject::getFormatsForName(JNIEnv * env, jstring formatName, FORMATETC ** formats) { const char * formatNameA = (const char *)env->GetStringUTFChars(formatName, NULL); int cnt = getFormatsForName(formatNameA, formats); env->ReleaseStringUTFChars(formatName, formatNameA); return cnt; } UINT WinDataObject::getSerializedFormat(JNIEnv * env, jstring formatName) { const jchar * formatNameW = env->GetStringChars(formatName, NULL); UINT result = 0; if (wcsstr((const wchar_t *)formatNameW, FORMAT_SERIALIZED) != NULL) { result = RegisterClipboardFormatW((LPCWSTR)formatNameW); } env->ReleaseStringChars(formatName, formatNameW); return result; } void WinDataObject::init(JNIEnv * env, jobject dataSnapshot) { dataSnapshotGlobalRef = env->NewGlobalRef(dataSnapshot); jobjectArray nativeFormats = (jobjectArray)env->CallObjectMethod( dataSnapshot, methodDataSnapshotGetNativeFormats); jsize formatCount = env->GetArrayLength(nativeFormats); for (jsize i = 0; i < formatCount; i++) { jstring formatName = (jstring)(env->GetObjectArrayElement(nativeFormats, i)); FORMATETC * list; int listLen = getFormatsForName(env, formatName, &list); for (int j = 0; j < listLen; j++) { formatArray.Add(list[j]); } if (listLen == 0) { UINT serializedFormat = getSerializedFormat(env, formatName); if (serializedFormat != 0) { FORMATETC fmt = { serializedFormat, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; formatArray.Add(fmt); } } } } STDMETHODIMP WinDataObject::GetData(FORMATETC * pFormatEtc, STGMEDIUM * pMedium) { if (pFormatEtc == NULL || pMedium == NULL) { return E_INVALIDARG; } if (pFormatEtc->tymed != TYMED_HGLOBAL) { return DV_E_FORMATETC; } int idx = getFormatIndex(pFormatEtc); if(idx < 0) { return DV_E_FORMATETC; } pMedium->tymed = TYMED_HGLOBAL; pMedium->pUnkForRelease = NULL; if (pFormatEtc->cfFormat == CF_UNICODETEXT || pFormatEtc->cfFormat == CF_TEXT) { return getText(pFormatEtc->cfFormat == CF_UNICODETEXT, pMedium); } if (pFormatEtc->cfFormat == CF_HDROP) { return getFileList(pMedium); } if (pFormatEtc->cfFormat == cfHTML) { return getHTML(pMedium); } if (pFormatEtc->cfFormat == cfShellUrlW || pFormatEtc->cfFormat == cfShellUrlA) { return getURL(pFormatEtc->cfFormat == cfShellUrlA, pMedium); } for (int i = 0; i < sizeof(imageFormats)/sizeof(FORMATETC); i++) { if (pFormatEtc->cfFormat == imageFormats[i].cfFormat) { return getImage(pFormatEtc->cfFormat, pMedium); } } return getSerializedObject(pFormatEtc->cfFormat, pMedium); } STDMETHODIMP WinDataObject::GetDataHere(FORMATETC *,STGMEDIUM *) { return DATA_E_FORMATETC; } STDMETHODIMP WinDataObject::QueryGetData(FORMATETC * pFormatEtc) { HRESULT hr = (getFormatIndex(pFormatEtc) >= 0) ? S_OK: DV_E_FORMATETC; return hr; } STDMETHODIMP WinDataObject::GetCanonicalFormatEtc(FORMATETC *, FORMATETC * pFormatEtcOut) { pFormatEtcOut->ptd = NULL; return E_NOTIMPL; } STDMETHODIMP WinDataObject::SetData(FORMATETC * pFormatetc, STGMEDIUM * pmedium, BOOL fRelease) { return E_NOTIMPL; } STDMETHODIMP WinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC ** ppEnumFormatEtc) { if(dwDirection == DATADIR_GET) { return SHCreateStdEnumFmtEtc((UINT)formatArray.GetSize(), formatArray.GetData(), ppEnumFormatEtc); } return E_NOTIMPL; } STDMETHODIMP WinDataObject::DAdvise(FORMATETC *,DWORD,IAdviseSink *,DWORD *) { return OLE_E_ADVISENOTSUPPORTED; } STDMETHODIMP WinDataObject::DUnadvise(DWORD) { return OLE_E_ADVISENOTSUPPORTED; } STDMETHODIMP WinDataObject::EnumDAdvise(IEnumSTATDATA **) { return OLE_E_ADVISENOTSUPPORTED; } int WinDataObject::getFormatIndex(FORMATETC * fmt) { for (int i=0; icfFormat && f.ptd == fmt->ptd && f.dwAspect == fmt->dwAspect && f.lindex == fmt->lindex && f.tymed == fmt->tymed) { return (int)i; } } return -1; } HGLOBAL WinDataObject::getTextGlobal(JNIEnv * env, jstring text, BOOL unicode) { jsize len = env->GetStringLength(text); if (unicode) { wchar_t * wstr = (wchar_t *)GlobalAlloc(GMEM_FIXED, (len + 1) * sizeof(wchar_t)); if (wstr == NULL) { return NULL; } env->GetStringRegion(text, 0, len, (jchar *)wstr); wstr[len] = 0; return (HGLOBAL)wstr; } // convert to ASCII text wchar_t * wstr = new wchar_t[len + 1]; if (wstr == NULL) { return NULL; } env->GetStringRegion(text, 0, len, (jchar *)wstr); wstr[len] = 0; int cLen = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL); char * cstr = (char *)GlobalAlloc(GMEM_FIXED, cLen); if (cstr == NULL) { delete [] wstr; return NULL; } WideCharToMultiByte(CP_ACP, 0, wstr, -1, cstr, cLen, NULL, NULL); delete [] wstr; return (HGLOBAL)cstr; } HRESULT WinDataObject::getText(BOOL unicode, STGMEDIUM * pMedium) { JNIEnv * env = getEnv(); jstring text = (jstring)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetText); if (text == NULL) { return DV_E_FORMATETC; } pMedium->hGlobal = getTextGlobal(env, text, unicode); return (pMedium->hGlobal != NULL) ? S_OK : E_OUTOFMEMORY; } HRESULT WinDataObject::getHTML(STGMEDIUM * pMedium) { JNIEnv * env = getEnv(); jstring text = (jstring)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetHTML); if (text == NULL) { return DV_E_FORMATETC; } const char startFragment[] = ""; const char endFragment[] = ""; const char headerFormat[] = "Version:1.0\r\nStartHTML:%010d\r\nEndHTML:%010d\r\nStartFragment:%010d\r\nEndFragment:%010d\r\n"; char header[sizeof(headerFormat) + 40]; wsprintfA(header, headerFormat, 0, 0, 0, 0); size_t headerLen = strlen(header); jboolean isCopy; const char * utfStr = env->GetStringUTFChars(text, &isCopy); const char * pStart = strstr(utfStr, startFragment); const char * pEnd = strstr(utfStr, endFragment); size_t iLen = strlen(utfStr); size_t iStart = (pStart != NULL) ? (pStart - utfStr) + strlen(startFragment) : 0; size_t iEnd = (pEnd != NULL) ? (pEnd - utfStr) : iLen; char * cstr = (char *)GlobalAlloc(GMEM_FIXED, headerLen + iLen + 1); wsprintfA(cstr, headerFormat, headerLen, headerLen + iLen + 1, headerLen + iStart, headerLen + iEnd); memcpy(cstr + headerLen, utfStr, iLen); cstr[headerLen + iLen] = 0; env->ReleaseStringUTFChars(text, utfStr); pMedium->hGlobal = cstr; return S_OK; } HRESULT WinDataObject::getFileList(STGMEDIUM * pMedium) { JNIEnv * env = getEnv(); jobjectArray fileList = (jobjectArray)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetFileList); if (fileList == NULL) { return DV_E_FORMATETC; } jsize listLength = env->GetArrayLength(fileList); jsize charCount = 0, i; for (i=0; iGetObjectArrayElement(fileList, i); jsize len = (jstr != NULL) ? env->GetStringLength(jstr) : 0; if (len != 0) { charCount += len + 1; } } if (charCount == 0) { return DV_E_FORMATETC; } BYTE * buffer = (BYTE *)GlobalAlloc(GMEM_FIXED, sizeof(DROPFILES) + (charCount + 1) * sizeof(wchar_t)); DROPFILES * dropFiles = (DROPFILES *)buffer; memset(dropFiles, 0, sizeof(DROPFILES)); dropFiles->fWide = TRUE; dropFiles->pFiles = sizeof(DROPFILES); wchar_t * wstr = (wchar_t *)(buffer + sizeof(DROPFILES)); charCount = 0; for (i=0; iGetObjectArrayElement(fileList, i); jsize len = (jstr != NULL) ? env->GetStringLength(jstr) : 0; if (len != 0) { env->GetStringRegion(jstr, 0, len, (jchar *)(wstr + charCount)); charCount += len + 1; wstr[charCount - 1] = 0; } } wstr[charCount] = 0; pMedium->hGlobal = buffer; return S_OK; } HRESULT WinDataObject::getURL(BOOL unicode, STGMEDIUM * pMedium) { JNIEnv * env = getEnv(); jstring url = (jstring)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetURL); if (url == NULL) { return DV_E_FORMATETC; } pMedium->hGlobal = getTextGlobal(env, url, unicode); return (pMedium->hGlobal != NULL) ? S_OK : E_OUTOFMEMORY; } HRESULT WinDataObject::getImage(UINT format, STGMEDIUM * pMedium) { if (format != CF_DIB) { return DV_E_FORMATETC; } JNIEnv * env = getEnv(); jintArray bitmapBuffer = (jintArray)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetRawBitmapBuffer32); jintArray bitmapHeader = (jintArray)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetRawBitmapHeader); if (bitmapBuffer == NULL || bitmapHeader == NULL) { return DV_E_FORMATETC; } jsize headerLength = env->GetArrayLength(bitmapHeader); if (headerLength != RAW_BITMAP_HEADER_LENGTH) { return DV_E_FORMATETC; } jint rawHeader[RAW_BITMAP_HEADER_LENGTH]; env->GetIntArrayRegion(bitmapHeader, 0, RAW_BITMAP_HEADER_LENGTH, rawHeader); int width = rawHeader[0]; int height = rawHeader[1]; // Accept only 32-bit RGB bitmap if (rawHeader[2] != width || rawHeader[3] != 32 || rawHeader[4] != 0xFF0000 || rawHeader[5] != 0xFF00 || rawHeader[6] != 0xFF) { return DV_E_FORMATETC; } pMedium->hGlobal = GlobalAlloc(GMEM_FIXED, sizeof(BITMAPINFOHEADER) + width * height * 4); if (pMedium->hGlobal == NULL) { return E_OUTOFMEMORY; } BITMAPINFOHEADER * hdr = (BITMAPINFOHEADER *)(pMedium->hGlobal); memset(hdr, 0, sizeof(BITMAPINFOHEADER)); hdr->biSize = sizeof(BITMAPINFOHEADER); hdr->biWidth = width; hdr->biHeight = -height; hdr->biPlanes = 1; hdr->biBitCount = 32; hdr->biCompression = BI_RGB; jint * rawBuffer = (jint *)(hdr + 1); env->GetIntArrayRegion(bitmapBuffer, 0, width * height, rawBuffer); return S_OK; } HRESULT WinDataObject::getSerializedObject( UINT format, STGMEDIUM * pMedium) { JNIEnv * env = getEnv(); jstring jstr = getSerializedFormatName(env, format); if (jstr == NULL) { return DV_E_FORMATETC; } jbyteArray bytes = (jbyteArray)env->CallObjectMethod(dataSnapshotGlobalRef, methodDataSnapshotGetSerializedObject, jstr); if (bytes == NULL) { return DV_E_FORMATETC; } jsize length = env->GetArrayLength(bytes); pMedium->hGlobal = GlobalAlloc(GMEM_FIXED, length); if (pMedium->hGlobal == NULL) { return E_OUTOFMEMORY; } env->GetByteArrayRegion(bytes, 0, length, (jbyte *)pMedium->hGlobal); return S_OK; } WinDropTarget::WinDropTarget() { hWnd = NULL; dropTargetGlobalRef = NULL; } WinDropTarget::~WinDropTarget(void) { if (dropTargetGlobalRef != NULL) { getEnv()->DeleteGlobalRef(dropTargetGlobalRef); } } void WinDropTarget::init(HWND hwnd, jobject targetObj) { hWnd = hwnd; dropTargetGlobalRef = getEnv()->NewGlobalRef(targetObj); } HRESULT WinDropTarget::DragEnter(IDataObject * pDataObject, DWORD grfKeyState, POINTL pt, DWORD * pdwEffect) { currentData = NULL; if (pdwEffect == NULL) { return E_POINTER; } *pdwEffect &= fireDragEnter(pDataObject, grfKeyState, pt, *pdwEffect); if (*pdwEffect != DROPEFFECT_NONE) { currentData = pDataObject; } return S_OK; } HRESULT WinDropTarget::DragLeave() { fireDragLeave(); currentData = NULL; return S_OK; } HRESULT WinDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) { if (pdwEffect == NULL) { return E_POINTER; } *pdwEffect &= fireDragOver(grfKeyState, pt, *pdwEffect); return S_OK; } HRESULT WinDropTarget::Drop(IDataObject *pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) { if (pdwEffect == NULL) { currentData = NULL; return E_POINTER; } *pdwEffect &= fireDrop(pDataObject, grfKeyState, pt, *pdwEffect); currentData = NULL; return S_OK; } int WinDropTarget::fireDrop(IDataObject * pDataObject, DWORD keyState, POINTL pt, DWORD allowedActions) { JNIEnv * env = getEnv(); jint dropAction = (jint)getDropAction(keyState, allowedActions); return env->CallIntMethod(dropTargetGlobalRef, methodWinDropTargetDrop, (jlong)pDataObject, (jint)pt.x, (jint)pt.y, dropAction, (jint)allowedActions); } int WinDropTarget::fireDragEnter(IDataObject * pDataObject, DWORD keyState, POINTL pt, DWORD allowedActions) { JNIEnv * env = getEnv(); jint dropAction = (jint)getDropAction(keyState, allowedActions); return env->CallIntMethod(dropTargetGlobalRef, methodWinDropTargetDragEnter, (jlong)pDataObject, (jint)pt.x, (jint)pt.y, dropAction, (jint)allowedActions); } int WinDropTarget::fireDragOver(DWORD keyState, POINTL pt, DWORD allowedActions) { JNIEnv * env = getEnv(); jint dropAction = (jint)getDropAction(keyState, allowedActions); return env->CallIntMethod(dropTargetGlobalRef, methodWinDropTargetDragOver, (jint)pt.x, (jint)pt.y, dropAction, (jint)allowedActions); } void WinDropTarget::fireDragLeave() { JNIEnv * env = getEnv(); env->CallVoidMethod(dropTargetGlobalRef, methodWinDropTargetDragLeave); } DWORD WinDropTarget::getDropAction(DWORD keyState, DWORD allowedActions) { if(keyState & MK_CONTROL) { if(keyState & MK_SHIFT) { return DROPEFFECT_LINK; } else { return DROPEFFECT_COPY; } } else if(keyState & MK_SHIFT) { return DROPEFFECT_MOVE; } if (allowedActions & DROPEFFECT_MOVE) { return DROPEFFECT_MOVE; } if (allowedActions & DROPEFFECT_COPY) { return DROPEFFECT_COPY; } if (allowedActions & DROPEFFECT_LINK) { return DROPEFFECT_LINK; } return DROPEFFECT_NONE; } WinDragSource::WinDragSource() { dragSourceGlobalRef = NULL; } WinDragSource::~WinDragSource() { if (dragSourceGlobalRef != NULL) { getEnv()->DeleteGlobalRef(dragSourceGlobalRef); } } STDMETHODIMP WinDragSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState) { if(fEscapePressed == TRUE) return DRAGDROP_S_CANCEL; if((grfKeyState & MK_LBUTTON) == 0) return DRAGDROP_S_DROP; getEnv()->CallVoidMethod(dragSourceGlobalRef, methodWinDragSourceContinueDrag); return S_OK; } STDMETHODIMP WinDragSource::GiveFeedback(DWORD dwEffect) { jint actions = (jint)(dwEffect & ~DROPEFFECT_SCROLL); jboolean scroll = (dwEffect & DROPEFFECT_SCROLL) != 0; getEnv()->CallVoidMethod(dragSourceGlobalRef, methodWinDragSourceGiveFeedback, actions, scroll); return DRAGDROP_S_USEDEFAULTCURSORS; } void WinDragSource::init(JNIEnv * env, jobject winDragSource) { dragSourceGlobalRef = env->NewGlobalRef(winDragSource); }