diff options
Diffstat (limited to 'bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32')
11 files changed, 1140 insertions, 0 deletions
diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/swt_wgl.rc b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/swt_wgl.rc new file mode 100644 index 0000000000..e46095f457 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/swt_wgl.rc @@ -0,0 +1,45 @@ +/******************************************************************************* + * Copyright (c) 2000, 2006 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#include "windows.h" + +VS_VERSION_INFO VERSIONINFO + FILEVERSION SWT_COMMA_VERSION + PRODUCTVERSION 0,0,0,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x40000L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "Eclipse Foundation\0" + VALUE "FileDescription", "SWT for Windows native library\0" + VALUE "FileVersion", SWT_FILE_VERSION + VALUE "InternalName", "SWT\0" + VALUE "LegalCopyright", "Copyright (c) 2000, 2006 IBM Corp. All Rights Reserved.\0" + VALUE "OriginalFilename", SWT_ORG_FILENAME + VALUE "ProductName", "Standard Widget Toolkit\0" + VALUE "ProductVersion", "0,0,0,0\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.c b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.c new file mode 100644 index 0000000000..85eed92707 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.c @@ -0,0 +1,273 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#include "swt.h" +#include "wgl_structs.h" +#include "wgl_stats.h" + +#define WGL_NATIVE(func) Java_org_eclipse_swt_internal_opengl_win32_WGL_##func + +#ifndef NO_ChoosePixelFormat +JNIEXPORT jint JNICALL WGL_NATIVE(ChoosePixelFormat) + (JNIEnv *env, jclass that, jintLong arg0, jobject arg1) +{ + PIXELFORMATDESCRIPTOR _arg1, *lparg1=NULL; + jint rc = 0; + WGL_NATIVE_ENTER(env, that, ChoosePixelFormat_FUNC); + if (arg1) if ((lparg1 = getPIXELFORMATDESCRIPTORFields(env, arg1, &_arg1)) == NULL) goto fail; + rc = (jint)ChoosePixelFormat((HDC)arg0, lparg1); +fail: + if (arg1 && lparg1) setPIXELFORMATDESCRIPTORFields(env, arg1, lparg1); + WGL_NATIVE_EXIT(env, that, ChoosePixelFormat_FUNC); + return rc; +} +#endif + +#ifndef NO_DescribePixelFormat +JNIEXPORT jint JNICALL WGL_NATIVE(DescribePixelFormat) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jint arg2, jobject arg3) +{ + PIXELFORMATDESCRIPTOR _arg3, *lparg3=NULL; + jint rc = 0; + WGL_NATIVE_ENTER(env, that, DescribePixelFormat_FUNC); + if (arg3) if ((lparg3 = getPIXELFORMATDESCRIPTORFields(env, arg3, &_arg3)) == NULL) goto fail; + rc = (jint)DescribePixelFormat((HDC)arg0, arg1, arg2, lparg3); +fail: + if (arg3 && lparg3) setPIXELFORMATDESCRIPTORFields(env, arg3, lparg3); + WGL_NATIVE_EXIT(env, that, DescribePixelFormat_FUNC); + return rc; +} +#endif + +#ifndef NO_GetPixelFormat +JNIEXPORT jint JNICALL WGL_NATIVE(GetPixelFormat) + (JNIEnv *env, jclass that, jintLong arg0) +{ + jint rc = 0; + WGL_NATIVE_ENTER(env, that, GetPixelFormat_FUNC); + rc = (jint)GetPixelFormat((HDC)arg0); + WGL_NATIVE_EXIT(env, that, GetPixelFormat_FUNC); + return rc; +} +#endif + +#ifndef NO_SetPixelFormat +JNIEXPORT jboolean JNICALL WGL_NATIVE(SetPixelFormat) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jobject arg2) +{ + PIXELFORMATDESCRIPTOR _arg2, *lparg2=NULL; + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, SetPixelFormat_FUNC); + if (arg2) if ((lparg2 = getPIXELFORMATDESCRIPTORFields(env, arg2, &_arg2)) == NULL) goto fail; + rc = (jboolean)SetPixelFormat((HDC)arg0, arg1, lparg2); +fail: + if (arg2 && lparg2) setPIXELFORMATDESCRIPTORFields(env, arg2, lparg2); + WGL_NATIVE_EXIT(env, that, SetPixelFormat_FUNC); + return rc; +} +#endif + +#ifndef NO_SwapBuffers +JNIEXPORT jboolean JNICALL WGL_NATIVE(SwapBuffers) + (JNIEnv *env, jclass that, jintLong arg0) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, SwapBuffers_FUNC); + rc = (jboolean)SwapBuffers((HDC)arg0); + WGL_NATIVE_EXIT(env, that, SwapBuffers_FUNC); + return rc; +} +#endif + +#ifndef NO_wglCopyContext +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglCopyContext) + (JNIEnv *env, jclass that, jintLong arg0, jintLong arg1, jint arg2) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglCopyContext_FUNC); + rc = (jboolean)wglCopyContext((HGLRC)arg0, (HGLRC)arg1, arg2); + WGL_NATIVE_EXIT(env, that, wglCopyContext_FUNC); + return rc; +} +#endif + +#ifndef NO_wglCreateContext +JNIEXPORT jintLong JNICALL WGL_NATIVE(wglCreateContext) + (JNIEnv *env, jclass that, jintLong arg0) +{ + jintLong rc = 0; + WGL_NATIVE_ENTER(env, that, wglCreateContext_FUNC); + rc = (jintLong)wglCreateContext((HDC)arg0); + WGL_NATIVE_EXIT(env, that, wglCreateContext_FUNC); + return rc; +} +#endif + +#ifndef NO_wglCreateLayerContext +JNIEXPORT jintLong JNICALL WGL_NATIVE(wglCreateLayerContext) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1) +{ + jintLong rc = 0; + WGL_NATIVE_ENTER(env, that, wglCreateLayerContext_FUNC); + rc = (jintLong)wglCreateLayerContext((HDC)arg0, arg1); + WGL_NATIVE_EXIT(env, that, wglCreateLayerContext_FUNC); + return rc; +} +#endif + +#ifndef NO_wglDeleteContext +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDeleteContext) + (JNIEnv *env, jclass that, jintLong arg0) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglDeleteContext_FUNC); + rc = (jboolean)wglDeleteContext((HGLRC)arg0); + WGL_NATIVE_EXIT(env, that, wglDeleteContext_FUNC); + return rc; +} +#endif + +#ifndef NO_wglDescribeLayerPlane +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDescribeLayerPlane) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jint arg2, jint arg3, jobject arg4) +{ + LAYERPLANEDESCRIPTOR _arg4, *lparg4=NULL; + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglDescribeLayerPlane_FUNC); + if (arg4) if ((lparg4 = getLAYERPLANEDESCRIPTORFields(env, arg4, &_arg4)) == NULL) goto fail; + rc = (jboolean)wglDescribeLayerPlane((HDC)arg0, arg1, arg2, arg3, lparg4); +fail: + if (arg4 && lparg4) setLAYERPLANEDESCRIPTORFields(env, arg4, lparg4); + WGL_NATIVE_EXIT(env, that, wglDescribeLayerPlane_FUNC); + return rc; +} +#endif + +#ifndef NO_wglGetCurrentContext +JNIEXPORT jintLong JNICALL WGL_NATIVE(wglGetCurrentContext) + (JNIEnv *env, jclass that) +{ + jintLong rc = 0; + WGL_NATIVE_ENTER(env, that, wglGetCurrentContext_FUNC); + rc = (jintLong)wglGetCurrentContext(); + WGL_NATIVE_EXIT(env, that, wglGetCurrentContext_FUNC); + return rc; +} +#endif + +#ifndef NO_wglGetCurrentDC +JNIEXPORT jintLong JNICALL WGL_NATIVE(wglGetCurrentDC) + (JNIEnv *env, jclass that) +{ + jintLong rc = 0; + WGL_NATIVE_ENTER(env, that, wglGetCurrentDC_FUNC); + rc = (jintLong)wglGetCurrentDC(); + WGL_NATIVE_EXIT(env, that, wglGetCurrentDC_FUNC); + return rc; +} +#endif + +#ifndef NO_wglGetLayerPaletteEntries +JNIEXPORT jint JNICALL WGL_NATIVE(wglGetLayerPaletteEntries) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jint arg2, jint arg3, jintArray arg4) +{ + jint *lparg4=NULL; + jint rc = 0; + WGL_NATIVE_ENTER(env, that, wglGetLayerPaletteEntries_FUNC); + if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail; + rc = (jint)wglGetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (COLORREF *)lparg4); +fail: + if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0); + WGL_NATIVE_EXIT(env, that, wglGetLayerPaletteEntries_FUNC); + return rc; +} +#endif + +#ifndef NO_wglGetProcAddress +JNIEXPORT jintLong JNICALL WGL_NATIVE(wglGetProcAddress) + (JNIEnv *env, jclass that, jbyteArray arg0) +{ + jbyte *lparg0=NULL; + jintLong rc = 0; + WGL_NATIVE_ENTER(env, that, wglGetProcAddress_FUNC); + if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail; + rc = (jintLong)wglGetProcAddress(lparg0); +fail: + if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); + WGL_NATIVE_EXIT(env, that, wglGetProcAddress_FUNC); + return rc; +} +#endif + +#ifndef NO_wglMakeCurrent +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglMakeCurrent) + (JNIEnv *env, jclass that, jintLong arg0, jintLong arg1) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglMakeCurrent_FUNC); + rc = (jboolean)wglMakeCurrent((HDC)arg0, (HGLRC)arg1); + WGL_NATIVE_EXIT(env, that, wglMakeCurrent_FUNC); + return rc; +} +#endif + +#ifndef NO_wglRealizeLayerPalette +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglRealizeLayerPalette) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jboolean arg2) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglRealizeLayerPalette_FUNC); + rc = (jboolean)wglRealizeLayerPalette((HDC)arg0, arg1, arg2); + WGL_NATIVE_EXIT(env, that, wglRealizeLayerPalette_FUNC); + return rc; +} +#endif + +#ifndef NO_wglSetLayerPaletteEntries +JNIEXPORT jint JNICALL WGL_NATIVE(wglSetLayerPaletteEntries) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1, jint arg2, jint arg3, jintArray arg4) +{ + jint *lparg4=NULL; + jint rc = 0; + WGL_NATIVE_ENTER(env, that, wglSetLayerPaletteEntries_FUNC); + if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail; + rc = (jint)wglSetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (COLORREF *)lparg4); +fail: + if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0); + WGL_NATIVE_EXIT(env, that, wglSetLayerPaletteEntries_FUNC); + return rc; +} +#endif + +#ifndef NO_wglShareLists +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglShareLists) + (JNIEnv *env, jclass that, jintLong arg0, jintLong arg1) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglShareLists_FUNC); + rc = (jboolean)wglShareLists((HGLRC)arg0, (HGLRC)arg1); + WGL_NATIVE_EXIT(env, that, wglShareLists_FUNC); + return rc; +} +#endif + +#ifndef NO_wglSwapLayerBuffers +JNIEXPORT jboolean JNICALL WGL_NATIVE(wglSwapLayerBuffers) + (JNIEnv *env, jclass that, jintLong arg0, jint arg1) +{ + jboolean rc = 0; + WGL_NATIVE_ENTER(env, that, wglSwapLayerBuffers_FUNC); + rc = (jboolean)wglSwapLayerBuffers((HDC)arg0, arg1); + WGL_NATIVE_EXIT(env, that, wglSwapLayerBuffers_FUNC); + return rc; +} +#endif + diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.h b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.h new file mode 100644 index 0000000000..7a65730562 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl.h @@ -0,0 +1,28 @@ +/******************************************************************************* + * Copyright (c) 2000, 2005 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#ifndef SWT_WGL_H_INCLUDED +#define SWT_WGL_H_INCLUDED + +#include <windows.h> +#include <winuser.h> +#include <commctrl.h> +#include <commdlg.h> +#include <oaidl.h> +#include <shlobj.h> +#include <ole2.h> +#include <olectl.h> +#include <objbase.h> +#include <shlwapi.h> +#include <shellapi.h> +#include <wingdi.h> + +#endif /* SWT_WGL_H_INCLUDED */ diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.c b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.c new file mode 100644 index 0000000000..cb879220c0 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.c @@ -0,0 +1,61 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#include "swt.h" +#include "wgl_stats.h" + +#ifdef NATIVE_STATS + +int WGL_nativeFunctionCount = 19; +int WGL_nativeFunctionCallCount[19]; +char * WGL_nativeFunctionNames[] = { + "ChoosePixelFormat", + "DescribePixelFormat", + "GetPixelFormat", + "SetPixelFormat", + "SwapBuffers", + "wglCopyContext", + "wglCreateContext", + "wglCreateLayerContext", + "wglDeleteContext", + "wglDescribeLayerPlane", + "wglGetCurrentContext", + "wglGetCurrentDC", + "wglGetLayerPaletteEntries", + "wglGetProcAddress", + "wglMakeCurrent", + "wglRealizeLayerPalette", + "wglSetLayerPaletteEntries", + "wglShareLists", + "wglSwapLayerBuffers", +}; + +#define STATS_NATIVE(func) Java_org_eclipse_swt_tools_internal_NativeStats_##func + +JNIEXPORT jint JNICALL STATS_NATIVE(WGL_1GetFunctionCount) + (JNIEnv *env, jclass that) +{ + return WGL_nativeFunctionCount; +} + +JNIEXPORT jstring JNICALL STATS_NATIVE(WGL_1GetFunctionName) + (JNIEnv *env, jclass that, jint index) +{ + return (*env)->NewStringUTF(env, WGL_nativeFunctionNames[index]); +} + +JNIEXPORT jint JNICALL STATS_NATIVE(WGL_1GetFunctionCallCount) + (JNIEnv *env, jclass that, jint index) +{ + return WGL_nativeFunctionCallCount[index]; +} + +#endif diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.h b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.h new file mode 100644 index 0000000000..c6a9c4f741 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_stats.h @@ -0,0 +1,47 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#ifdef NATIVE_STATS +extern int WGL_nativeFunctionCount; +extern int WGL_nativeFunctionCallCount[]; +extern char* WGL_nativeFunctionNames[]; +#define WGL_NATIVE_ENTER(env, that, func) WGL_nativeFunctionCallCount[func]++; +#define WGL_NATIVE_EXIT(env, that, func) +#else +#ifndef WGL_NATIVE_ENTER +#define WGL_NATIVE_ENTER(env, that, func) +#endif +#ifndef WGL_NATIVE_EXIT +#define WGL_NATIVE_EXIT(env, that, func) +#endif +#endif + +typedef enum { + ChoosePixelFormat_FUNC, + DescribePixelFormat_FUNC, + GetPixelFormat_FUNC, + SetPixelFormat_FUNC, + SwapBuffers_FUNC, + wglCopyContext_FUNC, + wglCreateContext_FUNC, + wglCreateLayerContext_FUNC, + wglDeleteContext_FUNC, + wglDescribeLayerPlane_FUNC, + wglGetCurrentContext_FUNC, + wglGetCurrentDC_FUNC, + wglGetLayerPaletteEntries_FUNC, + wglGetProcAddress_FUNC, + wglMakeCurrent_FUNC, + wglRealizeLayerPalette_FUNC, + wglSetLayerPaletteEntries_FUNC, + wglShareLists_FUNC, + wglSwapLayerBuffers_FUNC, +} WGL_FUNCS; diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.c b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.c new file mode 100644 index 0000000000..3f0bbcb428 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.c @@ -0,0 +1,220 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#include "swt.h" +#include "wgl_structs.h" + +#ifndef NO_LAYERPLANEDESCRIPTOR +typedef struct LAYERPLANEDESCRIPTOR_FID_CACHE { + int cached; + jclass clazz; + jfieldID nSize, nVersion, dwFlags, iPixelType, cColorBits, cRedBits, cRedShift, cGreenBits, cGreenShift, cBlueBits, cBlueShift, cAlphaBits, cAlphaShift, cAccumBits, cAccumRedBits, cAccumGreenBits, cAccumBlueBits, cAccumAlphaBits, cDepthBits, cStencilBits, cAuxBuffers, iLayerPlane, bReserved, crTransparent; +} LAYERPLANEDESCRIPTOR_FID_CACHE; + +LAYERPLANEDESCRIPTOR_FID_CACHE LAYERPLANEDESCRIPTORFc; + +void cacheLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject) +{ + if (LAYERPLANEDESCRIPTORFc.cached) return; + LAYERPLANEDESCRIPTORFc.clazz = (*env)->GetObjectClass(env, lpObject); + LAYERPLANEDESCRIPTORFc.nSize = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "nSize", "S"); + LAYERPLANEDESCRIPTORFc.nVersion = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "nVersion", "S"); + LAYERPLANEDESCRIPTORFc.dwFlags = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "dwFlags", "I"); + LAYERPLANEDESCRIPTORFc.iPixelType = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "iPixelType", "B"); + LAYERPLANEDESCRIPTORFc.cColorBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cColorBits", "B"); + LAYERPLANEDESCRIPTORFc.cRedBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cRedBits", "B"); + LAYERPLANEDESCRIPTORFc.cRedShift = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cRedShift", "B"); + LAYERPLANEDESCRIPTORFc.cGreenBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cGreenBits", "B"); + LAYERPLANEDESCRIPTORFc.cGreenShift = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cGreenShift", "B"); + LAYERPLANEDESCRIPTORFc.cBlueBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cBlueBits", "B"); + LAYERPLANEDESCRIPTORFc.cBlueShift = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cBlueShift", "B"); + LAYERPLANEDESCRIPTORFc.cAlphaBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAlphaBits", "B"); + LAYERPLANEDESCRIPTORFc.cAlphaShift = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAlphaShift", "B"); + LAYERPLANEDESCRIPTORFc.cAccumBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAccumBits", "B"); + LAYERPLANEDESCRIPTORFc.cAccumRedBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAccumRedBits", "B"); + LAYERPLANEDESCRIPTORFc.cAccumGreenBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAccumGreenBits", "B"); + LAYERPLANEDESCRIPTORFc.cAccumBlueBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAccumBlueBits", "B"); + LAYERPLANEDESCRIPTORFc.cAccumAlphaBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAccumAlphaBits", "B"); + LAYERPLANEDESCRIPTORFc.cDepthBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cDepthBits", "B"); + LAYERPLANEDESCRIPTORFc.cStencilBits = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cStencilBits", "B"); + LAYERPLANEDESCRIPTORFc.cAuxBuffers = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "cAuxBuffers", "B"); + LAYERPLANEDESCRIPTORFc.iLayerPlane = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "iLayerPlane", "B"); + LAYERPLANEDESCRIPTORFc.bReserved = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "bReserved", "B"); + LAYERPLANEDESCRIPTORFc.crTransparent = (*env)->GetFieldID(env, LAYERPLANEDESCRIPTORFc.clazz, "crTransparent", "I"); + LAYERPLANEDESCRIPTORFc.cached = 1; +} + +LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct) +{ + if (!LAYERPLANEDESCRIPTORFc.cached) cacheLAYERPLANEDESCRIPTORFields(env, lpObject); + lpStruct->nSize = (*env)->GetShortField(env, lpObject, LAYERPLANEDESCRIPTORFc.nSize); + lpStruct->nVersion = (*env)->GetShortField(env, lpObject, LAYERPLANEDESCRIPTORFc.nVersion); + lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, LAYERPLANEDESCRIPTORFc.dwFlags); + lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.iPixelType); + lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cColorBits); + lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cRedBits); + lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cRedShift); + lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cGreenBits); + lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cGreenShift); + lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cBlueBits); + lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cBlueShift); + lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAlphaBits); + lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAlphaShift); + lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumBits); + lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumRedBits); + lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumGreenBits); + lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumBlueBits); + lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumAlphaBits); + lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cDepthBits); + lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cStencilBits); + lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAuxBuffers); + lpStruct->iLayerPlane = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.iLayerPlane); + lpStruct->bReserved = (*env)->GetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.bReserved); + lpStruct->crTransparent = (*env)->GetIntField(env, lpObject, LAYERPLANEDESCRIPTORFc.crTransparent); + return lpStruct; +} + +void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct) +{ + if (!LAYERPLANEDESCRIPTORFc.cached) cacheLAYERPLANEDESCRIPTORFields(env, lpObject); + (*env)->SetShortField(env, lpObject, LAYERPLANEDESCRIPTORFc.nSize, (jshort)lpStruct->nSize); + (*env)->SetShortField(env, lpObject, LAYERPLANEDESCRIPTORFc.nVersion, (jshort)lpStruct->nVersion); + (*env)->SetIntField(env, lpObject, LAYERPLANEDESCRIPTORFc.dwFlags, (jint)lpStruct->dwFlags); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.iPixelType, (jbyte)lpStruct->iPixelType); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cColorBits, (jbyte)lpStruct->cColorBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cRedBits, (jbyte)lpStruct->cRedBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cRedShift, (jbyte)lpStruct->cRedShift); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cGreenBits, (jbyte)lpStruct->cGreenBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cGreenShift, (jbyte)lpStruct->cGreenShift); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cBlueBits, (jbyte)lpStruct->cBlueBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cBlueShift, (jbyte)lpStruct->cBlueShift); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAlphaBits, (jbyte)lpStruct->cAlphaBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAlphaShift, (jbyte)lpStruct->cAlphaShift); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumBits, (jbyte)lpStruct->cAccumBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumRedBits, (jbyte)lpStruct->cAccumRedBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cDepthBits, (jbyte)lpStruct->cDepthBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cStencilBits, (jbyte)lpStruct->cStencilBits); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.cAuxBuffers, (jbyte)lpStruct->cAuxBuffers); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.iLayerPlane, (jbyte)lpStruct->iLayerPlane); + (*env)->SetByteField(env, lpObject, LAYERPLANEDESCRIPTORFc.bReserved, (jbyte)lpStruct->bReserved); + (*env)->SetIntField(env, lpObject, LAYERPLANEDESCRIPTORFc.crTransparent, (jint)lpStruct->crTransparent); +} +#endif + +#ifndef NO_PIXELFORMATDESCRIPTOR +typedef struct PIXELFORMATDESCRIPTOR_FID_CACHE { + int cached; + jclass clazz; + jfieldID nSize, nVersion, dwFlags, iPixelType, cColorBits, cRedBits, cRedShift, cGreenBits, cGreenShift, cBlueBits, cBlueShift, cAlphaBits, cAlphaShift, cAccumBits, cAccumRedBits, cAccumGreenBits, cAccumBlueBits, cAccumAlphaBits, cDepthBits, cStencilBits, cAuxBuffers, iLayerType, bReserved, dwLayerMask, dwVisibleMask, dwDamageMask; +} PIXELFORMATDESCRIPTOR_FID_CACHE; + +PIXELFORMATDESCRIPTOR_FID_CACHE PIXELFORMATDESCRIPTORFc; + +void cachePIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject) +{ + if (PIXELFORMATDESCRIPTORFc.cached) return; + PIXELFORMATDESCRIPTORFc.clazz = (*env)->GetObjectClass(env, lpObject); + PIXELFORMATDESCRIPTORFc.nSize = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "nSize", "S"); + PIXELFORMATDESCRIPTORFc.nVersion = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "nVersion", "S"); + PIXELFORMATDESCRIPTORFc.dwFlags = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "dwFlags", "I"); + PIXELFORMATDESCRIPTORFc.iPixelType = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "iPixelType", "B"); + PIXELFORMATDESCRIPTORFc.cColorBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cColorBits", "B"); + PIXELFORMATDESCRIPTORFc.cRedBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cRedBits", "B"); + PIXELFORMATDESCRIPTORFc.cRedShift = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cRedShift", "B"); + PIXELFORMATDESCRIPTORFc.cGreenBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cGreenBits", "B"); + PIXELFORMATDESCRIPTORFc.cGreenShift = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cGreenShift", "B"); + PIXELFORMATDESCRIPTORFc.cBlueBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cBlueBits", "B"); + PIXELFORMATDESCRIPTORFc.cBlueShift = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cBlueShift", "B"); + PIXELFORMATDESCRIPTORFc.cAlphaBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAlphaBits", "B"); + PIXELFORMATDESCRIPTORFc.cAlphaShift = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAlphaShift", "B"); + PIXELFORMATDESCRIPTORFc.cAccumBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAccumBits", "B"); + PIXELFORMATDESCRIPTORFc.cAccumRedBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAccumRedBits", "B"); + PIXELFORMATDESCRIPTORFc.cAccumGreenBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAccumGreenBits", "B"); + PIXELFORMATDESCRIPTORFc.cAccumBlueBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAccumBlueBits", "B"); + PIXELFORMATDESCRIPTORFc.cAccumAlphaBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAccumAlphaBits", "B"); + PIXELFORMATDESCRIPTORFc.cDepthBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cDepthBits", "B"); + PIXELFORMATDESCRIPTORFc.cStencilBits = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cStencilBits", "B"); + PIXELFORMATDESCRIPTORFc.cAuxBuffers = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "cAuxBuffers", "B"); + PIXELFORMATDESCRIPTORFc.iLayerType = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "iLayerType", "B"); + PIXELFORMATDESCRIPTORFc.bReserved = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "bReserved", "B"); + PIXELFORMATDESCRIPTORFc.dwLayerMask = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "dwLayerMask", "I"); + PIXELFORMATDESCRIPTORFc.dwVisibleMask = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "dwVisibleMask", "I"); + PIXELFORMATDESCRIPTORFc.dwDamageMask = (*env)->GetFieldID(env, PIXELFORMATDESCRIPTORFc.clazz, "dwDamageMask", "I"); + PIXELFORMATDESCRIPTORFc.cached = 1; +} + +PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct) +{ + if (!PIXELFORMATDESCRIPTORFc.cached) cachePIXELFORMATDESCRIPTORFields(env, lpObject); + lpStruct->nSize = (*env)->GetShortField(env, lpObject, PIXELFORMATDESCRIPTORFc.nSize); + lpStruct->nVersion = (*env)->GetShortField(env, lpObject, PIXELFORMATDESCRIPTORFc.nVersion); + lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwFlags); + lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.iPixelType); + lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cColorBits); + lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cRedBits); + lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cRedShift); + lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cGreenBits); + lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cGreenShift); + lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cBlueBits); + lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cBlueShift); + lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAlphaBits); + lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAlphaShift); + lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumBits); + lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumRedBits); + lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumGreenBits); + lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumBlueBits); + lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumAlphaBits); + lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cDepthBits); + lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cStencilBits); + lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAuxBuffers); + lpStruct->iLayerType = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.iLayerType); + lpStruct->bReserved = (*env)->GetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.bReserved); + lpStruct->dwLayerMask = (*env)->GetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwLayerMask); + lpStruct->dwVisibleMask = (*env)->GetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwVisibleMask); + lpStruct->dwDamageMask = (*env)->GetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwDamageMask); + return lpStruct; +} + +void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct) +{ + if (!PIXELFORMATDESCRIPTORFc.cached) cachePIXELFORMATDESCRIPTORFields(env, lpObject); + (*env)->SetShortField(env, lpObject, PIXELFORMATDESCRIPTORFc.nSize, (jshort)lpStruct->nSize); + (*env)->SetShortField(env, lpObject, PIXELFORMATDESCRIPTORFc.nVersion, (jshort)lpStruct->nVersion); + (*env)->SetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwFlags, (jint)lpStruct->dwFlags); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.iPixelType, (jbyte)lpStruct->iPixelType); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cColorBits, (jbyte)lpStruct->cColorBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cRedBits, (jbyte)lpStruct->cRedBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cRedShift, (jbyte)lpStruct->cRedShift); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cGreenBits, (jbyte)lpStruct->cGreenBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cGreenShift, (jbyte)lpStruct->cGreenShift); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cBlueBits, (jbyte)lpStruct->cBlueBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cBlueShift, (jbyte)lpStruct->cBlueShift); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAlphaBits, (jbyte)lpStruct->cAlphaBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAlphaShift, (jbyte)lpStruct->cAlphaShift); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumBits, (jbyte)lpStruct->cAccumBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumRedBits, (jbyte)lpStruct->cAccumRedBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cDepthBits, (jbyte)lpStruct->cDepthBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cStencilBits, (jbyte)lpStruct->cStencilBits); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.cAuxBuffers, (jbyte)lpStruct->cAuxBuffers); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.iLayerType, (jbyte)lpStruct->iLayerType); + (*env)->SetByteField(env, lpObject, PIXELFORMATDESCRIPTORFc.bReserved, (jbyte)lpStruct->bReserved); + (*env)->SetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwLayerMask, (jint)lpStruct->dwLayerMask); + (*env)->SetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwVisibleMask, (jint)lpStruct->dwVisibleMask); + (*env)->SetIntField(env, lpObject, PIXELFORMATDESCRIPTORFc.dwDamageMask, (jint)lpStruct->dwDamageMask); +} +#endif + diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.h b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.h new file mode 100644 index 0000000000..a656f5445d --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library/wgl_structs.h @@ -0,0 +1,37 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +#include "wgl.h" + +#ifndef NO_LAYERPLANEDESCRIPTOR +void cacheLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject); +LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct); +void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct); +#define LAYERPLANEDESCRIPTOR_sizeof() sizeof(LAYERPLANEDESCRIPTOR) +#else +#define cacheLAYERPLANEDESCRIPTORFields(a,b) +#define getLAYERPLANEDESCRIPTORFields(a,b,c) NULL +#define setLAYERPLANEDESCRIPTORFields(a,b,c) +#define LAYERPLANEDESCRIPTOR_sizeof() 0 +#endif + +#ifndef NO_PIXELFORMATDESCRIPTOR +void cachePIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject); +PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct); +void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct); +#define PIXELFORMATDESCRIPTOR_sizeof() sizeof(PIXELFORMATDESCRIPTOR) +#else +#define cachePIXELFORMATDESCRIPTORFields(a,b) +#define getPIXELFORMATDESCRIPTORFields(a,b,c) NULL +#define setPIXELFORMATDESCRIPTORFields(a,b,c) +#define PIXELFORMATDESCRIPTOR_sizeof() 0 +#endif + diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/LAYERPLANEDESCRIPTOR.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/LAYERPLANEDESCRIPTOR.java new file mode 100755 index 0000000000..49d2361d76 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/LAYERPLANEDESCRIPTOR.java @@ -0,0 +1,40 @@ +/******************************************************************************* + * Copyright (c) 2000, 2005 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.internal.opengl.win32; + + +public class LAYERPLANEDESCRIPTOR { + public short nSize; + public short nVersion; + public int dwFlags; + public byte iPixelType; + public byte cColorBits; + public byte cRedBits; + public byte cRedShift; + public byte cGreenBits; + public byte cGreenShift; + public byte cBlueBits; + public byte cBlueShift; + public byte cAlphaBits; + public byte cAlphaShift; + public byte cAccumBits; + public byte cAccumRedBits; + public byte cAccumGreenBits; + public byte cAccumBlueBits; + public byte cAccumAlphaBits; + public byte cDepthBits; + public byte cStencilBits; + public byte cAuxBuffers; + public byte iLayerPlane; + public byte bReserved; + public int crTransparent; + public static final int sizeof = 36; +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/PIXELFORMATDESCRIPTOR.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/PIXELFORMATDESCRIPTOR.java new file mode 100755 index 0000000000..29024643b1 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/PIXELFORMATDESCRIPTOR.java @@ -0,0 +1,42 @@ +/******************************************************************************* + * Copyright (c) 2000, 2005 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.internal.opengl.win32; + + +public class PIXELFORMATDESCRIPTOR { + public short nSize; + public short nVersion; + public int dwFlags; + public byte iPixelType; + public byte cColorBits; + public byte cRedBits; + public byte cRedShift; + public byte cGreenBits; + public byte cGreenShift; + public byte cBlueBits; + public byte cBlueShift; + public byte cAlphaBits; + public byte cAlphaShift; + public byte cAccumBits; + public byte cAccumRedBits; + public byte cAccumGreenBits; + public byte cAccumBlueBits; + public byte cAccumAlphaBits; + public byte cDepthBits; + public byte cStencilBits; + public byte cAuxBuffers; + public byte iLayerType; + public byte bReserved; + public int dwLayerMask; + public int dwVisibleMask; + public int dwDamageMask; + public static final int sizeof = 40; +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/WGL.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/WGL.java new file mode 100755 index 0000000000..4904161221 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/internal/opengl/win32/WGL.java @@ -0,0 +1,151 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.internal.opengl.win32; + +import org.eclipse.swt.internal.*; + +public class WGL extends Platform { + static { + Library.loadLibrary("swt-wgl"); + } + + public static final int WGL_FONT_LINES = 0; + public static final int WGL_FONT_POLYGONS = 1; + + /* LAYERPLANEDESCRIPTOR flags */ + public static final int LPD_DOUBLEBUFFER = 0x00000001; + public static final int LPD_STEREO = 0x00000002; + public static final int LPD_SUPPORT_GDI = 0x00000010; + public static final int LPD_SUPPORT_OPENGL = 0x00000020; + public static final int LPD_SHARE_DEPTH = 0x00000040; + public static final int LPD_SHARE_STENCIL = 0x00000080; + public static final int LPD_SHARE_ACCUM = 0x00000100; + public static final int LPD_SWAP_EXCHANGE = 0x00000200; + public static final int LPD_SWAP_COPY = 0x00000400; + public static final int LPD_TRANSPARENT = 0x00001000; + + public static final int LPD_TYPE_RGBA = 0; + public static final int LPD_TYPE_COLORINDEX = 1; + + /* wglSwapLayerBuffers flags */ + public static final int WGL_SWAP_MAIN_PLANE = 0x00000001; + public static final int WGL_SWAP_OVERLAY1 = 0x00000002; + public static final int WGL_SWAP_OVERLAY2 = 0x00000004; + public static final int WGL_SWAP_OVERLAY3 = 0x00000008; + public static final int WGL_SWAP_OVERLAY4 = 0x00000010; + public static final int WGL_SWAP_OVERLAY5 = 0x00000020; + public static final int WGL_SWAP_OVERLAY6 = 0x00000040; + public static final int WGL_SWAP_OVERLAY7 = 0x00000080; + public static final int WGL_SWAP_OVERLAY8 = 0x00000100; + public static final int WGL_SWAP_OVERLAY9 = 0x00000200; + public static final int WGL_SWAP_OVERLAY10 = 0x00000400; + public static final int WGL_SWAP_OVERLAY11 = 0x00000800; + public static final int WGL_SWAP_OVERLAY12 = 0x00001000; + public static final int WGL_SWAP_OVERLAY13 = 0x00002000; + public static final int WGL_SWAP_OVERLAY14 = 0x00004000; + public static final int WGL_SWAP_OVERLAY15 = 0x00008000; + public static final int WGL_SWAP_UNDERLAY1 = 0x00010000; + public static final int WGL_SWAP_UNDERLAY2 = 0x00020000; + public static final int WGL_SWAP_UNDERLAY3 = 0x00040000; + public static final int WGL_SWAP_UNDERLAY4 = 0x00080000; + public static final int WGL_SWAP_UNDERLAY5 = 0x00100000; + public static final int WGL_SWAP_UNDERLAY6 = 0x00200000; + public static final int WGL_SWAP_UNDERLAY7 = 0x00400000; + public static final int WGL_SWAP_UNDERLAY8 = 0x00800000; + public static final int WGL_SWAP_UNDERLAY9 = 0x01000000; + public static final int WGL_SWAP_UNDERLAY10 = 0x02000000; + public static final int WGL_SWAP_UNDERLAY11 = 0x04000000; + public static final int WGL_SWAP_UNDERLAY12 = 0x08000000; + public static final int WGL_SWAP_UNDERLAY13 = 0x10000000; + public static final int WGL_SWAP_UNDERLAY14 = 0x20000000; + public static final int WGL_SWAP_UNDERLAY15 = 0x40000000; + + /* pixel types */ + public static final int PFD_TYPE_RGBA = 0; + public static final int PFD_TYPE_COLORINDEX = 1; + + /* layer types */ + public static final int PFD_MAIN_PLANE = 0; + public static final int PFD_OVERLAY_PLANE = 1; + public static final int PFD_UNDERLAY_PLANE = (-1); + + /* PIXELFORMATDESCRIPTOR flags */ + public static final int PFD_DOUBLEBUFFER = 0x00000001; + public static final int PFD_STEREO = 0x00000002; + public static final int PFD_DRAW_TO_WINDOW = 0x00000004; + public static final int PFD_DRAW_TO_BITMAP = 0x00000008; + public static final int PFD_SUPPORT_GDI = 0x00000010; + public static final int PFD_SUPPORT_OPENGL = 0x00000020; + public static final int PFD_GENERIC_FORMAT = 0x00000040; + public static final int PFD_NEED_PALETTE = 0x00000080; + public static final int PFD_NEED_SYSTEM_PALETTE = 0x00000100; + public static final int PFD_SWAP_EXCHANGE = 0x00000200; + public static final int PFD_SWAP_COPY = 0x00000400; + public static final int PFD_SWAP_LAYER_BUFFERS = 0x00000800; + public static final int PFD_GENERIC_ACCELERATED = 0x00001000; + public static final int PFD_SUPPORT_DIRECTDRAW = 0x00002000; + + /* PIXELFORMATDESCRIPTOR flags for use in ChoosePixelFormat only */ + public static final int PFD_DEPTH_DONTCARE = 0x20000000; + public static final int PFD_DOUBLEBUFFER_DONTCARE = 0x40000000; + public static final int PFD_STEREO_DONTCARE = 0x80000000; + +/** @param hdc cast=(HDC) */ +public static final native int ChoosePixelFormat(int /*long*/ hdc, PIXELFORMATDESCRIPTOR ppfd); +/** @param hdc cast=(HDC) */ +public static final native int DescribePixelFormat(int /*long*/ hdc, int iPixelFormat, int nBytes, PIXELFORMATDESCRIPTOR ppfd); +/** @param hdc cast=(HDC) */ +public static final native int GetPixelFormat(int /*long*/ hdc); +/** @param hdc cast=(HDC) */ +public static final native boolean SetPixelFormat(int /*long*/ hdc, int iPixelFormat, PIXELFORMATDESCRIPTOR ppfd); +/** @param hdc cast=(HDC) */ +public static final native boolean SwapBuffers(int /*long*/ hdc); +/** + * @param hglrcSrc cast=(HGLRC) + * @param hglrcDst cast=(HGLRC) + */ +public static final native boolean wglCopyContext(int /*long*/ hglrcSrc, int /*long*/ hglrcDst, int mask); +/** @param hdc cast=(HDC) */ +public static final native int /*long*/ wglCreateContext(int /*long*/ hdc); +/** @param hdc cast=(HDC) */ +public static final native int /*long*/ wglCreateLayerContext(int /*long*/ hdc, int iLayerPlane); +/** @param hglrc cast=(HGLRC) */ +public static final native boolean wglDeleteContext(int /*long*/ hglrc); +public static final native int /*long*/ wglGetCurrentContext(); +public static final native int /*long*/ wglGetCurrentDC(); +public static final native int /*long*/ wglGetProcAddress(byte[] lpszProc); +/** + * @param hdc cast=(HDC) + * @param hglrc cast=(HGLRC) + */ +public static final native boolean wglMakeCurrent(int /*long*/ hdc, int /*long*/ hglrc); +/** + * @param hglrc1 cast=(HGLRC) + * @param hglrc2 cast=(HGLRC) + */ +public static final native boolean wglShareLists(int /*long*/ hglrc1, int /*long*/ hglrc2); +/** @param hdc cast=(HDC) */ +public static final native boolean wglDescribeLayerPlane(int /*long*/ hdc, int iPixelFormat, int iLayerPlane, int nBytes, LAYERPLANEDESCRIPTOR plpd); +/** + * @param hdc cast=(HDC) + * @param pcr cast=(COLORREF *) + */ +public static final native int wglSetLayerPaletteEntries(int /*long*/ hdc, int iLayerPlane, int iStart, int cEntries, int[] pcr); +/** + * @param hdc cast=(HDC) + * @param pcr cast=(COLORREF *) + */ +public static final native int wglGetLayerPaletteEntries(int /*long*/ hdc, int iLayerPlane, int iStart, int cEntries, int[] pcr); +/** @param hdc cast=(HDC) */ +public static final native boolean wglRealizeLayerPalette(int /*long*/ hdc, int iLayerPlane, boolean bRealize); +/** @param hdc cast=(HDC) */ +public static final native boolean wglSwapLayerBuffers(int /*long*/ hdc, int fuPlanes); +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java new file mode 100644 index 0000000000..39b6350898 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java @@ -0,0 +1,196 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.opengl; + +import org.eclipse.swt.*; +import org.eclipse.swt.widgets.*; +import org.eclipse.swt.internal.win32.*; +import org.eclipse.swt.internal.opengl.win32.*; + +/** + * GLCanvas is a widget capable of displaying OpenGL content. + * + * @see GLData + * @see <a href="http://www.eclipse.org/swt/snippets/#opengl">OpenGL snippets</a> + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * + * @since 3.2 + */ + +public class GLCanvas extends Canvas { + int /*long*/ context; + int pixelFormat; + static final String USE_OWNDC_KEY = "org.eclipse.swt.internal.win32.useOwnDC"; //$NON-NLS-1$ +/** + * Create a GLCanvas widget using the attributes described in the GLData + * object provided. + * + * @param parent a composite widget + * @param style the bitwise OR'ing of widget styles + * @param data the requested attributes of the GLCanvas + * + * @exception IllegalArgumentException + * <ul><li>ERROR_NULL_ARGUMENT when the data is null + * <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</ul> + * </ul> + */ +public GLCanvas (Composite parent, int style, GLData data) { + super (parent, checkStyle (parent, style)); + parent.getDisplay ().setData (USE_OWNDC_KEY, new Boolean (false)); + if (data == null) SWT.error (SWT.ERROR_NULL_ARGUMENT); + PIXELFORMATDESCRIPTOR pfd = new PIXELFORMATDESCRIPTOR (); + pfd.nSize = (short) PIXELFORMATDESCRIPTOR.sizeof; + pfd.nVersion = 1; + pfd.dwFlags = WGL.PFD_DRAW_TO_WINDOW | WGL.PFD_SUPPORT_OPENGL; + pfd.dwLayerMask = WGL.PFD_MAIN_PLANE; + pfd.iPixelType = (byte) WGL.PFD_TYPE_RGBA; + if (data.doubleBuffer) pfd.dwFlags |= WGL.PFD_DOUBLEBUFFER; + if (data.stereo) pfd.dwFlags |= WGL.PFD_STEREO; + pfd.cRedBits = (byte) data.redSize; + pfd.cGreenBits = (byte) data.greenSize; + pfd.cBlueBits = (byte) data.blueSize; + pfd.cAlphaBits = (byte) data.alphaSize; + pfd.cDepthBits = (byte) data.depthSize; + pfd.cStencilBits = (byte) data.stencilSize; + pfd.cAccumRedBits = (byte) data.accumRedSize; + pfd.cAccumGreenBits = (byte) data.accumGreenSize; + pfd.cAccumBlueBits = (byte) data.accumBlueSize; + pfd.cAccumAlphaBits = (byte) data.accumAlphaSize; + pfd.cAccumBits = (byte) (pfd.cAccumRedBits + pfd.cAccumGreenBits + pfd.cAccumBlueBits + pfd.cAccumAlphaBits); + + //FIXME - use wglChoosePixelFormatARB +// if (data.sampleBuffers > 0) { +// wglAttrib [pos++] = WGL.WGL_SAMPLE_BUFFERS_ARB; +// wglAttrib [pos++] = data.sampleBuffers; +// } +// if (data.samples > 0) { +// wglAttrib [pos++] = WGL.WGL_SAMPLES_ARB; +// wglAttrib [pos++] = data.samples; +// } + + int /*long*/ hDC = OS.GetDC (handle); + pixelFormat = WGL.ChoosePixelFormat (hDC, pfd); + if (pixelFormat == 0 || !WGL.SetPixelFormat (hDC, pixelFormat, pfd)) { + OS.ReleaseDC (handle, hDC); + dispose (); + SWT.error (SWT.ERROR_UNSUPPORTED_DEPTH); + } + context = WGL.wglCreateContext (hDC); + if (context == 0) { + OS.ReleaseDC (handle, hDC); + SWT.error (SWT.ERROR_NO_HANDLES); + } + OS.ReleaseDC (handle, hDC); + if (data.shareContext != null) { + WGL.wglShareLists (data.shareContext.context, context); + } + + Listener listener = new Listener () { + public void handleEvent (Event event) { + switch (event.type) { + case SWT.Dispose: + WGL.wglDeleteContext (context); + break; + } + } + }; + addListener (SWT.Dispose, listener); +} + +static int checkStyle(Composite parent, int style) { + if (parent != null) { + if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (6, 0)) { + parent.getDisplay ().setData (USE_OWNDC_KEY, new Boolean (true)); + } + } + return style; +} + +/** + * Returns a GLData object describing the created context. + * + * @return GLData description of the OpenGL context attributes + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +public GLData getGLData () { + checkWidget (); + GLData data = new GLData (); + PIXELFORMATDESCRIPTOR pfd = new PIXELFORMATDESCRIPTOR (); + pfd.nSize = (short) PIXELFORMATDESCRIPTOR.sizeof; + int /*long*/ hDC = OS.GetDC (handle); + WGL.DescribePixelFormat (hDC, pixelFormat, PIXELFORMATDESCRIPTOR.sizeof, pfd); + OS.ReleaseDC (handle, hDC); + data.doubleBuffer = (pfd.dwFlags & WGL.PFD_DOUBLEBUFFER) != 0; + data.stereo = (pfd.dwFlags & WGL.PFD_STEREO) != 0; + data.redSize = pfd.cRedBits; + data.greenSize = pfd.cGreenBits; + data.blueSize = pfd.cBlueBits; + data.alphaSize = pfd.cAlphaBits; + data.depthSize = pfd.cDepthBits; + data.stencilSize = pfd.cStencilBits; + data.accumRedSize = pfd.cAccumRedBits; + data.accumGreenSize = pfd.cAccumGreenBits; + data.accumBlueSize = pfd.cAccumBlueBits; + data.accumAlphaSize = pfd.cAccumAlphaBits; + return data; +} + +/** + * Returns a boolean indicating whether the receiver's OpenGL context + * is the current context. + * + * @return true if the receiver holds the current OpenGL context, + * false otherwise + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +public boolean isCurrent () { + checkWidget (); + return WGL.wglGetCurrentContext () == context; +} + +/** + * Sets the OpenGL context associated with this GLCanvas to be the + * current GL context. + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +public void setCurrent () { + checkWidget (); + if (WGL.wglGetCurrentContext () == context) return; + int /*long*/ hDC = OS.GetDC (handle); + WGL.wglMakeCurrent (hDC, context); + OS.ReleaseDC (handle, hDC); +} + +/** + * Swaps the front and back color buffers. + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +public void swapBuffers () { + checkWidget (); + int /*long*/ hDC = OS.GetDC (handle); + WGL.SwapBuffers (hDC); + OS.ReleaseDC (handle, hDC); +} +} |