diff options
Diffstat (limited to 'bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/library')
7 files changed, 711 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 + |