bundles/org.eclipse.swt.win32.win32.x86_64/library/os_structs.c

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2019 IBM Corporation and others.
   3  *
   4  * This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License 2.0
   6  * which accompanies this distribution, and is available at
   7  * https://www.eclipse.org/legal/epl-2.0/
   8  *
   9  * SPDX-License-Identifier: EPL-2.0
  10  *
  11  * Contributors:
  12  *    IBM Corporation - initial API and implementation
  13  *******************************************************************************/
  14
  15 /* Note: This file was auto-generated by org.eclipse.swt.tools.internal.JNIGenerator */
  16 /* DO NOT EDIT - your changes will be lost. */
  17
  18 #include "swt.h"
  19 #include "os_structs.h"
  20
  21 #ifndef NO_ACCEL
  22 typedef struct ACCEL_FID_CACHE {
  23         int cached;
  24         jclass clazz;
  25         jfieldID fVirt, key, cmd;
  26 } ACCEL_FID_CACHE;
  27
  28 ACCEL_FID_CACHE ACCELFc;
  29
  30 void cacheACCELFields(JNIEnv *env, jobject lpObject)
  31 {
  32         if (ACCELFc.cached) return;
  33         ACCELFc.clazz = (*env)->GetObjectClass(env, lpObject);
  34         ACCELFc.fVirt = (*env)->GetFieldID(env, ACCELFc.clazz, "fVirt", "B");
  35         ACCELFc.key = (*env)->GetFieldID(env, ACCELFc.clazz, "key", "S");
  36         ACCELFc.cmd = (*env)->GetFieldID(env, ACCELFc.clazz, "cmd", "S");
  37         ACCELFc.cached = 1;
  38 }
  39
  40 ACCEL *getACCELFields(JNIEnv *env, jobject lpObject, ACCEL *lpStruct)
  41 {
  42         if (!ACCELFc.cached) cacheACCELFields(env, lpObject);
  43         lpStruct->fVirt = (*env)->GetByteField(env, lpObject, ACCELFc.fVirt);
  44         lpStruct->key = (*env)->GetShortField(env, lpObject, ACCELFc.key);
  45         lpStruct->cmd = (*env)->GetShortField(env, lpObject, ACCELFc.cmd);
  46         return lpStruct;
  47 }
  48
  49 void setACCELFields(JNIEnv *env, jobject lpObject, ACCEL *lpStruct)
  50 {
  51         if (!ACCELFc.cached) cacheACCELFields(env, lpObject);
  52         (*env)->SetByteField(env, lpObject, ACCELFc.fVirt, (jbyte)lpStruct->fVirt);
  53         (*env)->SetShortField(env, lpObject, ACCELFc.key, (jshort)lpStruct->key);
  54         (*env)->SetShortField(env, lpObject, ACCELFc.cmd, (jshort)lpStruct->cmd);
  55 }
  56 #endif
  57
  58 #ifndef NO_ACTCTX
  59 typedef struct ACTCTX_FID_CACHE {
  60         int cached;
  61         jclass clazz;
  62         jfieldID cbSize, dwFlags, lpSource, wProcessorArchitecture, wLangId, lpAssemblyDirectory, lpResourceName, lpApplicationName, hModule;
  63 } ACTCTX_FID_CACHE;
  64
  65 ACTCTX_FID_CACHE ACTCTXFc;
  66
  67 void cacheACTCTXFields(JNIEnv *env, jobject lpObject)
  68 {
  69         if (ACTCTXFc.cached) return;
  70         ACTCTXFc.clazz = (*env)->GetObjectClass(env, lpObject);
  71         ACTCTXFc.cbSize = (*env)->GetFieldID(env, ACTCTXFc.clazz, "cbSize", "I");
  72         ACTCTXFc.dwFlags = (*env)->GetFieldID(env, ACTCTXFc.clazz, "dwFlags", "I");
  73         ACTCTXFc.lpSource = (*env)->GetFieldID(env, ACTCTXFc.clazz, "lpSource", "J");
  74         ACTCTXFc.wProcessorArchitecture = (*env)->GetFieldID(env, ACTCTXFc.clazz, "wProcessorArchitecture", "S");
  75         ACTCTXFc.wLangId = (*env)->GetFieldID(env, ACTCTXFc.clazz, "wLangId", "S");
  76         ACTCTXFc.lpAssemblyDirectory = (*env)->GetFieldID(env, ACTCTXFc.clazz, "lpAssemblyDirectory", "J");
  77         ACTCTXFc.lpResourceName = (*env)->GetFieldID(env, ACTCTXFc.clazz, "lpResourceName", "J");
  78         ACTCTXFc.lpApplicationName = (*env)->GetFieldID(env, ACTCTXFc.clazz, "lpApplicationName", "J");
  79         ACTCTXFc.hModule = (*env)->GetFieldID(env, ACTCTXFc.clazz, "hModule", "J");
  80         ACTCTXFc.cached = 1;
  81 }
  82
  83 ACTCTX *getACTCTXFields(JNIEnv *env, jobject lpObject, ACTCTX *lpStruct)
  84 {
  85         if (!ACTCTXFc.cached) cacheACTCTXFields(env, lpObject);
  86         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, ACTCTXFc.cbSize);
  87         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, ACTCTXFc.dwFlags);
  88         lpStruct->lpSource = (LPCTSTR)(*env)->GetLongField(env, lpObject, ACTCTXFc.lpSource);
  89         lpStruct->wProcessorArchitecture = (*env)->GetShortField(env, lpObject, ACTCTXFc.wProcessorArchitecture);
  90         lpStruct->wLangId = (*env)->GetShortField(env, lpObject, ACTCTXFc.wLangId);
  91         lpStruct->lpAssemblyDirectory = (LPCTSTR)(*env)->GetLongField(env, lpObject, ACTCTXFc.lpAssemblyDirectory);
  92         lpStruct->lpResourceName = (LPCTSTR)(*env)->GetLongField(env, lpObject, ACTCTXFc.lpResourceName);
  93         lpStruct->lpApplicationName = (LPCTSTR)(*env)->GetLongField(env, lpObject, ACTCTXFc.lpApplicationName);
  94         lpStruct->hModule = (HMODULE)(*env)->GetLongField(env, lpObject, ACTCTXFc.hModule);
  95         return lpStruct;
  96 }
  97
  98 void setACTCTXFields(JNIEnv *env, jobject lpObject, ACTCTX *lpStruct)
  99 {
 100         if (!ACTCTXFc.cached) cacheACTCTXFields(env, lpObject);
 101         (*env)->SetIntField(env, lpObject, ACTCTXFc.cbSize, (jint)lpStruct->cbSize);
 102         (*env)->SetIntField(env, lpObject, ACTCTXFc.dwFlags, (jint)lpStruct->dwFlags);
 103         (*env)->SetLongField(env, lpObject, ACTCTXFc.lpSource, (jlong)lpStruct->lpSource);
 104         (*env)->SetShortField(env, lpObject, ACTCTXFc.wProcessorArchitecture, (jshort)lpStruct->wProcessorArchitecture);
 105         (*env)->SetShortField(env, lpObject, ACTCTXFc.wLangId, (jshort)lpStruct->wLangId);
 106         (*env)->SetLongField(env, lpObject, ACTCTXFc.lpAssemblyDirectory, (jlong)lpStruct->lpAssemblyDirectory);
 107         (*env)->SetLongField(env, lpObject, ACTCTXFc.lpResourceName, (jlong)lpStruct->lpResourceName);
 108         (*env)->SetLongField(env, lpObject, ACTCTXFc.lpApplicationName, (jlong)lpStruct->lpApplicationName);
 109         (*env)->SetLongField(env, lpObject, ACTCTXFc.hModule, (jlong)lpStruct->hModule);
 110 }
 111 #endif
 112
 113 #ifndef NO_BITMAP
 114 typedef struct BITMAP_FID_CACHE {
 115         int cached;
 116         jclass clazz;
 117         jfieldID bmType, bmWidth, bmHeight, bmWidthBytes, bmPlanes, bmBitsPixel, bmBits;
 118 } BITMAP_FID_CACHE;
 119
 120 BITMAP_FID_CACHE BITMAPFc;
 121
 122 void cacheBITMAPFields(JNIEnv *env, jobject lpObject)
 123 {
 124         if (BITMAPFc.cached) return;
 125         BITMAPFc.clazz = (*env)->GetObjectClass(env, lpObject);
 126         BITMAPFc.bmType = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmType", "I");
 127         BITMAPFc.bmWidth = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmWidth", "I");
 128         BITMAPFc.bmHeight = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmHeight", "I");
 129         BITMAPFc.bmWidthBytes = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmWidthBytes", "I");
 130         BITMAPFc.bmPlanes = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmPlanes", "S");
 131         BITMAPFc.bmBitsPixel = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmBitsPixel", "S");
 132         BITMAPFc.bmBits = (*env)->GetFieldID(env, BITMAPFc.clazz, "bmBits", "J");
 133         BITMAPFc.cached = 1;
 134 }
 135
 136 BITMAP *getBITMAPFields(JNIEnv *env, jobject lpObject, BITMAP *lpStruct)
 137 {
 138         if (!BITMAPFc.cached) cacheBITMAPFields(env, lpObject);
 139         lpStruct->bmType = (*env)->GetIntField(env, lpObject, BITMAPFc.bmType);
 140         lpStruct->bmWidth = (*env)->GetIntField(env, lpObject, BITMAPFc.bmWidth);
 141         lpStruct->bmHeight = (*env)->GetIntField(env, lpObject, BITMAPFc.bmHeight);
 142         lpStruct->bmWidthBytes = (*env)->GetIntField(env, lpObject, BITMAPFc.bmWidthBytes);
 143         lpStruct->bmPlanes = (*env)->GetShortField(env, lpObject, BITMAPFc.bmPlanes);
 144         lpStruct->bmBitsPixel = (*env)->GetShortField(env, lpObject, BITMAPFc.bmBitsPixel);
 145         lpStruct->bmBits = (LPVOID)(*env)->GetLongField(env, lpObject, BITMAPFc.bmBits);
 146         return lpStruct;
 147 }
 148
 149 void setBITMAPFields(JNIEnv *env, jobject lpObject, BITMAP *lpStruct)
 150 {
 151         if (!BITMAPFc.cached) cacheBITMAPFields(env, lpObject);
 152         (*env)->SetIntField(env, lpObject, BITMAPFc.bmType, (jint)lpStruct->bmType);
 153         (*env)->SetIntField(env, lpObject, BITMAPFc.bmWidth, (jint)lpStruct->bmWidth);
 154         (*env)->SetIntField(env, lpObject, BITMAPFc.bmHeight, (jint)lpStruct->bmHeight);
 155         (*env)->SetIntField(env, lpObject, BITMAPFc.bmWidthBytes, (jint)lpStruct->bmWidthBytes);
 156         (*env)->SetShortField(env, lpObject, BITMAPFc.bmPlanes, (jshort)lpStruct->bmPlanes);
 157         (*env)->SetShortField(env, lpObject, BITMAPFc.bmBitsPixel, (jshort)lpStruct->bmBitsPixel);
 158         (*env)->SetLongField(env, lpObject, BITMAPFc.bmBits, (jlong)lpStruct->bmBits);
 159 }
 160 #endif
 161
 162 #ifndef NO_BITMAPINFOHEADER
 163 typedef struct BITMAPINFOHEADER_FID_CACHE {
 164         int cached;
 165         jclass clazz;
 166         jfieldID biSize, biWidth, biHeight, biPlanes, biBitCount, biCompression, biSizeImage, biXPelsPerMeter, biYPelsPerMeter, biClrUsed, biClrImportant;
 167 } BITMAPINFOHEADER_FID_CACHE;
 168
 169 BITMAPINFOHEADER_FID_CACHE BITMAPINFOHEADERFc;
 170
 171 void cacheBITMAPINFOHEADERFields(JNIEnv *env, jobject lpObject)
 172 {
 173         if (BITMAPINFOHEADERFc.cached) return;
 174         BITMAPINFOHEADERFc.clazz = (*env)->GetObjectClass(env, lpObject);
 175         BITMAPINFOHEADERFc.biSize = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biSize", "I");
 176         BITMAPINFOHEADERFc.biWidth = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biWidth", "I");
 177         BITMAPINFOHEADERFc.biHeight = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biHeight", "I");
 178         BITMAPINFOHEADERFc.biPlanes = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biPlanes", "S");
 179         BITMAPINFOHEADERFc.biBitCount = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biBitCount", "S");
 180         BITMAPINFOHEADERFc.biCompression = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biCompression", "I");
 181         BITMAPINFOHEADERFc.biSizeImage = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biSizeImage", "I");
 182         BITMAPINFOHEADERFc.biXPelsPerMeter = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biXPelsPerMeter", "I");
 183         BITMAPINFOHEADERFc.biYPelsPerMeter = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biYPelsPerMeter", "I");
 184         BITMAPINFOHEADERFc.biClrUsed = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biClrUsed", "I");
 185         BITMAPINFOHEADERFc.biClrImportant = (*env)->GetFieldID(env, BITMAPINFOHEADERFc.clazz, "biClrImportant", "I");
 186         BITMAPINFOHEADERFc.cached = 1;
 187 }
 188
 189 BITMAPINFOHEADER *getBITMAPINFOHEADERFields(JNIEnv *env, jobject lpObject, BITMAPINFOHEADER *lpStruct)
 190 {
 191         if (!BITMAPINFOHEADERFc.cached) cacheBITMAPINFOHEADERFields(env, lpObject);
 192         lpStruct->biSize = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biSize);
 193         lpStruct->biWidth = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biWidth);
 194         lpStruct->biHeight = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biHeight);
 195         lpStruct->biPlanes = (*env)->GetShortField(env, lpObject, BITMAPINFOHEADERFc.biPlanes);
 196         lpStruct->biBitCount = (*env)->GetShortField(env, lpObject, BITMAPINFOHEADERFc.biBitCount);
 197         lpStruct->biCompression = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biCompression);
 198         lpStruct->biSizeImage = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biSizeImage);
 199         lpStruct->biXPelsPerMeter = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biXPelsPerMeter);
 200         lpStruct->biYPelsPerMeter = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biYPelsPerMeter);
 201         lpStruct->biClrUsed = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biClrUsed);
 202         lpStruct->biClrImportant = (*env)->GetIntField(env, lpObject, BITMAPINFOHEADERFc.biClrImportant);
 203         return lpStruct;
 204 }
 205
 206 void setBITMAPINFOHEADERFields(JNIEnv *env, jobject lpObject, BITMAPINFOHEADER *lpStruct)
 207 {
 208         if (!BITMAPINFOHEADERFc.cached) cacheBITMAPINFOHEADERFields(env, lpObject);
 209         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biSize, (jint)lpStruct->biSize);
 210         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biWidth, (jint)lpStruct->biWidth);
 211         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biHeight, (jint)lpStruct->biHeight);
 212         (*env)->SetShortField(env, lpObject, BITMAPINFOHEADERFc.biPlanes, (jshort)lpStruct->biPlanes);
 213         (*env)->SetShortField(env, lpObject, BITMAPINFOHEADERFc.biBitCount, (jshort)lpStruct->biBitCount);
 214         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biCompression, (jint)lpStruct->biCompression);
 215         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biSizeImage, (jint)lpStruct->biSizeImage);
 216         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biXPelsPerMeter, (jint)lpStruct->biXPelsPerMeter);
 217         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biYPelsPerMeter, (jint)lpStruct->biYPelsPerMeter);
 218         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biClrUsed, (jint)lpStruct->biClrUsed);
 219         (*env)->SetIntField(env, lpObject, BITMAPINFOHEADERFc.biClrImportant, (jint)lpStruct->biClrImportant);
 220 }
 221 #endif
 222
 223 #ifndef NO_BLENDFUNCTION
 224 typedef struct BLENDFUNCTION_FID_CACHE {
 225         int cached;
 226         jclass clazz;
 227         jfieldID BlendOp, BlendFlags, SourceConstantAlpha, AlphaFormat;
 228 } BLENDFUNCTION_FID_CACHE;
 229
 230 BLENDFUNCTION_FID_CACHE BLENDFUNCTIONFc;
 231
 232 void cacheBLENDFUNCTIONFields(JNIEnv *env, jobject lpObject)
 233 {
 234         if (BLENDFUNCTIONFc.cached) return;
 235         BLENDFUNCTIONFc.clazz = (*env)->GetObjectClass(env, lpObject);
 236         BLENDFUNCTIONFc.BlendOp = (*env)->GetFieldID(env, BLENDFUNCTIONFc.clazz, "BlendOp", "B");
 237         BLENDFUNCTIONFc.BlendFlags = (*env)->GetFieldID(env, BLENDFUNCTIONFc.clazz, "BlendFlags", "B");
 238         BLENDFUNCTIONFc.SourceConstantAlpha = (*env)->GetFieldID(env, BLENDFUNCTIONFc.clazz, "SourceConstantAlpha", "B");
 239         BLENDFUNCTIONFc.AlphaFormat = (*env)->GetFieldID(env, BLENDFUNCTIONFc.clazz, "AlphaFormat", "B");
 240         BLENDFUNCTIONFc.cached = 1;
 241 }
 242
 243 BLENDFUNCTION *getBLENDFUNCTIONFields(JNIEnv *env, jobject lpObject, BLENDFUNCTION *lpStruct)
 244 {
 245         if (!BLENDFUNCTIONFc.cached) cacheBLENDFUNCTIONFields(env, lpObject);
 246         lpStruct->BlendOp = (*env)->GetByteField(env, lpObject, BLENDFUNCTIONFc.BlendOp);
 247         lpStruct->BlendFlags = (*env)->GetByteField(env, lpObject, BLENDFUNCTIONFc.BlendFlags);
 248         lpStruct->SourceConstantAlpha = (*env)->GetByteField(env, lpObject, BLENDFUNCTIONFc.SourceConstantAlpha);
 249         lpStruct->AlphaFormat = (*env)->GetByteField(env, lpObject, BLENDFUNCTIONFc.AlphaFormat);
 250         return lpStruct;
 251 }
 252
 253 void setBLENDFUNCTIONFields(JNIEnv *env, jobject lpObject, BLENDFUNCTION *lpStruct)
 254 {
 255         if (!BLENDFUNCTIONFc.cached) cacheBLENDFUNCTIONFields(env, lpObject);
 256         (*env)->SetByteField(env, lpObject, BLENDFUNCTIONFc.BlendOp, (jbyte)lpStruct->BlendOp);
 257         (*env)->SetByteField(env, lpObject, BLENDFUNCTIONFc.BlendFlags, (jbyte)lpStruct->BlendFlags);
 258         (*env)->SetByteField(env, lpObject, BLENDFUNCTIONFc.SourceConstantAlpha, (jbyte)lpStruct->SourceConstantAlpha);
 259         (*env)->SetByteField(env, lpObject, BLENDFUNCTIONFc.AlphaFormat, (jbyte)lpStruct->AlphaFormat);
 260 }
 261 #endif
 262
 263 #ifndef NO_BP_PAINTPARAMS
 264 typedef struct BP_PAINTPARAMS_FID_CACHE {
 265         int cached;
 266         jclass clazz;
 267         jfieldID cbSize, dwFlags, prcExclude, pBlendFunction;
 268 } BP_PAINTPARAMS_FID_CACHE;
 269
 270 BP_PAINTPARAMS_FID_CACHE BP_PAINTPARAMSFc;
 271
 272 void cacheBP_PAINTPARAMSFields(JNIEnv *env, jobject lpObject)
 273 {
 274         if (BP_PAINTPARAMSFc.cached) return;
 275         BP_PAINTPARAMSFc.clazz = (*env)->GetObjectClass(env, lpObject);
 276         BP_PAINTPARAMSFc.cbSize = (*env)->GetFieldID(env, BP_PAINTPARAMSFc.clazz, "cbSize", "I");
 277         BP_PAINTPARAMSFc.dwFlags = (*env)->GetFieldID(env, BP_PAINTPARAMSFc.clazz, "dwFlags", "I");
 278         BP_PAINTPARAMSFc.prcExclude = (*env)->GetFieldID(env, BP_PAINTPARAMSFc.clazz, "prcExclude", "J");
 279         BP_PAINTPARAMSFc.pBlendFunction = (*env)->GetFieldID(env, BP_PAINTPARAMSFc.clazz, "pBlendFunction", "J");
 280         BP_PAINTPARAMSFc.cached = 1;
 281 }
 282
 283 BP_PAINTPARAMS *getBP_PAINTPARAMSFields(JNIEnv *env, jobject lpObject, BP_PAINTPARAMS *lpStruct)
 284 {
 285         if (!BP_PAINTPARAMSFc.cached) cacheBP_PAINTPARAMSFields(env, lpObject);
 286         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, BP_PAINTPARAMSFc.cbSize);
 287         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, BP_PAINTPARAMSFc.dwFlags);
 288         lpStruct->prcExclude = (RECT*)(*env)->GetLongField(env, lpObject, BP_PAINTPARAMSFc.prcExclude);
 289         lpStruct->pBlendFunction = (BLENDFUNCTION*)(*env)->GetLongField(env, lpObject, BP_PAINTPARAMSFc.pBlendFunction);
 290         return lpStruct;
 291 }
 292
 293 void setBP_PAINTPARAMSFields(JNIEnv *env, jobject lpObject, BP_PAINTPARAMS *lpStruct)
 294 {
 295         if (!BP_PAINTPARAMSFc.cached) cacheBP_PAINTPARAMSFields(env, lpObject);
 296         (*env)->SetIntField(env, lpObject, BP_PAINTPARAMSFc.cbSize, (jint)lpStruct->cbSize);
 297         (*env)->SetIntField(env, lpObject, BP_PAINTPARAMSFc.dwFlags, (jint)lpStruct->dwFlags);
 298         (*env)->SetLongField(env, lpObject, BP_PAINTPARAMSFc.prcExclude, (jlong)lpStruct->prcExclude);
 299         (*env)->SetLongField(env, lpObject, BP_PAINTPARAMSFc.pBlendFunction, (jlong)lpStruct->pBlendFunction);
 300 }
 301 #endif
 302
 303 #ifndef NO_BROWSEINFO
 304 typedef struct BROWSEINFO_FID_CACHE {
 305         int cached;
 306         jclass clazz;
 307         jfieldID hwndOwner, pidlRoot, pszDisplayName, lpszTitle, ulFlags, lpfn, lParam, iImage;
 308 } BROWSEINFO_FID_CACHE;
 309
 310 BROWSEINFO_FID_CACHE BROWSEINFOFc;
 311
 312 void cacheBROWSEINFOFields(JNIEnv *env, jobject lpObject)
 313 {
 314         if (BROWSEINFOFc.cached) return;
 315         BROWSEINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 316         BROWSEINFOFc.hwndOwner = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "hwndOwner", "J");
 317         BROWSEINFOFc.pidlRoot = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "pidlRoot", "J");
 318         BROWSEINFOFc.pszDisplayName = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "pszDisplayName", "J");
 319         BROWSEINFOFc.lpszTitle = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "lpszTitle", "J");
 320         BROWSEINFOFc.ulFlags = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "ulFlags", "I");
 321         BROWSEINFOFc.lpfn = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "lpfn", "J");
 322         BROWSEINFOFc.lParam = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "lParam", "J");
 323         BROWSEINFOFc.iImage = (*env)->GetFieldID(env, BROWSEINFOFc.clazz, "iImage", "I");
 324         BROWSEINFOFc.cached = 1;
 325 }
 326
 327 BROWSEINFO *getBROWSEINFOFields(JNIEnv *env, jobject lpObject, BROWSEINFO *lpStruct)
 328 {
 329         if (!BROWSEINFOFc.cached) cacheBROWSEINFOFields(env, lpObject);
 330         lpStruct->hwndOwner = (HWND)(*env)->GetLongField(env, lpObject, BROWSEINFOFc.hwndOwner);
 331         lpStruct->pidlRoot = (LPCITEMIDLIST)(*env)->GetLongField(env, lpObject, BROWSEINFOFc.pidlRoot);
 332         lpStruct->pszDisplayName = (LPTSTR)(*env)->GetLongField(env, lpObject, BROWSEINFOFc.pszDisplayName);
 333         lpStruct->lpszTitle = (LPCTSTR)(*env)->GetLongField(env, lpObject, BROWSEINFOFc.lpszTitle);
 334         lpStruct->ulFlags = (*env)->GetIntField(env, lpObject, BROWSEINFOFc.ulFlags);
 335         lpStruct->lpfn = (BFFCALLBACK)(*env)->GetLongField(env, lpObject, BROWSEINFOFc.lpfn);
 336         lpStruct->lParam = (*env)->GetLongField(env, lpObject, BROWSEINFOFc.lParam);
 337         lpStruct->iImage = (*env)->GetIntField(env, lpObject, BROWSEINFOFc.iImage);
 338         return lpStruct;
 339 }
 340
 341 void setBROWSEINFOFields(JNIEnv *env, jobject lpObject, BROWSEINFO *lpStruct)
 342 {
 343         if (!BROWSEINFOFc.cached) cacheBROWSEINFOFields(env, lpObject);
 344         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.hwndOwner, (jlong)lpStruct->hwndOwner);
 345         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.pidlRoot, (jlong)lpStruct->pidlRoot);
 346         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.pszDisplayName, (jlong)lpStruct->pszDisplayName);
 347         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.lpszTitle, (jlong)lpStruct->lpszTitle);
 348         (*env)->SetIntField(env, lpObject, BROWSEINFOFc.ulFlags, (jint)lpStruct->ulFlags);
 349         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.lpfn, (jlong)lpStruct->lpfn);
 350         (*env)->SetLongField(env, lpObject, BROWSEINFOFc.lParam, (jlong)lpStruct->lParam);
 351         (*env)->SetIntField(env, lpObject, BROWSEINFOFc.iImage, (jint)lpStruct->iImage);
 352 }
 353 #endif
 354
 355 #ifndef NO_BUTTON_IMAGELIST
 356 typedef struct BUTTON_IMAGELIST_FID_CACHE {
 357         int cached;
 358         jclass clazz;
 359         jfieldID himl, margin_left, margin_top, margin_right, margin_bottom, uAlign;
 360 } BUTTON_IMAGELIST_FID_CACHE;
 361
 362 BUTTON_IMAGELIST_FID_CACHE BUTTON_IMAGELISTFc;
 363
 364 void cacheBUTTON_IMAGELISTFields(JNIEnv *env, jobject lpObject)
 365 {
 366         if (BUTTON_IMAGELISTFc.cached) return;
 367         BUTTON_IMAGELISTFc.clazz = (*env)->GetObjectClass(env, lpObject);
 368         BUTTON_IMAGELISTFc.himl = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "himl", "J");
 369         BUTTON_IMAGELISTFc.margin_left = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "margin_left", "I");
 370         BUTTON_IMAGELISTFc.margin_top = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "margin_top", "I");
 371         BUTTON_IMAGELISTFc.margin_right = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "margin_right", "I");
 372         BUTTON_IMAGELISTFc.margin_bottom = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "margin_bottom", "I");
 373         BUTTON_IMAGELISTFc.uAlign = (*env)->GetFieldID(env, BUTTON_IMAGELISTFc.clazz, "uAlign", "I");
 374         BUTTON_IMAGELISTFc.cached = 1;
 375 }
 376
 377 BUTTON_IMAGELIST *getBUTTON_IMAGELISTFields(JNIEnv *env, jobject lpObject, BUTTON_IMAGELIST *lpStruct)
 378 {
 379         if (!BUTTON_IMAGELISTFc.cached) cacheBUTTON_IMAGELISTFields(env, lpObject);
 380         lpStruct->himl = (HIMAGELIST)(*env)->GetLongField(env, lpObject, BUTTON_IMAGELISTFc.himl);
 381         lpStruct->margin.left = (LONG)(*env)->GetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_left);
 382         lpStruct->margin.top = (LONG)(*env)->GetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_top);
 383         lpStruct->margin.right = (LONG)(*env)->GetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_right);
 384         lpStruct->margin.bottom = (LONG)(*env)->GetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_bottom);
 385         lpStruct->uAlign = (UINT)(*env)->GetIntField(env, lpObject, BUTTON_IMAGELISTFc.uAlign);
 386         return lpStruct;
 387 }
 388
 389 void setBUTTON_IMAGELISTFields(JNIEnv *env, jobject lpObject, BUTTON_IMAGELIST *lpStruct)
 390 {
 391         if (!BUTTON_IMAGELISTFc.cached) cacheBUTTON_IMAGELISTFields(env, lpObject);
 392         (*env)->SetLongField(env, lpObject, BUTTON_IMAGELISTFc.himl, (jlong)lpStruct->himl);
 393         (*env)->SetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_left, (jint)lpStruct->margin.left);
 394         (*env)->SetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_top, (jint)lpStruct->margin.top);
 395         (*env)->SetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_right, (jint)lpStruct->margin.right);
 396         (*env)->SetIntField(env, lpObject, BUTTON_IMAGELISTFc.margin_bottom, (jint)lpStruct->margin.bottom);
 397         (*env)->SetIntField(env, lpObject, BUTTON_IMAGELISTFc.uAlign, (jint)lpStruct->uAlign);
 398 }
 399 #endif
 400
 401 #ifndef NO_CANDIDATEFORM
 402 typedef struct CANDIDATEFORM_FID_CACHE {
 403         int cached;
 404         jclass clazz;
 405         jfieldID dwIndex, dwStyle, ptCurrentPos, rcArea;
 406 } CANDIDATEFORM_FID_CACHE;
 407
 408 CANDIDATEFORM_FID_CACHE CANDIDATEFORMFc;
 409
 410 void cacheCANDIDATEFORMFields(JNIEnv *env, jobject lpObject)
 411 {
 412         if (CANDIDATEFORMFc.cached) return;
 413         CANDIDATEFORMFc.clazz = (*env)->GetObjectClass(env, lpObject);
 414         CANDIDATEFORMFc.dwIndex = (*env)->GetFieldID(env, CANDIDATEFORMFc.clazz, "dwIndex", "I");
 415         CANDIDATEFORMFc.dwStyle = (*env)->GetFieldID(env, CANDIDATEFORMFc.clazz, "dwStyle", "I");
 416         CANDIDATEFORMFc.ptCurrentPos = (*env)->GetFieldID(env, CANDIDATEFORMFc.clazz, "ptCurrentPos", "Lorg/eclipse/swt/internal/win32/POINT;");
 417         CANDIDATEFORMFc.rcArea = (*env)->GetFieldID(env, CANDIDATEFORMFc.clazz, "rcArea", "Lorg/eclipse/swt/internal/win32/RECT;");
 418         CANDIDATEFORMFc.cached = 1;
 419 }
 420
 421 CANDIDATEFORM *getCANDIDATEFORMFields(JNIEnv *env, jobject lpObject, CANDIDATEFORM *lpStruct)
 422 {
 423         if (!CANDIDATEFORMFc.cached) cacheCANDIDATEFORMFields(env, lpObject);
 424         lpStruct->dwIndex = (*env)->GetIntField(env, lpObject, CANDIDATEFORMFc.dwIndex);
 425         lpStruct->dwStyle = (*env)->GetIntField(env, lpObject, CANDIDATEFORMFc.dwStyle);
 426         {
 427         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CANDIDATEFORMFc.ptCurrentPos);
 428         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->ptCurrentPos);
 429         }
 430         {
 431         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CANDIDATEFORMFc.rcArea);
 432         if (lpObject1 != NULL) getRECTFields(env, lpObject1, &lpStruct->rcArea);
 433         }
 434         return lpStruct;
 435 }
 436
 437 void setCANDIDATEFORMFields(JNIEnv *env, jobject lpObject, CANDIDATEFORM *lpStruct)
 438 {
 439         if (!CANDIDATEFORMFc.cached) cacheCANDIDATEFORMFields(env, lpObject);
 440         (*env)->SetIntField(env, lpObject, CANDIDATEFORMFc.dwIndex, (jint)lpStruct->dwIndex);
 441         (*env)->SetIntField(env, lpObject, CANDIDATEFORMFc.dwStyle, (jint)lpStruct->dwStyle);
 442         {
 443         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CANDIDATEFORMFc.ptCurrentPos);
 444         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->ptCurrentPos);
 445         }
 446         {
 447         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CANDIDATEFORMFc.rcArea);
 448         if (lpObject1 != NULL) setRECTFields(env, lpObject1, &lpStruct->rcArea);
 449         }
 450 }
 451 #endif
 452
 453 #ifndef NO_CERT_CONTEXT
 454 typedef struct CERT_CONTEXT_FID_CACHE {
 455         int cached;
 456         jclass clazz;
 457         jfieldID dwCertEncodingType, pbCertEncoded, cbCertEncoded, pCertInfo, hCertStore;
 458 } CERT_CONTEXT_FID_CACHE;
 459
 460 CERT_CONTEXT_FID_CACHE CERT_CONTEXTFc;
 461
 462 void cacheCERT_CONTEXTFields(JNIEnv *env, jobject lpObject)
 463 {
 464         if (CERT_CONTEXTFc.cached) return;
 465         CERT_CONTEXTFc.clazz = (*env)->GetObjectClass(env, lpObject);
 466         CERT_CONTEXTFc.dwCertEncodingType = (*env)->GetFieldID(env, CERT_CONTEXTFc.clazz, "dwCertEncodingType", "I");
 467         CERT_CONTEXTFc.pbCertEncoded = (*env)->GetFieldID(env, CERT_CONTEXTFc.clazz, "pbCertEncoded", "J");
 468         CERT_CONTEXTFc.cbCertEncoded = (*env)->GetFieldID(env, CERT_CONTEXTFc.clazz, "cbCertEncoded", "I");
 469         CERT_CONTEXTFc.pCertInfo = (*env)->GetFieldID(env, CERT_CONTEXTFc.clazz, "pCertInfo", "J");
 470         CERT_CONTEXTFc.hCertStore = (*env)->GetFieldID(env, CERT_CONTEXTFc.clazz, "hCertStore", "J");
 471         CERT_CONTEXTFc.cached = 1;
 472 }
 473
 474 CERT_CONTEXT *getCERT_CONTEXTFields(JNIEnv *env, jobject lpObject, CERT_CONTEXT *lpStruct)
 475 {
 476         if (!CERT_CONTEXTFc.cached) cacheCERT_CONTEXTFields(env, lpObject);
 477         lpStruct->dwCertEncodingType = (*env)->GetIntField(env, lpObject, CERT_CONTEXTFc.dwCertEncodingType);
 478         lpStruct->pbCertEncoded = (BYTE *)(*env)->GetLongField(env, lpObject, CERT_CONTEXTFc.pbCertEncoded);
 479         lpStruct->cbCertEncoded = (*env)->GetIntField(env, lpObject, CERT_CONTEXTFc.cbCertEncoded);
 480         lpStruct->pCertInfo = (PCERT_INFO)(*env)->GetLongField(env, lpObject, CERT_CONTEXTFc.pCertInfo);
 481         lpStruct->hCertStore = (HCERTSTORE)(*env)->GetLongField(env, lpObject, CERT_CONTEXTFc.hCertStore);
 482         return lpStruct;
 483 }
 484
 485 void setCERT_CONTEXTFields(JNIEnv *env, jobject lpObject, CERT_CONTEXT *lpStruct)
 486 {
 487         if (!CERT_CONTEXTFc.cached) cacheCERT_CONTEXTFields(env, lpObject);
 488         (*env)->SetIntField(env, lpObject, CERT_CONTEXTFc.dwCertEncodingType, (jint)lpStruct->dwCertEncodingType);
 489         (*env)->SetLongField(env, lpObject, CERT_CONTEXTFc.pbCertEncoded, (jlong)lpStruct->pbCertEncoded);
 490         (*env)->SetIntField(env, lpObject, CERT_CONTEXTFc.cbCertEncoded, (jint)lpStruct->cbCertEncoded);
 491         (*env)->SetLongField(env, lpObject, CERT_CONTEXTFc.pCertInfo, (jlong)lpStruct->pCertInfo);
 492         (*env)->SetLongField(env, lpObject, CERT_CONTEXTFc.hCertStore, (jlong)lpStruct->hCertStore);
 493 }
 494 #endif
 495
 496 #ifndef NO_CERT_INFO
 497 typedef struct CERT_INFO_FID_CACHE {
 498         int cached;
 499         jclass clazz;
 500         jfieldID dwVersion, SerialNumber, SignatureAlgorithm, Issuer, NotBefore, NotAfter, Subject, SubjectPublicKeyInfo, IssuerUniqueId, SubjectUniqueId, cExtension, rgExtension;
 501 } CERT_INFO_FID_CACHE;
 502
 503 CERT_INFO_FID_CACHE CERT_INFOFc;
 504
 505 void cacheCERT_INFOFields(JNIEnv *env, jobject lpObject)
 506 {
 507         if (CERT_INFOFc.cached) return;
 508         CERT_INFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 509         CERT_INFOFc.dwVersion = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "dwVersion", "I");
 510         CERT_INFOFc.SerialNumber = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "SerialNumber", "Lorg/eclipse/swt/internal/win32/CRYPT_INTEGER_BLOB;");
 511         CERT_INFOFc.SignatureAlgorithm = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "SignatureAlgorithm", "Lorg/eclipse/swt/internal/win32/CRYPT_ALGORITHM_IDENTIFIER;");
 512         CERT_INFOFc.Issuer = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "Issuer", "Lorg/eclipse/swt/internal/win32/CERT_NAME_BLOB;");
 513         CERT_INFOFc.NotBefore = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "NotBefore", "Lorg/eclipse/swt/internal/win32/FILETIME;");
 514         CERT_INFOFc.NotAfter = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "NotAfter", "Lorg/eclipse/swt/internal/win32/FILETIME;");
 515         CERT_INFOFc.Subject = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "Subject", "Lorg/eclipse/swt/internal/win32/CERT_NAME_BLOB;");
 516         CERT_INFOFc.SubjectPublicKeyInfo = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "SubjectPublicKeyInfo", "Lorg/eclipse/swt/internal/win32/CERT_PUBLIC_KEY_INFO;");
 517         CERT_INFOFc.IssuerUniqueId = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "IssuerUniqueId", "Lorg/eclipse/swt/internal/win32/CRYPT_BIT_BLOB;");
 518         CERT_INFOFc.SubjectUniqueId = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "SubjectUniqueId", "Lorg/eclipse/swt/internal/win32/CRYPT_BIT_BLOB;");
 519         CERT_INFOFc.cExtension = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "cExtension", "I");
 520         CERT_INFOFc.rgExtension = (*env)->GetFieldID(env, CERT_INFOFc.clazz, "rgExtension", "J");
 521         CERT_INFOFc.cached = 1;
 522 }
 523
 524 CERT_INFO *getCERT_INFOFields(JNIEnv *env, jobject lpObject, CERT_INFO *lpStruct)
 525 {
 526         if (!CERT_INFOFc.cached) cacheCERT_INFOFields(env, lpObject);
 527         lpStruct->dwVersion = (*env)->GetIntField(env, lpObject, CERT_INFOFc.dwVersion);
 528         {
 529         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SerialNumber);
 530         if (lpObject1 != NULL) getCRYPT_INTEGER_BLOBFields(env, lpObject1, &lpStruct->SerialNumber);
 531         }
 532         {
 533         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SignatureAlgorithm);
 534         if (lpObject1 != NULL) getCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject1, &lpStruct->SignatureAlgorithm);
 535         }
 536         {
 537         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.Issuer);
 538         if (lpObject1 != NULL) getCERT_NAME_BLOBFields(env, lpObject1, &lpStruct->Issuer);
 539         }
 540         {
 541         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.NotBefore);
 542         if (lpObject1 != NULL) getFILETIMEFields(env, lpObject1, &lpStruct->NotBefore);
 543         }
 544         {
 545         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.NotAfter);
 546         if (lpObject1 != NULL) getFILETIMEFields(env, lpObject1, &lpStruct->NotAfter);
 547         }
 548         {
 549         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.Subject);
 550         if (lpObject1 != NULL) getCERT_NAME_BLOBFields(env, lpObject1, &lpStruct->Subject);
 551         }
 552         {
 553         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SubjectPublicKeyInfo);
 554         if (lpObject1 != NULL) getCERT_PUBLIC_KEY_INFOFields(env, lpObject1, &lpStruct->SubjectPublicKeyInfo);
 555         }
 556         {
 557         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.IssuerUniqueId);
 558         if (lpObject1 != NULL) getCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->IssuerUniqueId);
 559         }
 560         {
 561         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SubjectUniqueId);
 562         if (lpObject1 != NULL) getCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->SubjectUniqueId);
 563         }
 564         lpStruct->cExtension = (*env)->GetIntField(env, lpObject, CERT_INFOFc.cExtension);
 565         lpStruct->rgExtension = (PCERT_EXTENSION)(*env)->GetLongField(env, lpObject, CERT_INFOFc.rgExtension);
 566         return lpStruct;
 567 }
 568
 569 void setCERT_INFOFields(JNIEnv *env, jobject lpObject, CERT_INFO *lpStruct)
 570 {
 571         if (!CERT_INFOFc.cached) cacheCERT_INFOFields(env, lpObject);
 572         (*env)->SetIntField(env, lpObject, CERT_INFOFc.dwVersion, (jint)lpStruct->dwVersion);
 573         {
 574         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SerialNumber);
 575         if (lpObject1 != NULL) setCRYPT_INTEGER_BLOBFields(env, lpObject1, &lpStruct->SerialNumber);
 576         }
 577         {
 578         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SignatureAlgorithm);
 579         if (lpObject1 != NULL) setCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject1, &lpStruct->SignatureAlgorithm);
 580         }
 581         {
 582         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.Issuer);
 583         if (lpObject1 != NULL) setCERT_NAME_BLOBFields(env, lpObject1, &lpStruct->Issuer);
 584         }
 585         {
 586         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.NotBefore);
 587         if (lpObject1 != NULL) setFILETIMEFields(env, lpObject1, &lpStruct->NotBefore);
 588         }
 589         {
 590         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.NotAfter);
 591         if (lpObject1 != NULL) setFILETIMEFields(env, lpObject1, &lpStruct->NotAfter);
 592         }
 593         {
 594         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.Subject);
 595         if (lpObject1 != NULL) setCERT_NAME_BLOBFields(env, lpObject1, &lpStruct->Subject);
 596         }
 597         {
 598         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SubjectPublicKeyInfo);
 599         if (lpObject1 != NULL) setCERT_PUBLIC_KEY_INFOFields(env, lpObject1, &lpStruct->SubjectPublicKeyInfo);
 600         }
 601         {
 602         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.IssuerUniqueId);
 603         if (lpObject1 != NULL) setCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->IssuerUniqueId);
 604         }
 605         {
 606         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_INFOFc.SubjectUniqueId);
 607         if (lpObject1 != NULL) setCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->SubjectUniqueId);
 608         }
 609         (*env)->SetIntField(env, lpObject, CERT_INFOFc.cExtension, (jint)lpStruct->cExtension);
 610         (*env)->SetLongField(env, lpObject, CERT_INFOFc.rgExtension, (jlong)lpStruct->rgExtension);
 611 }
 612 #endif
 613
 614 #ifndef NO_CERT_NAME_BLOB
 615 typedef struct CERT_NAME_BLOB_FID_CACHE {
 616         int cached;
 617         jclass clazz;
 618         jfieldID cbData, pbData;
 619 } CERT_NAME_BLOB_FID_CACHE;
 620
 621 CERT_NAME_BLOB_FID_CACHE CERT_NAME_BLOBFc;
 622
 623 void cacheCERT_NAME_BLOBFields(JNIEnv *env, jobject lpObject)
 624 {
 625         if (CERT_NAME_BLOBFc.cached) return;
 626         CERT_NAME_BLOBFc.clazz = (*env)->GetObjectClass(env, lpObject);
 627         CERT_NAME_BLOBFc.cbData = (*env)->GetFieldID(env, CERT_NAME_BLOBFc.clazz, "cbData", "I");
 628         CERT_NAME_BLOBFc.pbData = (*env)->GetFieldID(env, CERT_NAME_BLOBFc.clazz, "pbData", "J");
 629         CERT_NAME_BLOBFc.cached = 1;
 630 }
 631
 632 CERT_NAME_BLOB *getCERT_NAME_BLOBFields(JNIEnv *env, jobject lpObject, CERT_NAME_BLOB *lpStruct)
 633 {
 634         if (!CERT_NAME_BLOBFc.cached) cacheCERT_NAME_BLOBFields(env, lpObject);
 635         lpStruct->cbData = (*env)->GetIntField(env, lpObject, CERT_NAME_BLOBFc.cbData);
 636         lpStruct->pbData = (BYTE *)(*env)->GetLongField(env, lpObject, CERT_NAME_BLOBFc.pbData);
 637         return lpStruct;
 638 }
 639
 640 void setCERT_NAME_BLOBFields(JNIEnv *env, jobject lpObject, CERT_NAME_BLOB *lpStruct)
 641 {
 642         if (!CERT_NAME_BLOBFc.cached) cacheCERT_NAME_BLOBFields(env, lpObject);
 643         (*env)->SetIntField(env, lpObject, CERT_NAME_BLOBFc.cbData, (jint)lpStruct->cbData);
 644         (*env)->SetLongField(env, lpObject, CERT_NAME_BLOBFc.pbData, (jlong)lpStruct->pbData);
 645 }
 646 #endif
 647
 648 #ifndef NO_CERT_PUBLIC_KEY_INFO
 649 typedef struct CERT_PUBLIC_KEY_INFO_FID_CACHE {
 650         int cached;
 651         jclass clazz;
 652         jfieldID Algorithm, PublicKey;
 653 } CERT_PUBLIC_KEY_INFO_FID_CACHE;
 654
 655 CERT_PUBLIC_KEY_INFO_FID_CACHE CERT_PUBLIC_KEY_INFOFc;
 656
 657 void cacheCERT_PUBLIC_KEY_INFOFields(JNIEnv *env, jobject lpObject)
 658 {
 659         if (CERT_PUBLIC_KEY_INFOFc.cached) return;
 660         CERT_PUBLIC_KEY_INFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 661         CERT_PUBLIC_KEY_INFOFc.Algorithm = (*env)->GetFieldID(env, CERT_PUBLIC_KEY_INFOFc.clazz, "Algorithm", "Lorg/eclipse/swt/internal/win32/CRYPT_ALGORITHM_IDENTIFIER;");
 662         CERT_PUBLIC_KEY_INFOFc.PublicKey = (*env)->GetFieldID(env, CERT_PUBLIC_KEY_INFOFc.clazz, "PublicKey", "Lorg/eclipse/swt/internal/win32/CRYPT_BIT_BLOB;");
 663         CERT_PUBLIC_KEY_INFOFc.cached = 1;
 664 }
 665
 666 CERT_PUBLIC_KEY_INFO *getCERT_PUBLIC_KEY_INFOFields(JNIEnv *env, jobject lpObject, CERT_PUBLIC_KEY_INFO *lpStruct)
 667 {
 668         if (!CERT_PUBLIC_KEY_INFOFc.cached) cacheCERT_PUBLIC_KEY_INFOFields(env, lpObject);
 669         {
 670         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_PUBLIC_KEY_INFOFc.Algorithm);
 671         if (lpObject1 != NULL) getCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject1, &lpStruct->Algorithm);
 672         }
 673         {
 674         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_PUBLIC_KEY_INFOFc.PublicKey);
 675         if (lpObject1 != NULL) getCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->PublicKey);
 676         }
 677         return lpStruct;
 678 }
 679
 680 void setCERT_PUBLIC_KEY_INFOFields(JNIEnv *env, jobject lpObject, CERT_PUBLIC_KEY_INFO *lpStruct)
 681 {
 682         if (!CERT_PUBLIC_KEY_INFOFc.cached) cacheCERT_PUBLIC_KEY_INFOFields(env, lpObject);
 683         {
 684         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_PUBLIC_KEY_INFOFc.Algorithm);
 685         if (lpObject1 != NULL) setCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject1, &lpStruct->Algorithm);
 686         }
 687         {
 688         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CERT_PUBLIC_KEY_INFOFc.PublicKey);
 689         if (lpObject1 != NULL) setCRYPT_BIT_BLOBFields(env, lpObject1, &lpStruct->PublicKey);
 690         }
 691 }
 692 #endif
 693
 694 #ifndef NO_CHOOSECOLOR
 695 typedef struct CHOOSECOLOR_FID_CACHE {
 696         int cached;
 697         jclass clazz;
 698         jfieldID lStructSize, hwndOwner, hInstance, rgbResult, lpCustColors, Flags, lCustData, lpfnHook, lpTemplateName;
 699 } CHOOSECOLOR_FID_CACHE;
 700
 701 CHOOSECOLOR_FID_CACHE CHOOSECOLORFc;
 702
 703 void cacheCHOOSECOLORFields(JNIEnv *env, jobject lpObject)
 704 {
 705         if (CHOOSECOLORFc.cached) return;
 706         CHOOSECOLORFc.clazz = (*env)->GetObjectClass(env, lpObject);
 707         CHOOSECOLORFc.lStructSize = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "lStructSize", "I");
 708         CHOOSECOLORFc.hwndOwner = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "hwndOwner", "J");
 709         CHOOSECOLORFc.hInstance = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "hInstance", "J");
 710         CHOOSECOLORFc.rgbResult = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "rgbResult", "I");
 711         CHOOSECOLORFc.lpCustColors = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "lpCustColors", "J");
 712         CHOOSECOLORFc.Flags = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "Flags", "I");
 713         CHOOSECOLORFc.lCustData = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "lCustData", "J");
 714         CHOOSECOLORFc.lpfnHook = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "lpfnHook", "J");
 715         CHOOSECOLORFc.lpTemplateName = (*env)->GetFieldID(env, CHOOSECOLORFc.clazz, "lpTemplateName", "J");
 716         CHOOSECOLORFc.cached = 1;
 717 }
 718
 719 CHOOSECOLOR *getCHOOSECOLORFields(JNIEnv *env, jobject lpObject, CHOOSECOLOR *lpStruct)
 720 {
 721         if (!CHOOSECOLORFc.cached) cacheCHOOSECOLORFields(env, lpObject);
 722         lpStruct->lStructSize = (*env)->GetIntField(env, lpObject, CHOOSECOLORFc.lStructSize);
 723         lpStruct->hwndOwner = (HWND)(*env)->GetLongField(env, lpObject, CHOOSECOLORFc.hwndOwner);
 724         lpStruct->hInstance = (HANDLE)(*env)->GetLongField(env, lpObject, CHOOSECOLORFc.hInstance);
 725         lpStruct->rgbResult = (*env)->GetIntField(env, lpObject, CHOOSECOLORFc.rgbResult);
 726         lpStruct->lpCustColors = (COLORREF *)(*env)->GetLongField(env, lpObject, CHOOSECOLORFc.lpCustColors);
 727         lpStruct->Flags = (*env)->GetIntField(env, lpObject, CHOOSECOLORFc.Flags);
 728         lpStruct->lCustData = (*env)->GetLongField(env, lpObject, CHOOSECOLORFc.lCustData);
 729         lpStruct->lpfnHook = (LPCCHOOKPROC)(*env)->GetLongField(env, lpObject, CHOOSECOLORFc.lpfnHook);
 730         lpStruct->lpTemplateName = (LPCTSTR)(*env)->GetLongField(env, lpObject, CHOOSECOLORFc.lpTemplateName);
 731         return lpStruct;
 732 }
 733
 734 void setCHOOSECOLORFields(JNIEnv *env, jobject lpObject, CHOOSECOLOR *lpStruct)
 735 {
 736         if (!CHOOSECOLORFc.cached) cacheCHOOSECOLORFields(env, lpObject);
 737         (*env)->SetIntField(env, lpObject, CHOOSECOLORFc.lStructSize, (jint)lpStruct->lStructSize);
 738         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.hwndOwner, (jlong)lpStruct->hwndOwner);
 739         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.hInstance, (jlong)lpStruct->hInstance);
 740         (*env)->SetIntField(env, lpObject, CHOOSECOLORFc.rgbResult, (jint)lpStruct->rgbResult);
 741         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.lpCustColors, (jlong)lpStruct->lpCustColors);
 742         (*env)->SetIntField(env, lpObject, CHOOSECOLORFc.Flags, (jint)lpStruct->Flags);
 743         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.lCustData, (jlong)lpStruct->lCustData);
 744         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.lpfnHook, (jlong)lpStruct->lpfnHook);
 745         (*env)->SetLongField(env, lpObject, CHOOSECOLORFc.lpTemplateName, (jlong)lpStruct->lpTemplateName);
 746 }
 747 #endif
 748
 749 #ifndef NO_CHOOSEFONT
 750 typedef struct CHOOSEFONT_FID_CACHE {
 751         int cached;
 752         jclass clazz;
 753         jfieldID lStructSize, hwndOwner, hDC, lpLogFont, iPointSize, Flags, rgbColors, lCustData, lpfnHook, lpTemplateName, hInstance, lpszStyle, nFontType, nSizeMin, nSizeMax;
 754 } CHOOSEFONT_FID_CACHE;
 755
 756 CHOOSEFONT_FID_CACHE CHOOSEFONTFc;
 757
 758 void cacheCHOOSEFONTFields(JNIEnv *env, jobject lpObject)
 759 {
 760         if (CHOOSEFONTFc.cached) return;
 761         CHOOSEFONTFc.clazz = (*env)->GetObjectClass(env, lpObject);
 762         CHOOSEFONTFc.lStructSize = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lStructSize", "I");
 763         CHOOSEFONTFc.hwndOwner = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "hwndOwner", "J");
 764         CHOOSEFONTFc.hDC = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "hDC", "J");
 765         CHOOSEFONTFc.lpLogFont = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lpLogFont", "J");
 766         CHOOSEFONTFc.iPointSize = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "iPointSize", "I");
 767         CHOOSEFONTFc.Flags = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "Flags", "I");
 768         CHOOSEFONTFc.rgbColors = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "rgbColors", "I");
 769         CHOOSEFONTFc.lCustData = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lCustData", "J");
 770         CHOOSEFONTFc.lpfnHook = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lpfnHook", "J");
 771         CHOOSEFONTFc.lpTemplateName = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lpTemplateName", "J");
 772         CHOOSEFONTFc.hInstance = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "hInstance", "J");
 773         CHOOSEFONTFc.lpszStyle = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "lpszStyle", "J");
 774         CHOOSEFONTFc.nFontType = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "nFontType", "S");
 775         CHOOSEFONTFc.nSizeMin = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "nSizeMin", "I");
 776         CHOOSEFONTFc.nSizeMax = (*env)->GetFieldID(env, CHOOSEFONTFc.clazz, "nSizeMax", "I");
 777         CHOOSEFONTFc.cached = 1;
 778 }
 779
 780 CHOOSEFONT *getCHOOSEFONTFields(JNIEnv *env, jobject lpObject, CHOOSEFONT *lpStruct)
 781 {
 782         if (!CHOOSEFONTFc.cached) cacheCHOOSEFONTFields(env, lpObject);
 783         lpStruct->lStructSize = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.lStructSize);
 784         lpStruct->hwndOwner = (HWND)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.hwndOwner);
 785         lpStruct->hDC = (HDC)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.hDC);
 786         lpStruct->lpLogFont = (LPLOGFONT)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.lpLogFont);
 787         lpStruct->iPointSize = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.iPointSize);
 788         lpStruct->Flags = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.Flags);
 789         lpStruct->rgbColors = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.rgbColors);
 790         lpStruct->lCustData = (*env)->GetLongField(env, lpObject, CHOOSEFONTFc.lCustData);
 791         lpStruct->lpfnHook = (LPCFHOOKPROC)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.lpfnHook);
 792         lpStruct->lpTemplateName = (LPCTSTR)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.lpTemplateName);
 793         lpStruct->hInstance = (HINSTANCE)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.hInstance);
 794         lpStruct->lpszStyle = (LPTSTR)(*env)->GetLongField(env, lpObject, CHOOSEFONTFc.lpszStyle);
 795         lpStruct->nFontType = (*env)->GetShortField(env, lpObject, CHOOSEFONTFc.nFontType);
 796         lpStruct->nSizeMin = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.nSizeMin);
 797         lpStruct->nSizeMax = (*env)->GetIntField(env, lpObject, CHOOSEFONTFc.nSizeMax);
 798         return lpStruct;
 799 }
 800
 801 void setCHOOSEFONTFields(JNIEnv *env, jobject lpObject, CHOOSEFONT *lpStruct)
 802 {
 803         if (!CHOOSEFONTFc.cached) cacheCHOOSEFONTFields(env, lpObject);
 804         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.lStructSize, (jint)lpStruct->lStructSize);
 805         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.hwndOwner, (jlong)lpStruct->hwndOwner);
 806         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.hDC, (jlong)lpStruct->hDC);
 807         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.lpLogFont, (jlong)lpStruct->lpLogFont);
 808         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.iPointSize, (jint)lpStruct->iPointSize);
 809         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.Flags, (jint)lpStruct->Flags);
 810         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.rgbColors, (jint)lpStruct->rgbColors);
 811         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.lCustData, (jlong)lpStruct->lCustData);
 812         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.lpfnHook, (jlong)lpStruct->lpfnHook);
 813         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.lpTemplateName, (jlong)lpStruct->lpTemplateName);
 814         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.hInstance, (jlong)lpStruct->hInstance);
 815         (*env)->SetLongField(env, lpObject, CHOOSEFONTFc.lpszStyle, (jlong)lpStruct->lpszStyle);
 816         (*env)->SetShortField(env, lpObject, CHOOSEFONTFc.nFontType, (jshort)lpStruct->nFontType);
 817         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.nSizeMin, (jint)lpStruct->nSizeMin);
 818         (*env)->SetIntField(env, lpObject, CHOOSEFONTFc.nSizeMax, (jint)lpStruct->nSizeMax);
 819 }
 820 #endif
 821
 822 #ifndef NO_CIDA
 823 typedef struct CIDA_FID_CACHE {
 824         int cached;
 825         jclass clazz;
 826         jfieldID cidl, aoffset;
 827 } CIDA_FID_CACHE;
 828
 829 CIDA_FID_CACHE CIDAFc;
 830
 831 void cacheCIDAFields(JNIEnv *env, jobject lpObject)
 832 {
 833         if (CIDAFc.cached) return;
 834         CIDAFc.clazz = (*env)->GetObjectClass(env, lpObject);
 835         CIDAFc.cidl = (*env)->GetFieldID(env, CIDAFc.clazz, "cidl", "I");
 836         CIDAFc.aoffset = (*env)->GetFieldID(env, CIDAFc.clazz, "aoffset", "I");
 837         CIDAFc.cached = 1;
 838 }
 839
 840 CIDA *getCIDAFields(JNIEnv *env, jobject lpObject, CIDA *lpStruct)
 841 {
 842         if (!CIDAFc.cached) cacheCIDAFields(env, lpObject);
 843         lpStruct->cidl = (*env)->GetIntField(env, lpObject, CIDAFc.cidl);
 844         lpStruct->aoffset[0] = (*env)->GetIntField(env, lpObject, CIDAFc.aoffset);
 845         return lpStruct;
 846 }
 847
 848 void setCIDAFields(JNIEnv *env, jobject lpObject, CIDA *lpStruct)
 849 {
 850         if (!CIDAFc.cached) cacheCIDAFields(env, lpObject);
 851         (*env)->SetIntField(env, lpObject, CIDAFc.cidl, (jint)lpStruct->cidl);
 852         (*env)->SetIntField(env, lpObject, CIDAFc.aoffset, (jint)lpStruct->aoffset[0]);
 853 }
 854 #endif
 855
 856 #ifndef NO_COMBOBOXINFO
 857 typedef struct COMBOBOXINFO_FID_CACHE {
 858         int cached;
 859         jclass clazz;
 860         jfieldID cbSize, itemLeft, itemTop, itemRight, itemBottom, buttonLeft, buttonTop, buttonRight, buttonBottom, stateButton, hwndCombo, hwndItem, hwndList;
 861 } COMBOBOXINFO_FID_CACHE;
 862
 863 COMBOBOXINFO_FID_CACHE COMBOBOXINFOFc;
 864
 865 void cacheCOMBOBOXINFOFields(JNIEnv *env, jobject lpObject)
 866 {
 867         if (COMBOBOXINFOFc.cached) return;
 868         COMBOBOXINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 869         COMBOBOXINFOFc.cbSize = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "cbSize", "I");
 870         COMBOBOXINFOFc.itemLeft = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "itemLeft", "I");
 871         COMBOBOXINFOFc.itemTop = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "itemTop", "I");
 872         COMBOBOXINFOFc.itemRight = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "itemRight", "I");
 873         COMBOBOXINFOFc.itemBottom = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "itemBottom", "I");
 874         COMBOBOXINFOFc.buttonLeft = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "buttonLeft", "I");
 875         COMBOBOXINFOFc.buttonTop = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "buttonTop", "I");
 876         COMBOBOXINFOFc.buttonRight = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "buttonRight", "I");
 877         COMBOBOXINFOFc.buttonBottom = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "buttonBottom", "I");
 878         COMBOBOXINFOFc.stateButton = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "stateButton", "I");
 879         COMBOBOXINFOFc.hwndCombo = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "hwndCombo", "J");
 880         COMBOBOXINFOFc.hwndItem = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "hwndItem", "J");
 881         COMBOBOXINFOFc.hwndList = (*env)->GetFieldID(env, COMBOBOXINFOFc.clazz, "hwndList", "J");
 882         COMBOBOXINFOFc.cached = 1;
 883 }
 884
 885 COMBOBOXINFO *getCOMBOBOXINFOFields(JNIEnv *env, jobject lpObject, COMBOBOXINFO *lpStruct)
 886 {
 887         if (!COMBOBOXINFOFc.cached) cacheCOMBOBOXINFOFields(env, lpObject);
 888         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.cbSize);
 889         lpStruct->rcItem.left = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.itemLeft);
 890         lpStruct->rcItem.top = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.itemTop);
 891         lpStruct->rcItem.right = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.itemRight);
 892         lpStruct->rcItem.bottom = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.itemBottom);
 893         lpStruct->rcButton.left = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.buttonLeft);
 894         lpStruct->rcButton.top = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.buttonTop);
 895         lpStruct->rcButton.right = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.buttonRight);
 896         lpStruct->rcButton.bottom = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.buttonBottom);
 897         lpStruct->stateButton = (*env)->GetIntField(env, lpObject, COMBOBOXINFOFc.stateButton);
 898         lpStruct->hwndCombo = (HWND)(*env)->GetLongField(env, lpObject, COMBOBOXINFOFc.hwndCombo);
 899         lpStruct->hwndItem = (HWND)(*env)->GetLongField(env, lpObject, COMBOBOXINFOFc.hwndItem);
 900         lpStruct->hwndList = (HWND)(*env)->GetLongField(env, lpObject, COMBOBOXINFOFc.hwndList);
 901         return lpStruct;
 902 }
 903
 904 void setCOMBOBOXINFOFields(JNIEnv *env, jobject lpObject, COMBOBOXINFO *lpStruct)
 905 {
 906         if (!COMBOBOXINFOFc.cached) cacheCOMBOBOXINFOFields(env, lpObject);
 907         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.cbSize, (jint)lpStruct->cbSize);
 908         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.itemLeft, (jint)lpStruct->rcItem.left);
 909         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.itemTop, (jint)lpStruct->rcItem.top);
 910         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.itemRight, (jint)lpStruct->rcItem.right);
 911         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.itemBottom, (jint)lpStruct->rcItem.bottom);
 912         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.buttonLeft, (jint)lpStruct->rcButton.left);
 913         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.buttonTop, (jint)lpStruct->rcButton.top);
 914         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.buttonRight, (jint)lpStruct->rcButton.right);
 915         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.buttonBottom, (jint)lpStruct->rcButton.bottom);
 916         (*env)->SetIntField(env, lpObject, COMBOBOXINFOFc.stateButton, (jint)lpStruct->stateButton);
 917         (*env)->SetLongField(env, lpObject, COMBOBOXINFOFc.hwndCombo, (jlong)lpStruct->hwndCombo);
 918         (*env)->SetLongField(env, lpObject, COMBOBOXINFOFc.hwndItem, (jlong)lpStruct->hwndItem);
 919         (*env)->SetLongField(env, lpObject, COMBOBOXINFOFc.hwndList, (jlong)lpStruct->hwndList);
 920 }
 921 #endif
 922
 923 #ifndef NO_COMPOSITIONFORM
 924 typedef struct COMPOSITIONFORM_FID_CACHE {
 925         int cached;
 926         jclass clazz;
 927         jfieldID dwStyle, x, y, left, top, right, bottom;
 928 } COMPOSITIONFORM_FID_CACHE;
 929
 930 COMPOSITIONFORM_FID_CACHE COMPOSITIONFORMFc;
 931
 932 void cacheCOMPOSITIONFORMFields(JNIEnv *env, jobject lpObject)
 933 {
 934         if (COMPOSITIONFORMFc.cached) return;
 935         COMPOSITIONFORMFc.clazz = (*env)->GetObjectClass(env, lpObject);
 936         COMPOSITIONFORMFc.dwStyle = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "dwStyle", "I");
 937         COMPOSITIONFORMFc.x = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "x", "I");
 938         COMPOSITIONFORMFc.y = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "y", "I");
 939         COMPOSITIONFORMFc.left = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "left", "I");
 940         COMPOSITIONFORMFc.top = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "top", "I");
 941         COMPOSITIONFORMFc.right = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "right", "I");
 942         COMPOSITIONFORMFc.bottom = (*env)->GetFieldID(env, COMPOSITIONFORMFc.clazz, "bottom", "I");
 943         COMPOSITIONFORMFc.cached = 1;
 944 }
 945
 946 COMPOSITIONFORM *getCOMPOSITIONFORMFields(JNIEnv *env, jobject lpObject, COMPOSITIONFORM *lpStruct)
 947 {
 948         if (!COMPOSITIONFORMFc.cached) cacheCOMPOSITIONFORMFields(env, lpObject);
 949         lpStruct->dwStyle = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.dwStyle);
 950         lpStruct->ptCurrentPos.x = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.x);
 951         lpStruct->ptCurrentPos.y = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.y);
 952         lpStruct->rcArea.left = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.left);
 953         lpStruct->rcArea.top = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.top);
 954         lpStruct->rcArea.right = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.right);
 955         lpStruct->rcArea.bottom = (*env)->GetIntField(env, lpObject, COMPOSITIONFORMFc.bottom);
 956         return lpStruct;
 957 }
 958
 959 void setCOMPOSITIONFORMFields(JNIEnv *env, jobject lpObject, COMPOSITIONFORM *lpStruct)
 960 {
 961         if (!COMPOSITIONFORMFc.cached) cacheCOMPOSITIONFORMFields(env, lpObject);
 962         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.dwStyle, (jint)lpStruct->dwStyle);
 963         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.x, (jint)lpStruct->ptCurrentPos.x);
 964         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.y, (jint)lpStruct->ptCurrentPos.y);
 965         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.left, (jint)lpStruct->rcArea.left);
 966         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.top, (jint)lpStruct->rcArea.top);
 967         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.right, (jint)lpStruct->rcArea.right);
 968         (*env)->SetIntField(env, lpObject, COMPOSITIONFORMFc.bottom, (jint)lpStruct->rcArea.bottom);
 969 }
 970 #endif
 971
 972 #ifndef NO_CREATESTRUCT
 973 typedef struct CREATESTRUCT_FID_CACHE {
 974         int cached;
 975         jclass clazz;
 976         jfieldID lpCreateParams, hInstance, hMenu, hwndParent, cy, cx, y, x, style, lpszName, lpszClass, dwExStyle;
 977 } CREATESTRUCT_FID_CACHE;
 978
 979 CREATESTRUCT_FID_CACHE CREATESTRUCTFc;
 980
 981 void cacheCREATESTRUCTFields(JNIEnv *env, jobject lpObject)
 982 {
 983         if (CREATESTRUCTFc.cached) return;
 984         CREATESTRUCTFc.clazz = (*env)->GetObjectClass(env, lpObject);
 985         CREATESTRUCTFc.lpCreateParams = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "lpCreateParams", "J");
 986         CREATESTRUCTFc.hInstance = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "hInstance", "J");
 987         CREATESTRUCTFc.hMenu = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "hMenu", "J");
 988         CREATESTRUCTFc.hwndParent = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "hwndParent", "J");
 989         CREATESTRUCTFc.cy = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "cy", "I");
 990         CREATESTRUCTFc.cx = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "cx", "I");
 991         CREATESTRUCTFc.y = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "y", "I");
 992         CREATESTRUCTFc.x = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "x", "I");
 993         CREATESTRUCTFc.style = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "style", "I");
 994         CREATESTRUCTFc.lpszName = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "lpszName", "J");
 995         CREATESTRUCTFc.lpszClass = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "lpszClass", "J");
 996         CREATESTRUCTFc.dwExStyle = (*env)->GetFieldID(env, CREATESTRUCTFc.clazz, "dwExStyle", "I");
 997         CREATESTRUCTFc.cached = 1;
 998 }
 999
1000 CREATESTRUCT *getCREATESTRUCTFields(JNIEnv *env, jobject lpObject, CREATESTRUCT *lpStruct)
1001 {
1002         if (!CREATESTRUCTFc.cached) cacheCREATESTRUCTFields(env, lpObject);
1003         lpStruct->lpCreateParams = (LPVOID)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.lpCreateParams);
1004         lpStruct->hInstance = (HINSTANCE)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.hInstance);
1005         lpStruct->hMenu = (HMENU)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.hMenu);
1006         lpStruct->hwndParent = (HWND)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.hwndParent);
1007         lpStruct->cy = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.cy);
1008         lpStruct->cx = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.cx);
1009         lpStruct->y = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.y);
1010         lpStruct->x = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.x);
1011         lpStruct->style = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.style);
1012         lpStruct->lpszName = (LPCTSTR)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.lpszName);
1013         lpStruct->lpszClass = (LPCTSTR)(*env)->GetLongField(env, lpObject, CREATESTRUCTFc.lpszClass);
1014         lpStruct->dwExStyle = (*env)->GetIntField(env, lpObject, CREATESTRUCTFc.dwExStyle);
1015         return lpStruct;
1016 }
1017
1018 void setCREATESTRUCTFields(JNIEnv *env, jobject lpObject, CREATESTRUCT *lpStruct)
1019 {
1020         if (!CREATESTRUCTFc.cached) cacheCREATESTRUCTFields(env, lpObject);
1021         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.lpCreateParams, (jlong)lpStruct->lpCreateParams);
1022         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.hInstance, (jlong)lpStruct->hInstance);
1023         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.hMenu, (jlong)lpStruct->hMenu);
1024         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.hwndParent, (jlong)lpStruct->hwndParent);
1025         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.cy, (jint)lpStruct->cy);
1026         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.cx, (jint)lpStruct->cx);
1027         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.y, (jint)lpStruct->y);
1028         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.x, (jint)lpStruct->x);
1029         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.style, (jint)lpStruct->style);
1030         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.lpszName, (jlong)lpStruct->lpszName);
1031         (*env)->SetLongField(env, lpObject, CREATESTRUCTFc.lpszClass, (jlong)lpStruct->lpszClass);
1032         (*env)->SetIntField(env, lpObject, CREATESTRUCTFc.dwExStyle, (jint)lpStruct->dwExStyle);
1033 }
1034 #endif
1035
1036 #ifndef NO_CRYPT_ALGORITHM_IDENTIFIER
1037 typedef struct CRYPT_ALGORITHM_IDENTIFIER_FID_CACHE {
1038         int cached;
1039         jclass clazz;
1040         jfieldID pszObjId, Parameters;
1041 } CRYPT_ALGORITHM_IDENTIFIER_FID_CACHE;
1042
1043 CRYPT_ALGORITHM_IDENTIFIER_FID_CACHE CRYPT_ALGORITHM_IDENTIFIERFc;
1044
1045 void cacheCRYPT_ALGORITHM_IDENTIFIERFields(JNIEnv *env, jobject lpObject)
1046 {
1047         if (CRYPT_ALGORITHM_IDENTIFIERFc.cached) return;
1048         CRYPT_ALGORITHM_IDENTIFIERFc.clazz = (*env)->GetObjectClass(env, lpObject);
1049         CRYPT_ALGORITHM_IDENTIFIERFc.pszObjId = (*env)->GetFieldID(env, CRYPT_ALGORITHM_IDENTIFIERFc.clazz, "pszObjId", "J");
1050         CRYPT_ALGORITHM_IDENTIFIERFc.Parameters = (*env)->GetFieldID(env, CRYPT_ALGORITHM_IDENTIFIERFc.clazz, "Parameters", "Lorg/eclipse/swt/internal/win32/CRYPT_OBJID_BLOB;");
1051         CRYPT_ALGORITHM_IDENTIFIERFc.cached = 1;
1052 }
1053
1054 CRYPT_ALGORITHM_IDENTIFIER *getCRYPT_ALGORITHM_IDENTIFIERFields(JNIEnv *env, jobject lpObject, CRYPT_ALGORITHM_IDENTIFIER *lpStruct)
1055 {
1056         if (!CRYPT_ALGORITHM_IDENTIFIERFc.cached) cacheCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject);
1057         lpStruct->pszObjId = (LPSTR)(*env)->GetLongField(env, lpObject, CRYPT_ALGORITHM_IDENTIFIERFc.pszObjId);
1058         {
1059         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CRYPT_ALGORITHM_IDENTIFIERFc.Parameters);
1060         if (lpObject1 != NULL) getCRYPT_OBJID_BLOBFields(env, lpObject1, &lpStruct->Parameters);
1061         }
1062         return lpStruct;
1063 }
1064
1065 void setCRYPT_ALGORITHM_IDENTIFIERFields(JNIEnv *env, jobject lpObject, CRYPT_ALGORITHM_IDENTIFIER *lpStruct)
1066 {
1067         if (!CRYPT_ALGORITHM_IDENTIFIERFc.cached) cacheCRYPT_ALGORITHM_IDENTIFIERFields(env, lpObject);
1068         (*env)->SetLongField(env, lpObject, CRYPT_ALGORITHM_IDENTIFIERFc.pszObjId, (jlong)lpStruct->pszObjId);
1069         {
1070         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, CRYPT_ALGORITHM_IDENTIFIERFc.Parameters);
1071         if (lpObject1 != NULL) setCRYPT_OBJID_BLOBFields(env, lpObject1, &lpStruct->Parameters);
1072         }
1073 }
1074 #endif
1075
1076 #ifndef NO_CRYPT_BIT_BLOB
1077 typedef struct CRYPT_BIT_BLOB_FID_CACHE {
1078         int cached;
1079         jclass clazz;
1080         jfieldID cbData, pbData, cUnusedBits;
1081 } CRYPT_BIT_BLOB_FID_CACHE;
1082
1083 CRYPT_BIT_BLOB_FID_CACHE CRYPT_BIT_BLOBFc;
1084
1085 void cacheCRYPT_BIT_BLOBFields(JNIEnv *env, jobject lpObject)
1086 {
1087         if (CRYPT_BIT_BLOBFc.cached) return;
1088         CRYPT_BIT_BLOBFc.clazz = (*env)->GetObjectClass(env, lpObject);
1089         CRYPT_BIT_BLOBFc.cbData = (*env)->GetFieldID(env, CRYPT_BIT_BLOBFc.clazz, "cbData", "I");
1090         CRYPT_BIT_BLOBFc.pbData = (*env)->GetFieldID(env, CRYPT_BIT_BLOBFc.clazz, "pbData", "J");
1091         CRYPT_BIT_BLOBFc.cUnusedBits = (*env)->GetFieldID(env, CRYPT_BIT_BLOBFc.clazz, "cUnusedBits", "I");
1092         CRYPT_BIT_BLOBFc.cached = 1;
1093 }
1094
1095 CRYPT_BIT_BLOB *getCRYPT_BIT_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_BIT_BLOB *lpStruct)
1096 {
1097         if (!CRYPT_BIT_BLOBFc.cached) cacheCRYPT_BIT_BLOBFields(env, lpObject);
1098         lpStruct->cbData = (*env)->GetIntField(env, lpObject, CRYPT_BIT_BLOBFc.cbData);
1099         lpStruct->pbData = (BYTE *)(*env)->GetLongField(env, lpObject, CRYPT_BIT_BLOBFc.pbData);
1100         lpStruct->cUnusedBits = (*env)->GetIntField(env, lpObject, CRYPT_BIT_BLOBFc.cUnusedBits);
1101         return lpStruct;
1102 }
1103
1104 void setCRYPT_BIT_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_BIT_BLOB *lpStruct)
1105 {
1106         if (!CRYPT_BIT_BLOBFc.cached) cacheCRYPT_BIT_BLOBFields(env, lpObject);
1107         (*env)->SetIntField(env, lpObject, CRYPT_BIT_BLOBFc.cbData, (jint)lpStruct->cbData);
1108         (*env)->SetLongField(env, lpObject, CRYPT_BIT_BLOBFc.pbData, (jlong)lpStruct->pbData);
1109         (*env)->SetIntField(env, lpObject, CRYPT_BIT_BLOBFc.cUnusedBits, (jint)lpStruct->cUnusedBits);
1110 }
1111 #endif
1112
1113 #ifndef NO_CRYPT_INTEGER_BLOB
1114 typedef struct CRYPT_INTEGER_BLOB_FID_CACHE {
1115         int cached;
1116         jclass clazz;
1117         jfieldID cbData, pbData;
1118 } CRYPT_INTEGER_BLOB_FID_CACHE;
1119
1120 CRYPT_INTEGER_BLOB_FID_CACHE CRYPT_INTEGER_BLOBFc;
1121
1122 void cacheCRYPT_INTEGER_BLOBFields(JNIEnv *env, jobject lpObject)
1123 {
1124         if (CRYPT_INTEGER_BLOBFc.cached) return;
1125         CRYPT_INTEGER_BLOBFc.clazz = (*env)->GetObjectClass(env, lpObject);
1126         CRYPT_INTEGER_BLOBFc.cbData = (*env)->GetFieldID(env, CRYPT_INTEGER_BLOBFc.clazz, "cbData", "I");
1127         CRYPT_INTEGER_BLOBFc.pbData = (*env)->GetFieldID(env, CRYPT_INTEGER_BLOBFc.clazz, "pbData", "J");
1128         CRYPT_INTEGER_BLOBFc.cached = 1;
1129 }
1130
1131 CRYPT_INTEGER_BLOB *getCRYPT_INTEGER_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_INTEGER_BLOB *lpStruct)
1132 {
1133         if (!CRYPT_INTEGER_BLOBFc.cached) cacheCRYPT_INTEGER_BLOBFields(env, lpObject);
1134         lpStruct->cbData = (*env)->GetIntField(env, lpObject, CRYPT_INTEGER_BLOBFc.cbData);
1135         lpStruct->pbData = (BYTE *)(*env)->GetLongField(env, lpObject, CRYPT_INTEGER_BLOBFc.pbData);
1136         return lpStruct;
1137 }
1138
1139 void setCRYPT_INTEGER_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_INTEGER_BLOB *lpStruct)
1140 {
1141         if (!CRYPT_INTEGER_BLOBFc.cached) cacheCRYPT_INTEGER_BLOBFields(env, lpObject);
1142         (*env)->SetIntField(env, lpObject, CRYPT_INTEGER_BLOBFc.cbData, (jint)lpStruct->cbData);
1143         (*env)->SetLongField(env, lpObject, CRYPT_INTEGER_BLOBFc.pbData, (jlong)lpStruct->pbData);
1144 }
1145 #endif
1146
1147 #ifndef NO_CRYPT_OBJID_BLOB
1148 typedef struct CRYPT_OBJID_BLOB_FID_CACHE {
1149         int cached;
1150         jclass clazz;
1151         jfieldID cbData, pbData;
1152 } CRYPT_OBJID_BLOB_FID_CACHE;
1153
1154 CRYPT_OBJID_BLOB_FID_CACHE CRYPT_OBJID_BLOBFc;
1155
1156 void cacheCRYPT_OBJID_BLOBFields(JNIEnv *env, jobject lpObject)
1157 {
1158         if (CRYPT_OBJID_BLOBFc.cached) return;
1159         CRYPT_OBJID_BLOBFc.clazz = (*env)->GetObjectClass(env, lpObject);
1160         CRYPT_OBJID_BLOBFc.cbData = (*env)->GetFieldID(env, CRYPT_OBJID_BLOBFc.clazz, "cbData", "I");
1161         CRYPT_OBJID_BLOBFc.pbData = (*env)->GetFieldID(env, CRYPT_OBJID_BLOBFc.clazz, "pbData", "J");
1162         CRYPT_OBJID_BLOBFc.cached = 1;
1163 }
1164
1165 CRYPT_OBJID_BLOB *getCRYPT_OBJID_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_OBJID_BLOB *lpStruct)
1166 {
1167         if (!CRYPT_OBJID_BLOBFc.cached) cacheCRYPT_OBJID_BLOBFields(env, lpObject);
1168         lpStruct->cbData = (*env)->GetIntField(env, lpObject, CRYPT_OBJID_BLOBFc.cbData);
1169         lpStruct->pbData = (BYTE *)(*env)->GetLongField(env, lpObject, CRYPT_OBJID_BLOBFc.pbData);
1170         return lpStruct;
1171 }
1172
1173 void setCRYPT_OBJID_BLOBFields(JNIEnv *env, jobject lpObject, CRYPT_OBJID_BLOB *lpStruct)
1174 {
1175         if (!CRYPT_OBJID_BLOBFc.cached) cacheCRYPT_OBJID_BLOBFields(env, lpObject);
1176         (*env)->SetIntField(env, lpObject, CRYPT_OBJID_BLOBFc.cbData, (jint)lpStruct->cbData);
1177         (*env)->SetLongField(env, lpObject, CRYPT_OBJID_BLOBFc.pbData, (jlong)lpStruct->pbData);
1178 }
1179 #endif
1180
1181 #ifndef NO_DEVMODE
1182 typedef struct DEVMODE_FID_CACHE {
1183         int cached;
1184         jclass clazz;
1185         jfieldID dmDeviceName, dmSpecVersion, dmDriverVersion, dmSize, dmDriverExtra, dmFields, dmOrientation, dmPaperSize, dmPaperLength, dmPaperWidth, dmScale, dmCopies, dmDefaultSource, dmPrintQuality, dmColor, dmDuplex, dmYResolution, dmTTOption, dmCollate, dmFormName, dmLogPixels, dmBitsPerPel, dmPelsWidth, dmPelsHeight, dmNup, dmDisplayFrequency, dmICMMethod, dmICMIntent, dmMediaType, dmDitherType, dmReserved1, dmReserved2, dmPanningWidth, dmPanningHeight;
1186 } DEVMODE_FID_CACHE;
1187
1188 DEVMODE_FID_CACHE DEVMODEFc;
1189
1190 void cacheDEVMODEFields(JNIEnv *env, jobject lpObject)
1191 {
1192         if (DEVMODEFc.cached) return;
1193         DEVMODEFc.clazz = (*env)->GetObjectClass(env, lpObject);
1194         DEVMODEFc.dmDeviceName = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDeviceName", "[C");
1195         DEVMODEFc.dmSpecVersion = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmSpecVersion", "S");
1196         DEVMODEFc.dmDriverVersion = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDriverVersion", "S");
1197         DEVMODEFc.dmSize = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmSize", "S");
1198         DEVMODEFc.dmDriverExtra = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDriverExtra", "S");
1199         DEVMODEFc.dmFields = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmFields", "I");
1200         DEVMODEFc.dmOrientation = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmOrientation", "S");
1201         DEVMODEFc.dmPaperSize = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPaperSize", "S");
1202         DEVMODEFc.dmPaperLength = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPaperLength", "S");
1203         DEVMODEFc.dmPaperWidth = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPaperWidth", "S");
1204         DEVMODEFc.dmScale = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmScale", "S");
1205         DEVMODEFc.dmCopies = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmCopies", "S");
1206         DEVMODEFc.dmDefaultSource = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDefaultSource", "S");
1207         DEVMODEFc.dmPrintQuality = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPrintQuality", "S");
1208         DEVMODEFc.dmColor = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmColor", "S");
1209         DEVMODEFc.dmDuplex = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDuplex", "S");
1210         DEVMODEFc.dmYResolution = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmYResolution", "S");
1211         DEVMODEFc.dmTTOption = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmTTOption", "S");
1212         DEVMODEFc.dmCollate = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmCollate", "S");
1213         DEVMODEFc.dmFormName = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmFormName", "[C");
1214         DEVMODEFc.dmLogPixels = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmLogPixels", "S");
1215         DEVMODEFc.dmBitsPerPel = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmBitsPerPel", "I");
1216         DEVMODEFc.dmPelsWidth = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPelsWidth", "I");
1217         DEVMODEFc.dmPelsHeight = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPelsHeight", "I");
1218         DEVMODEFc.dmNup = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmNup", "I");
1219         DEVMODEFc.dmDisplayFrequency = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDisplayFrequency", "I");
1220         DEVMODEFc.dmICMMethod = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmICMMethod", "I");
1221         DEVMODEFc.dmICMIntent = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmICMIntent", "I");
1222         DEVMODEFc.dmMediaType = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmMediaType", "I");
1223         DEVMODEFc.dmDitherType = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmDitherType", "I");
1224         DEVMODEFc.dmReserved1 = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmReserved1", "I");
1225         DEVMODEFc.dmReserved2 = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmReserved2", "I");
1226         DEVMODEFc.dmPanningWidth = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPanningWidth", "I");
1227         DEVMODEFc.dmPanningHeight = (*env)->GetFieldID(env, DEVMODEFc.clazz, "dmPanningHeight", "I");
1228         DEVMODEFc.cached = 1;
1229 }
1230
1231 DEVMODE *getDEVMODEFields(JNIEnv *env, jobject lpObject, DEVMODE *lpStruct)
1232 {
1233         if (!DEVMODEFc.cached) cacheDEVMODEFields(env, lpObject);
1234         {
1235         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, DEVMODEFc.dmDeviceName);
1236         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->dmDeviceName) / sizeof(jchar), (jchar *)lpStruct->dmDeviceName);
1237         }
1238         lpStruct->dmSpecVersion = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmSpecVersion);
1239         lpStruct->dmDriverVersion = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmDriverVersion);
1240         lpStruct->dmSize = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmSize);
1241         lpStruct->dmDriverExtra = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmDriverExtra);
1242         lpStruct->dmFields = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmFields);
1243         lpStruct->dmOrientation = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmOrientation);
1244         lpStruct->dmPaperSize = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmPaperSize);
1245         lpStruct->dmPaperLength = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmPaperLength);
1246         lpStruct->dmPaperWidth = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmPaperWidth);
1247         lpStruct->dmScale = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmScale);
1248         lpStruct->dmCopies = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmCopies);
1249         lpStruct->dmDefaultSource = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmDefaultSource);
1250         lpStruct->dmPrintQuality = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmPrintQuality);
1251         lpStruct->dmColor = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmColor);
1252         lpStruct->dmDuplex = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmDuplex);
1253         lpStruct->dmYResolution = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmYResolution);
1254         lpStruct->dmTTOption = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmTTOption);
1255         lpStruct->dmCollate = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmCollate);
1256         {
1257         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, DEVMODEFc.dmFormName);
1258         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->dmFormName) / sizeof(jchar), (jchar *)lpStruct->dmFormName);
1259         }
1260         lpStruct->dmLogPixels = (*env)->GetShortField(env, lpObject, DEVMODEFc.dmLogPixels);
1261         lpStruct->dmBitsPerPel = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmBitsPerPel);
1262         lpStruct->dmPelsWidth = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmPelsWidth);
1263         lpStruct->dmPelsHeight = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmPelsHeight);
1264         lpStruct->dmNup = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmNup);
1265         lpStruct->dmDisplayFrequency = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmDisplayFrequency);
1266         lpStruct->dmICMMethod = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmICMMethod);
1267         lpStruct->dmICMIntent = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmICMIntent);
1268         lpStruct->dmMediaType = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmMediaType);
1269         lpStruct->dmDitherType = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmDitherType);
1270         lpStruct->dmReserved1 = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmReserved1);
1271         lpStruct->dmReserved2 = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmReserved2);
1272         lpStruct->dmPanningWidth = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmPanningWidth);
1273         lpStruct->dmPanningHeight = (*env)->GetIntField(env, lpObject, DEVMODEFc.dmPanningHeight);
1274         return lpStruct;
1275 }
1276
1277 void setDEVMODEFields(JNIEnv *env, jobject lpObject, DEVMODE *lpStruct)
1278 {
1279         if (!DEVMODEFc.cached) cacheDEVMODEFields(env, lpObject);
1280         {
1281         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, DEVMODEFc.dmDeviceName);
1282         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->dmDeviceName) / sizeof(jchar), (jchar *)lpStruct->dmDeviceName);
1283         }
1284         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmSpecVersion, (jshort)lpStruct->dmSpecVersion);
1285         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmDriverVersion, (jshort)lpStruct->dmDriverVersion);
1286         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmSize, (jshort)lpStruct->dmSize);
1287         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmDriverExtra, (jshort)lpStruct->dmDriverExtra);
1288         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmFields, (jint)lpStruct->dmFields);
1289         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmOrientation, (jshort)lpStruct->dmOrientation);
1290         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmPaperSize, (jshort)lpStruct->dmPaperSize);
1291         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmPaperLength, (jshort)lpStruct->dmPaperLength);
1292         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmPaperWidth, (jshort)lpStruct->dmPaperWidth);
1293         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmScale, (jshort)lpStruct->dmScale);
1294         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmCopies, (jshort)lpStruct->dmCopies);
1295         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmDefaultSource, (jshort)lpStruct->dmDefaultSource);
1296         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmPrintQuality, (jshort)lpStruct->dmPrintQuality);
1297         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmColor, (jshort)lpStruct->dmColor);
1298         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmDuplex, (jshort)lpStruct->dmDuplex);
1299         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmYResolution, (jshort)lpStruct->dmYResolution);
1300         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmTTOption, (jshort)lpStruct->dmTTOption);
1301         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmCollate, (jshort)lpStruct->dmCollate);
1302         {
1303         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, DEVMODEFc.dmFormName);
1304         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->dmFormName) / sizeof(jchar), (jchar *)lpStruct->dmFormName);
1305         }
1306         (*env)->SetShortField(env, lpObject, DEVMODEFc.dmLogPixels, (jshort)lpStruct->dmLogPixels);
1307         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmBitsPerPel, (jint)lpStruct->dmBitsPerPel);
1308         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmPelsWidth, (jint)lpStruct->dmPelsWidth);
1309         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmPelsHeight, (jint)lpStruct->dmPelsHeight);
1310         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmNup, (jint)lpStruct->dmNup);
1311         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmDisplayFrequency, (jint)lpStruct->dmDisplayFrequency);
1312         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmICMMethod, (jint)lpStruct->dmICMMethod);
1313         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmICMIntent, (jint)lpStruct->dmICMIntent);
1314         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmMediaType, (jint)lpStruct->dmMediaType);
1315         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmDitherType, (jint)lpStruct->dmDitherType);
1316         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmReserved1, (jint)lpStruct->dmReserved1);
1317         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmReserved2, (jint)lpStruct->dmReserved2);
1318         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmPanningWidth, (jint)lpStruct->dmPanningWidth);
1319         (*env)->SetIntField(env, lpObject, DEVMODEFc.dmPanningHeight, (jint)lpStruct->dmPanningHeight);
1320 }
1321 #endif
1322
1323 #ifndef NO_DIBSECTION
1324 typedef struct DIBSECTION_FID_CACHE {
1325         int cached;
1326         jclass clazz;
1327         jfieldID biSize, biWidth, biHeight, biPlanes, biBitCount, biCompression, biSizeImage, biXPelsPerMeter, biYPelsPerMeter, biClrUsed, biClrImportant, dsBitfields0, dsBitfields1, dsBitfields2, dshSection, dsOffset;
1328 } DIBSECTION_FID_CACHE;
1329
1330 DIBSECTION_FID_CACHE DIBSECTIONFc;
1331
1332 void cacheDIBSECTIONFields(JNIEnv *env, jobject lpObject)
1333 {
1334         if (DIBSECTIONFc.cached) return;
1335         cacheBITMAPFields(env, lpObject);
1336         DIBSECTIONFc.clazz = (*env)->GetObjectClass(env, lpObject);
1337         DIBSECTIONFc.biSize = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biSize", "I");
1338         DIBSECTIONFc.biWidth = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biWidth", "I");
1339         DIBSECTIONFc.biHeight = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biHeight", "I");
1340         DIBSECTIONFc.biPlanes = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biPlanes", "S");
1341         DIBSECTIONFc.biBitCount = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biBitCount", "S");
1342         DIBSECTIONFc.biCompression = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biCompression", "I");
1343         DIBSECTIONFc.biSizeImage = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biSizeImage", "I");
1344         DIBSECTIONFc.biXPelsPerMeter = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biXPelsPerMeter", "I");
1345         DIBSECTIONFc.biYPelsPerMeter = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biYPelsPerMeter", "I");
1346         DIBSECTIONFc.biClrUsed = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biClrUsed", "I");
1347         DIBSECTIONFc.biClrImportant = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "biClrImportant", "I");
1348         DIBSECTIONFc.dsBitfields0 = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "dsBitfields0", "I");
1349         DIBSECTIONFc.dsBitfields1 = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "dsBitfields1", "I");
1350         DIBSECTIONFc.dsBitfields2 = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "dsBitfields2", "I");
1351         DIBSECTIONFc.dshSection = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "dshSection", "J");
1352         DIBSECTIONFc.dsOffset = (*env)->GetFieldID(env, DIBSECTIONFc.clazz, "dsOffset", "I");
1353         DIBSECTIONFc.cached = 1;
1354 }
1355
1356 DIBSECTION *getDIBSECTIONFields(JNIEnv *env, jobject lpObject, DIBSECTION *lpStruct)
1357 {
1358         if (!DIBSECTIONFc.cached) cacheDIBSECTIONFields(env, lpObject);
1359         getBITMAPFields(env, lpObject, (BITMAP *)lpStruct);
1360         lpStruct->dsBmih.biSize = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biSize);
1361         lpStruct->dsBmih.biWidth = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biWidth);
1362         lpStruct->dsBmih.biHeight = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biHeight);
1363         lpStruct->dsBmih.biPlanes = (*env)->GetShortField(env, lpObject, DIBSECTIONFc.biPlanes);
1364         lpStruct->dsBmih.biBitCount = (*env)->GetShortField(env, lpObject, DIBSECTIONFc.biBitCount);
1365         lpStruct->dsBmih.biCompression = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biCompression);
1366         lpStruct->dsBmih.biSizeImage = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biSizeImage);
1367         lpStruct->dsBmih.biXPelsPerMeter = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biXPelsPerMeter);
1368         lpStruct->dsBmih.biYPelsPerMeter = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biYPelsPerMeter);
1369         lpStruct->dsBmih.biClrUsed = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biClrUsed);
1370         lpStruct->dsBmih.biClrImportant = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.biClrImportant);
1371         lpStruct->dsBitfields[0] = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.dsBitfields0);
1372         lpStruct->dsBitfields[1] = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.dsBitfields1);
1373         lpStruct->dsBitfields[2] = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.dsBitfields2);
1374         lpStruct->dshSection = (HANDLE)(*env)->GetLongField(env, lpObject, DIBSECTIONFc.dshSection);
1375         lpStruct->dsOffset = (*env)->GetIntField(env, lpObject, DIBSECTIONFc.dsOffset);
1376         return lpStruct;
1377 }
1378
1379 void setDIBSECTIONFields(JNIEnv *env, jobject lpObject, DIBSECTION *lpStruct)
1380 {
1381         if (!DIBSECTIONFc.cached) cacheDIBSECTIONFields(env, lpObject);
1382         setBITMAPFields(env, lpObject, (BITMAP *)lpStruct);
1383         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biSize, (jint)lpStruct->dsBmih.biSize);
1384         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biWidth, (jint)lpStruct->dsBmih.biWidth);
1385         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biHeight, (jint)lpStruct->dsBmih.biHeight);
1386         (*env)->SetShortField(env, lpObject, DIBSECTIONFc.biPlanes, (jshort)lpStruct->dsBmih.biPlanes);
1387         (*env)->SetShortField(env, lpObject, DIBSECTIONFc.biBitCount, (jshort)lpStruct->dsBmih.biBitCount);
1388         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biCompression, (jint)lpStruct->dsBmih.biCompression);
1389         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biSizeImage, (jint)lpStruct->dsBmih.biSizeImage);
1390         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biXPelsPerMeter, (jint)lpStruct->dsBmih.biXPelsPerMeter);
1391         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biYPelsPerMeter, (jint)lpStruct->dsBmih.biYPelsPerMeter);
1392         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biClrUsed, (jint)lpStruct->dsBmih.biClrUsed);
1393         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.biClrImportant, (jint)lpStruct->dsBmih.biClrImportant);
1394         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.dsBitfields0, (jint)lpStruct->dsBitfields[0]);
1395         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.dsBitfields1, (jint)lpStruct->dsBitfields[1]);
1396         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.dsBitfields2, (jint)lpStruct->dsBitfields[2]);
1397         (*env)->SetLongField(env, lpObject, DIBSECTIONFc.dshSection, (jlong)lpStruct->dshSection);
1398         (*env)->SetIntField(env, lpObject, DIBSECTIONFc.dsOffset, (jint)lpStruct->dsOffset);
1399 }
1400 #endif
1401
1402 #ifndef NO_DOCHOSTUIINFO
1403 typedef struct DOCHOSTUIINFO_FID_CACHE {
1404         int cached;
1405         jclass clazz;
1406         jfieldID cbSize, dwFlags, dwDoubleClick, pchHostCss, pchHostNS;
1407 } DOCHOSTUIINFO_FID_CACHE;
1408
1409 DOCHOSTUIINFO_FID_CACHE DOCHOSTUIINFOFc;
1410
1411 void cacheDOCHOSTUIINFOFields(JNIEnv *env, jobject lpObject)
1412 {
1413         if (DOCHOSTUIINFOFc.cached) return;
1414         DOCHOSTUIINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
1415         DOCHOSTUIINFOFc.cbSize = (*env)->GetFieldID(env, DOCHOSTUIINFOFc.clazz, "cbSize", "I");
1416         DOCHOSTUIINFOFc.dwFlags = (*env)->GetFieldID(env, DOCHOSTUIINFOFc.clazz, "dwFlags", "I");
1417         DOCHOSTUIINFOFc.dwDoubleClick = (*env)->GetFieldID(env, DOCHOSTUIINFOFc.clazz, "dwDoubleClick", "I");
1418         DOCHOSTUIINFOFc.pchHostCss = (*env)->GetFieldID(env, DOCHOSTUIINFOFc.clazz, "pchHostCss", "J");
1419         DOCHOSTUIINFOFc.pchHostNS = (*env)->GetFieldID(env, DOCHOSTUIINFOFc.clazz, "pchHostNS", "J");
1420         DOCHOSTUIINFOFc.cached = 1;
1421 }
1422
1423 DOCHOSTUIINFO *getDOCHOSTUIINFOFields(JNIEnv *env, jobject lpObject, DOCHOSTUIINFO *lpStruct)
1424 {
1425         if (!DOCHOSTUIINFOFc.cached) cacheDOCHOSTUIINFOFields(env, lpObject);
1426         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, DOCHOSTUIINFOFc.cbSize);
1427         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, DOCHOSTUIINFOFc.dwFlags);
1428         lpStruct->dwDoubleClick = (*env)->GetIntField(env, lpObject, DOCHOSTUIINFOFc.dwDoubleClick);
1429         lpStruct->pchHostCss = (OLECHAR *)(*env)->GetLongField(env, lpObject, DOCHOSTUIINFOFc.pchHostCss);
1430         lpStruct->pchHostNS = (OLECHAR *)(*env)->GetLongField(env, lpObject, DOCHOSTUIINFOFc.pchHostNS);
1431         return lpStruct;
1432 }
1433
1434 void setDOCHOSTUIINFOFields(JNIEnv *env, jobject lpObject, DOCHOSTUIINFO *lpStruct)
1435 {
1436         if (!DOCHOSTUIINFOFc.cached) cacheDOCHOSTUIINFOFields(env, lpObject);
1437         (*env)->SetIntField(env, lpObject, DOCHOSTUIINFOFc.cbSize, (jint)lpStruct->cbSize);
1438         (*env)->SetIntField(env, lpObject, DOCHOSTUIINFOFc.dwFlags, (jint)lpStruct->dwFlags);
1439         (*env)->SetIntField(env, lpObject, DOCHOSTUIINFOFc.dwDoubleClick, (jint)lpStruct->dwDoubleClick);
1440         (*env)->SetLongField(env, lpObject, DOCHOSTUIINFOFc.pchHostCss, (jlong)lpStruct->pchHostCss);
1441         (*env)->SetLongField(env, lpObject, DOCHOSTUIINFOFc.pchHostNS, (jlong)lpStruct->pchHostNS);
1442 }
1443 #endif
1444
1445 #ifndef NO_DOCINFO
1446 typedef struct DOCINFO_FID_CACHE {
1447         int cached;
1448         jclass clazz;
1449         jfieldID cbSize, lpszDocName, lpszOutput, lpszDatatype, fwType;
1450 } DOCINFO_FID_CACHE;
1451
1452 DOCINFO_FID_CACHE DOCINFOFc;
1453
1454 void cacheDOCINFOFields(JNIEnv *env, jobject lpObject)
1455 {
1456         if (DOCINFOFc.cached) return;
1457         DOCINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
1458         DOCINFOFc.cbSize = (*env)->GetFieldID(env, DOCINFOFc.clazz, "cbSize", "I");
1459         DOCINFOFc.lpszDocName = (*env)->GetFieldID(env, DOCINFOFc.clazz, "lpszDocName", "J");
1460         DOCINFOFc.lpszOutput = (*env)->GetFieldID(env, DOCINFOFc.clazz, "lpszOutput", "J");
1461         DOCINFOFc.lpszDatatype = (*env)->GetFieldID(env, DOCINFOFc.clazz, "lpszDatatype", "J");
1462         DOCINFOFc.fwType = (*env)->GetFieldID(env, DOCINFOFc.clazz, "fwType", "I");
1463         DOCINFOFc.cached = 1;
1464 }
1465
1466 DOCINFO *getDOCINFOFields(JNIEnv *env, jobject lpObject, DOCINFO *lpStruct)
1467 {
1468         if (!DOCINFOFc.cached) cacheDOCINFOFields(env, lpObject);
1469         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, DOCINFOFc.cbSize);
1470         lpStruct->lpszDocName = (LPCTSTR)(*env)->GetLongField(env, lpObject, DOCINFOFc.lpszDocName);
1471         lpStruct->lpszOutput = (LPCTSTR)(*env)->GetLongField(env, lpObject, DOCINFOFc.lpszOutput);
1472         lpStruct->lpszDatatype = (LPCTSTR)(*env)->GetLongField(env, lpObject, DOCINFOFc.lpszDatatype);
1473         lpStruct->fwType = (*env)->GetIntField(env, lpObject, DOCINFOFc.fwType);
1474         return lpStruct;
1475 }
1476
1477 void setDOCINFOFields(JNIEnv *env, jobject lpObject, DOCINFO *lpStruct)
1478 {
1479         if (!DOCINFOFc.cached) cacheDOCINFOFields(env, lpObject);
1480         (*env)->SetIntField(env, lpObject, DOCINFOFc.cbSize, (jint)lpStruct->cbSize);
1481         (*env)->SetLongField(env, lpObject, DOCINFOFc.lpszDocName, (jlong)lpStruct->lpszDocName);
1482         (*env)->SetLongField(env, lpObject, DOCINFOFc.lpszOutput, (jlong)lpStruct->lpszOutput);
1483         (*env)->SetLongField(env, lpObject, DOCINFOFc.lpszDatatype, (jlong)lpStruct->lpszDatatype);
1484         (*env)->SetIntField(env, lpObject, DOCINFOFc.fwType, (jint)lpStruct->fwType);
1485 }
1486 #endif
1487
1488 #ifndef NO_DRAWITEMSTRUCT
1489 typedef struct DRAWITEMSTRUCT_FID_CACHE {
1490         int cached;
1491         jclass clazz;
1492         jfieldID CtlType, CtlID, itemID, itemAction, itemState, hwndItem, hDC, left, top, bottom, right, itemData;
1493 } DRAWITEMSTRUCT_FID_CACHE;
1494
1495 DRAWITEMSTRUCT_FID_CACHE DRAWITEMSTRUCTFc;
1496
1497 void cacheDRAWITEMSTRUCTFields(JNIEnv *env, jobject lpObject)
1498 {
1499         if (DRAWITEMSTRUCTFc.cached) return;
1500         DRAWITEMSTRUCTFc.clazz = (*env)->GetObjectClass(env, lpObject);
1501         DRAWITEMSTRUCTFc.CtlType = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "CtlType", "I");
1502         DRAWITEMSTRUCTFc.CtlID = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "CtlID", "I");
1503         DRAWITEMSTRUCTFc.itemID = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "itemID", "I");
1504         DRAWITEMSTRUCTFc.itemAction = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "itemAction", "I");
1505         DRAWITEMSTRUCTFc.itemState = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "itemState", "I");
1506         DRAWITEMSTRUCTFc.hwndItem = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "hwndItem", "J");
1507         DRAWITEMSTRUCTFc.hDC = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "hDC", "J");
1508         DRAWITEMSTRUCTFc.left = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "left", "I");
1509         DRAWITEMSTRUCTFc.top = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "top", "I");
1510         DRAWITEMSTRUCTFc.bottom = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "bottom", "I");
1511         DRAWITEMSTRUCTFc.right = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "right", "I");
1512         DRAWITEMSTRUCTFc.itemData = (*env)->GetFieldID(env, DRAWITEMSTRUCTFc.clazz, "itemData", "J");
1513         DRAWITEMSTRUCTFc.cached = 1;
1514 }
1515
1516 DRAWITEMSTRUCT *getDRAWITEMSTRUCTFields(JNIEnv *env, jobject lpObject, DRAWITEMSTRUCT *lpStruct)
1517 {
1518         if (!DRAWITEMSTRUCTFc.cached) cacheDRAWITEMSTRUCTFields(env, lpObject);
1519         lpStruct->CtlType = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.CtlType);
1520         lpStruct->CtlID = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.CtlID);
1521         lpStruct->itemID = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemID);
1522         lpStruct->itemAction = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemAction);
1523         lpStruct->itemState = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemState);
1524         lpStruct->hwndItem = (HWND)(*env)->GetLongField(env, lpObject, DRAWITEMSTRUCTFc.hwndItem);
1525         lpStruct->hDC = (HDC)(*env)->GetLongField(env, lpObject, DRAWITEMSTRUCTFc.hDC);
1526         lpStruct->rcItem.left = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.left);
1527         lpStruct->rcItem.top = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.top);
1528         lpStruct->rcItem.bottom = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.bottom);
1529         lpStruct->rcItem.right = (*env)->GetIntField(env, lpObject, DRAWITEMSTRUCTFc.right);
1530         lpStruct->itemData = (*env)->GetLongField(env, lpObject, DRAWITEMSTRUCTFc.itemData);
1531         return lpStruct;
1532 }
1533
1534 void setDRAWITEMSTRUCTFields(JNIEnv *env, jobject lpObject, DRAWITEMSTRUCT *lpStruct)
1535 {
1536         if (!DRAWITEMSTRUCTFc.cached) cacheDRAWITEMSTRUCTFields(env, lpObject);
1537         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.CtlType, (jint)lpStruct->CtlType);
1538         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.CtlID, (jint)lpStruct->CtlID);
1539         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemID, (jint)lpStruct->itemID);
1540         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemAction, (jint)lpStruct->itemAction);
1541         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.itemState, (jint)lpStruct->itemState);
1542         (*env)->SetLongField(env, lpObject, DRAWITEMSTRUCTFc.hwndItem, (jlong)lpStruct->hwndItem);
1543         (*env)->SetLongField(env, lpObject, DRAWITEMSTRUCTFc.hDC, (jlong)lpStruct->hDC);
1544         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.left, (jint)lpStruct->rcItem.left);
1545         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.top, (jint)lpStruct->rcItem.top);
1546         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.bottom, (jint)lpStruct->rcItem.bottom);
1547         (*env)->SetIntField(env, lpObject, DRAWITEMSTRUCTFc.right, (jint)lpStruct->rcItem.right);
1548         (*env)->SetLongField(env, lpObject, DRAWITEMSTRUCTFc.itemData, (jlong)lpStruct->itemData);
1549 }
1550 #endif
1551
1552 #ifndef NO_DROPFILES
1553 typedef struct DROPFILES_FID_CACHE {
1554         int cached;
1555         jclass clazz;
1556         jfieldID pFiles, pt_x, pt_y, fNC, fWide;
1557 } DROPFILES_FID_CACHE;
1558
1559 DROPFILES_FID_CACHE DROPFILESFc;
1560
1561 void cacheDROPFILESFields(JNIEnv *env, jobject lpObject)
1562 {
1563         if (DROPFILESFc.cached) return;
1564         DROPFILESFc.clazz = (*env)->GetObjectClass(env, lpObject);
1565         DROPFILESFc.pFiles = (*env)->GetFieldID(env, DROPFILESFc.clazz, "pFiles", "I");
1566         DROPFILESFc.pt_x = (*env)->GetFieldID(env, DROPFILESFc.clazz, "pt_x", "I");
1567         DROPFILESFc.pt_y = (*env)->GetFieldID(env, DROPFILESFc.clazz, "pt_y", "I");
1568         DROPFILESFc.fNC = (*env)->GetFieldID(env, DROPFILESFc.clazz, "fNC", "I");
1569         DROPFILESFc.fWide = (*env)->GetFieldID(env, DROPFILESFc.clazz, "fWide", "I");
1570         DROPFILESFc.cached = 1;
1571 }
1572
1573 DROPFILES *getDROPFILESFields(JNIEnv *env, jobject lpObject, DROPFILES *lpStruct)
1574 {
1575         if (!DROPFILESFc.cached) cacheDROPFILESFields(env, lpObject);
1576         lpStruct->pFiles = (*env)->GetIntField(env, lpObject, DROPFILESFc.pFiles);
1577         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, DROPFILESFc.pt_x);
1578         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, DROPFILESFc.pt_y);
1579         lpStruct->fNC = (*env)->GetIntField(env, lpObject, DROPFILESFc.fNC);
1580         lpStruct->fWide = (*env)->GetIntField(env, lpObject, DROPFILESFc.fWide);
1581         return lpStruct;
1582 }
1583
1584 void setDROPFILESFields(JNIEnv *env, jobject lpObject, DROPFILES *lpStruct)
1585 {
1586         if (!DROPFILESFc.cached) cacheDROPFILESFields(env, lpObject);
1587         (*env)->SetIntField(env, lpObject, DROPFILESFc.pFiles, (jint)lpStruct->pFiles);
1588         (*env)->SetIntField(env, lpObject, DROPFILESFc.pt_x, (jint)lpStruct->pt.x);
1589         (*env)->SetIntField(env, lpObject, DROPFILESFc.pt_y, (jint)lpStruct->pt.y);
1590         (*env)->SetIntField(env, lpObject, DROPFILESFc.fNC, (jint)lpStruct->fNC);
1591         (*env)->SetIntField(env, lpObject, DROPFILESFc.fWide, (jint)lpStruct->fWide);
1592 }
1593 #endif
1594
1595 #ifndef NO_DTTOPTS
1596 typedef struct DTTOPTS_FID_CACHE {
1597         int cached;
1598         jclass clazz;
1599         jfieldID dwSize, dwFlags, crText, crBorder, crShadow, iTextShadowType, ptShadowOffset, iBorderSize, iFontPropId, iColorPropId, iStateId, fApplyOverlay, iGlowSize, pfnDrawTextCallback, lParam;
1600 } DTTOPTS_FID_CACHE;
1601
1602 DTTOPTS_FID_CACHE DTTOPTSFc;
1603
1604 void cacheDTTOPTSFields(JNIEnv *env, jobject lpObject)
1605 {
1606         if (DTTOPTSFc.cached) return;
1607         DTTOPTSFc.clazz = (*env)->GetObjectClass(env, lpObject);
1608         DTTOPTSFc.dwSize = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "dwSize", "I");
1609         DTTOPTSFc.dwFlags = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "dwFlags", "I");
1610         DTTOPTSFc.crText = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "crText", "I");
1611         DTTOPTSFc.crBorder = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "crBorder", "I");
1612         DTTOPTSFc.crShadow = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "crShadow", "I");
1613         DTTOPTSFc.iTextShadowType = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iTextShadowType", "I");
1614         DTTOPTSFc.ptShadowOffset = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "ptShadowOffset", "Lorg/eclipse/swt/internal/win32/POINT;");
1615         DTTOPTSFc.iBorderSize = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iBorderSize", "I");
1616         DTTOPTSFc.iFontPropId = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iFontPropId", "I");
1617         DTTOPTSFc.iColorPropId = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iColorPropId", "I");
1618         DTTOPTSFc.iStateId = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iStateId", "I");
1619         DTTOPTSFc.fApplyOverlay = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "fApplyOverlay", "Z");
1620         DTTOPTSFc.iGlowSize = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "iGlowSize", "I");
1621         DTTOPTSFc.pfnDrawTextCallback = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "pfnDrawTextCallback", "J");
1622         DTTOPTSFc.lParam = (*env)->GetFieldID(env, DTTOPTSFc.clazz, "lParam", "J");
1623         DTTOPTSFc.cached = 1;
1624 }
1625
1626 DTTOPTS *getDTTOPTSFields(JNIEnv *env, jobject lpObject, DTTOPTS *lpStruct)
1627 {
1628         if (!DTTOPTSFc.cached) cacheDTTOPTSFields(env, lpObject);
1629         lpStruct->dwSize = (*env)->GetIntField(env, lpObject, DTTOPTSFc.dwSize);
1630         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, DTTOPTSFc.dwFlags);
1631         lpStruct->crText = (*env)->GetIntField(env, lpObject, DTTOPTSFc.crText);
1632         lpStruct->crBorder = (*env)->GetIntField(env, lpObject, DTTOPTSFc.crBorder);
1633         lpStruct->crShadow = (*env)->GetIntField(env, lpObject, DTTOPTSFc.crShadow);
1634         lpStruct->iTextShadowType = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iTextShadowType);
1635         {
1636         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, DTTOPTSFc.ptShadowOffset);
1637         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->ptShadowOffset);
1638         }
1639         lpStruct->iBorderSize = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iBorderSize);
1640         lpStruct->iFontPropId = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iFontPropId);
1641         lpStruct->iColorPropId = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iColorPropId);
1642         lpStruct->iStateId = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iStateId);
1643         lpStruct->fApplyOverlay = (*env)->GetBooleanField(env, lpObject, DTTOPTSFc.fApplyOverlay);
1644         lpStruct->iGlowSize = (*env)->GetIntField(env, lpObject, DTTOPTSFc.iGlowSize);
1645         lpStruct->pfnDrawTextCallback = (DTT_CALLBACK_PROC)(*env)->GetLongField(env, lpObject, DTTOPTSFc.pfnDrawTextCallback);
1646         lpStruct->lParam = (*env)->GetLongField(env, lpObject, DTTOPTSFc.lParam);
1647         return lpStruct;
1648 }
1649
1650 void setDTTOPTSFields(JNIEnv *env, jobject lpObject, DTTOPTS *lpStruct)
1651 {
1652         if (!DTTOPTSFc.cached) cacheDTTOPTSFields(env, lpObject);
1653         (*env)->SetIntField(env, lpObject, DTTOPTSFc.dwSize, (jint)lpStruct->dwSize);
1654         (*env)->SetIntField(env, lpObject, DTTOPTSFc.dwFlags, (jint)lpStruct->dwFlags);
1655         (*env)->SetIntField(env, lpObject, DTTOPTSFc.crText, (jint)lpStruct->crText);
1656         (*env)->SetIntField(env, lpObject, DTTOPTSFc.crBorder, (jint)lpStruct->crBorder);
1657         (*env)->SetIntField(env, lpObject, DTTOPTSFc.crShadow, (jint)lpStruct->crShadow);
1658         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iTextShadowType, (jint)lpStruct->iTextShadowType);
1659         {
1660         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, DTTOPTSFc.ptShadowOffset);
1661         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->ptShadowOffset);
1662         }
1663         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iBorderSize, (jint)lpStruct->iBorderSize);
1664         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iFontPropId, (jint)lpStruct->iFontPropId);
1665         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iColorPropId, (jint)lpStruct->iColorPropId);
1666         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iStateId, (jint)lpStruct->iStateId);
1667         (*env)->SetBooleanField(env, lpObject, DTTOPTSFc.fApplyOverlay, (jboolean)lpStruct->fApplyOverlay);
1668         (*env)->SetIntField(env, lpObject, DTTOPTSFc.iGlowSize, (jint)lpStruct->iGlowSize);
1669         (*env)->SetLongField(env, lpObject, DTTOPTSFc.pfnDrawTextCallback, (jlong)lpStruct->pfnDrawTextCallback);
1670         (*env)->SetLongField(env, lpObject, DTTOPTSFc.lParam, (jlong)lpStruct->lParam);
1671 }
1672 #endif
1673
1674 #ifndef NO_EMR
1675 typedef struct EMR_FID_CACHE {
1676         int cached;
1677         jclass clazz;
1678         jfieldID iType, nSize;
1679 } EMR_FID_CACHE;
1680
1681 EMR_FID_CACHE EMRFc;
1682
1683 void cacheEMRFields(JNIEnv *env, jobject lpObject)
1684 {
1685         if (EMRFc.cached) return;
1686         EMRFc.clazz = (*env)->GetObjectClass(env, lpObject);
1687         EMRFc.iType = (*env)->GetFieldID(env, EMRFc.clazz, "iType", "I");
1688         EMRFc.nSize = (*env)->GetFieldID(env, EMRFc.clazz, "nSize", "I");
1689         EMRFc.cached = 1;
1690 }
1691
1692 EMR *getEMRFields(JNIEnv *env, jobject lpObject, EMR *lpStruct)
1693 {
1694         if (!EMRFc.cached) cacheEMRFields(env, lpObject);
1695         lpStruct->iType = (*env)->GetIntField(env, lpObject, EMRFc.iType);
1696         lpStruct->nSize = (*env)->GetIntField(env, lpObject, EMRFc.nSize);
1697         return lpStruct;
1698 }
1699
1700 void setEMRFields(JNIEnv *env, jobject lpObject, EMR *lpStruct)
1701 {
1702         if (!EMRFc.cached) cacheEMRFields(env, lpObject);
1703         (*env)->SetIntField(env, lpObject, EMRFc.iType, (jint)lpStruct->iType);
1704         (*env)->SetIntField(env, lpObject, EMRFc.nSize, (jint)lpStruct->nSize);
1705 }
1706 #endif
1707
1708 #ifndef NO_EMREXTCREATEFONTINDIRECTW
1709 typedef struct EMREXTCREATEFONTINDIRECTW_FID_CACHE {
1710         int cached;
1711         jclass clazz;
1712         jfieldID emr, ihFont, elfw;
1713 } EMREXTCREATEFONTINDIRECTW_FID_CACHE;
1714
1715 EMREXTCREATEFONTINDIRECTW_FID_CACHE EMREXTCREATEFONTINDIRECTWFc;
1716
1717 void cacheEMREXTCREATEFONTINDIRECTWFields(JNIEnv *env, jobject lpObject)
1718 {
1719         if (EMREXTCREATEFONTINDIRECTWFc.cached) return;
1720         EMREXTCREATEFONTINDIRECTWFc.clazz = (*env)->GetObjectClass(env, lpObject);
1721         EMREXTCREATEFONTINDIRECTWFc.emr = (*env)->GetFieldID(env, EMREXTCREATEFONTINDIRECTWFc.clazz, "emr", "Lorg/eclipse/swt/internal/win32/EMR;");
1722         EMREXTCREATEFONTINDIRECTWFc.ihFont = (*env)->GetFieldID(env, EMREXTCREATEFONTINDIRECTWFc.clazz, "ihFont", "I");
1723         EMREXTCREATEFONTINDIRECTWFc.elfw = (*env)->GetFieldID(env, EMREXTCREATEFONTINDIRECTWFc.clazz, "elfw", "Lorg/eclipse/swt/internal/win32/EXTLOGFONTW;");
1724         EMREXTCREATEFONTINDIRECTWFc.cached = 1;
1725 }
1726
1727 EMREXTCREATEFONTINDIRECTW *getEMREXTCREATEFONTINDIRECTWFields(JNIEnv *env, jobject lpObject, EMREXTCREATEFONTINDIRECTW *lpStruct)
1728 {
1729         if (!EMREXTCREATEFONTINDIRECTWFc.cached) cacheEMREXTCREATEFONTINDIRECTWFields(env, lpObject);
1730         {
1731         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.emr);
1732         if (lpObject1 != NULL) getEMRFields(env, lpObject1, &lpStruct->emr);
1733         }
1734         lpStruct->ihFont = (*env)->GetIntField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.ihFont);
1735         {
1736         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.elfw);
1737         if (lpObject1 != NULL) getEXTLOGFONTWFields(env, lpObject1, &lpStruct->elfw);
1738         }
1739         return lpStruct;
1740 }
1741
1742 void setEMREXTCREATEFONTINDIRECTWFields(JNIEnv *env, jobject lpObject, EMREXTCREATEFONTINDIRECTW *lpStruct)
1743 {
1744         if (!EMREXTCREATEFONTINDIRECTWFc.cached) cacheEMREXTCREATEFONTINDIRECTWFields(env, lpObject);
1745         {
1746         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.emr);
1747         if (lpObject1 != NULL) setEMRFields(env, lpObject1, &lpStruct->emr);
1748         }
1749         (*env)->SetIntField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.ihFont, (jint)lpStruct->ihFont);
1750         {
1751         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EMREXTCREATEFONTINDIRECTWFc.elfw);
1752         if (lpObject1 != NULL) setEXTLOGFONTWFields(env, lpObject1, &lpStruct->elfw);
1753         }
1754 }
1755 #endif
1756
1757 #ifndef NO_EXTLOGFONTW
1758 typedef struct EXTLOGFONTW_FID_CACHE {
1759         int cached;
1760         jclass clazz;
1761         jfieldID elfLogFont, elfFullName, elfStyle, elfVersion, elfStyleSize, elfMatch, elfReserved, elfVendorId, elfCulture, elfPanose;
1762 } EXTLOGFONTW_FID_CACHE;
1763
1764 EXTLOGFONTW_FID_CACHE EXTLOGFONTWFc;
1765
1766 void cacheEXTLOGFONTWFields(JNIEnv *env, jobject lpObject)
1767 {
1768         if (EXTLOGFONTWFc.cached) return;
1769         EXTLOGFONTWFc.clazz = (*env)->GetObjectClass(env, lpObject);
1770         EXTLOGFONTWFc.elfLogFont = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfLogFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
1771         EXTLOGFONTWFc.elfFullName = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfFullName", "[C");
1772         EXTLOGFONTWFc.elfStyle = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfStyle", "[C");
1773         EXTLOGFONTWFc.elfVersion = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfVersion", "I");
1774         EXTLOGFONTWFc.elfStyleSize = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfStyleSize", "I");
1775         EXTLOGFONTWFc.elfMatch = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfMatch", "I");
1776         EXTLOGFONTWFc.elfReserved = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfReserved", "I");
1777         EXTLOGFONTWFc.elfVendorId = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfVendorId", "[B");
1778         EXTLOGFONTWFc.elfCulture = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfCulture", "I");
1779         EXTLOGFONTWFc.elfPanose = (*env)->GetFieldID(env, EXTLOGFONTWFc.clazz, "elfPanose", "Lorg/eclipse/swt/internal/win32/PANOSE;");
1780         EXTLOGFONTWFc.cached = 1;
1781 }
1782
1783 EXTLOGFONTW *getEXTLOGFONTWFields(JNIEnv *env, jobject lpObject, EXTLOGFONTW *lpStruct)
1784 {
1785         if (!EXTLOGFONTWFc.cached) cacheEXTLOGFONTWFields(env, lpObject);
1786         {
1787         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfLogFont);
1788         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->elfLogFont);
1789         }
1790         {
1791         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfFullName);
1792         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfFullName) / sizeof(jchar), (jchar *)lpStruct->elfFullName);
1793         }
1794         {
1795         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfStyle);
1796         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfStyle) / sizeof(jchar), (jchar *)lpStruct->elfStyle);
1797         }
1798         lpStruct->elfVersion = (*env)->GetIntField(env, lpObject, EXTLOGFONTWFc.elfVersion);
1799         lpStruct->elfStyleSize = (*env)->GetIntField(env, lpObject, EXTLOGFONTWFc.elfStyleSize);
1800         lpStruct->elfMatch = (*env)->GetIntField(env, lpObject, EXTLOGFONTWFc.elfMatch);
1801         lpStruct->elfReserved = (*env)->GetIntField(env, lpObject, EXTLOGFONTWFc.elfReserved);
1802         {
1803         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfVendorId);
1804         (*env)->GetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfVendorId), (jbyte *)lpStruct->elfVendorId);
1805         }
1806         lpStruct->elfCulture = (*env)->GetIntField(env, lpObject, EXTLOGFONTWFc.elfCulture);
1807         {
1808         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfPanose);
1809         if (lpObject1 != NULL) getPANOSEFields(env, lpObject1, &lpStruct->elfPanose);
1810         }
1811         return lpStruct;
1812 }
1813
1814 void setEXTLOGFONTWFields(JNIEnv *env, jobject lpObject, EXTLOGFONTW *lpStruct)
1815 {
1816         if (!EXTLOGFONTWFc.cached) cacheEXTLOGFONTWFields(env, lpObject);
1817         {
1818         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfLogFont);
1819         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->elfLogFont);
1820         }
1821         {
1822         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfFullName);
1823         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfFullName) / sizeof(jchar), (jchar *)lpStruct->elfFullName);
1824         }
1825         {
1826         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfStyle);
1827         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfStyle) / sizeof(jchar), (jchar *)lpStruct->elfStyle);
1828         }
1829         (*env)->SetIntField(env, lpObject, EXTLOGFONTWFc.elfVersion, (jint)lpStruct->elfVersion);
1830         (*env)->SetIntField(env, lpObject, EXTLOGFONTWFc.elfStyleSize, (jint)lpStruct->elfStyleSize);
1831         (*env)->SetIntField(env, lpObject, EXTLOGFONTWFc.elfMatch, (jint)lpStruct->elfMatch);
1832         (*env)->SetIntField(env, lpObject, EXTLOGFONTWFc.elfReserved, (jint)lpStruct->elfReserved);
1833         {
1834         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfVendorId);
1835         (*env)->SetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->elfVendorId), (jbyte *)lpStruct->elfVendorId);
1836         }
1837         (*env)->SetIntField(env, lpObject, EXTLOGFONTWFc.elfCulture, (jint)lpStruct->elfCulture);
1838         {
1839         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, EXTLOGFONTWFc.elfPanose);
1840         if (lpObject1 != NULL) setPANOSEFields(env, lpObject1, &lpStruct->elfPanose);
1841         }
1842 }
1843 #endif
1844
1845 #ifndef NO_FILETIME
1846 typedef struct FILETIME_FID_CACHE {
1847         int cached;
1848         jclass clazz;
1849         jfieldID dwLowDateTime, dwHighDateTime;
1850 } FILETIME_FID_CACHE;
1851
1852 FILETIME_FID_CACHE FILETIMEFc;
1853
1854 void cacheFILETIMEFields(JNIEnv *env, jobject lpObject)
1855 {
1856         if (FILETIMEFc.cached) return;
1857         FILETIMEFc.clazz = (*env)->GetObjectClass(env, lpObject);
1858         FILETIMEFc.dwLowDateTime = (*env)->GetFieldID(env, FILETIMEFc.clazz, "dwLowDateTime", "I");
1859         FILETIMEFc.dwHighDateTime = (*env)->GetFieldID(env, FILETIMEFc.clazz, "dwHighDateTime", "I");
1860         FILETIMEFc.cached = 1;
1861 }
1862
1863 FILETIME *getFILETIMEFields(JNIEnv *env, jobject lpObject, FILETIME *lpStruct)
1864 {
1865         if (!FILETIMEFc.cached) cacheFILETIMEFields(env, lpObject);
1866         lpStruct->dwLowDateTime = (*env)->GetIntField(env, lpObject, FILETIMEFc.dwLowDateTime);
1867         lpStruct->dwHighDateTime = (*env)->GetIntField(env, lpObject, FILETIMEFc.dwHighDateTime);
1868         return lpStruct;
1869 }
1870
1871 void setFILETIMEFields(JNIEnv *env, jobject lpObject, FILETIME *lpStruct)
1872 {
1873         if (!FILETIMEFc.cached) cacheFILETIMEFields(env, lpObject);
1874         (*env)->SetIntField(env, lpObject, FILETIMEFc.dwLowDateTime, (jint)lpStruct->dwLowDateTime);
1875         (*env)->SetIntField(env, lpObject, FILETIMEFc.dwHighDateTime, (jint)lpStruct->dwHighDateTime);
1876 }
1877 #endif
1878
1879 #ifndef NO_FLICK_DATA
1880 typedef struct FLICK_DATA_FID_CACHE {
1881         int cached;
1882         jclass clazz;
1883         jfieldID iFlickActionCommandCode, iFlickDirection, fControlModifier, fMenuModifier, fAltGRModifier, fWinModifier, fShiftModifier, iReserved, fOnInkingSurface, iActionArgument;
1884 } FLICK_DATA_FID_CACHE;
1885
1886 FLICK_DATA_FID_CACHE FLICK_DATAFc;
1887
1888 void cacheFLICK_DATAFields(JNIEnv *env, jobject lpObject)
1889 {
1890         if (FLICK_DATAFc.cached) return;
1891         FLICK_DATAFc.clazz = (*env)->GetObjectClass(env, lpObject);
1892         FLICK_DATAFc.iFlickActionCommandCode = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "iFlickActionCommandCode", "I");
1893         FLICK_DATAFc.iFlickDirection = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "iFlickDirection", "B");
1894         FLICK_DATAFc.fControlModifier = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fControlModifier", "Z");
1895         FLICK_DATAFc.fMenuModifier = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fMenuModifier", "Z");
1896         FLICK_DATAFc.fAltGRModifier = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fAltGRModifier", "Z");
1897         FLICK_DATAFc.fWinModifier = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fWinModifier", "Z");
1898         FLICK_DATAFc.fShiftModifier = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fShiftModifier", "Z");
1899         FLICK_DATAFc.iReserved = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "iReserved", "I");
1900         FLICK_DATAFc.fOnInkingSurface = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "fOnInkingSurface", "Z");
1901         FLICK_DATAFc.iActionArgument = (*env)->GetFieldID(env, FLICK_DATAFc.clazz, "iActionArgument", "I");
1902         FLICK_DATAFc.cached = 1;
1903 }
1904
1905 FLICK_DATA *getFLICK_DATAFields(JNIEnv *env, jobject lpObject, FLICK_DATA *lpStruct)
1906 {
1907         if (!FLICK_DATAFc.cached) cacheFLICK_DATAFields(env, lpObject);
1908         lpStruct->iFlickActionCommandCode = (*env)->GetIntField(env, lpObject, FLICK_DATAFc.iFlickActionCommandCode);
1909         lpStruct->iFlickDirection = (*env)->GetByteField(env, lpObject, FLICK_DATAFc.iFlickDirection);
1910         lpStruct->fControlModifier = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fControlModifier);
1911         lpStruct->fMenuModifier = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fMenuModifier);
1912         lpStruct->fAltGRModifier = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fAltGRModifier);
1913         lpStruct->fWinModifier = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fWinModifier);
1914         lpStruct->fShiftModifier = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fShiftModifier);
1915         lpStruct->iReserved = (*env)->GetIntField(env, lpObject, FLICK_DATAFc.iReserved);
1916         lpStruct->fOnInkingSurface = (*env)->GetBooleanField(env, lpObject, FLICK_DATAFc.fOnInkingSurface);
1917         lpStruct->iActionArgument = (*env)->GetIntField(env, lpObject, FLICK_DATAFc.iActionArgument);
1918         return lpStruct;
1919 }
1920
1921 void setFLICK_DATAFields(JNIEnv *env, jobject lpObject, FLICK_DATA *lpStruct)
1922 {
1923         if (!FLICK_DATAFc.cached) cacheFLICK_DATAFields(env, lpObject);
1924         (*env)->SetIntField(env, lpObject, FLICK_DATAFc.iFlickActionCommandCode, (jint)lpStruct->iFlickActionCommandCode);
1925         (*env)->SetByteField(env, lpObject, FLICK_DATAFc.iFlickDirection, (jbyte)lpStruct->iFlickDirection);
1926         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fControlModifier, (jboolean)lpStruct->fControlModifier);
1927         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fMenuModifier, (jboolean)lpStruct->fMenuModifier);
1928         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fAltGRModifier, (jboolean)lpStruct->fAltGRModifier);
1929         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fWinModifier, (jboolean)lpStruct->fWinModifier);
1930         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fShiftModifier, (jboolean)lpStruct->fShiftModifier);
1931         (*env)->SetIntField(env, lpObject, FLICK_DATAFc.iReserved, (jint)lpStruct->iReserved);
1932         (*env)->SetBooleanField(env, lpObject, FLICK_DATAFc.fOnInkingSurface, (jboolean)lpStruct->fOnInkingSurface);
1933         (*env)->SetIntField(env, lpObject, FLICK_DATAFc.iActionArgument, (jint)lpStruct->iActionArgument);
1934 }
1935 #endif
1936
1937 #ifndef NO_FLICK_POINT
1938 typedef struct FLICK_POINT_FID_CACHE {
1939         int cached;
1940         jclass clazz;
1941         jfieldID x, y;
1942 } FLICK_POINT_FID_CACHE;
1943
1944 FLICK_POINT_FID_CACHE FLICK_POINTFc;
1945
1946 void cacheFLICK_POINTFields(JNIEnv *env, jobject lpObject)
1947 {
1948         if (FLICK_POINTFc.cached) return;
1949         FLICK_POINTFc.clazz = (*env)->GetObjectClass(env, lpObject);
1950         FLICK_POINTFc.x = (*env)->GetFieldID(env, FLICK_POINTFc.clazz, "x", "I");
1951         FLICK_POINTFc.y = (*env)->GetFieldID(env, FLICK_POINTFc.clazz, "y", "I");
1952         FLICK_POINTFc.cached = 1;
1953 }
1954
1955 FLICK_POINT *getFLICK_POINTFields(JNIEnv *env, jobject lpObject, FLICK_POINT *lpStruct)
1956 {
1957         if (!FLICK_POINTFc.cached) cacheFLICK_POINTFields(env, lpObject);
1958         lpStruct->x = (*env)->GetIntField(env, lpObject, FLICK_POINTFc.x);
1959         lpStruct->y = (*env)->GetIntField(env, lpObject, FLICK_POINTFc.y);
1960         return lpStruct;
1961 }
1962
1963 void setFLICK_POINTFields(JNIEnv *env, jobject lpObject, FLICK_POINT *lpStruct)
1964 {
1965         if (!FLICK_POINTFc.cached) cacheFLICK_POINTFields(env, lpObject);
1966         (*env)->SetIntField(env, lpObject, FLICK_POINTFc.x, (jint)lpStruct->x);
1967         (*env)->SetIntField(env, lpObject, FLICK_POINTFc.y, (jint)lpStruct->y);
1968 }
1969 #endif
1970
1971 #ifndef NO_GCP_RESULTS
1972 typedef struct GCP_RESULTS_FID_CACHE {
1973         int cached;
1974         jclass clazz;
1975         jfieldID lStructSize, lpOutString, lpOrder, lpDx, lpCaretPos, lpClass, lpGlyphs, nGlyphs, nMaxFit;
1976 } GCP_RESULTS_FID_CACHE;
1977
1978 GCP_RESULTS_FID_CACHE GCP_RESULTSFc;
1979
1980 void cacheGCP_RESULTSFields(JNIEnv *env, jobject lpObject)
1981 {
1982         if (GCP_RESULTSFc.cached) return;
1983         GCP_RESULTSFc.clazz = (*env)->GetObjectClass(env, lpObject);
1984         GCP_RESULTSFc.lStructSize = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lStructSize", "I");
1985         GCP_RESULTSFc.lpOutString = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpOutString", "J");
1986         GCP_RESULTSFc.lpOrder = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpOrder", "J");
1987         GCP_RESULTSFc.lpDx = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpDx", "J");
1988         GCP_RESULTSFc.lpCaretPos = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpCaretPos", "J");
1989         GCP_RESULTSFc.lpClass = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpClass", "J");
1990         GCP_RESULTSFc.lpGlyphs = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "lpGlyphs", "J");
1991         GCP_RESULTSFc.nGlyphs = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "nGlyphs", "I");
1992         GCP_RESULTSFc.nMaxFit = (*env)->GetFieldID(env, GCP_RESULTSFc.clazz, "nMaxFit", "I");
1993         GCP_RESULTSFc.cached = 1;
1994 }
1995
1996 GCP_RESULTS *getGCP_RESULTSFields(JNIEnv *env, jobject lpObject, GCP_RESULTS *lpStruct)
1997 {
1998         if (!GCP_RESULTSFc.cached) cacheGCP_RESULTSFields(env, lpObject);
1999         lpStruct->lStructSize = (*env)->GetIntField(env, lpObject, GCP_RESULTSFc.lStructSize);
2000         lpStruct->lpOutString = (LPTSTR)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpOutString);
2001         lpStruct->lpOrder = (UINT  *)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpOrder);
2002         lpStruct->lpDx = (int  *)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpDx);
2003         lpStruct->lpCaretPos = (int  *)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpCaretPos);
2004         lpStruct->lpClass = (LPSTR)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpClass);
2005         lpStruct->lpGlyphs = (LPWSTR)(*env)->GetLongField(env, lpObject, GCP_RESULTSFc.lpGlyphs);
2006         lpStruct->nGlyphs = (*env)->GetIntField(env, lpObject, GCP_RESULTSFc.nGlyphs);
2007         lpStruct->nMaxFit = (*env)->GetIntField(env, lpObject, GCP_RESULTSFc.nMaxFit);
2008         return lpStruct;
2009 }
2010
2011 void setGCP_RESULTSFields(JNIEnv *env, jobject lpObject, GCP_RESULTS *lpStruct)
2012 {
2013         if (!GCP_RESULTSFc.cached) cacheGCP_RESULTSFields(env, lpObject);
2014         (*env)->SetIntField(env, lpObject, GCP_RESULTSFc.lStructSize, (jint)lpStruct->lStructSize);
2015         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpOutString, (jlong)lpStruct->lpOutString);
2016         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpOrder, (jlong)lpStruct->lpOrder);
2017         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpDx, (jlong)lpStruct->lpDx);
2018         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpCaretPos, (jlong)lpStruct->lpCaretPos);
2019         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpClass, (jlong)lpStruct->lpClass);
2020         (*env)->SetLongField(env, lpObject, GCP_RESULTSFc.lpGlyphs, (jlong)lpStruct->lpGlyphs);
2021         (*env)->SetIntField(env, lpObject, GCP_RESULTSFc.nGlyphs, (jint)lpStruct->nGlyphs);
2022         (*env)->SetIntField(env, lpObject, GCP_RESULTSFc.nMaxFit, (jint)lpStruct->nMaxFit);
2023 }
2024 #endif
2025
2026 #ifndef NO_GESTURECONFIG
2027 typedef struct GESTURECONFIG_FID_CACHE {
2028         int cached;
2029         jclass clazz;
2030         jfieldID dwID, dwWant, dwBlock;
2031 } GESTURECONFIG_FID_CACHE;
2032
2033 GESTURECONFIG_FID_CACHE GESTURECONFIGFc;
2034
2035 void cacheGESTURECONFIGFields(JNIEnv *env, jobject lpObject)
2036 {
2037         if (GESTURECONFIGFc.cached) return;
2038         GESTURECONFIGFc.clazz = (*env)->GetObjectClass(env, lpObject);
2039         GESTURECONFIGFc.dwID = (*env)->GetFieldID(env, GESTURECONFIGFc.clazz, "dwID", "I");
2040         GESTURECONFIGFc.dwWant = (*env)->GetFieldID(env, GESTURECONFIGFc.clazz, "dwWant", "I");
2041         GESTURECONFIGFc.dwBlock = (*env)->GetFieldID(env, GESTURECONFIGFc.clazz, "dwBlock", "I");
2042         GESTURECONFIGFc.cached = 1;
2043 }
2044
2045 GESTURECONFIG *getGESTURECONFIGFields(JNIEnv *env, jobject lpObject, GESTURECONFIG *lpStruct)
2046 {
2047         if (!GESTURECONFIGFc.cached) cacheGESTURECONFIGFields(env, lpObject);
2048         lpStruct->dwID = (*env)->GetIntField(env, lpObject, GESTURECONFIGFc.dwID);
2049         lpStruct->dwWant = (*env)->GetIntField(env, lpObject, GESTURECONFIGFc.dwWant);
2050         lpStruct->dwBlock = (*env)->GetIntField(env, lpObject, GESTURECONFIGFc.dwBlock);
2051         return lpStruct;
2052 }
2053
2054 void setGESTURECONFIGFields(JNIEnv *env, jobject lpObject, GESTURECONFIG *lpStruct)
2055 {
2056         if (!GESTURECONFIGFc.cached) cacheGESTURECONFIGFields(env, lpObject);
2057         (*env)->SetIntField(env, lpObject, GESTURECONFIGFc.dwID, (jint)lpStruct->dwID);
2058         (*env)->SetIntField(env, lpObject, GESTURECONFIGFc.dwWant, (jint)lpStruct->dwWant);
2059         (*env)->SetIntField(env, lpObject, GESTURECONFIGFc.dwBlock, (jint)lpStruct->dwBlock);
2060 }
2061 #endif
2062
2063 #ifndef NO_GESTUREINFO
2064 typedef struct GESTUREINFO_FID_CACHE {
2065         int cached;
2066         jclass clazz;
2067         jfieldID cbSize, dwFlags, dwID, hwndTarget, x, y, dwInstanceID, dwSequenceID, ullArguments, cbExtraArgs;
2068 } GESTUREINFO_FID_CACHE;
2069
2070 GESTUREINFO_FID_CACHE GESTUREINFOFc;
2071
2072 void cacheGESTUREINFOFields(JNIEnv *env, jobject lpObject)
2073 {
2074         if (GESTUREINFOFc.cached) return;
2075         GESTUREINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2076         GESTUREINFOFc.cbSize = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "cbSize", "I");
2077         GESTUREINFOFc.dwFlags = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "dwFlags", "I");
2078         GESTUREINFOFc.dwID = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "dwID", "I");
2079         GESTUREINFOFc.hwndTarget = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "hwndTarget", "J");
2080         GESTUREINFOFc.x = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "x", "S");
2081         GESTUREINFOFc.y = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "y", "S");
2082         GESTUREINFOFc.dwInstanceID = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "dwInstanceID", "I");
2083         GESTUREINFOFc.dwSequenceID = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "dwSequenceID", "I");
2084         GESTUREINFOFc.ullArguments = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "ullArguments", "J");
2085         GESTUREINFOFc.cbExtraArgs = (*env)->GetFieldID(env, GESTUREINFOFc.clazz, "cbExtraArgs", "I");
2086         GESTUREINFOFc.cached = 1;
2087 }
2088
2089 GESTUREINFO *getGESTUREINFOFields(JNIEnv *env, jobject lpObject, GESTUREINFO *lpStruct)
2090 {
2091         if (!GESTUREINFOFc.cached) cacheGESTUREINFOFields(env, lpObject);
2092         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.cbSize);
2093         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.dwFlags);
2094         lpStruct->dwID = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.dwID);
2095         lpStruct->hwndTarget = (HWND)(*env)->GetLongField(env, lpObject, GESTUREINFOFc.hwndTarget);
2096         lpStruct->ptsLocation.x = (*env)->GetShortField(env, lpObject, GESTUREINFOFc.x);
2097         lpStruct->ptsLocation.y = (*env)->GetShortField(env, lpObject, GESTUREINFOFc.y);
2098         lpStruct->dwInstanceID = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.dwInstanceID);
2099         lpStruct->dwSequenceID = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.dwSequenceID);
2100         lpStruct->ullArguments = (*env)->GetLongField(env, lpObject, GESTUREINFOFc.ullArguments);
2101         lpStruct->cbExtraArgs = (*env)->GetIntField(env, lpObject, GESTUREINFOFc.cbExtraArgs);
2102         return lpStruct;
2103 }
2104
2105 void setGESTUREINFOFields(JNIEnv *env, jobject lpObject, GESTUREINFO *lpStruct)
2106 {
2107         if (!GESTUREINFOFc.cached) cacheGESTUREINFOFields(env, lpObject);
2108         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.cbSize, (jint)lpStruct->cbSize);
2109         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.dwFlags, (jint)lpStruct->dwFlags);
2110         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.dwID, (jint)lpStruct->dwID);
2111         (*env)->SetLongField(env, lpObject, GESTUREINFOFc.hwndTarget, (jlong)lpStruct->hwndTarget);
2112         (*env)->SetShortField(env, lpObject, GESTUREINFOFc.x, (jshort)lpStruct->ptsLocation.x);
2113         (*env)->SetShortField(env, lpObject, GESTUREINFOFc.y, (jshort)lpStruct->ptsLocation.y);
2114         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.dwInstanceID, (jint)lpStruct->dwInstanceID);
2115         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.dwSequenceID, (jint)lpStruct->dwSequenceID);
2116         (*env)->SetLongField(env, lpObject, GESTUREINFOFc.ullArguments, (jlong)lpStruct->ullArguments);
2117         (*env)->SetIntField(env, lpObject, GESTUREINFOFc.cbExtraArgs, (jint)lpStruct->cbExtraArgs);
2118 }
2119 #endif
2120
2121 #ifndef NO_GRADIENT_RECT
2122 typedef struct GRADIENT_RECT_FID_CACHE {
2123         int cached;
2124         jclass clazz;
2125         jfieldID UpperLeft, LowerRight;
2126 } GRADIENT_RECT_FID_CACHE;
2127
2128 GRADIENT_RECT_FID_CACHE GRADIENT_RECTFc;
2129
2130 void cacheGRADIENT_RECTFields(JNIEnv *env, jobject lpObject)
2131 {
2132         if (GRADIENT_RECTFc.cached) return;
2133         GRADIENT_RECTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2134         GRADIENT_RECTFc.UpperLeft = (*env)->GetFieldID(env, GRADIENT_RECTFc.clazz, "UpperLeft", "I");
2135         GRADIENT_RECTFc.LowerRight = (*env)->GetFieldID(env, GRADIENT_RECTFc.clazz, "LowerRight", "I");
2136         GRADIENT_RECTFc.cached = 1;
2137 }
2138
2139 GRADIENT_RECT *getGRADIENT_RECTFields(JNIEnv *env, jobject lpObject, GRADIENT_RECT *lpStruct)
2140 {
2141         if (!GRADIENT_RECTFc.cached) cacheGRADIENT_RECTFields(env, lpObject);
2142         lpStruct->UpperLeft = (*env)->GetIntField(env, lpObject, GRADIENT_RECTFc.UpperLeft);
2143         lpStruct->LowerRight = (*env)->GetIntField(env, lpObject, GRADIENT_RECTFc.LowerRight);
2144         return lpStruct;
2145 }
2146
2147 void setGRADIENT_RECTFields(JNIEnv *env, jobject lpObject, GRADIENT_RECT *lpStruct)
2148 {
2149         if (!GRADIENT_RECTFc.cached) cacheGRADIENT_RECTFields(env, lpObject);
2150         (*env)->SetIntField(env, lpObject, GRADIENT_RECTFc.UpperLeft, (jint)lpStruct->UpperLeft);
2151         (*env)->SetIntField(env, lpObject, GRADIENT_RECTFc.LowerRight, (jint)lpStruct->LowerRight);
2152 }
2153 #endif
2154
2155 #ifndef NO_GUITHREADINFO
2156 typedef struct GUITHREADINFO_FID_CACHE {
2157         int cached;
2158         jclass clazz;
2159         jfieldID cbSize, flags, hwndActive, hwndFocus, hwndCapture, hwndMenuOwner, hwndMoveSize, hwndCaret, left, top, right, bottom;
2160 } GUITHREADINFO_FID_CACHE;
2161
2162 GUITHREADINFO_FID_CACHE GUITHREADINFOFc;
2163
2164 void cacheGUITHREADINFOFields(JNIEnv *env, jobject lpObject)
2165 {
2166         if (GUITHREADINFOFc.cached) return;
2167         GUITHREADINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2168         GUITHREADINFOFc.cbSize = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "cbSize", "I");
2169         GUITHREADINFOFc.flags = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "flags", "I");
2170         GUITHREADINFOFc.hwndActive = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndActive", "J");
2171         GUITHREADINFOFc.hwndFocus = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndFocus", "J");
2172         GUITHREADINFOFc.hwndCapture = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndCapture", "J");
2173         GUITHREADINFOFc.hwndMenuOwner = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndMenuOwner", "J");
2174         GUITHREADINFOFc.hwndMoveSize = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndMoveSize", "J");
2175         GUITHREADINFOFc.hwndCaret = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "hwndCaret", "J");
2176         GUITHREADINFOFc.left = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "left", "I");
2177         GUITHREADINFOFc.top = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "top", "I");
2178         GUITHREADINFOFc.right = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "right", "I");
2179         GUITHREADINFOFc.bottom = (*env)->GetFieldID(env, GUITHREADINFOFc.clazz, "bottom", "I");
2180         GUITHREADINFOFc.cached = 1;
2181 }
2182
2183 GUITHREADINFO *getGUITHREADINFOFields(JNIEnv *env, jobject lpObject, GUITHREADINFO *lpStruct)
2184 {
2185         if (!GUITHREADINFOFc.cached) cacheGUITHREADINFOFields(env, lpObject);
2186         lpStruct->cbSize = (DWORD)(*env)->GetIntField(env, lpObject, GUITHREADINFOFc.cbSize);
2187         lpStruct->flags = (DWORD)(*env)->GetIntField(env, lpObject, GUITHREADINFOFc.flags);
2188         lpStruct->hwndActive = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndActive);
2189         lpStruct->hwndFocus = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndFocus);
2190         lpStruct->hwndCapture = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndCapture);
2191         lpStruct->hwndMenuOwner = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndMenuOwner);
2192         lpStruct->hwndMoveSize = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndMoveSize);
2193         lpStruct->hwndCaret = (HWND)(*env)->GetLongField(env, lpObject, GUITHREADINFOFc.hwndCaret);
2194         lpStruct->rcCaret.left = (*env)->GetIntField(env, lpObject, GUITHREADINFOFc.left);
2195         lpStruct->rcCaret.top = (*env)->GetIntField(env, lpObject, GUITHREADINFOFc.top);
2196         lpStruct->rcCaret.right = (*env)->GetIntField(env, lpObject, GUITHREADINFOFc.right);
2197         lpStruct->rcCaret.bottom = (*env)->GetIntField(env, lpObject, GUITHREADINFOFc.bottom);
2198         return lpStruct;
2199 }
2200
2201 void setGUITHREADINFOFields(JNIEnv *env, jobject lpObject, GUITHREADINFO *lpStruct)
2202 {
2203         if (!GUITHREADINFOFc.cached) cacheGUITHREADINFOFields(env, lpObject);
2204         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.cbSize, (jint)lpStruct->cbSize);
2205         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.flags, (jint)lpStruct->flags);
2206         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndActive, (jlong)lpStruct->hwndActive);
2207         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndFocus, (jlong)lpStruct->hwndFocus);
2208         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndCapture, (jlong)lpStruct->hwndCapture);
2209         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndMenuOwner, (jlong)lpStruct->hwndMenuOwner);
2210         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndMoveSize, (jlong)lpStruct->hwndMoveSize);
2211         (*env)->SetLongField(env, lpObject, GUITHREADINFOFc.hwndCaret, (jlong)lpStruct->hwndCaret);
2212         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.left, (jint)lpStruct->rcCaret.left);
2213         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.top, (jint)lpStruct->rcCaret.top);
2214         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.right, (jint)lpStruct->rcCaret.right);
2215         (*env)->SetIntField(env, lpObject, GUITHREADINFOFc.bottom, (jint)lpStruct->rcCaret.bottom);
2216 }
2217 #endif
2218
2219 #ifndef NO_HDHITTESTINFO
2220 typedef struct HDHITTESTINFO_FID_CACHE {
2221         int cached;
2222         jclass clazz;
2223         jfieldID x, y, flags, iItem;
2224 } HDHITTESTINFO_FID_CACHE;
2225
2226 HDHITTESTINFO_FID_CACHE HDHITTESTINFOFc;
2227
2228 void cacheHDHITTESTINFOFields(JNIEnv *env, jobject lpObject)
2229 {
2230         if (HDHITTESTINFOFc.cached) return;
2231         HDHITTESTINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2232         HDHITTESTINFOFc.x = (*env)->GetFieldID(env, HDHITTESTINFOFc.clazz, "x", "I");
2233         HDHITTESTINFOFc.y = (*env)->GetFieldID(env, HDHITTESTINFOFc.clazz, "y", "I");
2234         HDHITTESTINFOFc.flags = (*env)->GetFieldID(env, HDHITTESTINFOFc.clazz, "flags", "I");
2235         HDHITTESTINFOFc.iItem = (*env)->GetFieldID(env, HDHITTESTINFOFc.clazz, "iItem", "I");
2236         HDHITTESTINFOFc.cached = 1;
2237 }
2238
2239 HDHITTESTINFO *getHDHITTESTINFOFields(JNIEnv *env, jobject lpObject, HDHITTESTINFO *lpStruct)
2240 {
2241         if (!HDHITTESTINFOFc.cached) cacheHDHITTESTINFOFields(env, lpObject);
2242         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, HDHITTESTINFOFc.x);
2243         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, HDHITTESTINFOFc.y);
2244         lpStruct->flags = (*env)->GetIntField(env, lpObject, HDHITTESTINFOFc.flags);
2245         lpStruct->iItem = (*env)->GetIntField(env, lpObject, HDHITTESTINFOFc.iItem);
2246         return lpStruct;
2247 }
2248
2249 void setHDHITTESTINFOFields(JNIEnv *env, jobject lpObject, HDHITTESTINFO *lpStruct)
2250 {
2251         if (!HDHITTESTINFOFc.cached) cacheHDHITTESTINFOFields(env, lpObject);
2252         (*env)->SetIntField(env, lpObject, HDHITTESTINFOFc.x, (jint)lpStruct->pt.x);
2253         (*env)->SetIntField(env, lpObject, HDHITTESTINFOFc.y, (jint)lpStruct->pt.y);
2254         (*env)->SetIntField(env, lpObject, HDHITTESTINFOFc.flags, (jint)lpStruct->flags);
2255         (*env)->SetIntField(env, lpObject, HDHITTESTINFOFc.iItem, (jint)lpStruct->iItem);
2256 }
2257 #endif
2258
2259 #ifndef NO_HDITEM
2260 typedef struct HDITEM_FID_CACHE {
2261         int cached;
2262         jclass clazz;
2263         jfieldID mask, cxy, pszText, hbm, cchTextMax, fmt, lParam, iImage, iOrder, type, pvFilter;
2264 } HDITEM_FID_CACHE;
2265
2266 HDITEM_FID_CACHE HDITEMFc;
2267
2268 void cacheHDITEMFields(JNIEnv *env, jobject lpObject)
2269 {
2270         if (HDITEMFc.cached) return;
2271         HDITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
2272         HDITEMFc.mask = (*env)->GetFieldID(env, HDITEMFc.clazz, "mask", "I");
2273         HDITEMFc.cxy = (*env)->GetFieldID(env, HDITEMFc.clazz, "cxy", "I");
2274         HDITEMFc.pszText = (*env)->GetFieldID(env, HDITEMFc.clazz, "pszText", "J");
2275         HDITEMFc.hbm = (*env)->GetFieldID(env, HDITEMFc.clazz, "hbm", "J");
2276         HDITEMFc.cchTextMax = (*env)->GetFieldID(env, HDITEMFc.clazz, "cchTextMax", "I");
2277         HDITEMFc.fmt = (*env)->GetFieldID(env, HDITEMFc.clazz, "fmt", "I");
2278         HDITEMFc.lParam = (*env)->GetFieldID(env, HDITEMFc.clazz, "lParam", "J");
2279         HDITEMFc.iImage = (*env)->GetFieldID(env, HDITEMFc.clazz, "iImage", "I");
2280         HDITEMFc.iOrder = (*env)->GetFieldID(env, HDITEMFc.clazz, "iOrder", "I");
2281         HDITEMFc.type = (*env)->GetFieldID(env, HDITEMFc.clazz, "type", "I");
2282         HDITEMFc.pvFilter = (*env)->GetFieldID(env, HDITEMFc.clazz, "pvFilter", "J");
2283         HDITEMFc.cached = 1;
2284 }
2285
2286 HDITEM *getHDITEMFields(JNIEnv *env, jobject lpObject, HDITEM *lpStruct)
2287 {
2288         if (!HDITEMFc.cached) cacheHDITEMFields(env, lpObject);
2289         lpStruct->mask = (*env)->GetIntField(env, lpObject, HDITEMFc.mask);
2290         lpStruct->cxy = (*env)->GetIntField(env, lpObject, HDITEMFc.cxy);
2291         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, HDITEMFc.pszText);
2292         lpStruct->hbm = (HBITMAP)(*env)->GetLongField(env, lpObject, HDITEMFc.hbm);
2293         lpStruct->cchTextMax = (*env)->GetIntField(env, lpObject, HDITEMFc.cchTextMax);
2294         lpStruct->fmt = (*env)->GetIntField(env, lpObject, HDITEMFc.fmt);
2295         lpStruct->lParam = (*env)->GetLongField(env, lpObject, HDITEMFc.lParam);
2296         lpStruct->iImage = (*env)->GetIntField(env, lpObject, HDITEMFc.iImage);
2297         lpStruct->iOrder = (*env)->GetIntField(env, lpObject, HDITEMFc.iOrder);
2298         lpStruct->type = (*env)->GetIntField(env, lpObject, HDITEMFc.type);
2299         lpStruct->pvFilter = (void *)(*env)->GetLongField(env, lpObject, HDITEMFc.pvFilter);
2300         return lpStruct;
2301 }
2302
2303 void setHDITEMFields(JNIEnv *env, jobject lpObject, HDITEM *lpStruct)
2304 {
2305         if (!HDITEMFc.cached) cacheHDITEMFields(env, lpObject);
2306         (*env)->SetIntField(env, lpObject, HDITEMFc.mask, (jint)lpStruct->mask);
2307         (*env)->SetIntField(env, lpObject, HDITEMFc.cxy, (jint)lpStruct->cxy);
2308         (*env)->SetLongField(env, lpObject, HDITEMFc.pszText, (jlong)lpStruct->pszText);
2309         (*env)->SetLongField(env, lpObject, HDITEMFc.hbm, (jlong)lpStruct->hbm);
2310         (*env)->SetIntField(env, lpObject, HDITEMFc.cchTextMax, (jint)lpStruct->cchTextMax);
2311         (*env)->SetIntField(env, lpObject, HDITEMFc.fmt, (jint)lpStruct->fmt);
2312         (*env)->SetLongField(env, lpObject, HDITEMFc.lParam, (jlong)lpStruct->lParam);
2313         (*env)->SetIntField(env, lpObject, HDITEMFc.iImage, (jint)lpStruct->iImage);
2314         (*env)->SetIntField(env, lpObject, HDITEMFc.iOrder, (jint)lpStruct->iOrder);
2315         (*env)->SetIntField(env, lpObject, HDITEMFc.type, (jint)lpStruct->type);
2316         (*env)->SetLongField(env, lpObject, HDITEMFc.pvFilter, (jlong)lpStruct->pvFilter);
2317 }
2318 #endif
2319
2320 #ifndef NO_HDLAYOUT
2321 typedef struct HDLAYOUT_FID_CACHE {
2322         int cached;
2323         jclass clazz;
2324         jfieldID prc, pwpos;
2325 } HDLAYOUT_FID_CACHE;
2326
2327 HDLAYOUT_FID_CACHE HDLAYOUTFc;
2328
2329 void cacheHDLAYOUTFields(JNIEnv *env, jobject lpObject)
2330 {
2331         if (HDLAYOUTFc.cached) return;
2332         HDLAYOUTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2333         HDLAYOUTFc.prc = (*env)->GetFieldID(env, HDLAYOUTFc.clazz, "prc", "J");
2334         HDLAYOUTFc.pwpos = (*env)->GetFieldID(env, HDLAYOUTFc.clazz, "pwpos", "J");
2335         HDLAYOUTFc.cached = 1;
2336 }
2337
2338 HDLAYOUT *getHDLAYOUTFields(JNIEnv *env, jobject lpObject, HDLAYOUT *lpStruct)
2339 {
2340         if (!HDLAYOUTFc.cached) cacheHDLAYOUTFields(env, lpObject);
2341         lpStruct->prc = (RECT *)(*env)->GetLongField(env, lpObject, HDLAYOUTFc.prc);
2342         lpStruct->pwpos = (WINDOWPOS *)(*env)->GetLongField(env, lpObject, HDLAYOUTFc.pwpos);
2343         return lpStruct;
2344 }
2345
2346 void setHDLAYOUTFields(JNIEnv *env, jobject lpObject, HDLAYOUT *lpStruct)
2347 {
2348         if (!HDLAYOUTFc.cached) cacheHDLAYOUTFields(env, lpObject);
2349         (*env)->SetLongField(env, lpObject, HDLAYOUTFc.prc, (jlong)lpStruct->prc);
2350         (*env)->SetLongField(env, lpObject, HDLAYOUTFc.pwpos, (jlong)lpStruct->pwpos);
2351 }
2352 #endif
2353
2354 #ifndef NO_HELPINFO
2355 typedef struct HELPINFO_FID_CACHE {
2356         int cached;
2357         jclass clazz;
2358         jfieldID cbSize, iContextType, iCtrlId, hItemHandle, dwContextId, x, y;
2359 } HELPINFO_FID_CACHE;
2360
2361 HELPINFO_FID_CACHE HELPINFOFc;
2362
2363 void cacheHELPINFOFields(JNIEnv *env, jobject lpObject)
2364 {
2365         if (HELPINFOFc.cached) return;
2366         HELPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2367         HELPINFOFc.cbSize = (*env)->GetFieldID(env, HELPINFOFc.clazz, "cbSize", "I");
2368         HELPINFOFc.iContextType = (*env)->GetFieldID(env, HELPINFOFc.clazz, "iContextType", "I");
2369         HELPINFOFc.iCtrlId = (*env)->GetFieldID(env, HELPINFOFc.clazz, "iCtrlId", "I");
2370         HELPINFOFc.hItemHandle = (*env)->GetFieldID(env, HELPINFOFc.clazz, "hItemHandle", "J");
2371         HELPINFOFc.dwContextId = (*env)->GetFieldID(env, HELPINFOFc.clazz, "dwContextId", "I");
2372         HELPINFOFc.x = (*env)->GetFieldID(env, HELPINFOFc.clazz, "x", "I");
2373         HELPINFOFc.y = (*env)->GetFieldID(env, HELPINFOFc.clazz, "y", "I");
2374         HELPINFOFc.cached = 1;
2375 }
2376
2377 HELPINFO *getHELPINFOFields(JNIEnv *env, jobject lpObject, HELPINFO *lpStruct)
2378 {
2379         if (!HELPINFOFc.cached) cacheHELPINFOFields(env, lpObject);
2380         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, HELPINFOFc.cbSize);
2381         lpStruct->iContextType = (*env)->GetIntField(env, lpObject, HELPINFOFc.iContextType);
2382         lpStruct->iCtrlId = (*env)->GetIntField(env, lpObject, HELPINFOFc.iCtrlId);
2383         lpStruct->hItemHandle = (HANDLE)(*env)->GetLongField(env, lpObject, HELPINFOFc.hItemHandle);
2384         lpStruct->dwContextId = (*env)->GetIntField(env, lpObject, HELPINFOFc.dwContextId);
2385         lpStruct->MousePos.x = (*env)->GetIntField(env, lpObject, HELPINFOFc.x);
2386         lpStruct->MousePos.y = (*env)->GetIntField(env, lpObject, HELPINFOFc.y);
2387         return lpStruct;
2388 }
2389
2390 void setHELPINFOFields(JNIEnv *env, jobject lpObject, HELPINFO *lpStruct)
2391 {
2392         if (!HELPINFOFc.cached) cacheHELPINFOFields(env, lpObject);
2393         (*env)->SetIntField(env, lpObject, HELPINFOFc.cbSize, (jint)lpStruct->cbSize);
2394         (*env)->SetIntField(env, lpObject, HELPINFOFc.iContextType, (jint)lpStruct->iContextType);
2395         (*env)->SetIntField(env, lpObject, HELPINFOFc.iCtrlId, (jint)lpStruct->iCtrlId);
2396         (*env)->SetLongField(env, lpObject, HELPINFOFc.hItemHandle, (jlong)lpStruct->hItemHandle);
2397         (*env)->SetIntField(env, lpObject, HELPINFOFc.dwContextId, (jint)lpStruct->dwContextId);
2398         (*env)->SetIntField(env, lpObject, HELPINFOFc.x, (jint)lpStruct->MousePos.x);
2399         (*env)->SetIntField(env, lpObject, HELPINFOFc.y, (jint)lpStruct->MousePos.y);
2400 }
2401 #endif
2402
2403 #ifndef NO_HIGHCONTRAST
2404 typedef struct HIGHCONTRAST_FID_CACHE {
2405         int cached;
2406         jclass clazz;
2407         jfieldID cbSize, dwFlags, lpszDefaultScheme;
2408 } HIGHCONTRAST_FID_CACHE;
2409
2410 HIGHCONTRAST_FID_CACHE HIGHCONTRASTFc;
2411
2412 void cacheHIGHCONTRASTFields(JNIEnv *env, jobject lpObject)
2413 {
2414         if (HIGHCONTRASTFc.cached) return;
2415         HIGHCONTRASTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2416         HIGHCONTRASTFc.cbSize = (*env)->GetFieldID(env, HIGHCONTRASTFc.clazz, "cbSize", "I");
2417         HIGHCONTRASTFc.dwFlags = (*env)->GetFieldID(env, HIGHCONTRASTFc.clazz, "dwFlags", "I");
2418         HIGHCONTRASTFc.lpszDefaultScheme = (*env)->GetFieldID(env, HIGHCONTRASTFc.clazz, "lpszDefaultScheme", "J");
2419         HIGHCONTRASTFc.cached = 1;
2420 }
2421
2422 HIGHCONTRAST *getHIGHCONTRASTFields(JNIEnv *env, jobject lpObject, HIGHCONTRAST *lpStruct)
2423 {
2424         if (!HIGHCONTRASTFc.cached) cacheHIGHCONTRASTFields(env, lpObject);
2425         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, HIGHCONTRASTFc.cbSize);
2426         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, HIGHCONTRASTFc.dwFlags);
2427         lpStruct->lpszDefaultScheme = (LPTSTR)(*env)->GetLongField(env, lpObject, HIGHCONTRASTFc.lpszDefaultScheme);
2428         return lpStruct;
2429 }
2430
2431 void setHIGHCONTRASTFields(JNIEnv *env, jobject lpObject, HIGHCONTRAST *lpStruct)
2432 {
2433         if (!HIGHCONTRASTFc.cached) cacheHIGHCONTRASTFields(env, lpObject);
2434         (*env)->SetIntField(env, lpObject, HIGHCONTRASTFc.cbSize, (jint)lpStruct->cbSize);
2435         (*env)->SetIntField(env, lpObject, HIGHCONTRASTFc.dwFlags, (jint)lpStruct->dwFlags);
2436         (*env)->SetLongField(env, lpObject, HIGHCONTRASTFc.lpszDefaultScheme, (jlong)lpStruct->lpszDefaultScheme);
2437 }
2438 #endif
2439
2440 #ifndef NO_ICONINFO
2441 typedef struct ICONINFO_FID_CACHE {
2442         int cached;
2443         jclass clazz;
2444         jfieldID fIcon, xHotspot, yHotspot, hbmMask, hbmColor;
2445 } ICONINFO_FID_CACHE;
2446
2447 ICONINFO_FID_CACHE ICONINFOFc;
2448
2449 void cacheICONINFOFields(JNIEnv *env, jobject lpObject)
2450 {
2451         if (ICONINFOFc.cached) return;
2452         ICONINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2453         ICONINFOFc.fIcon = (*env)->GetFieldID(env, ICONINFOFc.clazz, "fIcon", "Z");
2454         ICONINFOFc.xHotspot = (*env)->GetFieldID(env, ICONINFOFc.clazz, "xHotspot", "I");
2455         ICONINFOFc.yHotspot = (*env)->GetFieldID(env, ICONINFOFc.clazz, "yHotspot", "I");
2456         ICONINFOFc.hbmMask = (*env)->GetFieldID(env, ICONINFOFc.clazz, "hbmMask", "J");
2457         ICONINFOFc.hbmColor = (*env)->GetFieldID(env, ICONINFOFc.clazz, "hbmColor", "J");
2458         ICONINFOFc.cached = 1;
2459 }
2460
2461 ICONINFO *getICONINFOFields(JNIEnv *env, jobject lpObject, ICONINFO *lpStruct)
2462 {
2463         if (!ICONINFOFc.cached) cacheICONINFOFields(env, lpObject);
2464         lpStruct->fIcon = (*env)->GetBooleanField(env, lpObject, ICONINFOFc.fIcon);
2465         lpStruct->xHotspot = (*env)->GetIntField(env, lpObject, ICONINFOFc.xHotspot);
2466         lpStruct->yHotspot = (*env)->GetIntField(env, lpObject, ICONINFOFc.yHotspot);
2467         lpStruct->hbmMask = (HBITMAP)(*env)->GetLongField(env, lpObject, ICONINFOFc.hbmMask);
2468         lpStruct->hbmColor = (HBITMAP)(*env)->GetLongField(env, lpObject, ICONINFOFc.hbmColor);
2469         return lpStruct;
2470 }
2471
2472 void setICONINFOFields(JNIEnv *env, jobject lpObject, ICONINFO *lpStruct)
2473 {
2474         if (!ICONINFOFc.cached) cacheICONINFOFields(env, lpObject);
2475         (*env)->SetBooleanField(env, lpObject, ICONINFOFc.fIcon, (jboolean)lpStruct->fIcon);
2476         (*env)->SetIntField(env, lpObject, ICONINFOFc.xHotspot, (jint)lpStruct->xHotspot);
2477         (*env)->SetIntField(env, lpObject, ICONINFOFc.yHotspot, (jint)lpStruct->yHotspot);
2478         (*env)->SetLongField(env, lpObject, ICONINFOFc.hbmMask, (jlong)lpStruct->hbmMask);
2479         (*env)->SetLongField(env, lpObject, ICONINFOFc.hbmColor, (jlong)lpStruct->hbmColor);
2480 }
2481 #endif
2482
2483 #ifndef NO_INITCOMMONCONTROLSEX
2484 typedef struct INITCOMMONCONTROLSEX_FID_CACHE {
2485         int cached;
2486         jclass clazz;
2487         jfieldID dwSize, dwICC;
2488 } INITCOMMONCONTROLSEX_FID_CACHE;
2489
2490 INITCOMMONCONTROLSEX_FID_CACHE INITCOMMONCONTROLSEXFc;
2491
2492 void cacheINITCOMMONCONTROLSEXFields(JNIEnv *env, jobject lpObject)
2493 {
2494         if (INITCOMMONCONTROLSEXFc.cached) return;
2495         INITCOMMONCONTROLSEXFc.clazz = (*env)->GetObjectClass(env, lpObject);
2496         INITCOMMONCONTROLSEXFc.dwSize = (*env)->GetFieldID(env, INITCOMMONCONTROLSEXFc.clazz, "dwSize", "I");
2497         INITCOMMONCONTROLSEXFc.dwICC = (*env)->GetFieldID(env, INITCOMMONCONTROLSEXFc.clazz, "dwICC", "I");
2498         INITCOMMONCONTROLSEXFc.cached = 1;
2499 }
2500
2501 INITCOMMONCONTROLSEX *getINITCOMMONCONTROLSEXFields(JNIEnv *env, jobject lpObject, INITCOMMONCONTROLSEX *lpStruct)
2502 {
2503         if (!INITCOMMONCONTROLSEXFc.cached) cacheINITCOMMONCONTROLSEXFields(env, lpObject);
2504         lpStruct->dwSize = (*env)->GetIntField(env, lpObject, INITCOMMONCONTROLSEXFc.dwSize);
2505         lpStruct->dwICC = (*env)->GetIntField(env, lpObject, INITCOMMONCONTROLSEXFc.dwICC);
2506         return lpStruct;
2507 }
2508
2509 void setINITCOMMONCONTROLSEXFields(JNIEnv *env, jobject lpObject, INITCOMMONCONTROLSEX *lpStruct)
2510 {
2511         if (!INITCOMMONCONTROLSEXFc.cached) cacheINITCOMMONCONTROLSEXFields(env, lpObject);
2512         (*env)->SetIntField(env, lpObject, INITCOMMONCONTROLSEXFc.dwSize, (jint)lpStruct->dwSize);
2513         (*env)->SetIntField(env, lpObject, INITCOMMONCONTROLSEXFc.dwICC, (jint)lpStruct->dwICC);
2514 }
2515 #endif
2516
2517 #ifndef NO_INPUT
2518 typedef struct INPUT_FID_CACHE {
2519         int cached;
2520         jclass clazz;
2521         jfieldID type;
2522 } INPUT_FID_CACHE;
2523
2524 INPUT_FID_CACHE INPUTFc;
2525
2526 void cacheINPUTFields(JNIEnv *env, jobject lpObject)
2527 {
2528         if (INPUTFc.cached) return;
2529         INPUTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2530         INPUTFc.type = (*env)->GetFieldID(env, INPUTFc.clazz, "type", "I");
2531         INPUTFc.cached = 1;
2532 }
2533
2534 INPUT *getINPUTFields(JNIEnv *env, jobject lpObject, INPUT *lpStruct)
2535 {
2536         if (!INPUTFc.cached) cacheINPUTFields(env, lpObject);
2537         lpStruct->type = (*env)->GetIntField(env, lpObject, INPUTFc.type);
2538         return lpStruct;
2539 }
2540
2541 void setINPUTFields(JNIEnv *env, jobject lpObject, INPUT *lpStruct)
2542 {
2543         if (!INPUTFc.cached) cacheINPUTFields(env, lpObject);
2544         (*env)->SetIntField(env, lpObject, INPUTFc.type, (jint)lpStruct->type);
2545 }
2546 #endif
2547
2548 #ifndef NO_KEYBDINPUT
2549 typedef struct KEYBDINPUT_FID_CACHE {
2550         int cached;
2551         jclass clazz;
2552         jfieldID wVk, wScan, dwFlags, time, dwExtraInfo;
2553 } KEYBDINPUT_FID_CACHE;
2554
2555 KEYBDINPUT_FID_CACHE KEYBDINPUTFc;
2556
2557 void cacheKEYBDINPUTFields(JNIEnv *env, jobject lpObject)
2558 {
2559         if (KEYBDINPUTFc.cached) return;
2560         KEYBDINPUTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2561         KEYBDINPUTFc.wVk = (*env)->GetFieldID(env, KEYBDINPUTFc.clazz, "wVk", "S");
2562         KEYBDINPUTFc.wScan = (*env)->GetFieldID(env, KEYBDINPUTFc.clazz, "wScan", "S");
2563         KEYBDINPUTFc.dwFlags = (*env)->GetFieldID(env, KEYBDINPUTFc.clazz, "dwFlags", "I");
2564         KEYBDINPUTFc.time = (*env)->GetFieldID(env, KEYBDINPUTFc.clazz, "time", "I");
2565         KEYBDINPUTFc.dwExtraInfo = (*env)->GetFieldID(env, KEYBDINPUTFc.clazz, "dwExtraInfo", "J");
2566         KEYBDINPUTFc.cached = 1;
2567 }
2568
2569 KEYBDINPUT *getKEYBDINPUTFields(JNIEnv *env, jobject lpObject, KEYBDINPUT *lpStruct)
2570 {
2571         if (!KEYBDINPUTFc.cached) cacheKEYBDINPUTFields(env, lpObject);
2572         lpStruct->wVk = (*env)->GetShortField(env, lpObject, KEYBDINPUTFc.wVk);
2573         lpStruct->wScan = (*env)->GetShortField(env, lpObject, KEYBDINPUTFc.wScan);
2574         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, KEYBDINPUTFc.dwFlags);
2575         lpStruct->time = (*env)->GetIntField(env, lpObject, KEYBDINPUTFc.time);
2576         lpStruct->dwExtraInfo = (*env)->GetLongField(env, lpObject, KEYBDINPUTFc.dwExtraInfo);
2577         return lpStruct;
2578 }
2579
2580 void setKEYBDINPUTFields(JNIEnv *env, jobject lpObject, KEYBDINPUT *lpStruct)
2581 {
2582         if (!KEYBDINPUTFc.cached) cacheKEYBDINPUTFields(env, lpObject);
2583         (*env)->SetShortField(env, lpObject, KEYBDINPUTFc.wVk, (jshort)lpStruct->wVk);
2584         (*env)->SetShortField(env, lpObject, KEYBDINPUTFc.wScan, (jshort)lpStruct->wScan);
2585         (*env)->SetIntField(env, lpObject, KEYBDINPUTFc.dwFlags, (jint)lpStruct->dwFlags);
2586         (*env)->SetIntField(env, lpObject, KEYBDINPUTFc.time, (jint)lpStruct->time);
2587         (*env)->SetLongField(env, lpObject, KEYBDINPUTFc.dwExtraInfo, (jlong)lpStruct->dwExtraInfo);
2588 }
2589 #endif
2590
2591 #ifndef NO_LITEM
2592 typedef struct LITEM_FID_CACHE {
2593         int cached;
2594         jclass clazz;
2595         jfieldID mask, iLink, state, stateMask, szID, szUrl;
2596 } LITEM_FID_CACHE;
2597
2598 LITEM_FID_CACHE LITEMFc;
2599
2600 void cacheLITEMFields(JNIEnv *env, jobject lpObject)
2601 {
2602         if (LITEMFc.cached) return;
2603         LITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
2604         LITEMFc.mask = (*env)->GetFieldID(env, LITEMFc.clazz, "mask", "I");
2605         LITEMFc.iLink = (*env)->GetFieldID(env, LITEMFc.clazz, "iLink", "I");
2606         LITEMFc.state = (*env)->GetFieldID(env, LITEMFc.clazz, "state", "I");
2607         LITEMFc.stateMask = (*env)->GetFieldID(env, LITEMFc.clazz, "stateMask", "I");
2608         LITEMFc.szID = (*env)->GetFieldID(env, LITEMFc.clazz, "szID", "[C");
2609         LITEMFc.szUrl = (*env)->GetFieldID(env, LITEMFc.clazz, "szUrl", "[C");
2610         LITEMFc.cached = 1;
2611 }
2612
2613 LITEM *getLITEMFields(JNIEnv *env, jobject lpObject, LITEM *lpStruct)
2614 {
2615         if (!LITEMFc.cached) cacheLITEMFields(env, lpObject);
2616         lpStruct->mask = (*env)->GetIntField(env, lpObject, LITEMFc.mask);
2617         lpStruct->iLink = (*env)->GetIntField(env, lpObject, LITEMFc.iLink);
2618         lpStruct->state = (*env)->GetIntField(env, lpObject, LITEMFc.state);
2619         lpStruct->stateMask = (*env)->GetIntField(env, lpObject, LITEMFc.stateMask);
2620         {
2621         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LITEMFc.szID);
2622         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szID) / sizeof(jchar), (jchar *)lpStruct->szID);
2623         }
2624         {
2625         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LITEMFc.szUrl);
2626         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szUrl) / sizeof(jchar), (jchar *)lpStruct->szUrl);
2627         }
2628         return lpStruct;
2629 }
2630
2631 void setLITEMFields(JNIEnv *env, jobject lpObject, LITEM *lpStruct)
2632 {
2633         if (!LITEMFc.cached) cacheLITEMFields(env, lpObject);
2634         (*env)->SetIntField(env, lpObject, LITEMFc.mask, (jint)lpStruct->mask);
2635         (*env)->SetIntField(env, lpObject, LITEMFc.iLink, (jint)lpStruct->iLink);
2636         (*env)->SetIntField(env, lpObject, LITEMFc.state, (jint)lpStruct->state);
2637         (*env)->SetIntField(env, lpObject, LITEMFc.stateMask, (jint)lpStruct->stateMask);
2638         {
2639         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LITEMFc.szID);
2640         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szID) / sizeof(jchar), (jchar *)lpStruct->szID);
2641         }
2642         {
2643         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LITEMFc.szUrl);
2644         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szUrl) / sizeof(jchar), (jchar *)lpStruct->szUrl);
2645         }
2646 }
2647 #endif
2648
2649 #ifndef NO_LOGBRUSH
2650 typedef struct LOGBRUSH_FID_CACHE {
2651         int cached;
2652         jclass clazz;
2653         jfieldID lbStyle, lbColor, lbHatch;
2654 } LOGBRUSH_FID_CACHE;
2655
2656 LOGBRUSH_FID_CACHE LOGBRUSHFc;
2657
2658 void cacheLOGBRUSHFields(JNIEnv *env, jobject lpObject)
2659 {
2660         if (LOGBRUSHFc.cached) return;
2661         LOGBRUSHFc.clazz = (*env)->GetObjectClass(env, lpObject);
2662         LOGBRUSHFc.lbStyle = (*env)->GetFieldID(env, LOGBRUSHFc.clazz, "lbStyle", "I");
2663         LOGBRUSHFc.lbColor = (*env)->GetFieldID(env, LOGBRUSHFc.clazz, "lbColor", "I");
2664         LOGBRUSHFc.lbHatch = (*env)->GetFieldID(env, LOGBRUSHFc.clazz, "lbHatch", "J");
2665         LOGBRUSHFc.cached = 1;
2666 }
2667
2668 LOGBRUSH *getLOGBRUSHFields(JNIEnv *env, jobject lpObject, LOGBRUSH *lpStruct)
2669 {
2670         if (!LOGBRUSHFc.cached) cacheLOGBRUSHFields(env, lpObject);
2671         lpStruct->lbStyle = (*env)->GetIntField(env, lpObject, LOGBRUSHFc.lbStyle);
2672         lpStruct->lbColor = (*env)->GetIntField(env, lpObject, LOGBRUSHFc.lbColor);
2673         lpStruct->lbHatch = (*env)->GetLongField(env, lpObject, LOGBRUSHFc.lbHatch);
2674         return lpStruct;
2675 }
2676
2677 void setLOGBRUSHFields(JNIEnv *env, jobject lpObject, LOGBRUSH *lpStruct)
2678 {
2679         if (!LOGBRUSHFc.cached) cacheLOGBRUSHFields(env, lpObject);
2680         (*env)->SetIntField(env, lpObject, LOGBRUSHFc.lbStyle, (jint)lpStruct->lbStyle);
2681         (*env)->SetIntField(env, lpObject, LOGBRUSHFc.lbColor, (jint)lpStruct->lbColor);
2682         (*env)->SetLongField(env, lpObject, LOGBRUSHFc.lbHatch, (jlong)lpStruct->lbHatch);
2683 }
2684 #endif
2685
2686 #ifndef NO_LOGFONT
2687 typedef struct LOGFONT_FID_CACHE {
2688         int cached;
2689         jclass clazz;
2690         jfieldID lfHeight, lfWidth, lfEscapement, lfOrientation, lfWeight, lfItalic, lfUnderline, lfStrikeOut, lfCharSet, lfOutPrecision, lfClipPrecision, lfQuality, lfPitchAndFamily, lfFaceName;
2691 } LOGFONT_FID_CACHE;
2692
2693 LOGFONT_FID_CACHE LOGFONTFc;
2694
2695 void cacheLOGFONTFields(JNIEnv *env, jobject lpObject)
2696 {
2697         if (LOGFONTFc.cached) return;
2698         LOGFONTFc.clazz = (*env)->GetObjectClass(env, lpObject);
2699         LOGFONTFc.lfHeight = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfHeight", "I");
2700         LOGFONTFc.lfWidth = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfWidth", "I");
2701         LOGFONTFc.lfEscapement = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfEscapement", "I");
2702         LOGFONTFc.lfOrientation = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfOrientation", "I");
2703         LOGFONTFc.lfWeight = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfWeight", "I");
2704         LOGFONTFc.lfItalic = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfItalic", "B");
2705         LOGFONTFc.lfUnderline = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfUnderline", "B");
2706         LOGFONTFc.lfStrikeOut = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfStrikeOut", "B");
2707         LOGFONTFc.lfCharSet = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfCharSet", "B");
2708         LOGFONTFc.lfOutPrecision = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfOutPrecision", "B");
2709         LOGFONTFc.lfClipPrecision = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfClipPrecision", "B");
2710         LOGFONTFc.lfQuality = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfQuality", "B");
2711         LOGFONTFc.lfPitchAndFamily = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfPitchAndFamily", "B");
2712         LOGFONTFc.lfFaceName = (*env)->GetFieldID(env, LOGFONTFc.clazz, "lfFaceName", "[C");
2713         LOGFONTFc.cached = 1;
2714 }
2715
2716 LOGFONT *getLOGFONTFields(JNIEnv *env, jobject lpObject, LOGFONT *lpStruct)
2717 {
2718         if (!LOGFONTFc.cached) cacheLOGFONTFields(env, lpObject);
2719         lpStruct->lfHeight = (*env)->GetIntField(env, lpObject, LOGFONTFc.lfHeight);
2720         lpStruct->lfWidth = (*env)->GetIntField(env, lpObject, LOGFONTFc.lfWidth);
2721         lpStruct->lfEscapement = (*env)->GetIntField(env, lpObject, LOGFONTFc.lfEscapement);
2722         lpStruct->lfOrientation = (*env)->GetIntField(env, lpObject, LOGFONTFc.lfOrientation);
2723         lpStruct->lfWeight = (*env)->GetIntField(env, lpObject, LOGFONTFc.lfWeight);
2724         lpStruct->lfItalic = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfItalic);
2725         lpStruct->lfUnderline = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfUnderline);
2726         lpStruct->lfStrikeOut = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfStrikeOut);
2727         lpStruct->lfCharSet = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfCharSet);
2728         lpStruct->lfOutPrecision = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfOutPrecision);
2729         lpStruct->lfClipPrecision = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfClipPrecision);
2730         lpStruct->lfQuality = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfQuality);
2731         lpStruct->lfPitchAndFamily = (*env)->GetByteField(env, lpObject, LOGFONTFc.lfPitchAndFamily);
2732         {
2733         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LOGFONTFc.lfFaceName);
2734         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->lfFaceName) / sizeof(jchar), (jchar *)lpStruct->lfFaceName);
2735         }
2736         return lpStruct;
2737 }
2738
2739 void setLOGFONTFields(JNIEnv *env, jobject lpObject, LOGFONT *lpStruct)
2740 {
2741         if (!LOGFONTFc.cached) cacheLOGFONTFields(env, lpObject);
2742         (*env)->SetIntField(env, lpObject, LOGFONTFc.lfHeight, (jint)lpStruct->lfHeight);
2743         (*env)->SetIntField(env, lpObject, LOGFONTFc.lfWidth, (jint)lpStruct->lfWidth);
2744         (*env)->SetIntField(env, lpObject, LOGFONTFc.lfEscapement, (jint)lpStruct->lfEscapement);
2745         (*env)->SetIntField(env, lpObject, LOGFONTFc.lfOrientation, (jint)lpStruct->lfOrientation);
2746         (*env)->SetIntField(env, lpObject, LOGFONTFc.lfWeight, (jint)lpStruct->lfWeight);
2747         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfItalic, (jbyte)lpStruct->lfItalic);
2748         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfUnderline, (jbyte)lpStruct->lfUnderline);
2749         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfStrikeOut, (jbyte)lpStruct->lfStrikeOut);
2750         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfCharSet, (jbyte)lpStruct->lfCharSet);
2751         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfOutPrecision, (jbyte)lpStruct->lfOutPrecision);
2752         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfClipPrecision, (jbyte)lpStruct->lfClipPrecision);
2753         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfQuality, (jbyte)lpStruct->lfQuality);
2754         (*env)->SetByteField(env, lpObject, LOGFONTFc.lfPitchAndFamily, (jbyte)lpStruct->lfPitchAndFamily);
2755         {
2756         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, LOGFONTFc.lfFaceName);
2757         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->lfFaceName) / sizeof(jchar), (jchar *)lpStruct->lfFaceName);
2758         }
2759 }
2760 #endif
2761
2762 #ifndef NO_LOGPEN
2763 typedef struct LOGPEN_FID_CACHE {
2764         int cached;
2765         jclass clazz;
2766         jfieldID lopnStyle, x, y, lopnColor;
2767 } LOGPEN_FID_CACHE;
2768
2769 LOGPEN_FID_CACHE LOGPENFc;
2770
2771 void cacheLOGPENFields(JNIEnv *env, jobject lpObject)
2772 {
2773         if (LOGPENFc.cached) return;
2774         LOGPENFc.clazz = (*env)->GetObjectClass(env, lpObject);
2775         LOGPENFc.lopnStyle = (*env)->GetFieldID(env, LOGPENFc.clazz, "lopnStyle", "I");
2776         LOGPENFc.x = (*env)->GetFieldID(env, LOGPENFc.clazz, "x", "I");
2777         LOGPENFc.y = (*env)->GetFieldID(env, LOGPENFc.clazz, "y", "I");
2778         LOGPENFc.lopnColor = (*env)->GetFieldID(env, LOGPENFc.clazz, "lopnColor", "I");
2779         LOGPENFc.cached = 1;
2780 }
2781
2782 LOGPEN *getLOGPENFields(JNIEnv *env, jobject lpObject, LOGPEN *lpStruct)
2783 {
2784         if (!LOGPENFc.cached) cacheLOGPENFields(env, lpObject);
2785         lpStruct->lopnStyle = (*env)->GetIntField(env, lpObject, LOGPENFc.lopnStyle);
2786         lpStruct->lopnWidth.x = (*env)->GetIntField(env, lpObject, LOGPENFc.x);
2787         lpStruct->lopnWidth.y = (*env)->GetIntField(env, lpObject, LOGPENFc.y);
2788         lpStruct->lopnColor = (*env)->GetIntField(env, lpObject, LOGPENFc.lopnColor);
2789         return lpStruct;
2790 }
2791
2792 void setLOGPENFields(JNIEnv *env, jobject lpObject, LOGPEN *lpStruct)
2793 {
2794         if (!LOGPENFc.cached) cacheLOGPENFields(env, lpObject);
2795         (*env)->SetIntField(env, lpObject, LOGPENFc.lopnStyle, (jint)lpStruct->lopnStyle);
2796         (*env)->SetIntField(env, lpObject, LOGPENFc.x, (jint)lpStruct->lopnWidth.x);
2797         (*env)->SetIntField(env, lpObject, LOGPENFc.y, (jint)lpStruct->lopnWidth.y);
2798         (*env)->SetIntField(env, lpObject, LOGPENFc.lopnColor, (jint)lpStruct->lopnColor);
2799 }
2800 #endif
2801
2802 #ifndef NO_LVCOLUMN
2803 typedef struct LVCOLUMN_FID_CACHE {
2804         int cached;
2805         jclass clazz;
2806         jfieldID mask, fmt, cx, pszText, cchTextMax, iSubItem, iImage, iOrder;
2807 } LVCOLUMN_FID_CACHE;
2808
2809 LVCOLUMN_FID_CACHE LVCOLUMNFc;
2810
2811 void cacheLVCOLUMNFields(JNIEnv *env, jobject lpObject)
2812 {
2813         if (LVCOLUMNFc.cached) return;
2814         LVCOLUMNFc.clazz = (*env)->GetObjectClass(env, lpObject);
2815         LVCOLUMNFc.mask = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "mask", "I");
2816         LVCOLUMNFc.fmt = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "fmt", "I");
2817         LVCOLUMNFc.cx = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "cx", "I");
2818         LVCOLUMNFc.pszText = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "pszText", "J");
2819         LVCOLUMNFc.cchTextMax = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "cchTextMax", "I");
2820         LVCOLUMNFc.iSubItem = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "iSubItem", "I");
2821         LVCOLUMNFc.iImage = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "iImage", "I");
2822         LVCOLUMNFc.iOrder = (*env)->GetFieldID(env, LVCOLUMNFc.clazz, "iOrder", "I");
2823         LVCOLUMNFc.cached = 1;
2824 }
2825
2826 LVCOLUMN *getLVCOLUMNFields(JNIEnv *env, jobject lpObject, LVCOLUMN *lpStruct)
2827 {
2828         if (!LVCOLUMNFc.cached) cacheLVCOLUMNFields(env, lpObject);
2829         lpStruct->mask = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.mask);
2830         lpStruct->fmt = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.fmt);
2831         lpStruct->cx = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.cx);
2832         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, LVCOLUMNFc.pszText);
2833         lpStruct->cchTextMax = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.cchTextMax);
2834         lpStruct->iSubItem = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.iSubItem);
2835         lpStruct->iImage = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.iImage);
2836         lpStruct->iOrder = (*env)->GetIntField(env, lpObject, LVCOLUMNFc.iOrder);
2837         return lpStruct;
2838 }
2839
2840 void setLVCOLUMNFields(JNIEnv *env, jobject lpObject, LVCOLUMN *lpStruct)
2841 {
2842         if (!LVCOLUMNFc.cached) cacheLVCOLUMNFields(env, lpObject);
2843         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.mask, (jint)lpStruct->mask);
2844         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.fmt, (jint)lpStruct->fmt);
2845         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.cx, (jint)lpStruct->cx);
2846         (*env)->SetLongField(env, lpObject, LVCOLUMNFc.pszText, (jlong)lpStruct->pszText);
2847         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.cchTextMax, (jint)lpStruct->cchTextMax);
2848         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.iSubItem, (jint)lpStruct->iSubItem);
2849         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.iImage, (jint)lpStruct->iImage);
2850         (*env)->SetIntField(env, lpObject, LVCOLUMNFc.iOrder, (jint)lpStruct->iOrder);
2851 }
2852 #endif
2853
2854 #ifndef NO_LVHITTESTINFO
2855 typedef struct LVHITTESTINFO_FID_CACHE {
2856         int cached;
2857         jclass clazz;
2858         jfieldID x, y, flags, iItem, iSubItem;
2859 } LVHITTESTINFO_FID_CACHE;
2860
2861 LVHITTESTINFO_FID_CACHE LVHITTESTINFOFc;
2862
2863 void cacheLVHITTESTINFOFields(JNIEnv *env, jobject lpObject)
2864 {
2865         if (LVHITTESTINFOFc.cached) return;
2866         LVHITTESTINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
2867         LVHITTESTINFOFc.x = (*env)->GetFieldID(env, LVHITTESTINFOFc.clazz, "x", "I");
2868         LVHITTESTINFOFc.y = (*env)->GetFieldID(env, LVHITTESTINFOFc.clazz, "y", "I");
2869         LVHITTESTINFOFc.flags = (*env)->GetFieldID(env, LVHITTESTINFOFc.clazz, "flags", "I");
2870         LVHITTESTINFOFc.iItem = (*env)->GetFieldID(env, LVHITTESTINFOFc.clazz, "iItem", "I");
2871         LVHITTESTINFOFc.iSubItem = (*env)->GetFieldID(env, LVHITTESTINFOFc.clazz, "iSubItem", "I");
2872         LVHITTESTINFOFc.cached = 1;
2873 }
2874
2875 LVHITTESTINFO *getLVHITTESTINFOFields(JNIEnv *env, jobject lpObject, LVHITTESTINFO *lpStruct)
2876 {
2877         if (!LVHITTESTINFOFc.cached) cacheLVHITTESTINFOFields(env, lpObject);
2878         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, LVHITTESTINFOFc.x);
2879         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, LVHITTESTINFOFc.y);
2880         lpStruct->flags = (*env)->GetIntField(env, lpObject, LVHITTESTINFOFc.flags);
2881         lpStruct->iItem = (*env)->GetIntField(env, lpObject, LVHITTESTINFOFc.iItem);
2882         lpStruct->iSubItem = (*env)->GetIntField(env, lpObject, LVHITTESTINFOFc.iSubItem);
2883         return lpStruct;
2884 }
2885
2886 void setLVHITTESTINFOFields(JNIEnv *env, jobject lpObject, LVHITTESTINFO *lpStruct)
2887 {
2888         if (!LVHITTESTINFOFc.cached) cacheLVHITTESTINFOFields(env, lpObject);
2889         (*env)->SetIntField(env, lpObject, LVHITTESTINFOFc.x, (jint)lpStruct->pt.x);
2890         (*env)->SetIntField(env, lpObject, LVHITTESTINFOFc.y, (jint)lpStruct->pt.y);
2891         (*env)->SetIntField(env, lpObject, LVHITTESTINFOFc.flags, (jint)lpStruct->flags);
2892         (*env)->SetIntField(env, lpObject, LVHITTESTINFOFc.iItem, (jint)lpStruct->iItem);
2893         (*env)->SetIntField(env, lpObject, LVHITTESTINFOFc.iSubItem, (jint)lpStruct->iSubItem);
2894 }
2895 #endif
2896
2897 #ifndef NO_LVINSERTMARK
2898 typedef struct LVINSERTMARK_FID_CACHE {
2899         int cached;
2900         jclass clazz;
2901         jfieldID cbSize, dwFlags, iItem, dwReserved;
2902 } LVINSERTMARK_FID_CACHE;
2903
2904 LVINSERTMARK_FID_CACHE LVINSERTMARKFc;
2905
2906 void cacheLVINSERTMARKFields(JNIEnv *env, jobject lpObject)
2907 {
2908         if (LVINSERTMARKFc.cached) return;
2909         LVINSERTMARKFc.clazz = (*env)->GetObjectClass(env, lpObject);
2910         LVINSERTMARKFc.cbSize = (*env)->GetFieldID(env, LVINSERTMARKFc.clazz, "cbSize", "I");
2911         LVINSERTMARKFc.dwFlags = (*env)->GetFieldID(env, LVINSERTMARKFc.clazz, "dwFlags", "I");
2912         LVINSERTMARKFc.iItem = (*env)->GetFieldID(env, LVINSERTMARKFc.clazz, "iItem", "I");
2913         LVINSERTMARKFc.dwReserved = (*env)->GetFieldID(env, LVINSERTMARKFc.clazz, "dwReserved", "I");
2914         LVINSERTMARKFc.cached = 1;
2915 }
2916
2917 LVINSERTMARK *getLVINSERTMARKFields(JNIEnv *env, jobject lpObject, LVINSERTMARK *lpStruct)
2918 {
2919         if (!LVINSERTMARKFc.cached) cacheLVINSERTMARKFields(env, lpObject);
2920         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, LVINSERTMARKFc.cbSize);
2921         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, LVINSERTMARKFc.dwFlags);
2922         lpStruct->iItem = (*env)->GetIntField(env, lpObject, LVINSERTMARKFc.iItem);
2923         lpStruct->dwReserved = (*env)->GetIntField(env, lpObject, LVINSERTMARKFc.dwReserved);
2924         return lpStruct;
2925 }
2926
2927 void setLVINSERTMARKFields(JNIEnv *env, jobject lpObject, LVINSERTMARK *lpStruct)
2928 {
2929         if (!LVINSERTMARKFc.cached) cacheLVINSERTMARKFields(env, lpObject);
2930         (*env)->SetIntField(env, lpObject, LVINSERTMARKFc.cbSize, (jint)lpStruct->cbSize);
2931         (*env)->SetIntField(env, lpObject, LVINSERTMARKFc.dwFlags, (jint)lpStruct->dwFlags);
2932         (*env)->SetIntField(env, lpObject, LVINSERTMARKFc.iItem, (jint)lpStruct->iItem);
2933         (*env)->SetIntField(env, lpObject, LVINSERTMARKFc.dwReserved, (jint)lpStruct->dwReserved);
2934 }
2935 #endif
2936
2937 #ifndef NO_LVITEM
2938 typedef struct LVITEM_FID_CACHE {
2939         int cached;
2940         jclass clazz;
2941         jfieldID mask, iItem, iSubItem, state, stateMask, pszText, cchTextMax, iImage, lParam, iIndent, iGroupId, cColumns, puColumns;
2942 } LVITEM_FID_CACHE;
2943
2944 LVITEM_FID_CACHE LVITEMFc;
2945
2946 void cacheLVITEMFields(JNIEnv *env, jobject lpObject)
2947 {
2948         if (LVITEMFc.cached) return;
2949         LVITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
2950         LVITEMFc.mask = (*env)->GetFieldID(env, LVITEMFc.clazz, "mask", "I");
2951         LVITEMFc.iItem = (*env)->GetFieldID(env, LVITEMFc.clazz, "iItem", "I");
2952         LVITEMFc.iSubItem = (*env)->GetFieldID(env, LVITEMFc.clazz, "iSubItem", "I");
2953         LVITEMFc.state = (*env)->GetFieldID(env, LVITEMFc.clazz, "state", "I");
2954         LVITEMFc.stateMask = (*env)->GetFieldID(env, LVITEMFc.clazz, "stateMask", "I");
2955         LVITEMFc.pszText = (*env)->GetFieldID(env, LVITEMFc.clazz, "pszText", "J");
2956         LVITEMFc.cchTextMax = (*env)->GetFieldID(env, LVITEMFc.clazz, "cchTextMax", "I");
2957         LVITEMFc.iImage = (*env)->GetFieldID(env, LVITEMFc.clazz, "iImage", "I");
2958         LVITEMFc.lParam = (*env)->GetFieldID(env, LVITEMFc.clazz, "lParam", "J");
2959         LVITEMFc.iIndent = (*env)->GetFieldID(env, LVITEMFc.clazz, "iIndent", "I");
2960         LVITEMFc.iGroupId = (*env)->GetFieldID(env, LVITEMFc.clazz, "iGroupId", "I");
2961         LVITEMFc.cColumns = (*env)->GetFieldID(env, LVITEMFc.clazz, "cColumns", "I");
2962         LVITEMFc.puColumns = (*env)->GetFieldID(env, LVITEMFc.clazz, "puColumns", "J");
2963         LVITEMFc.cached = 1;
2964 }
2965
2966 LVITEM *getLVITEMFields(JNIEnv *env, jobject lpObject, LVITEM *lpStruct)
2967 {
2968         if (!LVITEMFc.cached) cacheLVITEMFields(env, lpObject);
2969         lpStruct->mask = (*env)->GetIntField(env, lpObject, LVITEMFc.mask);
2970         lpStruct->iItem = (*env)->GetIntField(env, lpObject, LVITEMFc.iItem);
2971         lpStruct->iSubItem = (*env)->GetIntField(env, lpObject, LVITEMFc.iSubItem);
2972         lpStruct->state = (*env)->GetIntField(env, lpObject, LVITEMFc.state);
2973         lpStruct->stateMask = (*env)->GetIntField(env, lpObject, LVITEMFc.stateMask);
2974         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, LVITEMFc.pszText);
2975         lpStruct->cchTextMax = (*env)->GetIntField(env, lpObject, LVITEMFc.cchTextMax);
2976         lpStruct->iImage = (*env)->GetIntField(env, lpObject, LVITEMFc.iImage);
2977         lpStruct->lParam = (*env)->GetLongField(env, lpObject, LVITEMFc.lParam);
2978         lpStruct->iIndent = (*env)->GetIntField(env, lpObject, LVITEMFc.iIndent);
2979         lpStruct->iGroupId = (*env)->GetIntField(env, lpObject, LVITEMFc.iGroupId);
2980         lpStruct->cColumns = (*env)->GetIntField(env, lpObject, LVITEMFc.cColumns);
2981         lpStruct->puColumns = (PUINT)(*env)->GetLongField(env, lpObject, LVITEMFc.puColumns);
2982         return lpStruct;
2983 }
2984
2985 void setLVITEMFields(JNIEnv *env, jobject lpObject, LVITEM *lpStruct)
2986 {
2987         if (!LVITEMFc.cached) cacheLVITEMFields(env, lpObject);
2988         (*env)->SetIntField(env, lpObject, LVITEMFc.mask, (jint)lpStruct->mask);
2989         (*env)->SetIntField(env, lpObject, LVITEMFc.iItem, (jint)lpStruct->iItem);
2990         (*env)->SetIntField(env, lpObject, LVITEMFc.iSubItem, (jint)lpStruct->iSubItem);
2991         (*env)->SetIntField(env, lpObject, LVITEMFc.state, (jint)lpStruct->state);
2992         (*env)->SetIntField(env, lpObject, LVITEMFc.stateMask, (jint)lpStruct->stateMask);
2993         (*env)->SetLongField(env, lpObject, LVITEMFc.pszText, (jlong)lpStruct->pszText);
2994         (*env)->SetIntField(env, lpObject, LVITEMFc.cchTextMax, (jint)lpStruct->cchTextMax);
2995         (*env)->SetIntField(env, lpObject, LVITEMFc.iImage, (jint)lpStruct->iImage);
2996         (*env)->SetLongField(env, lpObject, LVITEMFc.lParam, (jlong)lpStruct->lParam);
2997         (*env)->SetIntField(env, lpObject, LVITEMFc.iIndent, (jint)lpStruct->iIndent);
2998         (*env)->SetIntField(env, lpObject, LVITEMFc.iGroupId, (jint)lpStruct->iGroupId);
2999         (*env)->SetIntField(env, lpObject, LVITEMFc.cColumns, (jint)lpStruct->cColumns);
3000         (*env)->SetLongField(env, lpObject, LVITEMFc.puColumns, (jlong)lpStruct->puColumns);
3001 }
3002 #endif
3003
3004 #ifndef NO_MARGINS
3005 typedef struct MARGINS_FID_CACHE {
3006         int cached;
3007         jclass clazz;
3008         jfieldID cxLeftWidth, cxRightWidth, cyTopHeight, cyBottomHeight;
3009 } MARGINS_FID_CACHE;
3010
3011 MARGINS_FID_CACHE MARGINSFc;
3012
3013 void cacheMARGINSFields(JNIEnv *env, jobject lpObject)
3014 {
3015         if (MARGINSFc.cached) return;
3016         MARGINSFc.clazz = (*env)->GetObjectClass(env, lpObject);
3017         MARGINSFc.cxLeftWidth = (*env)->GetFieldID(env, MARGINSFc.clazz, "cxLeftWidth", "I");
3018         MARGINSFc.cxRightWidth = (*env)->GetFieldID(env, MARGINSFc.clazz, "cxRightWidth", "I");
3019         MARGINSFc.cyTopHeight = (*env)->GetFieldID(env, MARGINSFc.clazz, "cyTopHeight", "I");
3020         MARGINSFc.cyBottomHeight = (*env)->GetFieldID(env, MARGINSFc.clazz, "cyBottomHeight", "I");
3021         MARGINSFc.cached = 1;
3022 }
3023
3024 MARGINS *getMARGINSFields(JNIEnv *env, jobject lpObject, MARGINS *lpStruct)
3025 {
3026         if (!MARGINSFc.cached) cacheMARGINSFields(env, lpObject);
3027         lpStruct->cxLeftWidth = (*env)->GetIntField(env, lpObject, MARGINSFc.cxLeftWidth);
3028         lpStruct->cxRightWidth = (*env)->GetIntField(env, lpObject, MARGINSFc.cxRightWidth);
3029         lpStruct->cyTopHeight = (*env)->GetIntField(env, lpObject, MARGINSFc.cyTopHeight);
3030         lpStruct->cyBottomHeight = (*env)->GetIntField(env, lpObject, MARGINSFc.cyBottomHeight);
3031         return lpStruct;
3032 }
3033
3034 void setMARGINSFields(JNIEnv *env, jobject lpObject, MARGINS *lpStruct)
3035 {
3036         if (!MARGINSFc.cached) cacheMARGINSFields(env, lpObject);
3037         (*env)->SetIntField(env, lpObject, MARGINSFc.cxLeftWidth, (jint)lpStruct->cxLeftWidth);
3038         (*env)->SetIntField(env, lpObject, MARGINSFc.cxRightWidth, (jint)lpStruct->cxRightWidth);
3039         (*env)->SetIntField(env, lpObject, MARGINSFc.cyTopHeight, (jint)lpStruct->cyTopHeight);
3040         (*env)->SetIntField(env, lpObject, MARGINSFc.cyBottomHeight, (jint)lpStruct->cyBottomHeight);
3041 }
3042 #endif
3043
3044 #ifndef NO_MCHITTESTINFO
3045 typedef struct MCHITTESTINFO_FID_CACHE {
3046         int cached;
3047         jclass clazz;
3048         jfieldID cbSize, pt, uHit, st;
3049 } MCHITTESTINFO_FID_CACHE;
3050
3051 MCHITTESTINFO_FID_CACHE MCHITTESTINFOFc;
3052
3053 void cacheMCHITTESTINFOFields(JNIEnv *env, jobject lpObject)
3054 {
3055         if (MCHITTESTINFOFc.cached) return;
3056         MCHITTESTINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3057         MCHITTESTINFOFc.cbSize = (*env)->GetFieldID(env, MCHITTESTINFOFc.clazz, "cbSize", "I");
3058         MCHITTESTINFOFc.pt = (*env)->GetFieldID(env, MCHITTESTINFOFc.clazz, "pt", "Lorg/eclipse/swt/internal/win32/POINT;");
3059         MCHITTESTINFOFc.uHit = (*env)->GetFieldID(env, MCHITTESTINFOFc.clazz, "uHit", "I");
3060         MCHITTESTINFOFc.st = (*env)->GetFieldID(env, MCHITTESTINFOFc.clazz, "st", "Lorg/eclipse/swt/internal/win32/SYSTEMTIME;");
3061         MCHITTESTINFOFc.cached = 1;
3062 }
3063
3064 MCHITTESTINFO *getMCHITTESTINFOFields(JNIEnv *env, jobject lpObject, MCHITTESTINFO *lpStruct)
3065 {
3066         if (!MCHITTESTINFOFc.cached) cacheMCHITTESTINFOFields(env, lpObject);
3067         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, MCHITTESTINFOFc.cbSize);
3068         {
3069         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, MCHITTESTINFOFc.pt);
3070         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->pt);
3071         }
3072         lpStruct->uHit = (*env)->GetIntField(env, lpObject, MCHITTESTINFOFc.uHit);
3073         {
3074         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, MCHITTESTINFOFc.st);
3075         if (lpObject1 != NULL) getSYSTEMTIMEFields(env, lpObject1, &lpStruct->st);
3076         }
3077         return lpStruct;
3078 }
3079
3080 void setMCHITTESTINFOFields(JNIEnv *env, jobject lpObject, MCHITTESTINFO *lpStruct)
3081 {
3082         if (!MCHITTESTINFOFc.cached) cacheMCHITTESTINFOFields(env, lpObject);
3083         (*env)->SetIntField(env, lpObject, MCHITTESTINFOFc.cbSize, (jint)lpStruct->cbSize);
3084         {
3085         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, MCHITTESTINFOFc.pt);
3086         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->pt);
3087         }
3088         (*env)->SetIntField(env, lpObject, MCHITTESTINFOFc.uHit, (jint)lpStruct->uHit);
3089         {
3090         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, MCHITTESTINFOFc.st);
3091         if (lpObject1 != NULL) setSYSTEMTIMEFields(env, lpObject1, &lpStruct->st);
3092         }
3093 }
3094 #endif
3095
3096 #ifndef NO_MEASUREITEMSTRUCT
3097 typedef struct MEASUREITEMSTRUCT_FID_CACHE {
3098         int cached;
3099         jclass clazz;
3100         jfieldID CtlType, CtlID, itemID, itemWidth, itemHeight, itemData;
3101 } MEASUREITEMSTRUCT_FID_CACHE;
3102
3103 MEASUREITEMSTRUCT_FID_CACHE MEASUREITEMSTRUCTFc;
3104
3105 void cacheMEASUREITEMSTRUCTFields(JNIEnv *env, jobject lpObject)
3106 {
3107         if (MEASUREITEMSTRUCTFc.cached) return;
3108         MEASUREITEMSTRUCTFc.clazz = (*env)->GetObjectClass(env, lpObject);
3109         MEASUREITEMSTRUCTFc.CtlType = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "CtlType", "I");
3110         MEASUREITEMSTRUCTFc.CtlID = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "CtlID", "I");
3111         MEASUREITEMSTRUCTFc.itemID = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "itemID", "I");
3112         MEASUREITEMSTRUCTFc.itemWidth = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "itemWidth", "I");
3113         MEASUREITEMSTRUCTFc.itemHeight = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "itemHeight", "I");
3114         MEASUREITEMSTRUCTFc.itemData = (*env)->GetFieldID(env, MEASUREITEMSTRUCTFc.clazz, "itemData", "J");
3115         MEASUREITEMSTRUCTFc.cached = 1;
3116 }
3117
3118 MEASUREITEMSTRUCT *getMEASUREITEMSTRUCTFields(JNIEnv *env, jobject lpObject, MEASUREITEMSTRUCT *lpStruct)
3119 {
3120         if (!MEASUREITEMSTRUCTFc.cached) cacheMEASUREITEMSTRUCTFields(env, lpObject);
3121         lpStruct->CtlType = (*env)->GetIntField(env, lpObject, MEASUREITEMSTRUCTFc.CtlType);
3122         lpStruct->CtlID = (*env)->GetIntField(env, lpObject, MEASUREITEMSTRUCTFc.CtlID);
3123         lpStruct->itemID = (*env)->GetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemID);
3124         lpStruct->itemWidth = (*env)->GetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemWidth);
3125         lpStruct->itemHeight = (*env)->GetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemHeight);
3126         lpStruct->itemData = (*env)->GetLongField(env, lpObject, MEASUREITEMSTRUCTFc.itemData);
3127         return lpStruct;
3128 }
3129
3130 void setMEASUREITEMSTRUCTFields(JNIEnv *env, jobject lpObject, MEASUREITEMSTRUCT *lpStruct)
3131 {
3132         if (!MEASUREITEMSTRUCTFc.cached) cacheMEASUREITEMSTRUCTFields(env, lpObject);
3133         (*env)->SetIntField(env, lpObject, MEASUREITEMSTRUCTFc.CtlType, (jint)lpStruct->CtlType);
3134         (*env)->SetIntField(env, lpObject, MEASUREITEMSTRUCTFc.CtlID, (jint)lpStruct->CtlID);
3135         (*env)->SetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemID, (jint)lpStruct->itemID);
3136         (*env)->SetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemWidth, (jint)lpStruct->itemWidth);
3137         (*env)->SetIntField(env, lpObject, MEASUREITEMSTRUCTFc.itemHeight, (jint)lpStruct->itemHeight);
3138         (*env)->SetLongField(env, lpObject, MEASUREITEMSTRUCTFc.itemData, (jlong)lpStruct->itemData);
3139 }
3140 #endif
3141
3142 #ifndef NO_MENUBARINFO
3143 typedef struct MENUBARINFO_FID_CACHE {
3144         int cached;
3145         jclass clazz;
3146         jfieldID cbSize, left, top, right, bottom, hMenu, hwndMenu, fBarFocused, fFocused;
3147 } MENUBARINFO_FID_CACHE;
3148
3149 MENUBARINFO_FID_CACHE MENUBARINFOFc;
3150
3151 void cacheMENUBARINFOFields(JNIEnv *env, jobject lpObject)
3152 {
3153         if (MENUBARINFOFc.cached) return;
3154         MENUBARINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3155         MENUBARINFOFc.cbSize = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "cbSize", "I");
3156         MENUBARINFOFc.left = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "left", "I");
3157         MENUBARINFOFc.top = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "top", "I");
3158         MENUBARINFOFc.right = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "right", "I");
3159         MENUBARINFOFc.bottom = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "bottom", "I");
3160         MENUBARINFOFc.hMenu = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "hMenu", "J");
3161         MENUBARINFOFc.hwndMenu = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "hwndMenu", "J");
3162         MENUBARINFOFc.fBarFocused = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "fBarFocused", "Z");
3163         MENUBARINFOFc.fFocused = (*env)->GetFieldID(env, MENUBARINFOFc.clazz, "fFocused", "Z");
3164         MENUBARINFOFc.cached = 1;
3165 }
3166
3167 MENUBARINFO *getMENUBARINFOFields(JNIEnv *env, jobject lpObject, MENUBARINFO *lpStruct)
3168 {
3169         if (!MENUBARINFOFc.cached) cacheMENUBARINFOFields(env, lpObject);
3170         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, MENUBARINFOFc.cbSize);
3171         lpStruct->rcBar.left = (*env)->GetIntField(env, lpObject, MENUBARINFOFc.left);
3172         lpStruct->rcBar.top = (*env)->GetIntField(env, lpObject, MENUBARINFOFc.top);
3173         lpStruct->rcBar.right = (*env)->GetIntField(env, lpObject, MENUBARINFOFc.right);
3174         lpStruct->rcBar.bottom = (*env)->GetIntField(env, lpObject, MENUBARINFOFc.bottom);
3175         lpStruct->hMenu = (HMENU)(*env)->GetLongField(env, lpObject, MENUBARINFOFc.hMenu);
3176         lpStruct->hwndMenu = (HWND)(*env)->GetLongField(env, lpObject, MENUBARINFOFc.hwndMenu);
3177         lpStruct->fBarFocused = (*env)->GetBooleanField(env, lpObject, MENUBARINFOFc.fBarFocused);
3178         lpStruct->fFocused = (*env)->GetBooleanField(env, lpObject, MENUBARINFOFc.fFocused);
3179         return lpStruct;
3180 }
3181
3182 void setMENUBARINFOFields(JNIEnv *env, jobject lpObject, MENUBARINFO *lpStruct)
3183 {
3184         if (!MENUBARINFOFc.cached) cacheMENUBARINFOFields(env, lpObject);
3185         (*env)->SetIntField(env, lpObject, MENUBARINFOFc.cbSize, (jint)lpStruct->cbSize);
3186         (*env)->SetIntField(env, lpObject, MENUBARINFOFc.left, (jint)lpStruct->rcBar.left);
3187         (*env)->SetIntField(env, lpObject, MENUBARINFOFc.top, (jint)lpStruct->rcBar.top);
3188         (*env)->SetIntField(env, lpObject, MENUBARINFOFc.right, (jint)lpStruct->rcBar.right);
3189         (*env)->SetIntField(env, lpObject, MENUBARINFOFc.bottom, (jint)lpStruct->rcBar.bottom);
3190         (*env)->SetLongField(env, lpObject, MENUBARINFOFc.hMenu, (jlong)lpStruct->hMenu);
3191         (*env)->SetLongField(env, lpObject, MENUBARINFOFc.hwndMenu, (jlong)lpStruct->hwndMenu);
3192         (*env)->SetBooleanField(env, lpObject, MENUBARINFOFc.fBarFocused, (jboolean)lpStruct->fBarFocused);
3193         (*env)->SetBooleanField(env, lpObject, MENUBARINFOFc.fFocused, (jboolean)lpStruct->fFocused);
3194 }
3195 #endif
3196
3197 #ifndef NO_MENUINFO
3198 typedef struct MENUINFO_FID_CACHE {
3199         int cached;
3200         jclass clazz;
3201         jfieldID cbSize, fMask, dwStyle, cyMax, hbrBack, dwContextHelpID, dwMenuData;
3202 } MENUINFO_FID_CACHE;
3203
3204 MENUINFO_FID_CACHE MENUINFOFc;
3205
3206 void cacheMENUINFOFields(JNIEnv *env, jobject lpObject)
3207 {
3208         if (MENUINFOFc.cached) return;
3209         MENUINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3210         MENUINFOFc.cbSize = (*env)->GetFieldID(env, MENUINFOFc.clazz, "cbSize", "I");
3211         MENUINFOFc.fMask = (*env)->GetFieldID(env, MENUINFOFc.clazz, "fMask", "I");
3212         MENUINFOFc.dwStyle = (*env)->GetFieldID(env, MENUINFOFc.clazz, "dwStyle", "I");
3213         MENUINFOFc.cyMax = (*env)->GetFieldID(env, MENUINFOFc.clazz, "cyMax", "I");
3214         MENUINFOFc.hbrBack = (*env)->GetFieldID(env, MENUINFOFc.clazz, "hbrBack", "J");
3215         MENUINFOFc.dwContextHelpID = (*env)->GetFieldID(env, MENUINFOFc.clazz, "dwContextHelpID", "I");
3216         MENUINFOFc.dwMenuData = (*env)->GetFieldID(env, MENUINFOFc.clazz, "dwMenuData", "J");
3217         MENUINFOFc.cached = 1;
3218 }
3219
3220 MENUINFO *getMENUINFOFields(JNIEnv *env, jobject lpObject, MENUINFO *lpStruct)
3221 {
3222         if (!MENUINFOFc.cached) cacheMENUINFOFields(env, lpObject);
3223         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, MENUINFOFc.cbSize);
3224         lpStruct->fMask = (*env)->GetIntField(env, lpObject, MENUINFOFc.fMask);
3225         lpStruct->dwStyle = (*env)->GetIntField(env, lpObject, MENUINFOFc.dwStyle);
3226         lpStruct->cyMax = (*env)->GetIntField(env, lpObject, MENUINFOFc.cyMax);
3227         lpStruct->hbrBack = (HBRUSH)(*env)->GetLongField(env, lpObject, MENUINFOFc.hbrBack);
3228         lpStruct->dwContextHelpID = (*env)->GetIntField(env, lpObject, MENUINFOFc.dwContextHelpID);
3229         lpStruct->dwMenuData = (*env)->GetLongField(env, lpObject, MENUINFOFc.dwMenuData);
3230         return lpStruct;
3231 }
3232
3233 void setMENUINFOFields(JNIEnv *env, jobject lpObject, MENUINFO *lpStruct)
3234 {
3235         if (!MENUINFOFc.cached) cacheMENUINFOFields(env, lpObject);
3236         (*env)->SetIntField(env, lpObject, MENUINFOFc.cbSize, (jint)lpStruct->cbSize);
3237         (*env)->SetIntField(env, lpObject, MENUINFOFc.fMask, (jint)lpStruct->fMask);
3238         (*env)->SetIntField(env, lpObject, MENUINFOFc.dwStyle, (jint)lpStruct->dwStyle);
3239         (*env)->SetIntField(env, lpObject, MENUINFOFc.cyMax, (jint)lpStruct->cyMax);
3240         (*env)->SetLongField(env, lpObject, MENUINFOFc.hbrBack, (jlong)lpStruct->hbrBack);
3241         (*env)->SetIntField(env, lpObject, MENUINFOFc.dwContextHelpID, (jint)lpStruct->dwContextHelpID);
3242         (*env)->SetLongField(env, lpObject, MENUINFOFc.dwMenuData, (jlong)lpStruct->dwMenuData);
3243 }
3244 #endif
3245
3246 #ifndef NO_MENUITEMINFO
3247 typedef struct MENUITEMINFO_FID_CACHE {
3248         int cached;
3249         jclass clazz;
3250         jfieldID cbSize, fMask, fType, fState, wID, hSubMenu, hbmpChecked, hbmpUnchecked, dwItemData, dwTypeData, cch, hbmpItem;
3251 } MENUITEMINFO_FID_CACHE;
3252
3253 MENUITEMINFO_FID_CACHE MENUITEMINFOFc;
3254
3255 void cacheMENUITEMINFOFields(JNIEnv *env, jobject lpObject)
3256 {
3257         if (MENUITEMINFOFc.cached) return;
3258         MENUITEMINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3259         MENUITEMINFOFc.cbSize = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "cbSize", "I");
3260         MENUITEMINFOFc.fMask = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "fMask", "I");
3261         MENUITEMINFOFc.fType = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "fType", "I");
3262         MENUITEMINFOFc.fState = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "fState", "I");
3263         MENUITEMINFOFc.wID = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "wID", "I");
3264         MENUITEMINFOFc.hSubMenu = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "hSubMenu", "J");
3265         MENUITEMINFOFc.hbmpChecked = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "hbmpChecked", "J");
3266         MENUITEMINFOFc.hbmpUnchecked = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "hbmpUnchecked", "J");
3267         MENUITEMINFOFc.dwItemData = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "dwItemData", "J");
3268         MENUITEMINFOFc.dwTypeData = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "dwTypeData", "J");
3269         MENUITEMINFOFc.cch = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "cch", "I");
3270         MENUITEMINFOFc.hbmpItem = (*env)->GetFieldID(env, MENUITEMINFOFc.clazz, "hbmpItem", "J");
3271         MENUITEMINFOFc.cached = 1;
3272 }
3273
3274 MENUITEMINFO *getMENUITEMINFOFields(JNIEnv *env, jobject lpObject, MENUITEMINFO *lpStruct)
3275 {
3276         if (!MENUITEMINFOFc.cached) cacheMENUITEMINFOFields(env, lpObject);
3277         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.cbSize);
3278         lpStruct->fMask = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.fMask);
3279         lpStruct->fType = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.fType);
3280         lpStruct->fState = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.fState);
3281         lpStruct->wID = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.wID);
3282         lpStruct->hSubMenu = (HMENU)(*env)->GetLongField(env, lpObject, MENUITEMINFOFc.hSubMenu);
3283         lpStruct->hbmpChecked = (HBITMAP)(*env)->GetLongField(env, lpObject, MENUITEMINFOFc.hbmpChecked);
3284         lpStruct->hbmpUnchecked = (HBITMAP)(*env)->GetLongField(env, lpObject, MENUITEMINFOFc.hbmpUnchecked);
3285         lpStruct->dwItemData = (*env)->GetLongField(env, lpObject, MENUITEMINFOFc.dwItemData);
3286         lpStruct->dwTypeData = (LPTSTR)(*env)->GetLongField(env, lpObject, MENUITEMINFOFc.dwTypeData);
3287         lpStruct->cch = (*env)->GetIntField(env, lpObject, MENUITEMINFOFc.cch);
3288         lpStruct->hbmpItem = (HBITMAP)(*env)->GetLongField(env, lpObject, MENUITEMINFOFc.hbmpItem);
3289         return lpStruct;
3290 }
3291
3292 void setMENUITEMINFOFields(JNIEnv *env, jobject lpObject, MENUITEMINFO *lpStruct)
3293 {
3294         if (!MENUITEMINFOFc.cached) cacheMENUITEMINFOFields(env, lpObject);
3295         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.cbSize, (jint)lpStruct->cbSize);
3296         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.fMask, (jint)lpStruct->fMask);
3297         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.fType, (jint)lpStruct->fType);
3298         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.fState, (jint)lpStruct->fState);
3299         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.wID, (jint)lpStruct->wID);
3300         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.hSubMenu, (jlong)lpStruct->hSubMenu);
3301         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.hbmpChecked, (jlong)lpStruct->hbmpChecked);
3302         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.hbmpUnchecked, (jlong)lpStruct->hbmpUnchecked);
3303         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.dwItemData, (jlong)lpStruct->dwItemData);
3304         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.dwTypeData, (jlong)lpStruct->dwTypeData);
3305         (*env)->SetIntField(env, lpObject, MENUITEMINFOFc.cch, (jint)lpStruct->cch);
3306         (*env)->SetLongField(env, lpObject, MENUITEMINFOFc.hbmpItem, (jlong)lpStruct->hbmpItem);
3307 }
3308 #endif
3309
3310 #ifndef NO_MINMAXINFO
3311 typedef struct MINMAXINFO_FID_CACHE {
3312         int cached;
3313         jclass clazz;
3314         jfieldID ptReserved_x, ptReserved_y, ptMaxSize_x, ptMaxSize_y, ptMaxPosition_x, ptMaxPosition_y, ptMinTrackSize_x, ptMinTrackSize_y, ptMaxTrackSize_x, ptMaxTrackSize_y;
3315 } MINMAXINFO_FID_CACHE;
3316
3317 MINMAXINFO_FID_CACHE MINMAXINFOFc;
3318
3319 void cacheMINMAXINFOFields(JNIEnv *env, jobject lpObject)
3320 {
3321         if (MINMAXINFOFc.cached) return;
3322         MINMAXINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3323         MINMAXINFOFc.ptReserved_x = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptReserved_x", "I");
3324         MINMAXINFOFc.ptReserved_y = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptReserved_y", "I");
3325         MINMAXINFOFc.ptMaxSize_x = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxSize_x", "I");
3326         MINMAXINFOFc.ptMaxSize_y = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxSize_y", "I");
3327         MINMAXINFOFc.ptMaxPosition_x = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxPosition_x", "I");
3328         MINMAXINFOFc.ptMaxPosition_y = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxPosition_y", "I");
3329         MINMAXINFOFc.ptMinTrackSize_x = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMinTrackSize_x", "I");
3330         MINMAXINFOFc.ptMinTrackSize_y = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMinTrackSize_y", "I");
3331         MINMAXINFOFc.ptMaxTrackSize_x = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxTrackSize_x", "I");
3332         MINMAXINFOFc.ptMaxTrackSize_y = (*env)->GetFieldID(env, MINMAXINFOFc.clazz, "ptMaxTrackSize_y", "I");
3333         MINMAXINFOFc.cached = 1;
3334 }
3335
3336 MINMAXINFO *getMINMAXINFOFields(JNIEnv *env, jobject lpObject, MINMAXINFO *lpStruct)
3337 {
3338         if (!MINMAXINFOFc.cached) cacheMINMAXINFOFields(env, lpObject);
3339         lpStruct->ptReserved.x = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptReserved_x);
3340         lpStruct->ptReserved.y = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptReserved_y);
3341         lpStruct->ptMaxSize.x = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxSize_x);
3342         lpStruct->ptMaxSize.y = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxSize_y);
3343         lpStruct->ptMaxPosition.x = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxPosition_x);
3344         lpStruct->ptMaxPosition.y = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxPosition_y);
3345         lpStruct->ptMinTrackSize.x = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMinTrackSize_x);
3346         lpStruct->ptMinTrackSize.y = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMinTrackSize_y);
3347         lpStruct->ptMaxTrackSize.x = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxTrackSize_x);
3348         lpStruct->ptMaxTrackSize.y = (*env)->GetIntField(env, lpObject, MINMAXINFOFc.ptMaxTrackSize_y);
3349         return lpStruct;
3350 }
3351
3352 void setMINMAXINFOFields(JNIEnv *env, jobject lpObject, MINMAXINFO *lpStruct)
3353 {
3354         if (!MINMAXINFOFc.cached) cacheMINMAXINFOFields(env, lpObject);
3355         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptReserved_x, (jint)lpStruct->ptReserved.x);
3356         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptReserved_y, (jint)lpStruct->ptReserved.y);
3357         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxSize_x, (jint)lpStruct->ptMaxSize.x);
3358         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxSize_y, (jint)lpStruct->ptMaxSize.y);
3359         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxPosition_x, (jint)lpStruct->ptMaxPosition.x);
3360         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxPosition_y, (jint)lpStruct->ptMaxPosition.y);
3361         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMinTrackSize_x, (jint)lpStruct->ptMinTrackSize.x);
3362         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMinTrackSize_y, (jint)lpStruct->ptMinTrackSize.y);
3363         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxTrackSize_x, (jint)lpStruct->ptMaxTrackSize.x);
3364         (*env)->SetIntField(env, lpObject, MINMAXINFOFc.ptMaxTrackSize_y, (jint)lpStruct->ptMaxTrackSize.y);
3365 }
3366 #endif
3367
3368 #ifndef NO_MONITORINFO
3369 typedef struct MONITORINFO_FID_CACHE {
3370         int cached;
3371         jclass clazz;
3372         jfieldID cbSize, rcMonitor_left, rcMonitor_top, rcMonitor_right, rcMonitor_bottom, rcWork_left, rcWork_top, rcWork_right, rcWork_bottom, dwFlags;
3373 } MONITORINFO_FID_CACHE;
3374
3375 MONITORINFO_FID_CACHE MONITORINFOFc;
3376
3377 void cacheMONITORINFOFields(JNIEnv *env, jobject lpObject)
3378 {
3379         if (MONITORINFOFc.cached) return;
3380         MONITORINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3381         MONITORINFOFc.cbSize = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "cbSize", "I");
3382         MONITORINFOFc.rcMonitor_left = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcMonitor_left", "I");
3383         MONITORINFOFc.rcMonitor_top = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcMonitor_top", "I");
3384         MONITORINFOFc.rcMonitor_right = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcMonitor_right", "I");
3385         MONITORINFOFc.rcMonitor_bottom = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcMonitor_bottom", "I");
3386         MONITORINFOFc.rcWork_left = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcWork_left", "I");
3387         MONITORINFOFc.rcWork_top = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcWork_top", "I");
3388         MONITORINFOFc.rcWork_right = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcWork_right", "I");
3389         MONITORINFOFc.rcWork_bottom = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "rcWork_bottom", "I");
3390         MONITORINFOFc.dwFlags = (*env)->GetFieldID(env, MONITORINFOFc.clazz, "dwFlags", "I");
3391         MONITORINFOFc.cached = 1;
3392 }
3393
3394 MONITORINFO *getMONITORINFOFields(JNIEnv *env, jobject lpObject, MONITORINFO *lpStruct)
3395 {
3396         if (!MONITORINFOFc.cached) cacheMONITORINFOFields(env, lpObject);
3397         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, MONITORINFOFc.cbSize);
3398         lpStruct->rcMonitor.left = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcMonitor_left);
3399         lpStruct->rcMonitor.top = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcMonitor_top);
3400         lpStruct->rcMonitor.right = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcMonitor_right);
3401         lpStruct->rcMonitor.bottom = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcMonitor_bottom);
3402         lpStruct->rcWork.left = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcWork_left);
3403         lpStruct->rcWork.top = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcWork_top);
3404         lpStruct->rcWork.right = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcWork_right);
3405         lpStruct->rcWork.bottom = (*env)->GetIntField(env, lpObject, MONITORINFOFc.rcWork_bottom);
3406         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, MONITORINFOFc.dwFlags);
3407         return lpStruct;
3408 }
3409
3410 void setMONITORINFOFields(JNIEnv *env, jobject lpObject, MONITORINFO *lpStruct)
3411 {
3412         if (!MONITORINFOFc.cached) cacheMONITORINFOFields(env, lpObject);
3413         (*env)->SetIntField(env, lpObject, MONITORINFOFc.cbSize, (jint)lpStruct->cbSize);
3414         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcMonitor_left, (jint)lpStruct->rcMonitor.left);
3415         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcMonitor_top, (jint)lpStruct->rcMonitor.top);
3416         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcMonitor_right, (jint)lpStruct->rcMonitor.right);
3417         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcMonitor_bottom, (jint)lpStruct->rcMonitor.bottom);
3418         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcWork_left, (jint)lpStruct->rcWork.left);
3419         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcWork_top, (jint)lpStruct->rcWork.top);
3420         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcWork_right, (jint)lpStruct->rcWork.right);
3421         (*env)->SetIntField(env, lpObject, MONITORINFOFc.rcWork_bottom, (jint)lpStruct->rcWork.bottom);
3422         (*env)->SetIntField(env, lpObject, MONITORINFOFc.dwFlags, (jint)lpStruct->dwFlags);
3423 }
3424 #endif
3425
3426 #ifndef NO_MOUSEINPUT
3427 typedef struct MOUSEINPUT_FID_CACHE {
3428         int cached;
3429         jclass clazz;
3430         jfieldID dx, dy, mouseData, dwFlags, time, dwExtraInfo;
3431 } MOUSEINPUT_FID_CACHE;
3432
3433 MOUSEINPUT_FID_CACHE MOUSEINPUTFc;
3434
3435 void cacheMOUSEINPUTFields(JNIEnv *env, jobject lpObject)
3436 {
3437         if (MOUSEINPUTFc.cached) return;
3438         MOUSEINPUTFc.clazz = (*env)->GetObjectClass(env, lpObject);
3439         MOUSEINPUTFc.dx = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "dx", "I");
3440         MOUSEINPUTFc.dy = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "dy", "I");
3441         MOUSEINPUTFc.mouseData = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "mouseData", "I");
3442         MOUSEINPUTFc.dwFlags = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "dwFlags", "I");
3443         MOUSEINPUTFc.time = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "time", "I");
3444         MOUSEINPUTFc.dwExtraInfo = (*env)->GetFieldID(env, MOUSEINPUTFc.clazz, "dwExtraInfo", "J");
3445         MOUSEINPUTFc.cached = 1;
3446 }
3447
3448 MOUSEINPUT *getMOUSEINPUTFields(JNIEnv *env, jobject lpObject, MOUSEINPUT *lpStruct)
3449 {
3450         if (!MOUSEINPUTFc.cached) cacheMOUSEINPUTFields(env, lpObject);
3451         lpStruct->dx = (*env)->GetIntField(env, lpObject, MOUSEINPUTFc.dx);
3452         lpStruct->dy = (*env)->GetIntField(env, lpObject, MOUSEINPUTFc.dy);
3453         lpStruct->mouseData = (*env)->GetIntField(env, lpObject, MOUSEINPUTFc.mouseData);
3454         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, MOUSEINPUTFc.dwFlags);
3455         lpStruct->time = (*env)->GetIntField(env, lpObject, MOUSEINPUTFc.time);
3456         lpStruct->dwExtraInfo = (*env)->GetLongField(env, lpObject, MOUSEINPUTFc.dwExtraInfo);
3457         return lpStruct;
3458 }
3459
3460 void setMOUSEINPUTFields(JNIEnv *env, jobject lpObject, MOUSEINPUT *lpStruct)
3461 {
3462         if (!MOUSEINPUTFc.cached) cacheMOUSEINPUTFields(env, lpObject);
3463         (*env)->SetIntField(env, lpObject, MOUSEINPUTFc.dx, (jint)lpStruct->dx);
3464         (*env)->SetIntField(env, lpObject, MOUSEINPUTFc.dy, (jint)lpStruct->dy);
3465         (*env)->SetIntField(env, lpObject, MOUSEINPUTFc.mouseData, (jint)lpStruct->mouseData);
3466         (*env)->SetIntField(env, lpObject, MOUSEINPUTFc.dwFlags, (jint)lpStruct->dwFlags);
3467         (*env)->SetIntField(env, lpObject, MOUSEINPUTFc.time, (jint)lpStruct->time);
3468         (*env)->SetLongField(env, lpObject, MOUSEINPUTFc.dwExtraInfo, (jlong)lpStruct->dwExtraInfo);
3469 }
3470 #endif
3471
3472 #ifndef NO_MSG
3473 typedef struct MSG_FID_CACHE {
3474         int cached;
3475         jclass clazz;
3476         jfieldID hwnd, message, wParam, lParam, time, x, y;
3477 } MSG_FID_CACHE;
3478
3479 MSG_FID_CACHE MSGFc;
3480
3481 void cacheMSGFields(JNIEnv *env, jobject lpObject)
3482 {
3483         if (MSGFc.cached) return;
3484         MSGFc.clazz = (*env)->GetObjectClass(env, lpObject);
3485         MSGFc.hwnd = (*env)->GetFieldID(env, MSGFc.clazz, "hwnd", "J");
3486         MSGFc.message = (*env)->GetFieldID(env, MSGFc.clazz, "message", "I");
3487         MSGFc.wParam = (*env)->GetFieldID(env, MSGFc.clazz, "wParam", "J");
3488         MSGFc.lParam = (*env)->GetFieldID(env, MSGFc.clazz, "lParam", "J");
3489         MSGFc.time = (*env)->GetFieldID(env, MSGFc.clazz, "time", "I");
3490         MSGFc.x = (*env)->GetFieldID(env, MSGFc.clazz, "x", "I");
3491         MSGFc.y = (*env)->GetFieldID(env, MSGFc.clazz, "y", "I");
3492         MSGFc.cached = 1;
3493 }
3494
3495 MSG *getMSGFields(JNIEnv *env, jobject lpObject, MSG *lpStruct)
3496 {
3497         if (!MSGFc.cached) cacheMSGFields(env, lpObject);
3498         lpStruct->hwnd = (HWND)(*env)->GetLongField(env, lpObject, MSGFc.hwnd);
3499         lpStruct->message = (*env)->GetIntField(env, lpObject, MSGFc.message);
3500         lpStruct->wParam = (*env)->GetLongField(env, lpObject, MSGFc.wParam);
3501         lpStruct->lParam = (*env)->GetLongField(env, lpObject, MSGFc.lParam);
3502         lpStruct->time = (*env)->GetIntField(env, lpObject, MSGFc.time);
3503         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, MSGFc.x);
3504         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, MSGFc.y);
3505         return lpStruct;
3506 }
3507
3508 void setMSGFields(JNIEnv *env, jobject lpObject, MSG *lpStruct)
3509 {
3510         if (!MSGFc.cached) cacheMSGFields(env, lpObject);
3511         (*env)->SetLongField(env, lpObject, MSGFc.hwnd, (jlong)lpStruct->hwnd);
3512         (*env)->SetIntField(env, lpObject, MSGFc.message, (jint)lpStruct->message);
3513         (*env)->SetLongField(env, lpObject, MSGFc.wParam, (jlong)lpStruct->wParam);
3514         (*env)->SetLongField(env, lpObject, MSGFc.lParam, (jlong)lpStruct->lParam);
3515         (*env)->SetIntField(env, lpObject, MSGFc.time, (jint)lpStruct->time);
3516         (*env)->SetIntField(env, lpObject, MSGFc.x, (jint)lpStruct->pt.x);
3517         (*env)->SetIntField(env, lpObject, MSGFc.y, (jint)lpStruct->pt.y);
3518 }
3519 #endif
3520
3521 #ifndef NO_NMCUSTOMDRAW
3522 typedef struct NMCUSTOMDRAW_FID_CACHE {
3523         int cached;
3524         jclass clazz;
3525         jfieldID dwDrawStage, hdc, left, top, right, bottom, dwItemSpec, uItemState, lItemlParam;
3526 } NMCUSTOMDRAW_FID_CACHE;
3527
3528 NMCUSTOMDRAW_FID_CACHE NMCUSTOMDRAWFc;
3529
3530 void cacheNMCUSTOMDRAWFields(JNIEnv *env, jobject lpObject)
3531 {
3532         if (NMCUSTOMDRAWFc.cached) return;
3533         cacheNMHDRFields(env, lpObject);
3534         NMCUSTOMDRAWFc.clazz = (*env)->GetObjectClass(env, lpObject);
3535         NMCUSTOMDRAWFc.dwDrawStage = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "dwDrawStage", "I");
3536         NMCUSTOMDRAWFc.hdc = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "hdc", "J");
3537         NMCUSTOMDRAWFc.left = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "left", "I");
3538         NMCUSTOMDRAWFc.top = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "top", "I");
3539         NMCUSTOMDRAWFc.right = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "right", "I");
3540         NMCUSTOMDRAWFc.bottom = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "bottom", "I");
3541         NMCUSTOMDRAWFc.dwItemSpec = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "dwItemSpec", "J");
3542         NMCUSTOMDRAWFc.uItemState = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "uItemState", "I");
3543         NMCUSTOMDRAWFc.lItemlParam = (*env)->GetFieldID(env, NMCUSTOMDRAWFc.clazz, "lItemlParam", "J");
3544         NMCUSTOMDRAWFc.cached = 1;
3545 }
3546
3547 NMCUSTOMDRAW *getNMCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMCUSTOMDRAW *lpStruct)
3548 {
3549         if (!NMCUSTOMDRAWFc.cached) cacheNMCUSTOMDRAWFields(env, lpObject);
3550         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3551         lpStruct->dwDrawStage = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.dwDrawStage);
3552         lpStruct->hdc = (HDC)(*env)->GetLongField(env, lpObject, NMCUSTOMDRAWFc.hdc);
3553         lpStruct->rc.left = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.left);
3554         lpStruct->rc.top = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.top);
3555         lpStruct->rc.right = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.right);
3556         lpStruct->rc.bottom = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.bottom);
3557         lpStruct->dwItemSpec = (*env)->GetLongField(env, lpObject, NMCUSTOMDRAWFc.dwItemSpec);
3558         lpStruct->uItemState = (*env)->GetIntField(env, lpObject, NMCUSTOMDRAWFc.uItemState);
3559         lpStruct->lItemlParam = (*env)->GetLongField(env, lpObject, NMCUSTOMDRAWFc.lItemlParam);
3560         return lpStruct;
3561 }
3562
3563 void setNMCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMCUSTOMDRAW *lpStruct)
3564 {
3565         if (!NMCUSTOMDRAWFc.cached) cacheNMCUSTOMDRAWFields(env, lpObject);
3566         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3567         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.dwDrawStage, (jint)lpStruct->dwDrawStage);
3568         (*env)->SetLongField(env, lpObject, NMCUSTOMDRAWFc.hdc, (jlong)lpStruct->hdc);
3569         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.left, (jint)lpStruct->rc.left);
3570         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.top, (jint)lpStruct->rc.top);
3571         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.right, (jint)lpStruct->rc.right);
3572         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.bottom, (jint)lpStruct->rc.bottom);
3573         (*env)->SetLongField(env, lpObject, NMCUSTOMDRAWFc.dwItemSpec, (jlong)lpStruct->dwItemSpec);
3574         (*env)->SetIntField(env, lpObject, NMCUSTOMDRAWFc.uItemState, (jint)lpStruct->uItemState);
3575         (*env)->SetLongField(env, lpObject, NMCUSTOMDRAWFc.lItemlParam, (jlong)lpStruct->lItemlParam);
3576 }
3577 #endif
3578
3579 #ifndef NO_NMHDR
3580 typedef struct NMHDR_FID_CACHE {
3581         int cached;
3582         jclass clazz;
3583         jfieldID hwndFrom, idFrom, code;
3584 } NMHDR_FID_CACHE;
3585
3586 NMHDR_FID_CACHE NMHDRFc;
3587
3588 void cacheNMHDRFields(JNIEnv *env, jobject lpObject)
3589 {
3590         if (NMHDRFc.cached) return;
3591         NMHDRFc.clazz = (*env)->GetObjectClass(env, lpObject);
3592         NMHDRFc.hwndFrom = (*env)->GetFieldID(env, NMHDRFc.clazz, "hwndFrom", "J");
3593         NMHDRFc.idFrom = (*env)->GetFieldID(env, NMHDRFc.clazz, "idFrom", "J");
3594         NMHDRFc.code = (*env)->GetFieldID(env, NMHDRFc.clazz, "code", "I");
3595         NMHDRFc.cached = 1;
3596 }
3597
3598 NMHDR *getNMHDRFields(JNIEnv *env, jobject lpObject, NMHDR *lpStruct)
3599 {
3600         if (!NMHDRFc.cached) cacheNMHDRFields(env, lpObject);
3601         lpStruct->hwndFrom = (HWND)(*env)->GetLongField(env, lpObject, NMHDRFc.hwndFrom);
3602         lpStruct->idFrom = (*env)->GetLongField(env, lpObject, NMHDRFc.idFrom);
3603         lpStruct->code = (*env)->GetIntField(env, lpObject, NMHDRFc.code);
3604         return lpStruct;
3605 }
3606
3607 void setNMHDRFields(JNIEnv *env, jobject lpObject, NMHDR *lpStruct)
3608 {
3609         if (!NMHDRFc.cached) cacheNMHDRFields(env, lpObject);
3610         (*env)->SetLongField(env, lpObject, NMHDRFc.hwndFrom, (jlong)lpStruct->hwndFrom);
3611         (*env)->SetLongField(env, lpObject, NMHDRFc.idFrom, (jlong)lpStruct->idFrom);
3612         (*env)->SetIntField(env, lpObject, NMHDRFc.code, (jint)lpStruct->code);
3613 }
3614 #endif
3615
3616 #ifndef NO_NMHEADER
3617 typedef struct NMHEADER_FID_CACHE {
3618         int cached;
3619         jclass clazz;
3620         jfieldID iItem, iButton, pitem;
3621 } NMHEADER_FID_CACHE;
3622
3623 NMHEADER_FID_CACHE NMHEADERFc;
3624
3625 void cacheNMHEADERFields(JNIEnv *env, jobject lpObject)
3626 {
3627         if (NMHEADERFc.cached) return;
3628         cacheNMHDRFields(env, lpObject);
3629         NMHEADERFc.clazz = (*env)->GetObjectClass(env, lpObject);
3630         NMHEADERFc.iItem = (*env)->GetFieldID(env, NMHEADERFc.clazz, "iItem", "I");
3631         NMHEADERFc.iButton = (*env)->GetFieldID(env, NMHEADERFc.clazz, "iButton", "I");
3632         NMHEADERFc.pitem = (*env)->GetFieldID(env, NMHEADERFc.clazz, "pitem", "J");
3633         NMHEADERFc.cached = 1;
3634 }
3635
3636 NMHEADER *getNMHEADERFields(JNIEnv *env, jobject lpObject, NMHEADER *lpStruct)
3637 {
3638         if (!NMHEADERFc.cached) cacheNMHEADERFields(env, lpObject);
3639         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3640         lpStruct->iItem = (*env)->GetIntField(env, lpObject, NMHEADERFc.iItem);
3641         lpStruct->iButton = (*env)->GetIntField(env, lpObject, NMHEADERFc.iButton);
3642         lpStruct->pitem = (HDITEM FAR *)(*env)->GetLongField(env, lpObject, NMHEADERFc.pitem);
3643         return lpStruct;
3644 }
3645
3646 void setNMHEADERFields(JNIEnv *env, jobject lpObject, NMHEADER *lpStruct)
3647 {
3648         if (!NMHEADERFc.cached) cacheNMHEADERFields(env, lpObject);
3649         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3650         (*env)->SetIntField(env, lpObject, NMHEADERFc.iItem, (jint)lpStruct->iItem);
3651         (*env)->SetIntField(env, lpObject, NMHEADERFc.iButton, (jint)lpStruct->iButton);
3652         (*env)->SetLongField(env, lpObject, NMHEADERFc.pitem, (jlong)lpStruct->pitem);
3653 }
3654 #endif
3655
3656 #ifndef NO_NMLINK
3657 typedef struct NMLINK_FID_CACHE {
3658         int cached;
3659         jclass clazz;
3660         jfieldID mask, iLink, state, stateMask, szID, szUrl;
3661 } NMLINK_FID_CACHE;
3662
3663 NMLINK_FID_CACHE NMLINKFc;
3664
3665 void cacheNMLINKFields(JNIEnv *env, jobject lpObject)
3666 {
3667         if (NMLINKFc.cached) return;
3668         cacheNMHDRFields(env, lpObject);
3669         NMLINKFc.clazz = (*env)->GetObjectClass(env, lpObject);
3670         NMLINKFc.mask = (*env)->GetFieldID(env, NMLINKFc.clazz, "mask", "I");
3671         NMLINKFc.iLink = (*env)->GetFieldID(env, NMLINKFc.clazz, "iLink", "I");
3672         NMLINKFc.state = (*env)->GetFieldID(env, NMLINKFc.clazz, "state", "I");
3673         NMLINKFc.stateMask = (*env)->GetFieldID(env, NMLINKFc.clazz, "stateMask", "I");
3674         NMLINKFc.szID = (*env)->GetFieldID(env, NMLINKFc.clazz, "szID", "[C");
3675         NMLINKFc.szUrl = (*env)->GetFieldID(env, NMLINKFc.clazz, "szUrl", "[C");
3676         NMLINKFc.cached = 1;
3677 }
3678
3679 NMLINK *getNMLINKFields(JNIEnv *env, jobject lpObject, NMLINK *lpStruct)
3680 {
3681         if (!NMLINKFc.cached) cacheNMLINKFields(env, lpObject);
3682         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3683         lpStruct->item.mask = (*env)->GetIntField(env, lpObject, NMLINKFc.mask);
3684         lpStruct->item.iLink = (*env)->GetIntField(env, lpObject, NMLINKFc.iLink);
3685         lpStruct->item.state = (*env)->GetIntField(env, lpObject, NMLINKFc.state);
3686         lpStruct->item.stateMask = (*env)->GetIntField(env, lpObject, NMLINKFc.stateMask);
3687         {
3688         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMLINKFc.szID);
3689         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->item.szID) / sizeof(jchar), (jchar *)lpStruct->item.szID);
3690         }
3691         {
3692         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMLINKFc.szUrl);
3693         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->item.szUrl) / sizeof(jchar), (jchar *)lpStruct->item.szUrl);
3694         }
3695         return lpStruct;
3696 }
3697
3698 void setNMLINKFields(JNIEnv *env, jobject lpObject, NMLINK *lpStruct)
3699 {
3700         if (!NMLINKFc.cached) cacheNMLINKFields(env, lpObject);
3701         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3702         (*env)->SetIntField(env, lpObject, NMLINKFc.mask, (jint)lpStruct->item.mask);
3703         (*env)->SetIntField(env, lpObject, NMLINKFc.iLink, (jint)lpStruct->item.iLink);
3704         (*env)->SetIntField(env, lpObject, NMLINKFc.state, (jint)lpStruct->item.state);
3705         (*env)->SetIntField(env, lpObject, NMLINKFc.stateMask, (jint)lpStruct->item.stateMask);
3706         {
3707         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMLINKFc.szID);
3708         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->item.szID) / sizeof(jchar), (jchar *)lpStruct->item.szID);
3709         }
3710         {
3711         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMLINKFc.szUrl);
3712         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->item.szUrl) / sizeof(jchar), (jchar *)lpStruct->item.szUrl);
3713         }
3714 }
3715 #endif
3716
3717 #ifndef NO_NMLISTVIEW
3718 typedef struct NMLISTVIEW_FID_CACHE {
3719         int cached;
3720         jclass clazz;
3721         jfieldID iItem, iSubItem, uNewState, uOldState, uChanged, x, y, lParam;
3722 } NMLISTVIEW_FID_CACHE;
3723
3724 NMLISTVIEW_FID_CACHE NMLISTVIEWFc;
3725
3726 void cacheNMLISTVIEWFields(JNIEnv *env, jobject lpObject)
3727 {
3728         if (NMLISTVIEWFc.cached) return;
3729         cacheNMHDRFields(env, lpObject);
3730         NMLISTVIEWFc.clazz = (*env)->GetObjectClass(env, lpObject);
3731         NMLISTVIEWFc.iItem = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "iItem", "I");
3732         NMLISTVIEWFc.iSubItem = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "iSubItem", "I");
3733         NMLISTVIEWFc.uNewState = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "uNewState", "I");
3734         NMLISTVIEWFc.uOldState = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "uOldState", "I");
3735         NMLISTVIEWFc.uChanged = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "uChanged", "I");
3736         NMLISTVIEWFc.x = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "x", "I");
3737         NMLISTVIEWFc.y = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "y", "I");
3738         NMLISTVIEWFc.lParam = (*env)->GetFieldID(env, NMLISTVIEWFc.clazz, "lParam", "J");
3739         NMLISTVIEWFc.cached = 1;
3740 }
3741
3742 NMLISTVIEW *getNMLISTVIEWFields(JNIEnv *env, jobject lpObject, NMLISTVIEW *lpStruct)
3743 {
3744         if (!NMLISTVIEWFc.cached) cacheNMLISTVIEWFields(env, lpObject);
3745         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3746         lpStruct->iItem = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.iItem);
3747         lpStruct->iSubItem = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.iSubItem);
3748         lpStruct->uNewState = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.uNewState);
3749         lpStruct->uOldState = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.uOldState);
3750         lpStruct->uChanged = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.uChanged);
3751         lpStruct->ptAction.x = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.x);
3752         lpStruct->ptAction.y = (*env)->GetIntField(env, lpObject, NMLISTVIEWFc.y);
3753         lpStruct->lParam = (*env)->GetLongField(env, lpObject, NMLISTVIEWFc.lParam);
3754         return lpStruct;
3755 }
3756
3757 void setNMLISTVIEWFields(JNIEnv *env, jobject lpObject, NMLISTVIEW *lpStruct)
3758 {
3759         if (!NMLISTVIEWFc.cached) cacheNMLISTVIEWFields(env, lpObject);
3760         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3761         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.iItem, (jint)lpStruct->iItem);
3762         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.iSubItem, (jint)lpStruct->iSubItem);
3763         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.uNewState, (jint)lpStruct->uNewState);
3764         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.uOldState, (jint)lpStruct->uOldState);
3765         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.uChanged, (jint)lpStruct->uChanged);
3766         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.x, (jint)lpStruct->ptAction.x);
3767         (*env)->SetIntField(env, lpObject, NMLISTVIEWFc.y, (jint)lpStruct->ptAction.y);
3768         (*env)->SetLongField(env, lpObject, NMLISTVIEWFc.lParam, (jlong)lpStruct->lParam);
3769 }
3770 #endif
3771
3772 #ifndef NO_NMLVCUSTOMDRAW
3773 typedef struct NMLVCUSTOMDRAW_FID_CACHE {
3774         int cached;
3775         jclass clazz;
3776         jfieldID clrText, clrTextBk, iSubItem, dwItemType, clrFace, iIconEffect, iIconPhase, iPartId, iStateId, rcText_left, rcText_top, rcText_right, rcText_bottom, uAlign;
3777 } NMLVCUSTOMDRAW_FID_CACHE;
3778
3779 NMLVCUSTOMDRAW_FID_CACHE NMLVCUSTOMDRAWFc;
3780
3781 void cacheNMLVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject)
3782 {
3783         if (NMLVCUSTOMDRAWFc.cached) return;
3784         cacheNMCUSTOMDRAWFields(env, lpObject);
3785         NMLVCUSTOMDRAWFc.clazz = (*env)->GetObjectClass(env, lpObject);
3786         NMLVCUSTOMDRAWFc.clrText = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "clrText", "I");
3787         NMLVCUSTOMDRAWFc.clrTextBk = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "clrTextBk", "I");
3788         NMLVCUSTOMDRAWFc.iSubItem = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "iSubItem", "I");
3789         NMLVCUSTOMDRAWFc.dwItemType = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "dwItemType", "I");
3790         NMLVCUSTOMDRAWFc.clrFace = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "clrFace", "I");
3791         NMLVCUSTOMDRAWFc.iIconEffect = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "iIconEffect", "I");
3792         NMLVCUSTOMDRAWFc.iIconPhase = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "iIconPhase", "I");
3793         NMLVCUSTOMDRAWFc.iPartId = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "iPartId", "I");
3794         NMLVCUSTOMDRAWFc.iStateId = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "iStateId", "I");
3795         NMLVCUSTOMDRAWFc.rcText_left = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "rcText_left", "I");
3796         NMLVCUSTOMDRAWFc.rcText_top = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "rcText_top", "I");
3797         NMLVCUSTOMDRAWFc.rcText_right = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "rcText_right", "I");
3798         NMLVCUSTOMDRAWFc.rcText_bottom = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "rcText_bottom", "I");
3799         NMLVCUSTOMDRAWFc.uAlign = (*env)->GetFieldID(env, NMLVCUSTOMDRAWFc.clazz, "uAlign", "I");
3800         NMLVCUSTOMDRAWFc.cached = 1;
3801 }
3802
3803 NMLVCUSTOMDRAW *getNMLVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMLVCUSTOMDRAW *lpStruct)
3804 {
3805         if (!NMLVCUSTOMDRAWFc.cached) cacheNMLVCUSTOMDRAWFields(env, lpObject);
3806         getNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
3807         lpStruct->clrText = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrText);
3808         lpStruct->clrTextBk = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrTextBk);
3809         lpStruct->iSubItem = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iSubItem);
3810         lpStruct->dwItemType = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.dwItemType);
3811         lpStruct->clrFace = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrFace);
3812         lpStruct->iIconEffect = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iIconEffect);
3813         lpStruct->iIconPhase = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iIconPhase);
3814         lpStruct->iPartId = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iPartId);
3815         lpStruct->iStateId = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iStateId);
3816         lpStruct->rcText.left = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_left);
3817         lpStruct->rcText.top = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_top);
3818         lpStruct->rcText.right = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_right);
3819         lpStruct->rcText.bottom = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_bottom);
3820         lpStruct->uAlign = (*env)->GetIntField(env, lpObject, NMLVCUSTOMDRAWFc.uAlign);
3821         return lpStruct;
3822 }
3823
3824 void setNMLVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMLVCUSTOMDRAW *lpStruct)
3825 {
3826         if (!NMLVCUSTOMDRAWFc.cached) cacheNMLVCUSTOMDRAWFields(env, lpObject);
3827         setNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
3828         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrText, (jint)lpStruct->clrText);
3829         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrTextBk, (jint)lpStruct->clrTextBk);
3830         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iSubItem, (jint)lpStruct->iSubItem);
3831         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.dwItemType, (jint)lpStruct->dwItemType);
3832         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.clrFace, (jint)lpStruct->clrFace);
3833         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iIconEffect, (jint)lpStruct->iIconEffect);
3834         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iIconPhase, (jint)lpStruct->iIconPhase);
3835         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iPartId, (jint)lpStruct->iPartId);
3836         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.iStateId, (jint)lpStruct->iStateId);
3837         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_left, (jint)lpStruct->rcText.left);
3838         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_top, (jint)lpStruct->rcText.top);
3839         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_right, (jint)lpStruct->rcText.right);
3840         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.rcText_bottom, (jint)lpStruct->rcText.bottom);
3841         (*env)->SetIntField(env, lpObject, NMLVCUSTOMDRAWFc.uAlign, (jint)lpStruct->uAlign);
3842 }
3843 #endif
3844
3845 #ifndef NO_NMLVDISPINFO
3846 typedef struct NMLVDISPINFO_FID_CACHE {
3847         int cached;
3848         jclass clazz;
3849         jfieldID mask, iItem, iSubItem, state, stateMask, pszText, cchTextMax, iImage, lParam, iIndent, iGroupId, cColumns, puColumns;
3850 } NMLVDISPINFO_FID_CACHE;
3851
3852 NMLVDISPINFO_FID_CACHE NMLVDISPINFOFc;
3853
3854 void cacheNMLVDISPINFOFields(JNIEnv *env, jobject lpObject)
3855 {
3856         if (NMLVDISPINFOFc.cached) return;
3857         cacheNMHDRFields(env, lpObject);
3858         NMLVDISPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
3859         NMLVDISPINFOFc.mask = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "mask", "I");
3860         NMLVDISPINFOFc.iItem = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "iItem", "I");
3861         NMLVDISPINFOFc.iSubItem = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "iSubItem", "I");
3862         NMLVDISPINFOFc.state = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "state", "I");
3863         NMLVDISPINFOFc.stateMask = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "stateMask", "I");
3864         NMLVDISPINFOFc.pszText = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "pszText", "J");
3865         NMLVDISPINFOFc.cchTextMax = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "cchTextMax", "I");
3866         NMLVDISPINFOFc.iImage = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "iImage", "I");
3867         NMLVDISPINFOFc.lParam = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "lParam", "J");
3868         NMLVDISPINFOFc.iIndent = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "iIndent", "I");
3869         NMLVDISPINFOFc.iGroupId = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "iGroupId", "I");
3870         NMLVDISPINFOFc.cColumns = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "cColumns", "I");
3871         NMLVDISPINFOFc.puColumns = (*env)->GetFieldID(env, NMLVDISPINFOFc.clazz, "puColumns", "J");
3872         NMLVDISPINFOFc.cached = 1;
3873 }
3874
3875 NMLVDISPINFO *getNMLVDISPINFOFields(JNIEnv *env, jobject lpObject, NMLVDISPINFO *lpStruct)
3876 {
3877         if (!NMLVDISPINFOFc.cached) cacheNMLVDISPINFOFields(env, lpObject);
3878         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3879         lpStruct->item.mask = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.mask);
3880         lpStruct->item.iItem = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.iItem);
3881         lpStruct->item.iSubItem = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.iSubItem);
3882         lpStruct->item.state = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.state);
3883         lpStruct->item.stateMask = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.stateMask);
3884         lpStruct->item.pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, NMLVDISPINFOFc.pszText);
3885         lpStruct->item.cchTextMax = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.cchTextMax);
3886         lpStruct->item.iImage = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.iImage);
3887         lpStruct->item.lParam = (*env)->GetLongField(env, lpObject, NMLVDISPINFOFc.lParam);
3888         lpStruct->item.iIndent = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.iIndent);
3889         lpStruct->item.iGroupId = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.iGroupId);
3890         lpStruct->item.cColumns = (*env)->GetIntField(env, lpObject, NMLVDISPINFOFc.cColumns);
3891         lpStruct->item.puColumns = (PUINT)(*env)->GetLongField(env, lpObject, NMLVDISPINFOFc.puColumns);
3892         return lpStruct;
3893 }
3894
3895 void setNMLVDISPINFOFields(JNIEnv *env, jobject lpObject, NMLVDISPINFO *lpStruct)
3896 {
3897         if (!NMLVDISPINFOFc.cached) cacheNMLVDISPINFOFields(env, lpObject);
3898         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3899         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.mask, (jint)lpStruct->item.mask);
3900         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.iItem, (jint)lpStruct->item.iItem);
3901         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.iSubItem, (jint)lpStruct->item.iSubItem);
3902         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.state, (jint)lpStruct->item.state);
3903         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.stateMask, (jint)lpStruct->item.stateMask);
3904         (*env)->SetLongField(env, lpObject, NMLVDISPINFOFc.pszText, (jlong)lpStruct->item.pszText);
3905         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.cchTextMax, (jint)lpStruct->item.cchTextMax);
3906         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.iImage, (jint)lpStruct->item.iImage);
3907         (*env)->SetLongField(env, lpObject, NMLVDISPINFOFc.lParam, (jlong)lpStruct->item.lParam);
3908         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.iIndent, (jint)lpStruct->item.iIndent);
3909         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.iGroupId, (jint)lpStruct->item.iGroupId);
3910         (*env)->SetIntField(env, lpObject, NMLVDISPINFOFc.cColumns, (jint)lpStruct->item.cColumns);
3911         (*env)->SetLongField(env, lpObject, NMLVDISPINFOFc.puColumns, (jlong)lpStruct->item.puColumns);
3912 }
3913 #endif
3914
3915 #ifndef NO_NMLVFINDITEM
3916 typedef struct NMLVFINDITEM_FID_CACHE {
3917         int cached;
3918         jclass clazz;
3919         jfieldID iStart, flags, psz, lParam, x, y, vkDirection;
3920 } NMLVFINDITEM_FID_CACHE;
3921
3922 NMLVFINDITEM_FID_CACHE NMLVFINDITEMFc;
3923
3924 void cacheNMLVFINDITEMFields(JNIEnv *env, jobject lpObject)
3925 {
3926         if (NMLVFINDITEMFc.cached) return;
3927         cacheNMHDRFields(env, lpObject);
3928         NMLVFINDITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
3929         NMLVFINDITEMFc.iStart = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "iStart", "I");
3930         NMLVFINDITEMFc.flags = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "flags", "I");
3931         NMLVFINDITEMFc.psz = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "psz", "J");
3932         NMLVFINDITEMFc.lParam = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "lParam", "J");
3933         NMLVFINDITEMFc.x = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "x", "I");
3934         NMLVFINDITEMFc.y = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "y", "I");
3935         NMLVFINDITEMFc.vkDirection = (*env)->GetFieldID(env, NMLVFINDITEMFc.clazz, "vkDirection", "I");
3936         NMLVFINDITEMFc.cached = 1;
3937 }
3938
3939 NMLVFINDITEM *getNMLVFINDITEMFields(JNIEnv *env, jobject lpObject, NMLVFINDITEM *lpStruct)
3940 {
3941         if (!NMLVFINDITEMFc.cached) cacheNMLVFINDITEMFields(env, lpObject);
3942         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3943         lpStruct->iStart = (*env)->GetIntField(env, lpObject, NMLVFINDITEMFc.iStart);
3944         lpStruct->lvfi.flags = (*env)->GetIntField(env, lpObject, NMLVFINDITEMFc.flags);
3945         lpStruct->lvfi.psz = (LPCTSTR)(*env)->GetLongField(env, lpObject, NMLVFINDITEMFc.psz);
3946         lpStruct->lvfi.lParam = (*env)->GetLongField(env, lpObject, NMLVFINDITEMFc.lParam);
3947         lpStruct->lvfi.pt.x = (*env)->GetIntField(env, lpObject, NMLVFINDITEMFc.x);
3948         lpStruct->lvfi.pt.y = (*env)->GetIntField(env, lpObject, NMLVFINDITEMFc.y);
3949         lpStruct->lvfi.vkDirection = (*env)->GetIntField(env, lpObject, NMLVFINDITEMFc.vkDirection);
3950         return lpStruct;
3951 }
3952
3953 void setNMLVFINDITEMFields(JNIEnv *env, jobject lpObject, NMLVFINDITEM *lpStruct)
3954 {
3955         if (!NMLVFINDITEMFc.cached) cacheNMLVFINDITEMFields(env, lpObject);
3956         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3957         (*env)->SetIntField(env, lpObject, NMLVFINDITEMFc.iStart, (jint)lpStruct->iStart);
3958         (*env)->SetIntField(env, lpObject, NMLVFINDITEMFc.flags, (jint)lpStruct->lvfi.flags);
3959         (*env)->SetLongField(env, lpObject, NMLVFINDITEMFc.psz, (jlong)lpStruct->lvfi.psz);
3960         (*env)->SetLongField(env, lpObject, NMLVFINDITEMFc.lParam, (jlong)lpStruct->lvfi.lParam);
3961         (*env)->SetIntField(env, lpObject, NMLVFINDITEMFc.x, (jint)lpStruct->lvfi.pt.x);
3962         (*env)->SetIntField(env, lpObject, NMLVFINDITEMFc.y, (jint)lpStruct->lvfi.pt.y);
3963         (*env)->SetIntField(env, lpObject, NMLVFINDITEMFc.vkDirection, (jint)lpStruct->lvfi.vkDirection);
3964 }
3965 #endif
3966
3967 #ifndef NO_NMLVODSTATECHANGE
3968 typedef struct NMLVODSTATECHANGE_FID_CACHE {
3969         int cached;
3970         jclass clazz;
3971         jfieldID iFrom, iTo, uNewState, uOldState;
3972 } NMLVODSTATECHANGE_FID_CACHE;
3973
3974 NMLVODSTATECHANGE_FID_CACHE NMLVODSTATECHANGEFc;
3975
3976 void cacheNMLVODSTATECHANGEFields(JNIEnv *env, jobject lpObject)
3977 {
3978         if (NMLVODSTATECHANGEFc.cached) return;
3979         cacheNMHDRFields(env, lpObject);
3980         NMLVODSTATECHANGEFc.clazz = (*env)->GetObjectClass(env, lpObject);
3981         NMLVODSTATECHANGEFc.iFrom = (*env)->GetFieldID(env, NMLVODSTATECHANGEFc.clazz, "iFrom", "I");
3982         NMLVODSTATECHANGEFc.iTo = (*env)->GetFieldID(env, NMLVODSTATECHANGEFc.clazz, "iTo", "I");
3983         NMLVODSTATECHANGEFc.uNewState = (*env)->GetFieldID(env, NMLVODSTATECHANGEFc.clazz, "uNewState", "I");
3984         NMLVODSTATECHANGEFc.uOldState = (*env)->GetFieldID(env, NMLVODSTATECHANGEFc.clazz, "uOldState", "I");
3985         NMLVODSTATECHANGEFc.cached = 1;
3986 }
3987
3988 NMLVODSTATECHANGE *getNMLVODSTATECHANGEFields(JNIEnv *env, jobject lpObject, NMLVODSTATECHANGE *lpStruct)
3989 {
3990         if (!NMLVODSTATECHANGEFc.cached) cacheNMLVODSTATECHANGEFields(env, lpObject);
3991         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
3992         lpStruct->iFrom = (*env)->GetIntField(env, lpObject, NMLVODSTATECHANGEFc.iFrom);
3993         lpStruct->iTo = (*env)->GetIntField(env, lpObject, NMLVODSTATECHANGEFc.iTo);
3994         lpStruct->uNewState = (*env)->GetIntField(env, lpObject, NMLVODSTATECHANGEFc.uNewState);
3995         lpStruct->uOldState = (*env)->GetIntField(env, lpObject, NMLVODSTATECHANGEFc.uOldState);
3996         return lpStruct;
3997 }
3998
3999 void setNMLVODSTATECHANGEFields(JNIEnv *env, jobject lpObject, NMLVODSTATECHANGE *lpStruct)
4000 {
4001         if (!NMLVODSTATECHANGEFc.cached) cacheNMLVODSTATECHANGEFields(env, lpObject);
4002         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4003         (*env)->SetIntField(env, lpObject, NMLVODSTATECHANGEFc.iFrom, (jint)lpStruct->iFrom);
4004         (*env)->SetIntField(env, lpObject, NMLVODSTATECHANGEFc.iTo, (jint)lpStruct->iTo);
4005         (*env)->SetIntField(env, lpObject, NMLVODSTATECHANGEFc.uNewState, (jint)lpStruct->uNewState);
4006         (*env)->SetIntField(env, lpObject, NMLVODSTATECHANGEFc.uOldState, (jint)lpStruct->uOldState);
4007 }
4008 #endif
4009
4010 #ifndef NO_NMREBARCHEVRON
4011 typedef struct NMREBARCHEVRON_FID_CACHE {
4012         int cached;
4013         jclass clazz;
4014         jfieldID uBand, wID, lParam, left, top, right, bottom, lParamNM;
4015 } NMREBARCHEVRON_FID_CACHE;
4016
4017 NMREBARCHEVRON_FID_CACHE NMREBARCHEVRONFc;
4018
4019 void cacheNMREBARCHEVRONFields(JNIEnv *env, jobject lpObject)
4020 {
4021         if (NMREBARCHEVRONFc.cached) return;
4022         cacheNMHDRFields(env, lpObject);
4023         NMREBARCHEVRONFc.clazz = (*env)->GetObjectClass(env, lpObject);
4024         NMREBARCHEVRONFc.uBand = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "uBand", "I");
4025         NMREBARCHEVRONFc.wID = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "wID", "I");
4026         NMREBARCHEVRONFc.lParam = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "lParam", "J");
4027         NMREBARCHEVRONFc.left = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "left", "I");
4028         NMREBARCHEVRONFc.top = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "top", "I");
4029         NMREBARCHEVRONFc.right = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "right", "I");
4030         NMREBARCHEVRONFc.bottom = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "bottom", "I");
4031         NMREBARCHEVRONFc.lParamNM = (*env)->GetFieldID(env, NMREBARCHEVRONFc.clazz, "lParamNM", "J");
4032         NMREBARCHEVRONFc.cached = 1;
4033 }
4034
4035 NMREBARCHEVRON *getNMREBARCHEVRONFields(JNIEnv *env, jobject lpObject, NMREBARCHEVRON *lpStruct)
4036 {
4037         if (!NMREBARCHEVRONFc.cached) cacheNMREBARCHEVRONFields(env, lpObject);
4038         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4039         lpStruct->uBand = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.uBand);
4040         lpStruct->wID = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.wID);
4041         lpStruct->lParam = (*env)->GetLongField(env, lpObject, NMREBARCHEVRONFc.lParam);
4042         lpStruct->rc.left = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.left);
4043         lpStruct->rc.top = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.top);
4044         lpStruct->rc.right = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.right);
4045         lpStruct->rc.bottom = (*env)->GetIntField(env, lpObject, NMREBARCHEVRONFc.bottom);
4046         lpStruct->lParamNM = (*env)->GetLongField(env, lpObject, NMREBARCHEVRONFc.lParamNM);
4047         return lpStruct;
4048 }
4049
4050 void setNMREBARCHEVRONFields(JNIEnv *env, jobject lpObject, NMREBARCHEVRON *lpStruct)
4051 {
4052         if (!NMREBARCHEVRONFc.cached) cacheNMREBARCHEVRONFields(env, lpObject);
4053         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4054         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.uBand, (jint)lpStruct->uBand);
4055         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.wID, (jint)lpStruct->wID);
4056         (*env)->SetLongField(env, lpObject, NMREBARCHEVRONFc.lParam, (jlong)lpStruct->lParam);
4057         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.left, (jint)lpStruct->rc.left);
4058         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.top, (jint)lpStruct->rc.top);
4059         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.right, (jint)lpStruct->rc.right);
4060         (*env)->SetIntField(env, lpObject, NMREBARCHEVRONFc.bottom, (jint)lpStruct->rc.bottom);
4061         (*env)->SetLongField(env, lpObject, NMREBARCHEVRONFc.lParamNM, (jlong)lpStruct->lParamNM);
4062 }
4063 #endif
4064
4065 #ifndef NO_NMREBARCHILDSIZE
4066 typedef struct NMREBARCHILDSIZE_FID_CACHE {
4067         int cached;
4068         jclass clazz;
4069         jfieldID uBand, wID, rcChild_left, rcChild_top, rcChild_right, rcChild_bottom, rcBand_left, rcBand_top, rcBand_right, rcBand_bottom;
4070 } NMREBARCHILDSIZE_FID_CACHE;
4071
4072 NMREBARCHILDSIZE_FID_CACHE NMREBARCHILDSIZEFc;
4073
4074 void cacheNMREBARCHILDSIZEFields(JNIEnv *env, jobject lpObject)
4075 {
4076         if (NMREBARCHILDSIZEFc.cached) return;
4077         cacheNMHDRFields(env, lpObject);
4078         NMREBARCHILDSIZEFc.clazz = (*env)->GetObjectClass(env, lpObject);
4079         NMREBARCHILDSIZEFc.uBand = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "uBand", "I");
4080         NMREBARCHILDSIZEFc.wID = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "wID", "I");
4081         NMREBARCHILDSIZEFc.rcChild_left = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcChild_left", "I");
4082         NMREBARCHILDSIZEFc.rcChild_top = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcChild_top", "I");
4083         NMREBARCHILDSIZEFc.rcChild_right = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcChild_right", "I");
4084         NMREBARCHILDSIZEFc.rcChild_bottom = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcChild_bottom", "I");
4085         NMREBARCHILDSIZEFc.rcBand_left = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcBand_left", "I");
4086         NMREBARCHILDSIZEFc.rcBand_top = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcBand_top", "I");
4087         NMREBARCHILDSIZEFc.rcBand_right = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcBand_right", "I");
4088         NMREBARCHILDSIZEFc.rcBand_bottom = (*env)->GetFieldID(env, NMREBARCHILDSIZEFc.clazz, "rcBand_bottom", "I");
4089         NMREBARCHILDSIZEFc.cached = 1;
4090 }
4091
4092 NMREBARCHILDSIZE *getNMREBARCHILDSIZEFields(JNIEnv *env, jobject lpObject, NMREBARCHILDSIZE *lpStruct)
4093 {
4094         if (!NMREBARCHILDSIZEFc.cached) cacheNMREBARCHILDSIZEFields(env, lpObject);
4095         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4096         lpStruct->uBand = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.uBand);
4097         lpStruct->wID = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.wID);
4098         lpStruct->rcChild.left = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_left);
4099         lpStruct->rcChild.top = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_top);
4100         lpStruct->rcChild.right = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_right);
4101         lpStruct->rcChild.bottom = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_bottom);
4102         lpStruct->rcBand.left = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_left);
4103         lpStruct->rcBand.top = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_top);
4104         lpStruct->rcBand.right = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_right);
4105         lpStruct->rcBand.bottom = (*env)->GetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_bottom);
4106         return lpStruct;
4107 }
4108
4109 void setNMREBARCHILDSIZEFields(JNIEnv *env, jobject lpObject, NMREBARCHILDSIZE *lpStruct)
4110 {
4111         if (!NMREBARCHILDSIZEFc.cached) cacheNMREBARCHILDSIZEFields(env, lpObject);
4112         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4113         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.uBand, (jint)lpStruct->uBand);
4114         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.wID, (jint)lpStruct->wID);
4115         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_left, (jint)lpStruct->rcChild.left);
4116         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_top, (jint)lpStruct->rcChild.top);
4117         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_right, (jint)lpStruct->rcChild.right);
4118         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcChild_bottom, (jint)lpStruct->rcChild.bottom);
4119         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_left, (jint)lpStruct->rcBand.left);
4120         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_top, (jint)lpStruct->rcBand.top);
4121         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_right, (jint)lpStruct->rcBand.right);
4122         (*env)->SetIntField(env, lpObject, NMREBARCHILDSIZEFc.rcBand_bottom, (jint)lpStruct->rcBand.bottom);
4123 }
4124 #endif
4125
4126 #ifndef NO_NMTBCUSTOMDRAW
4127 typedef struct NMTBCUSTOMDRAW_FID_CACHE {
4128         int cached;
4129         jclass clazz;
4130         jfieldID nmcd, hbrMonoDither, hbrLines, hpenLines, clrText, clrMark, clrTextHighlight, clrBtnFace, clrBtnHighlight, clrHighlightHotTrack, rcText_left, rcText_top, rcText_right, rcText_bottom, nStringBkMode, nHLStringBkMode, iListGap;
4131 } NMTBCUSTOMDRAW_FID_CACHE;
4132
4133 NMTBCUSTOMDRAW_FID_CACHE NMTBCUSTOMDRAWFc;
4134
4135 void cacheNMTBCUSTOMDRAWFields(JNIEnv *env, jobject lpObject)
4136 {
4137         if (NMTBCUSTOMDRAWFc.cached) return;
4138         cacheNMCUSTOMDRAWFields(env, lpObject);
4139         NMTBCUSTOMDRAWFc.clazz = (*env)->GetObjectClass(env, lpObject);
4140         NMTBCUSTOMDRAWFc.nmcd = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "nmcd", "Lorg/eclipse/swt/internal/win32/NMCUSTOMDRAW;");
4141         NMTBCUSTOMDRAWFc.hbrMonoDither = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "hbrMonoDither", "J");
4142         NMTBCUSTOMDRAWFc.hbrLines = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "hbrLines", "J");
4143         NMTBCUSTOMDRAWFc.hpenLines = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "hpenLines", "J");
4144         NMTBCUSTOMDRAWFc.clrText = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrText", "I");
4145         NMTBCUSTOMDRAWFc.clrMark = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrMark", "I");
4146         NMTBCUSTOMDRAWFc.clrTextHighlight = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrTextHighlight", "I");
4147         NMTBCUSTOMDRAWFc.clrBtnFace = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrBtnFace", "I");
4148         NMTBCUSTOMDRAWFc.clrBtnHighlight = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrBtnHighlight", "I");
4149         NMTBCUSTOMDRAWFc.clrHighlightHotTrack = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "clrHighlightHotTrack", "I");
4150         NMTBCUSTOMDRAWFc.rcText_left = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "rcText_left", "I");
4151         NMTBCUSTOMDRAWFc.rcText_top = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "rcText_top", "I");
4152         NMTBCUSTOMDRAWFc.rcText_right = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "rcText_right", "I");
4153         NMTBCUSTOMDRAWFc.rcText_bottom = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "rcText_bottom", "I");
4154         NMTBCUSTOMDRAWFc.nStringBkMode = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "nStringBkMode", "I");
4155         NMTBCUSTOMDRAWFc.nHLStringBkMode = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "nHLStringBkMode", "I");
4156         NMTBCUSTOMDRAWFc.iListGap = (*env)->GetFieldID(env, NMTBCUSTOMDRAWFc.clazz, "iListGap", "I");
4157         NMTBCUSTOMDRAWFc.cached = 1;
4158 }
4159
4160 NMTBCUSTOMDRAW *getNMTBCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTBCUSTOMDRAW *lpStruct)
4161 {
4162         if (!NMTBCUSTOMDRAWFc.cached) cacheNMTBCUSTOMDRAWFields(env, lpObject);
4163         getNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4164         {
4165         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTBCUSTOMDRAWFc.nmcd);
4166         if (lpObject1 != NULL) getNMCUSTOMDRAWFields(env, lpObject1, &lpStruct->nmcd);
4167         }
4168         lpStruct->hbrMonoDither = (HBRUSH)(*env)->GetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hbrMonoDither);
4169         lpStruct->hbrLines = (HBRUSH)(*env)->GetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hbrLines);
4170         lpStruct->hpenLines = (HPEN)(*env)->GetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hpenLines);
4171         lpStruct->clrText = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrText);
4172         lpStruct->clrMark = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrMark);
4173         lpStruct->clrTextHighlight = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrTextHighlight);
4174         lpStruct->clrBtnFace = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrBtnFace);
4175         lpStruct->clrBtnHighlight = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrBtnHighlight);
4176         lpStruct->clrHighlightHotTrack = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrHighlightHotTrack);
4177         lpStruct->rcText.left = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_left);
4178         lpStruct->rcText.top = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_top);
4179         lpStruct->rcText.right = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_right);
4180         lpStruct->rcText.bottom = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_bottom);
4181         lpStruct->nStringBkMode = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.nStringBkMode);
4182         lpStruct->nHLStringBkMode = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.nHLStringBkMode);
4183         lpStruct->iListGap = (*env)->GetIntField(env, lpObject, NMTBCUSTOMDRAWFc.iListGap);
4184         return lpStruct;
4185 }
4186
4187 void setNMTBCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTBCUSTOMDRAW *lpStruct)
4188 {
4189         if (!NMTBCUSTOMDRAWFc.cached) cacheNMTBCUSTOMDRAWFields(env, lpObject);
4190         setNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4191         {
4192         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTBCUSTOMDRAWFc.nmcd);
4193         if (lpObject1 != NULL) setNMCUSTOMDRAWFields(env, lpObject1, &lpStruct->nmcd);
4194         }
4195         (*env)->SetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hbrMonoDither, (jlong)lpStruct->hbrMonoDither);
4196         (*env)->SetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hbrLines, (jlong)lpStruct->hbrLines);
4197         (*env)->SetLongField(env, lpObject, NMTBCUSTOMDRAWFc.hpenLines, (jlong)lpStruct->hpenLines);
4198         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrText, (jint)lpStruct->clrText);
4199         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrMark, (jint)lpStruct->clrMark);
4200         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrTextHighlight, (jint)lpStruct->clrTextHighlight);
4201         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrBtnFace, (jint)lpStruct->clrBtnFace);
4202         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrBtnHighlight, (jint)lpStruct->clrBtnHighlight);
4203         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.clrHighlightHotTrack, (jint)lpStruct->clrHighlightHotTrack);
4204         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_left, (jint)lpStruct->rcText.left);
4205         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_top, (jint)lpStruct->rcText.top);
4206         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_right, (jint)lpStruct->rcText.right);
4207         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.rcText_bottom, (jint)lpStruct->rcText.bottom);
4208         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.nStringBkMode, (jint)lpStruct->nStringBkMode);
4209         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.nHLStringBkMode, (jint)lpStruct->nHLStringBkMode);
4210         (*env)->SetIntField(env, lpObject, NMTBCUSTOMDRAWFc.iListGap, (jint)lpStruct->iListGap);
4211 }
4212 #endif
4213
4214 #ifndef NO_NMTBHOTITEM
4215 typedef struct NMTBHOTITEM_FID_CACHE {
4216         int cached;
4217         jclass clazz;
4218         jfieldID idOld, idNew, dwFlags;
4219 } NMTBHOTITEM_FID_CACHE;
4220
4221 NMTBHOTITEM_FID_CACHE NMTBHOTITEMFc;
4222
4223 void cacheNMTBHOTITEMFields(JNIEnv *env, jobject lpObject)
4224 {
4225         if (NMTBHOTITEMFc.cached) return;
4226         cacheNMHDRFields(env, lpObject);
4227         NMTBHOTITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
4228         NMTBHOTITEMFc.idOld = (*env)->GetFieldID(env, NMTBHOTITEMFc.clazz, "idOld", "I");
4229         NMTBHOTITEMFc.idNew = (*env)->GetFieldID(env, NMTBHOTITEMFc.clazz, "idNew", "I");
4230         NMTBHOTITEMFc.dwFlags = (*env)->GetFieldID(env, NMTBHOTITEMFc.clazz, "dwFlags", "I");
4231         NMTBHOTITEMFc.cached = 1;
4232 }
4233
4234 NMTBHOTITEM *getNMTBHOTITEMFields(JNIEnv *env, jobject lpObject, NMTBHOTITEM *lpStruct)
4235 {
4236         if (!NMTBHOTITEMFc.cached) cacheNMTBHOTITEMFields(env, lpObject);
4237         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4238         lpStruct->idOld = (*env)->GetIntField(env, lpObject, NMTBHOTITEMFc.idOld);
4239         lpStruct->idNew = (*env)->GetIntField(env, lpObject, NMTBHOTITEMFc.idNew);
4240         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, NMTBHOTITEMFc.dwFlags);
4241         return lpStruct;
4242 }
4243
4244 void setNMTBHOTITEMFields(JNIEnv *env, jobject lpObject, NMTBHOTITEM *lpStruct)
4245 {
4246         if (!NMTBHOTITEMFc.cached) cacheNMTBHOTITEMFields(env, lpObject);
4247         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4248         (*env)->SetIntField(env, lpObject, NMTBHOTITEMFc.idOld, (jint)lpStruct->idOld);
4249         (*env)->SetIntField(env, lpObject, NMTBHOTITEMFc.idNew, (jint)lpStruct->idNew);
4250         (*env)->SetIntField(env, lpObject, NMTBHOTITEMFc.dwFlags, (jint)lpStruct->dwFlags);
4251 }
4252 #endif
4253
4254 #ifndef NO_NMTOOLBAR
4255 typedef struct NMTOOLBAR_FID_CACHE {
4256         int cached;
4257         jclass clazz;
4258         jfieldID iItem, iBitmap, idCommand, fsState, fsStyle, dwData, iString, cchText, pszText, left, top, right, bottom;
4259 } NMTOOLBAR_FID_CACHE;
4260
4261 NMTOOLBAR_FID_CACHE NMTOOLBARFc;
4262
4263 void cacheNMTOOLBARFields(JNIEnv *env, jobject lpObject)
4264 {
4265         if (NMTOOLBARFc.cached) return;
4266         cacheNMHDRFields(env, lpObject);
4267         NMTOOLBARFc.clazz = (*env)->GetObjectClass(env, lpObject);
4268         NMTOOLBARFc.iItem = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "iItem", "I");
4269         NMTOOLBARFc.iBitmap = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "iBitmap", "I");
4270         NMTOOLBARFc.idCommand = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "idCommand", "I");
4271         NMTOOLBARFc.fsState = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "fsState", "B");
4272         NMTOOLBARFc.fsStyle = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "fsStyle", "B");
4273         NMTOOLBARFc.dwData = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "dwData", "J");
4274         NMTOOLBARFc.iString = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "iString", "J");
4275         NMTOOLBARFc.cchText = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "cchText", "I");
4276         NMTOOLBARFc.pszText = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "pszText", "J");
4277         NMTOOLBARFc.left = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "left", "I");
4278         NMTOOLBARFc.top = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "top", "I");
4279         NMTOOLBARFc.right = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "right", "I");
4280         NMTOOLBARFc.bottom = (*env)->GetFieldID(env, NMTOOLBARFc.clazz, "bottom", "I");
4281         NMTOOLBARFc.cached = 1;
4282 }
4283
4284 NMTOOLBAR *getNMTOOLBARFields(JNIEnv *env, jobject lpObject, NMTOOLBAR *lpStruct)
4285 {
4286         if (!NMTOOLBARFc.cached) cacheNMTOOLBARFields(env, lpObject);
4287         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4288         lpStruct->iItem = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.iItem);
4289         lpStruct->tbButton.iBitmap = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.iBitmap);
4290         lpStruct->tbButton.idCommand = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.idCommand);
4291         lpStruct->tbButton.fsState = (*env)->GetByteField(env, lpObject, NMTOOLBARFc.fsState);
4292         lpStruct->tbButton.fsStyle = (*env)->GetByteField(env, lpObject, NMTOOLBARFc.fsStyle);
4293         lpStruct->tbButton.dwData = (*env)->GetLongField(env, lpObject, NMTOOLBARFc.dwData);
4294         lpStruct->tbButton.iString = (*env)->GetLongField(env, lpObject, NMTOOLBARFc.iString);
4295         lpStruct->cchText = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.cchText);
4296         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, NMTOOLBARFc.pszText);
4297         lpStruct->rcButton.left = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.left);
4298         lpStruct->rcButton.top = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.top);
4299         lpStruct->rcButton.right = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.right);
4300         lpStruct->rcButton.bottom = (*env)->GetIntField(env, lpObject, NMTOOLBARFc.bottom);
4301         return lpStruct;
4302 }
4303
4304 void setNMTOOLBARFields(JNIEnv *env, jobject lpObject, NMTOOLBAR *lpStruct)
4305 {
4306         if (!NMTOOLBARFc.cached) cacheNMTOOLBARFields(env, lpObject);
4307         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4308         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.iItem, (jint)lpStruct->iItem);
4309         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.iBitmap, (jint)lpStruct->tbButton.iBitmap);
4310         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.idCommand, (jint)lpStruct->tbButton.idCommand);
4311         (*env)->SetByteField(env, lpObject, NMTOOLBARFc.fsState, (jbyte)lpStruct->tbButton.fsState);
4312         (*env)->SetByteField(env, lpObject, NMTOOLBARFc.fsStyle, (jbyte)lpStruct->tbButton.fsStyle);
4313         (*env)->SetLongField(env, lpObject, NMTOOLBARFc.dwData, (jlong)lpStruct->tbButton.dwData);
4314         (*env)->SetLongField(env, lpObject, NMTOOLBARFc.iString, (jlong)lpStruct->tbButton.iString);
4315         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.cchText, (jint)lpStruct->cchText);
4316         (*env)->SetLongField(env, lpObject, NMTOOLBARFc.pszText, (jlong)lpStruct->pszText);
4317         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.left, (jint)lpStruct->rcButton.left);
4318         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.top, (jint)lpStruct->rcButton.top);
4319         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.right, (jint)lpStruct->rcButton.right);
4320         (*env)->SetIntField(env, lpObject, NMTOOLBARFc.bottom, (jint)lpStruct->rcButton.bottom);
4321 }
4322 #endif
4323
4324 #ifndef NO_NMTREEVIEW
4325 typedef struct NMTREEVIEW_FID_CACHE {
4326         int cached;
4327         jclass clazz;
4328         jfieldID hdr, action, itemOld, itemNew, ptDrag;
4329 } NMTREEVIEW_FID_CACHE;
4330
4331 NMTREEVIEW_FID_CACHE NMTREEVIEWFc;
4332
4333 void cacheNMTREEVIEWFields(JNIEnv *env, jobject lpObject)
4334 {
4335         if (NMTREEVIEWFc.cached) return;
4336         NMTREEVIEWFc.clazz = (*env)->GetObjectClass(env, lpObject);
4337         NMTREEVIEWFc.hdr = (*env)->GetFieldID(env, NMTREEVIEWFc.clazz, "hdr", "Lorg/eclipse/swt/internal/win32/NMHDR;");
4338         NMTREEVIEWFc.action = (*env)->GetFieldID(env, NMTREEVIEWFc.clazz, "action", "I");
4339         NMTREEVIEWFc.itemOld = (*env)->GetFieldID(env, NMTREEVIEWFc.clazz, "itemOld", "Lorg/eclipse/swt/internal/win32/TVITEM;");
4340         NMTREEVIEWFc.itemNew = (*env)->GetFieldID(env, NMTREEVIEWFc.clazz, "itemNew", "Lorg/eclipse/swt/internal/win32/TVITEM;");
4341         NMTREEVIEWFc.ptDrag = (*env)->GetFieldID(env, NMTREEVIEWFc.clazz, "ptDrag", "Lorg/eclipse/swt/internal/win32/POINT;");
4342         NMTREEVIEWFc.cached = 1;
4343 }
4344
4345 NMTREEVIEW *getNMTREEVIEWFields(JNIEnv *env, jobject lpObject, NMTREEVIEW *lpStruct)
4346 {
4347         if (!NMTREEVIEWFc.cached) cacheNMTREEVIEWFields(env, lpObject);
4348         {
4349         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.hdr);
4350         if (lpObject1 != NULL) getNMHDRFields(env, lpObject1, &lpStruct->hdr);
4351         }
4352         lpStruct->action = (*env)->GetIntField(env, lpObject, NMTREEVIEWFc.action);
4353         {
4354         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.itemOld);
4355         if (lpObject1 != NULL) getTVITEMFields(env, lpObject1, &lpStruct->itemOld);
4356         }
4357         {
4358         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.itemNew);
4359         if (lpObject1 != NULL) getTVITEMFields(env, lpObject1, &lpStruct->itemNew);
4360         }
4361         {
4362         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.ptDrag);
4363         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->ptDrag);
4364         }
4365         return lpStruct;
4366 }
4367
4368 void setNMTREEVIEWFields(JNIEnv *env, jobject lpObject, NMTREEVIEW *lpStruct)
4369 {
4370         if (!NMTREEVIEWFc.cached) cacheNMTREEVIEWFields(env, lpObject);
4371         {
4372         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.hdr);
4373         if (lpObject1 != NULL) setNMHDRFields(env, lpObject1, &lpStruct->hdr);
4374         }
4375         (*env)->SetIntField(env, lpObject, NMTREEVIEWFc.action, (jint)lpStruct->action);
4376         {
4377         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.itemOld);
4378         if (lpObject1 != NULL) setTVITEMFields(env, lpObject1, &lpStruct->itemOld);
4379         }
4380         {
4381         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.itemNew);
4382         if (lpObject1 != NULL) setTVITEMFields(env, lpObject1, &lpStruct->itemNew);
4383         }
4384         {
4385         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NMTREEVIEWFc.ptDrag);
4386         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->ptDrag);
4387         }
4388 }
4389 #endif
4390
4391 #ifndef NO_NMTTCUSTOMDRAW
4392 typedef struct NMTTCUSTOMDRAW_FID_CACHE {
4393         int cached;
4394         jclass clazz;
4395         jfieldID uDrawFlags;
4396 } NMTTCUSTOMDRAW_FID_CACHE;
4397
4398 NMTTCUSTOMDRAW_FID_CACHE NMTTCUSTOMDRAWFc;
4399
4400 void cacheNMTTCUSTOMDRAWFields(JNIEnv *env, jobject lpObject)
4401 {
4402         if (NMTTCUSTOMDRAWFc.cached) return;
4403         cacheNMCUSTOMDRAWFields(env, lpObject);
4404         NMTTCUSTOMDRAWFc.clazz = (*env)->GetObjectClass(env, lpObject);
4405         NMTTCUSTOMDRAWFc.uDrawFlags = (*env)->GetFieldID(env, NMTTCUSTOMDRAWFc.clazz, "uDrawFlags", "I");
4406         NMTTCUSTOMDRAWFc.cached = 1;
4407 }
4408
4409 NMTTCUSTOMDRAW *getNMTTCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTTCUSTOMDRAW *lpStruct)
4410 {
4411         if (!NMTTCUSTOMDRAWFc.cached) cacheNMTTCUSTOMDRAWFields(env, lpObject);
4412         getNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4413         lpStruct->uDrawFlags = (*env)->GetIntField(env, lpObject, NMTTCUSTOMDRAWFc.uDrawFlags);
4414         return lpStruct;
4415 }
4416
4417 void setNMTTCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTTCUSTOMDRAW *lpStruct)
4418 {
4419         if (!NMTTCUSTOMDRAWFc.cached) cacheNMTTCUSTOMDRAWFields(env, lpObject);
4420         setNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4421         (*env)->SetIntField(env, lpObject, NMTTCUSTOMDRAWFc.uDrawFlags, (jint)lpStruct->uDrawFlags);
4422 }
4423 #endif
4424
4425 #ifndef NO_NMTTDISPINFO
4426 typedef struct NMTTDISPINFO_FID_CACHE {
4427         int cached;
4428         jclass clazz;
4429         jfieldID lpszText, szText, hinst, uFlags, lParam;
4430 } NMTTDISPINFO_FID_CACHE;
4431
4432 NMTTDISPINFO_FID_CACHE NMTTDISPINFOFc;
4433
4434 void cacheNMTTDISPINFOFields(JNIEnv *env, jobject lpObject)
4435 {
4436         if (NMTTDISPINFOFc.cached) return;
4437         cacheNMHDRFields(env, lpObject);
4438         NMTTDISPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
4439         NMTTDISPINFOFc.lpszText = (*env)->GetFieldID(env, NMTTDISPINFOFc.clazz, "lpszText", "J");
4440         NMTTDISPINFOFc.szText = (*env)->GetFieldID(env, NMTTDISPINFOFc.clazz, "szText", "[C");
4441         NMTTDISPINFOFc.hinst = (*env)->GetFieldID(env, NMTTDISPINFOFc.clazz, "hinst", "J");
4442         NMTTDISPINFOFc.uFlags = (*env)->GetFieldID(env, NMTTDISPINFOFc.clazz, "uFlags", "I");
4443         NMTTDISPINFOFc.lParam = (*env)->GetFieldID(env, NMTTDISPINFOFc.clazz, "lParam", "J");
4444         NMTTDISPINFOFc.cached = 1;
4445 }
4446
4447 NMTTDISPINFO *getNMTTDISPINFOFields(JNIEnv *env, jobject lpObject, NMTTDISPINFO *lpStruct)
4448 {
4449         if (!NMTTDISPINFOFc.cached) cacheNMTTDISPINFOFields(env, lpObject);
4450         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4451         lpStruct->lpszText = (void *)(*env)->GetLongField(env, lpObject, NMTTDISPINFOFc.lpszText);
4452         {
4453         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMTTDISPINFOFc.szText);
4454         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szText) / sizeof(jchar), (jchar *)lpStruct->szText);
4455         }
4456         lpStruct->hinst = (HINSTANCE)(*env)->GetLongField(env, lpObject, NMTTDISPINFOFc.hinst);
4457         lpStruct->uFlags = (*env)->GetIntField(env, lpObject, NMTTDISPINFOFc.uFlags);
4458         lpStruct->lParam = (*env)->GetLongField(env, lpObject, NMTTDISPINFOFc.lParam);
4459         return lpStruct;
4460 }
4461
4462 void setNMTTDISPINFOFields(JNIEnv *env, jobject lpObject, NMTTDISPINFO *lpStruct)
4463 {
4464         if (!NMTTDISPINFOFc.cached) cacheNMTTDISPINFOFields(env, lpObject);
4465         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4466         (*env)->SetLongField(env, lpObject, NMTTDISPINFOFc.lpszText, (jlong)lpStruct->lpszText);
4467         {
4468         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NMTTDISPINFOFc.szText);
4469         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szText) / sizeof(jchar), (jchar *)lpStruct->szText);
4470         }
4471         (*env)->SetLongField(env, lpObject, NMTTDISPINFOFc.hinst, (jlong)lpStruct->hinst);
4472         (*env)->SetIntField(env, lpObject, NMTTDISPINFOFc.uFlags, (jint)lpStruct->uFlags);
4473         (*env)->SetLongField(env, lpObject, NMTTDISPINFOFc.lParam, (jlong)lpStruct->lParam);
4474 }
4475 #endif
4476
4477 #ifndef NO_NMTVCUSTOMDRAW
4478 typedef struct NMTVCUSTOMDRAW_FID_CACHE {
4479         int cached;
4480         jclass clazz;
4481         jfieldID clrText, clrTextBk, iLevel;
4482 } NMTVCUSTOMDRAW_FID_CACHE;
4483
4484 NMTVCUSTOMDRAW_FID_CACHE NMTVCUSTOMDRAWFc;
4485
4486 void cacheNMTVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject)
4487 {
4488         if (NMTVCUSTOMDRAWFc.cached) return;
4489         cacheNMCUSTOMDRAWFields(env, lpObject);
4490         NMTVCUSTOMDRAWFc.clazz = (*env)->GetObjectClass(env, lpObject);
4491         NMTVCUSTOMDRAWFc.clrText = (*env)->GetFieldID(env, NMTVCUSTOMDRAWFc.clazz, "clrText", "I");
4492         NMTVCUSTOMDRAWFc.clrTextBk = (*env)->GetFieldID(env, NMTVCUSTOMDRAWFc.clazz, "clrTextBk", "I");
4493         NMTVCUSTOMDRAWFc.iLevel = (*env)->GetFieldID(env, NMTVCUSTOMDRAWFc.clazz, "iLevel", "I");
4494         NMTVCUSTOMDRAWFc.cached = 1;
4495 }
4496
4497 NMTVCUSTOMDRAW *getNMTVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTVCUSTOMDRAW *lpStruct)
4498 {
4499         if (!NMTVCUSTOMDRAWFc.cached) cacheNMTVCUSTOMDRAWFields(env, lpObject);
4500         getNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4501         lpStruct->clrText = (*env)->GetIntField(env, lpObject, NMTVCUSTOMDRAWFc.clrText);
4502         lpStruct->clrTextBk = (*env)->GetIntField(env, lpObject, NMTVCUSTOMDRAWFc.clrTextBk);
4503         lpStruct->iLevel = (*env)->GetIntField(env, lpObject, NMTVCUSTOMDRAWFc.iLevel);
4504         return lpStruct;
4505 }
4506
4507 void setNMTVCUSTOMDRAWFields(JNIEnv *env, jobject lpObject, NMTVCUSTOMDRAW *lpStruct)
4508 {
4509         if (!NMTVCUSTOMDRAWFc.cached) cacheNMTVCUSTOMDRAWFields(env, lpObject);
4510         setNMCUSTOMDRAWFields(env, lpObject, (NMCUSTOMDRAW *)lpStruct);
4511         (*env)->SetIntField(env, lpObject, NMTVCUSTOMDRAWFc.clrText, (jint)lpStruct->clrText);
4512         (*env)->SetIntField(env, lpObject, NMTVCUSTOMDRAWFc.clrTextBk, (jint)lpStruct->clrTextBk);
4513         (*env)->SetIntField(env, lpObject, NMTVCUSTOMDRAWFc.iLevel, (jint)lpStruct->iLevel);
4514 }
4515 #endif
4516
4517 #ifndef NO_NMTVDISPINFO
4518 typedef struct NMTVDISPINFO_FID_CACHE {
4519         int cached;
4520         jclass clazz;
4521         jfieldID mask, hItem, state, stateMask, pszText, cchTextMax, iImage, iSelectedImage, cChildren, lParam;
4522 } NMTVDISPINFO_FID_CACHE;
4523
4524 NMTVDISPINFO_FID_CACHE NMTVDISPINFOFc;
4525
4526 void cacheNMTVDISPINFOFields(JNIEnv *env, jobject lpObject)
4527 {
4528         if (NMTVDISPINFOFc.cached) return;
4529         cacheNMHDRFields(env, lpObject);
4530         NMTVDISPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
4531         NMTVDISPINFOFc.mask = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "mask", "I");
4532         NMTVDISPINFOFc.hItem = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "hItem", "J");
4533         NMTVDISPINFOFc.state = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "state", "I");
4534         NMTVDISPINFOFc.stateMask = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "stateMask", "I");
4535         NMTVDISPINFOFc.pszText = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "pszText", "J");
4536         NMTVDISPINFOFc.cchTextMax = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "cchTextMax", "I");
4537         NMTVDISPINFOFc.iImage = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "iImage", "I");
4538         NMTVDISPINFOFc.iSelectedImage = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "iSelectedImage", "I");
4539         NMTVDISPINFOFc.cChildren = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "cChildren", "I");
4540         NMTVDISPINFOFc.lParam = (*env)->GetFieldID(env, NMTVDISPINFOFc.clazz, "lParam", "J");
4541         NMTVDISPINFOFc.cached = 1;
4542 }
4543
4544 NMTVDISPINFO *getNMTVDISPINFOFields(JNIEnv *env, jobject lpObject, NMTVDISPINFO *lpStruct)
4545 {
4546         if (!NMTVDISPINFOFc.cached) cacheNMTVDISPINFOFields(env, lpObject);
4547         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4548         lpStruct->item.mask = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.mask);
4549         lpStruct->item.hItem = (HTREEITEM)(*env)->GetLongField(env, lpObject, NMTVDISPINFOFc.hItem);
4550         lpStruct->item.state = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.state);
4551         lpStruct->item.stateMask = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.stateMask);
4552         lpStruct->item.pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, NMTVDISPINFOFc.pszText);
4553         lpStruct->item.cchTextMax = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.cchTextMax);
4554         lpStruct->item.iImage = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.iImage);
4555         lpStruct->item.iSelectedImage = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.iSelectedImage);
4556         lpStruct->item.cChildren = (*env)->GetIntField(env, lpObject, NMTVDISPINFOFc.cChildren);
4557         lpStruct->item.lParam = (*env)->GetLongField(env, lpObject, NMTVDISPINFOFc.lParam);
4558         return lpStruct;
4559 }
4560
4561 void setNMTVDISPINFOFields(JNIEnv *env, jobject lpObject, NMTVDISPINFO *lpStruct)
4562 {
4563         if (!NMTVDISPINFOFc.cached) cacheNMTVDISPINFOFields(env, lpObject);
4564         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4565         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.mask, (jint)lpStruct->item.mask);
4566         (*env)->SetLongField(env, lpObject, NMTVDISPINFOFc.hItem, (jlong)lpStruct->item.hItem);
4567         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.state, (jint)lpStruct->item.state);
4568         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.stateMask, (jint)lpStruct->item.stateMask);
4569         (*env)->SetLongField(env, lpObject, NMTVDISPINFOFc.pszText, (jlong)lpStruct->item.pszText);
4570         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.cchTextMax, (jint)lpStruct->item.cchTextMax);
4571         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.iImage, (jint)lpStruct->item.iImage);
4572         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.iSelectedImage, (jint)lpStruct->item.iSelectedImage);
4573         (*env)->SetIntField(env, lpObject, NMTVDISPINFOFc.cChildren, (jint)lpStruct->item.cChildren);
4574         (*env)->SetLongField(env, lpObject, NMTVDISPINFOFc.lParam, (jlong)lpStruct->item.lParam);
4575 }
4576 #endif
4577
4578 #ifndef NO_NMTVITEMCHANGE
4579 typedef struct NMTVITEMCHANGE_FID_CACHE {
4580         int cached;
4581         jclass clazz;
4582         jfieldID uChanged, hItem, uStateNew, uStateOld, lParam;
4583 } NMTVITEMCHANGE_FID_CACHE;
4584
4585 NMTVITEMCHANGE_FID_CACHE NMTVITEMCHANGEFc;
4586
4587 void cacheNMTVITEMCHANGEFields(JNIEnv *env, jobject lpObject)
4588 {
4589         if (NMTVITEMCHANGEFc.cached) return;
4590         cacheNMHDRFields(env, lpObject);
4591         NMTVITEMCHANGEFc.clazz = (*env)->GetObjectClass(env, lpObject);
4592         NMTVITEMCHANGEFc.uChanged = (*env)->GetFieldID(env, NMTVITEMCHANGEFc.clazz, "uChanged", "I");
4593         NMTVITEMCHANGEFc.hItem = (*env)->GetFieldID(env, NMTVITEMCHANGEFc.clazz, "hItem", "J");
4594         NMTVITEMCHANGEFc.uStateNew = (*env)->GetFieldID(env, NMTVITEMCHANGEFc.clazz, "uStateNew", "I");
4595         NMTVITEMCHANGEFc.uStateOld = (*env)->GetFieldID(env, NMTVITEMCHANGEFc.clazz, "uStateOld", "I");
4596         NMTVITEMCHANGEFc.lParam = (*env)->GetFieldID(env, NMTVITEMCHANGEFc.clazz, "lParam", "J");
4597         NMTVITEMCHANGEFc.cached = 1;
4598 }
4599
4600 NMTVITEMCHANGE *getNMTVITEMCHANGEFields(JNIEnv *env, jobject lpObject, NMTVITEMCHANGE *lpStruct)
4601 {
4602         if (!NMTVITEMCHANGEFc.cached) cacheNMTVITEMCHANGEFields(env, lpObject);
4603         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4604         lpStruct->uChanged = (*env)->GetIntField(env, lpObject, NMTVITEMCHANGEFc.uChanged);
4605         lpStruct->hItem = (HTREEITEM)(*env)->GetLongField(env, lpObject, NMTVITEMCHANGEFc.hItem);
4606         lpStruct->uStateNew = (*env)->GetIntField(env, lpObject, NMTVITEMCHANGEFc.uStateNew);
4607         lpStruct->uStateOld = (*env)->GetIntField(env, lpObject, NMTVITEMCHANGEFc.uStateOld);
4608         lpStruct->lParam = (*env)->GetLongField(env, lpObject, NMTVITEMCHANGEFc.lParam);
4609         return lpStruct;
4610 }
4611
4612 void setNMTVITEMCHANGEFields(JNIEnv *env, jobject lpObject, NMTVITEMCHANGE *lpStruct)
4613 {
4614         if (!NMTVITEMCHANGEFc.cached) cacheNMTVITEMCHANGEFields(env, lpObject);
4615         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4616         (*env)->SetIntField(env, lpObject, NMTVITEMCHANGEFc.uChanged, (jint)lpStruct->uChanged);
4617         (*env)->SetLongField(env, lpObject, NMTVITEMCHANGEFc.hItem, (jlong)lpStruct->hItem);
4618         (*env)->SetIntField(env, lpObject, NMTVITEMCHANGEFc.uStateNew, (jint)lpStruct->uStateNew);
4619         (*env)->SetIntField(env, lpObject, NMTVITEMCHANGEFc.uStateOld, (jint)lpStruct->uStateOld);
4620         (*env)->SetLongField(env, lpObject, NMTVITEMCHANGEFc.lParam, (jlong)lpStruct->lParam);
4621 }
4622 #endif
4623
4624 #ifndef NO_NMUPDOWN
4625 typedef struct NMUPDOWN_FID_CACHE {
4626         int cached;
4627         jclass clazz;
4628         jfieldID iPos, iDelta;
4629 } NMUPDOWN_FID_CACHE;
4630
4631 NMUPDOWN_FID_CACHE NMUPDOWNFc;
4632
4633 void cacheNMUPDOWNFields(JNIEnv *env, jobject lpObject)
4634 {
4635         if (NMUPDOWNFc.cached) return;
4636         cacheNMHDRFields(env, lpObject);
4637         NMUPDOWNFc.clazz = (*env)->GetObjectClass(env, lpObject);
4638         NMUPDOWNFc.iPos = (*env)->GetFieldID(env, NMUPDOWNFc.clazz, "iPos", "I");
4639         NMUPDOWNFc.iDelta = (*env)->GetFieldID(env, NMUPDOWNFc.clazz, "iDelta", "I");
4640         NMUPDOWNFc.cached = 1;
4641 }
4642
4643 NMUPDOWN *getNMUPDOWNFields(JNIEnv *env, jobject lpObject, NMUPDOWN *lpStruct)
4644 {
4645         if (!NMUPDOWNFc.cached) cacheNMUPDOWNFields(env, lpObject);
4646         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4647         lpStruct->iPos = (*env)->GetIntField(env, lpObject, NMUPDOWNFc.iPos);
4648         lpStruct->iDelta = (*env)->GetIntField(env, lpObject, NMUPDOWNFc.iDelta);
4649         return lpStruct;
4650 }
4651
4652 void setNMUPDOWNFields(JNIEnv *env, jobject lpObject, NMUPDOWN *lpStruct)
4653 {
4654         if (!NMUPDOWNFc.cached) cacheNMUPDOWNFields(env, lpObject);
4655         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4656         (*env)->SetIntField(env, lpObject, NMUPDOWNFc.iPos, (jint)lpStruct->iPos);
4657         (*env)->SetIntField(env, lpObject, NMUPDOWNFc.iDelta, (jint)lpStruct->iDelta);
4658 }
4659 #endif
4660
4661 #ifndef NO_NONCLIENTMETRICS
4662 typedef struct NONCLIENTMETRICS_FID_CACHE {
4663         int cached;
4664         jclass clazz;
4665         jfieldID cbSize, iBorderWidth, iScrollWidth, iScrollHeight, iCaptionWidth, iCaptionHeight, lfCaptionFont, iSmCaptionWidth, iSmCaptionHeight, lfSmCaptionFont, iMenuWidth, iMenuHeight, lfMenuFont, lfStatusFont, lfMessageFont;
4666 } NONCLIENTMETRICS_FID_CACHE;
4667
4668 NONCLIENTMETRICS_FID_CACHE NONCLIENTMETRICSFc;
4669
4670 void cacheNONCLIENTMETRICSFields(JNIEnv *env, jobject lpObject)
4671 {
4672         if (NONCLIENTMETRICSFc.cached) return;
4673         NONCLIENTMETRICSFc.clazz = (*env)->GetObjectClass(env, lpObject);
4674         NONCLIENTMETRICSFc.cbSize = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "cbSize", "I");
4675         NONCLIENTMETRICSFc.iBorderWidth = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iBorderWidth", "I");
4676         NONCLIENTMETRICSFc.iScrollWidth = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iScrollWidth", "I");
4677         NONCLIENTMETRICSFc.iScrollHeight = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iScrollHeight", "I");
4678         NONCLIENTMETRICSFc.iCaptionWidth = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iCaptionWidth", "I");
4679         NONCLIENTMETRICSFc.iCaptionHeight = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iCaptionHeight", "I");
4680         NONCLIENTMETRICSFc.lfCaptionFont = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "lfCaptionFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
4681         NONCLIENTMETRICSFc.iSmCaptionWidth = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iSmCaptionWidth", "I");
4682         NONCLIENTMETRICSFc.iSmCaptionHeight = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iSmCaptionHeight", "I");
4683         NONCLIENTMETRICSFc.lfSmCaptionFont = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "lfSmCaptionFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
4684         NONCLIENTMETRICSFc.iMenuWidth = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iMenuWidth", "I");
4685         NONCLIENTMETRICSFc.iMenuHeight = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "iMenuHeight", "I");
4686         NONCLIENTMETRICSFc.lfMenuFont = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "lfMenuFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
4687         NONCLIENTMETRICSFc.lfStatusFont = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "lfStatusFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
4688         NONCLIENTMETRICSFc.lfMessageFont = (*env)->GetFieldID(env, NONCLIENTMETRICSFc.clazz, "lfMessageFont", "Lorg/eclipse/swt/internal/win32/LOGFONT;");
4689         NONCLIENTMETRICSFc.cached = 1;
4690 }
4691
4692 NONCLIENTMETRICS *getNONCLIENTMETRICSFields(JNIEnv *env, jobject lpObject, NONCLIENTMETRICS *lpStruct)
4693 {
4694         if (!NONCLIENTMETRICSFc.cached) cacheNONCLIENTMETRICSFields(env, lpObject);
4695         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.cbSize);
4696         lpStruct->iBorderWidth = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iBorderWidth);
4697         lpStruct->iScrollWidth = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iScrollWidth);
4698         lpStruct->iScrollHeight = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iScrollHeight);
4699         lpStruct->iCaptionWidth = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iCaptionWidth);
4700         lpStruct->iCaptionHeight = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iCaptionHeight);
4701         {
4702         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfCaptionFont);
4703         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->lfCaptionFont);
4704         }
4705         lpStruct->iSmCaptionWidth = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iSmCaptionWidth);
4706         lpStruct->iSmCaptionHeight = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iSmCaptionHeight);
4707         {
4708         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfSmCaptionFont);
4709         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->lfSmCaptionFont);
4710         }
4711         lpStruct->iMenuWidth = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iMenuWidth);
4712         lpStruct->iMenuHeight = (*env)->GetIntField(env, lpObject, NONCLIENTMETRICSFc.iMenuHeight);
4713         {
4714         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfMenuFont);
4715         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->lfMenuFont);
4716         }
4717         {
4718         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfStatusFont);
4719         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->lfStatusFont);
4720         }
4721         {
4722         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfMessageFont);
4723         if (lpObject1 != NULL) getLOGFONTFields(env, lpObject1, &lpStruct->lfMessageFont);
4724         }
4725         return lpStruct;
4726 }
4727
4728 void setNONCLIENTMETRICSFields(JNIEnv *env, jobject lpObject, NONCLIENTMETRICS *lpStruct)
4729 {
4730         if (!NONCLIENTMETRICSFc.cached) cacheNONCLIENTMETRICSFields(env, lpObject);
4731         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.cbSize, (jint)lpStruct->cbSize);
4732         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iBorderWidth, (jint)lpStruct->iBorderWidth);
4733         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iScrollWidth, (jint)lpStruct->iScrollWidth);
4734         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iScrollHeight, (jint)lpStruct->iScrollHeight);
4735         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iCaptionWidth, (jint)lpStruct->iCaptionWidth);
4736         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iCaptionHeight, (jint)lpStruct->iCaptionHeight);
4737         {
4738         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfCaptionFont);
4739         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->lfCaptionFont);
4740         }
4741         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iSmCaptionWidth, (jint)lpStruct->iSmCaptionWidth);
4742         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iSmCaptionHeight, (jint)lpStruct->iSmCaptionHeight);
4743         {
4744         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfSmCaptionFont);
4745         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->lfSmCaptionFont);
4746         }
4747         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iMenuWidth, (jint)lpStruct->iMenuWidth);
4748         (*env)->SetIntField(env, lpObject, NONCLIENTMETRICSFc.iMenuHeight, (jint)lpStruct->iMenuHeight);
4749         {
4750         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfMenuFont);
4751         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->lfMenuFont);
4752         }
4753         {
4754         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfStatusFont);
4755         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->lfStatusFont);
4756         }
4757         {
4758         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, NONCLIENTMETRICSFc.lfMessageFont);
4759         if (lpObject1 != NULL) setLOGFONTFields(env, lpObject1, &lpStruct->lfMessageFont);
4760         }
4761 }
4762 #endif
4763
4764 #ifndef NO_NOTIFYICONDATA
4765 typedef struct NOTIFYICONDATA_FID_CACHE {
4766         int cached;
4767         jclass clazz;
4768         jfieldID cbSize, hWnd, uID, uFlags, uCallbackMessage, hIcon, szTip, dwState, dwStateMask, szInfo, szInfoTitle, uVersion, dwInfoFlags;
4769 } NOTIFYICONDATA_FID_CACHE;
4770
4771 NOTIFYICONDATA_FID_CACHE NOTIFYICONDATAFc;
4772
4773 void cacheNOTIFYICONDATAFields(JNIEnv *env, jobject lpObject)
4774 {
4775         if (NOTIFYICONDATAFc.cached) return;
4776         NOTIFYICONDATAFc.clazz = (*env)->GetObjectClass(env, lpObject);
4777         NOTIFYICONDATAFc.cbSize = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "cbSize", "I");
4778         NOTIFYICONDATAFc.hWnd = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "hWnd", "J");
4779         NOTIFYICONDATAFc.uID = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "uID", "I");
4780         NOTIFYICONDATAFc.uFlags = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "uFlags", "I");
4781         NOTIFYICONDATAFc.uCallbackMessage = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "uCallbackMessage", "I");
4782         NOTIFYICONDATAFc.hIcon = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "hIcon", "J");
4783         NOTIFYICONDATAFc.szTip = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "szTip", "[C");
4784         NOTIFYICONDATAFc.dwState = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "dwState", "I");
4785         NOTIFYICONDATAFc.dwStateMask = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "dwStateMask", "I");
4786         NOTIFYICONDATAFc.szInfo = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "szInfo", "[C");
4787         NOTIFYICONDATAFc.szInfoTitle = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "szInfoTitle", "[C");
4788         NOTIFYICONDATAFc.uVersion = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "uVersion", "I");
4789         NOTIFYICONDATAFc.dwInfoFlags = (*env)->GetFieldID(env, NOTIFYICONDATAFc.clazz, "dwInfoFlags", "I");
4790         NOTIFYICONDATAFc.cached = 1;
4791 }
4792
4793 NOTIFYICONDATA *getNOTIFYICONDATAFields(JNIEnv *env, jobject lpObject, NOTIFYICONDATA *lpStruct)
4794 {
4795         if (!NOTIFYICONDATAFc.cached) cacheNOTIFYICONDATAFields(env, lpObject);
4796         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.cbSize);
4797         lpStruct->hWnd = (HWND)(*env)->GetLongField(env, lpObject, NOTIFYICONDATAFc.hWnd);
4798         lpStruct->uID = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.uID);
4799         lpStruct->uFlags = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.uFlags);
4800         lpStruct->uCallbackMessage = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.uCallbackMessage);
4801         lpStruct->hIcon = (HICON)(*env)->GetLongField(env, lpObject, NOTIFYICONDATAFc.hIcon);
4802         {
4803         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szTip);
4804         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szTip) / sizeof(jchar), (jchar *)lpStruct->szTip);
4805         }
4806         lpStruct->dwState = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.dwState);
4807         lpStruct->dwStateMask = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.dwStateMask);
4808         {
4809         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szInfo);
4810         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szInfo) / sizeof(jchar), (jchar *)lpStruct->szInfo);
4811         }
4812         {
4813         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szInfoTitle);
4814         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szInfoTitle) / sizeof(jchar), (jchar *)lpStruct->szInfoTitle);
4815         }
4816         lpStruct->uVersion = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.uVersion);
4817         lpStruct->dwInfoFlags = (*env)->GetIntField(env, lpObject, NOTIFYICONDATAFc.dwInfoFlags);
4818         return lpStruct;
4819 }
4820
4821 void setNOTIFYICONDATAFields(JNIEnv *env, jobject lpObject, NOTIFYICONDATA *lpStruct)
4822 {
4823         if (!NOTIFYICONDATAFc.cached) cacheNOTIFYICONDATAFields(env, lpObject);
4824         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.cbSize, (jint)lpStruct->cbSize);
4825         (*env)->SetLongField(env, lpObject, NOTIFYICONDATAFc.hWnd, (jlong)lpStruct->hWnd);
4826         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.uID, (jint)lpStruct->uID);
4827         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.uFlags, (jint)lpStruct->uFlags);
4828         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.uCallbackMessage, (jint)lpStruct->uCallbackMessage);
4829         (*env)->SetLongField(env, lpObject, NOTIFYICONDATAFc.hIcon, (jlong)lpStruct->hIcon);
4830         {
4831         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szTip);
4832         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szTip) / sizeof(jchar), (jchar *)lpStruct->szTip);
4833         }
4834         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.dwState, (jint)lpStruct->dwState);
4835         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.dwStateMask, (jint)lpStruct->dwStateMask);
4836         {
4837         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szInfo);
4838         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szInfo) / sizeof(jchar), (jchar *)lpStruct->szInfo);
4839         }
4840         {
4841         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, NOTIFYICONDATAFc.szInfoTitle);
4842         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szInfoTitle) / sizeof(jchar), (jchar *)lpStruct->szInfoTitle);
4843         }
4844         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.uVersion, (jint)lpStruct->uVersion);
4845         (*env)->SetIntField(env, lpObject, NOTIFYICONDATAFc.dwInfoFlags, (jint)lpStruct->dwInfoFlags);
4846 }
4847 #endif
4848
4849 #ifndef NO_OFNOTIFY
4850 typedef struct OFNOTIFY_FID_CACHE {
4851         int cached;
4852         jclass clazz;
4853         jfieldID lpOFN, pszFile;
4854 } OFNOTIFY_FID_CACHE;
4855
4856 OFNOTIFY_FID_CACHE OFNOTIFYFc;
4857
4858 void cacheOFNOTIFYFields(JNIEnv *env, jobject lpObject)
4859 {
4860         if (OFNOTIFYFc.cached) return;
4861         cacheNMHDRFields(env, lpObject);
4862         OFNOTIFYFc.clazz = (*env)->GetObjectClass(env, lpObject);
4863         OFNOTIFYFc.lpOFN = (*env)->GetFieldID(env, OFNOTIFYFc.clazz, "lpOFN", "J");
4864         OFNOTIFYFc.pszFile = (*env)->GetFieldID(env, OFNOTIFYFc.clazz, "pszFile", "J");
4865         OFNOTIFYFc.cached = 1;
4866 }
4867
4868 OFNOTIFY *getOFNOTIFYFields(JNIEnv *env, jobject lpObject, OFNOTIFY *lpStruct)
4869 {
4870         if (!OFNOTIFYFc.cached) cacheOFNOTIFYFields(env, lpObject);
4871         getNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4872         lpStruct->lpOFN = (LPOPENFILENAME)(*env)->GetLongField(env, lpObject, OFNOTIFYFc.lpOFN);
4873         lpStruct->pszFile = (LPTSTR)(*env)->GetLongField(env, lpObject, OFNOTIFYFc.pszFile);
4874         return lpStruct;
4875 }
4876
4877 void setOFNOTIFYFields(JNIEnv *env, jobject lpObject, OFNOTIFY *lpStruct)
4878 {
4879         if (!OFNOTIFYFc.cached) cacheOFNOTIFYFields(env, lpObject);
4880         setNMHDRFields(env, lpObject, (NMHDR *)lpStruct);
4881         (*env)->SetLongField(env, lpObject, OFNOTIFYFc.lpOFN, (jlong)lpStruct->lpOFN);
4882         (*env)->SetLongField(env, lpObject, OFNOTIFYFc.pszFile, (jlong)lpStruct->pszFile);
4883 }
4884 #endif
4885
4886 #ifndef NO_OPENFILENAME
4887 typedef struct OPENFILENAME_FID_CACHE {
4888         int cached;
4889         jclass clazz;
4890         jfieldID lStructSize, hwndOwner, hInstance, lpstrFilter, lpstrCustomFilter, nMaxCustFilter, nFilterIndex, lpstrFile, nMaxFile, lpstrFileTitle, nMaxFileTitle, lpstrInitialDir, lpstrTitle, Flags, nFileOffset, nFileExtension, lpstrDefExt, lCustData, lpfnHook, lpTemplateName, pvReserved, dwReserved, FlagsEx;
4891 } OPENFILENAME_FID_CACHE;
4892
4893 OPENFILENAME_FID_CACHE OPENFILENAMEFc;
4894
4895 void cacheOPENFILENAMEFields(JNIEnv *env, jobject lpObject)
4896 {
4897         if (OPENFILENAMEFc.cached) return;
4898         OPENFILENAMEFc.clazz = (*env)->GetObjectClass(env, lpObject);
4899         OPENFILENAMEFc.lStructSize = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lStructSize", "I");
4900         OPENFILENAMEFc.hwndOwner = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "hwndOwner", "J");
4901         OPENFILENAMEFc.hInstance = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "hInstance", "J");
4902         OPENFILENAMEFc.lpstrFilter = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrFilter", "J");
4903         OPENFILENAMEFc.lpstrCustomFilter = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrCustomFilter", "J");
4904         OPENFILENAMEFc.nMaxCustFilter = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nMaxCustFilter", "I");
4905         OPENFILENAMEFc.nFilterIndex = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nFilterIndex", "I");
4906         OPENFILENAMEFc.lpstrFile = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrFile", "J");
4907         OPENFILENAMEFc.nMaxFile = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nMaxFile", "I");
4908         OPENFILENAMEFc.lpstrFileTitle = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrFileTitle", "J");
4909         OPENFILENAMEFc.nMaxFileTitle = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nMaxFileTitle", "I");
4910         OPENFILENAMEFc.lpstrInitialDir = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrInitialDir", "J");
4911         OPENFILENAMEFc.lpstrTitle = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrTitle", "J");
4912         OPENFILENAMEFc.Flags = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "Flags", "I");
4913         OPENFILENAMEFc.nFileOffset = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nFileOffset", "S");
4914         OPENFILENAMEFc.nFileExtension = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "nFileExtension", "S");
4915         OPENFILENAMEFc.lpstrDefExt = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpstrDefExt", "J");
4916         OPENFILENAMEFc.lCustData = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lCustData", "J");
4917         OPENFILENAMEFc.lpfnHook = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpfnHook", "J");
4918         OPENFILENAMEFc.lpTemplateName = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "lpTemplateName", "J");
4919         OPENFILENAMEFc.pvReserved = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "pvReserved", "J");
4920         OPENFILENAMEFc.dwReserved = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "dwReserved", "I");
4921         OPENFILENAMEFc.FlagsEx = (*env)->GetFieldID(env, OPENFILENAMEFc.clazz, "FlagsEx", "I");
4922         OPENFILENAMEFc.cached = 1;
4923 }
4924
4925 OPENFILENAME *getOPENFILENAMEFields(JNIEnv *env, jobject lpObject, OPENFILENAME *lpStruct)
4926 {
4927         if (!OPENFILENAMEFc.cached) cacheOPENFILENAMEFields(env, lpObject);
4928         lpStruct->lStructSize = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.lStructSize);
4929         lpStruct->hwndOwner = (HWND)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.hwndOwner);
4930         lpStruct->hInstance = (HINSTANCE)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.hInstance);
4931         lpStruct->lpstrFilter = (LPCTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrFilter);
4932         lpStruct->lpstrCustomFilter = (LPTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrCustomFilter);
4933         lpStruct->nMaxCustFilter = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.nMaxCustFilter);
4934         lpStruct->nFilterIndex = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.nFilterIndex);
4935         lpStruct->lpstrFile = (LPTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrFile);
4936         lpStruct->nMaxFile = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.nMaxFile);
4937         lpStruct->lpstrFileTitle = (LPTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrFileTitle);
4938         lpStruct->nMaxFileTitle = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.nMaxFileTitle);
4939         lpStruct->lpstrInitialDir = (LPCTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrInitialDir);
4940         lpStruct->lpstrTitle = (LPCTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrTitle);
4941         lpStruct->Flags = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.Flags);
4942         lpStruct->nFileOffset = (*env)->GetShortField(env, lpObject, OPENFILENAMEFc.nFileOffset);
4943         lpStruct->nFileExtension = (*env)->GetShortField(env, lpObject, OPENFILENAMEFc.nFileExtension);
4944         lpStruct->lpstrDefExt = (LPCTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpstrDefExt);
4945         lpStruct->lCustData = (*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lCustData);
4946         lpStruct->lpfnHook = (LPOFNHOOKPROC)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpfnHook);
4947         lpStruct->lpTemplateName = (LPCTSTR)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.lpTemplateName);
4948         lpStruct->pvReserved = (void *)(*env)->GetLongField(env, lpObject, OPENFILENAMEFc.pvReserved);
4949         lpStruct->dwReserved = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.dwReserved);
4950         lpStruct->FlagsEx = (*env)->GetIntField(env, lpObject, OPENFILENAMEFc.FlagsEx);
4951         return lpStruct;
4952 }
4953
4954 void setOPENFILENAMEFields(JNIEnv *env, jobject lpObject, OPENFILENAME *lpStruct)
4955 {
4956         if (!OPENFILENAMEFc.cached) cacheOPENFILENAMEFields(env, lpObject);
4957         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.lStructSize, (jint)lpStruct->lStructSize);
4958         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.hwndOwner, (jlong)lpStruct->hwndOwner);
4959         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.hInstance, (jlong)lpStruct->hInstance);
4960         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrFilter, (jlong)lpStruct->lpstrFilter);
4961         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrCustomFilter, (jlong)lpStruct->lpstrCustomFilter);
4962         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.nMaxCustFilter, (jint)lpStruct->nMaxCustFilter);
4963         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.nFilterIndex, (jint)lpStruct->nFilterIndex);
4964         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrFile, (jlong)lpStruct->lpstrFile);
4965         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.nMaxFile, (jint)lpStruct->nMaxFile);
4966         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrFileTitle, (jlong)lpStruct->lpstrFileTitle);
4967         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.nMaxFileTitle, (jint)lpStruct->nMaxFileTitle);
4968         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrInitialDir, (jlong)lpStruct->lpstrInitialDir);
4969         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrTitle, (jlong)lpStruct->lpstrTitle);
4970         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.Flags, (jint)lpStruct->Flags);
4971         (*env)->SetShortField(env, lpObject, OPENFILENAMEFc.nFileOffset, (jshort)lpStruct->nFileOffset);
4972         (*env)->SetShortField(env, lpObject, OPENFILENAMEFc.nFileExtension, (jshort)lpStruct->nFileExtension);
4973         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpstrDefExt, (jlong)lpStruct->lpstrDefExt);
4974         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lCustData, (jlong)lpStruct->lCustData);
4975         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpfnHook, (jlong)lpStruct->lpfnHook);
4976         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.lpTemplateName, (jlong)lpStruct->lpTemplateName);
4977         (*env)->SetLongField(env, lpObject, OPENFILENAMEFc.pvReserved, (jlong)lpStruct->pvReserved);
4978         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.dwReserved, (jint)lpStruct->dwReserved);
4979         (*env)->SetIntField(env, lpObject, OPENFILENAMEFc.FlagsEx, (jint)lpStruct->FlagsEx);
4980 }
4981 #endif
4982
4983 #ifndef NO_OUTLINETEXTMETRIC
4984 typedef struct OUTLINETEXTMETRIC_FID_CACHE {
4985         int cached;
4986         jclass clazz;
4987         jfieldID otmSize, otmTextMetrics, otmFiller, otmPanoseNumber_bFamilyType, otmPanoseNumber_bSerifStyle, otmPanoseNumber_bWeight, otmPanoseNumber_bProportion, otmPanoseNumber_bContrast, otmPanoseNumber_bStrokeVariation, otmPanoseNumber_bArmStyle, otmPanoseNumber_bLetterform, otmPanoseNumber_bMidline, otmPanoseNumber_bXHeight, otmfsSelection, otmfsType, otmsCharSlopeRise, otmsCharSlopeRun, otmItalicAngle, otmEMSquare, otmAscent, otmDescent, otmLineGap, otmsCapEmHeight, otmsXHeight, otmrcFontBox, otmMacAscent, otmMacDescent, otmMacLineGap, otmusMinimumPPEM, otmptSubscriptSize, otmptSubscriptOffset, otmptSuperscriptSize, otmptSuperscriptOffset, otmsStrikeoutSize, otmsStrikeoutPosition, otmsUnderscoreSize, otmsUnderscorePosition, otmpFamilyName, otmpFaceName, otmpStyleName, otmpFullName;
4988 } OUTLINETEXTMETRIC_FID_CACHE;
4989
4990 OUTLINETEXTMETRIC_FID_CACHE OUTLINETEXTMETRICFc;
4991
4992 void cacheOUTLINETEXTMETRICFields(JNIEnv *env, jobject lpObject)
4993 {
4994         if (OUTLINETEXTMETRICFc.cached) return;
4995         OUTLINETEXTMETRICFc.clazz = (*env)->GetObjectClass(env, lpObject);
4996         OUTLINETEXTMETRICFc.otmSize = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmSize", "I");
4997         OUTLINETEXTMETRICFc.otmTextMetrics = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmTextMetrics", "Lorg/eclipse/swt/internal/win32/TEXTMETRIC;");
4998         OUTLINETEXTMETRICFc.otmFiller = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmFiller", "B");
4999         OUTLINETEXTMETRICFc.otmPanoseNumber_bFamilyType = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bFamilyType", "B");
5000         OUTLINETEXTMETRICFc.otmPanoseNumber_bSerifStyle = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bSerifStyle", "B");
5001         OUTLINETEXTMETRICFc.otmPanoseNumber_bWeight = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bWeight", "B");
5002         OUTLINETEXTMETRICFc.otmPanoseNumber_bProportion = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bProportion", "B");
5003         OUTLINETEXTMETRICFc.otmPanoseNumber_bContrast = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bContrast", "B");
5004         OUTLINETEXTMETRICFc.otmPanoseNumber_bStrokeVariation = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bStrokeVariation", "B");
5005         OUTLINETEXTMETRICFc.otmPanoseNumber_bArmStyle = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bArmStyle", "B");
5006         OUTLINETEXTMETRICFc.otmPanoseNumber_bLetterform = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bLetterform", "B");
5007         OUTLINETEXTMETRICFc.otmPanoseNumber_bMidline = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bMidline", "B");
5008         OUTLINETEXTMETRICFc.otmPanoseNumber_bXHeight = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmPanoseNumber_bXHeight", "B");
5009         OUTLINETEXTMETRICFc.otmfsSelection = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmfsSelection", "I");
5010         OUTLINETEXTMETRICFc.otmfsType = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmfsType", "I");
5011         OUTLINETEXTMETRICFc.otmsCharSlopeRise = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsCharSlopeRise", "I");
5012         OUTLINETEXTMETRICFc.otmsCharSlopeRun = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsCharSlopeRun", "I");
5013         OUTLINETEXTMETRICFc.otmItalicAngle = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmItalicAngle", "I");
5014         OUTLINETEXTMETRICFc.otmEMSquare = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmEMSquare", "I");
5015         OUTLINETEXTMETRICFc.otmAscent = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmAscent", "I");
5016         OUTLINETEXTMETRICFc.otmDescent = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmDescent", "I");
5017         OUTLINETEXTMETRICFc.otmLineGap = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmLineGap", "I");
5018         OUTLINETEXTMETRICFc.otmsCapEmHeight = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsCapEmHeight", "I");
5019         OUTLINETEXTMETRICFc.otmsXHeight = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsXHeight", "I");
5020         OUTLINETEXTMETRICFc.otmrcFontBox = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmrcFontBox", "Lorg/eclipse/swt/internal/win32/RECT;");
5021         OUTLINETEXTMETRICFc.otmMacAscent = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmMacAscent", "I");
5022         OUTLINETEXTMETRICFc.otmMacDescent = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmMacDescent", "I");
5023         OUTLINETEXTMETRICFc.otmMacLineGap = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmMacLineGap", "I");
5024         OUTLINETEXTMETRICFc.otmusMinimumPPEM = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmusMinimumPPEM", "I");
5025         OUTLINETEXTMETRICFc.otmptSubscriptSize = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmptSubscriptSize", "Lorg/eclipse/swt/internal/win32/POINT;");
5026         OUTLINETEXTMETRICFc.otmptSubscriptOffset = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmptSubscriptOffset", "Lorg/eclipse/swt/internal/win32/POINT;");
5027         OUTLINETEXTMETRICFc.otmptSuperscriptSize = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmptSuperscriptSize", "Lorg/eclipse/swt/internal/win32/POINT;");
5028         OUTLINETEXTMETRICFc.otmptSuperscriptOffset = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmptSuperscriptOffset", "Lorg/eclipse/swt/internal/win32/POINT;");
5029         OUTLINETEXTMETRICFc.otmsStrikeoutSize = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsStrikeoutSize", "I");
5030         OUTLINETEXTMETRICFc.otmsStrikeoutPosition = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsStrikeoutPosition", "I");
5031         OUTLINETEXTMETRICFc.otmsUnderscoreSize = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsUnderscoreSize", "I");
5032         OUTLINETEXTMETRICFc.otmsUnderscorePosition = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmsUnderscorePosition", "I");
5033         OUTLINETEXTMETRICFc.otmpFamilyName = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmpFamilyName", "J");
5034         OUTLINETEXTMETRICFc.otmpFaceName = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmpFaceName", "J");
5035         OUTLINETEXTMETRICFc.otmpStyleName = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmpStyleName", "J");
5036         OUTLINETEXTMETRICFc.otmpFullName = (*env)->GetFieldID(env, OUTLINETEXTMETRICFc.clazz, "otmpFullName", "J");
5037         OUTLINETEXTMETRICFc.cached = 1;
5038 }
5039
5040 OUTLINETEXTMETRIC *getOUTLINETEXTMETRICFields(JNIEnv *env, jobject lpObject, OUTLINETEXTMETRIC *lpStruct)
5041 {
5042         if (!OUTLINETEXTMETRICFc.cached) cacheOUTLINETEXTMETRICFields(env, lpObject);
5043         lpStruct->otmSize = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmSize);
5044         {
5045         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmTextMetrics);
5046         if (lpObject1 != NULL) getTEXTMETRICFields(env, lpObject1, &lpStruct->otmTextMetrics);
5047         }
5048         lpStruct->otmFiller = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmFiller);
5049         lpStruct->otmPanoseNumber.bFamilyType = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bFamilyType);
5050         lpStruct->otmPanoseNumber.bSerifStyle = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bSerifStyle);
5051         lpStruct->otmPanoseNumber.bWeight = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bWeight);
5052         lpStruct->otmPanoseNumber.bProportion = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bProportion);
5053         lpStruct->otmPanoseNumber.bContrast = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bContrast);
5054         lpStruct->otmPanoseNumber.bStrokeVariation = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bStrokeVariation);
5055         lpStruct->otmPanoseNumber.bArmStyle = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bArmStyle);
5056         lpStruct->otmPanoseNumber.bLetterform = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bLetterform);
5057         lpStruct->otmPanoseNumber.bMidline = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bMidline);
5058         lpStruct->otmPanoseNumber.bXHeight = (*env)->GetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bXHeight);
5059         lpStruct->otmfsSelection = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmfsSelection);
5060         lpStruct->otmfsType = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmfsType);
5061         lpStruct->otmsCharSlopeRise = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCharSlopeRise);
5062         lpStruct->otmsCharSlopeRun = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCharSlopeRun);
5063         lpStruct->otmItalicAngle = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmItalicAngle);
5064         lpStruct->otmEMSquare = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmEMSquare);
5065         lpStruct->otmAscent = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmAscent);
5066         lpStruct->otmDescent = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmDescent);
5067         lpStruct->otmLineGap = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmLineGap);
5068         lpStruct->otmsCapEmHeight = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCapEmHeight);
5069         lpStruct->otmsXHeight = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsXHeight);
5070         {
5071         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmrcFontBox);
5072         if (lpObject1 != NULL) getRECTFields(env, lpObject1, &lpStruct->otmrcFontBox);
5073         }
5074         lpStruct->otmMacAscent = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacAscent);
5075         lpStruct->otmMacDescent = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacDescent);
5076         lpStruct->otmMacLineGap = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacLineGap);
5077         lpStruct->otmusMinimumPPEM = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmusMinimumPPEM);
5078         {
5079         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSubscriptSize);
5080         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->otmptSubscriptSize);
5081         }
5082         {
5083         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSubscriptOffset);
5084         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->otmptSubscriptOffset);
5085         }
5086         {
5087         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSuperscriptSize);
5088         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->otmptSuperscriptSize);
5089         }
5090         {
5091         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSuperscriptOffset);
5092         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->otmptSuperscriptOffset);
5093         }
5094         lpStruct->otmsStrikeoutSize = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsStrikeoutSize);
5095         lpStruct->otmsStrikeoutPosition = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsStrikeoutPosition);
5096         lpStruct->otmsUnderscoreSize = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsUnderscoreSize);
5097         lpStruct->otmsUnderscorePosition = (*env)->GetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsUnderscorePosition);
5098         lpStruct->otmpFamilyName = (PSTR)(*env)->GetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFamilyName);
5099         lpStruct->otmpFaceName = (PSTR)(*env)->GetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFaceName);
5100         lpStruct->otmpStyleName = (PSTR)(*env)->GetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpStyleName);
5101         lpStruct->otmpFullName = (PSTR)(*env)->GetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFullName);
5102         return lpStruct;
5103 }
5104
5105 void setOUTLINETEXTMETRICFields(JNIEnv *env, jobject lpObject, OUTLINETEXTMETRIC *lpStruct)
5106 {
5107         if (!OUTLINETEXTMETRICFc.cached) cacheOUTLINETEXTMETRICFields(env, lpObject);
5108         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmSize, (jint)lpStruct->otmSize);
5109         {
5110         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmTextMetrics);
5111         if (lpObject1 != NULL) setTEXTMETRICFields(env, lpObject1, &lpStruct->otmTextMetrics);
5112         }
5113         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmFiller, (jbyte)lpStruct->otmFiller);
5114         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bFamilyType, (jbyte)lpStruct->otmPanoseNumber.bFamilyType);
5115         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bSerifStyle, (jbyte)lpStruct->otmPanoseNumber.bSerifStyle);
5116         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bWeight, (jbyte)lpStruct->otmPanoseNumber.bWeight);
5117         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bProportion, (jbyte)lpStruct->otmPanoseNumber.bProportion);
5118         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bContrast, (jbyte)lpStruct->otmPanoseNumber.bContrast);
5119         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bStrokeVariation, (jbyte)lpStruct->otmPanoseNumber.bStrokeVariation);
5120         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bArmStyle, (jbyte)lpStruct->otmPanoseNumber.bArmStyle);
5121         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bLetterform, (jbyte)lpStruct->otmPanoseNumber.bLetterform);
5122         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bMidline, (jbyte)lpStruct->otmPanoseNumber.bMidline);
5123         (*env)->SetByteField(env, lpObject, OUTLINETEXTMETRICFc.otmPanoseNumber_bXHeight, (jbyte)lpStruct->otmPanoseNumber.bXHeight);
5124         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmfsSelection, (jint)lpStruct->otmfsSelection);
5125         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmfsType, (jint)lpStruct->otmfsType);
5126         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCharSlopeRise, (jint)lpStruct->otmsCharSlopeRise);
5127         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCharSlopeRun, (jint)lpStruct->otmsCharSlopeRun);
5128         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmItalicAngle, (jint)lpStruct->otmItalicAngle);
5129         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmEMSquare, (jint)lpStruct->otmEMSquare);
5130         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmAscent, (jint)lpStruct->otmAscent);
5131         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmDescent, (jint)lpStruct->otmDescent);
5132         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmLineGap, (jint)lpStruct->otmLineGap);
5133         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsCapEmHeight, (jint)lpStruct->otmsCapEmHeight);
5134         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsXHeight, (jint)lpStruct->otmsXHeight);
5135         {
5136         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmrcFontBox);
5137         if (lpObject1 != NULL) setRECTFields(env, lpObject1, &lpStruct->otmrcFontBox);
5138         }
5139         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacAscent, (jint)lpStruct->otmMacAscent);
5140         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacDescent, (jint)lpStruct->otmMacDescent);
5141         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmMacLineGap, (jint)lpStruct->otmMacLineGap);
5142         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmusMinimumPPEM, (jint)lpStruct->otmusMinimumPPEM);
5143         {
5144         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSubscriptSize);
5145         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->otmptSubscriptSize);
5146         }
5147         {
5148         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSubscriptOffset);
5149         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->otmptSubscriptOffset);
5150         }
5151         {
5152         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSuperscriptSize);
5153         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->otmptSuperscriptSize);
5154         }
5155         {
5156         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, OUTLINETEXTMETRICFc.otmptSuperscriptOffset);
5157         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->otmptSuperscriptOffset);
5158         }
5159         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsStrikeoutSize, (jint)lpStruct->otmsStrikeoutSize);
5160         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsStrikeoutPosition, (jint)lpStruct->otmsStrikeoutPosition);
5161         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsUnderscoreSize, (jint)lpStruct->otmsUnderscoreSize);
5162         (*env)->SetIntField(env, lpObject, OUTLINETEXTMETRICFc.otmsUnderscorePosition, (jint)lpStruct->otmsUnderscorePosition);
5163         (*env)->SetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFamilyName, (jlong)lpStruct->otmpFamilyName);
5164         (*env)->SetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFaceName, (jlong)lpStruct->otmpFaceName);
5165         (*env)->SetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpStyleName, (jlong)lpStruct->otmpStyleName);
5166         (*env)->SetLongField(env, lpObject, OUTLINETEXTMETRICFc.otmpFullName, (jlong)lpStruct->otmpFullName);
5167 }
5168 #endif
5169
5170 #ifndef NO_PAINTSTRUCT
5171 typedef struct PAINTSTRUCT_FID_CACHE {
5172         int cached;
5173         jclass clazz;
5174         jfieldID hdc, fErase, left, top, right, bottom, fRestore, fIncUpdate, rgbReserved;
5175 } PAINTSTRUCT_FID_CACHE;
5176
5177 PAINTSTRUCT_FID_CACHE PAINTSTRUCTFc;
5178
5179 void cachePAINTSTRUCTFields(JNIEnv *env, jobject lpObject)
5180 {
5181         if (PAINTSTRUCTFc.cached) return;
5182         PAINTSTRUCTFc.clazz = (*env)->GetObjectClass(env, lpObject);
5183         PAINTSTRUCTFc.hdc = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "hdc", "J");
5184         PAINTSTRUCTFc.fErase = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "fErase", "Z");
5185         PAINTSTRUCTFc.left = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "left", "I");
5186         PAINTSTRUCTFc.top = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "top", "I");
5187         PAINTSTRUCTFc.right = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "right", "I");
5188         PAINTSTRUCTFc.bottom = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "bottom", "I");
5189         PAINTSTRUCTFc.fRestore = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "fRestore", "Z");
5190         PAINTSTRUCTFc.fIncUpdate = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "fIncUpdate", "Z");
5191         PAINTSTRUCTFc.rgbReserved = (*env)->GetFieldID(env, PAINTSTRUCTFc.clazz, "rgbReserved", "[B");
5192         PAINTSTRUCTFc.cached = 1;
5193 }
5194
5195 PAINTSTRUCT *getPAINTSTRUCTFields(JNIEnv *env, jobject lpObject, PAINTSTRUCT *lpStruct)
5196 {
5197         if (!PAINTSTRUCTFc.cached) cachePAINTSTRUCTFields(env, lpObject);
5198         lpStruct->hdc = (HDC)(*env)->GetLongField(env, lpObject, PAINTSTRUCTFc.hdc);
5199         lpStruct->fErase = (*env)->GetBooleanField(env, lpObject, PAINTSTRUCTFc.fErase);
5200         lpStruct->rcPaint.left = (*env)->GetIntField(env, lpObject, PAINTSTRUCTFc.left);
5201         lpStruct->rcPaint.top = (*env)->GetIntField(env, lpObject, PAINTSTRUCTFc.top);
5202         lpStruct->rcPaint.right = (*env)->GetIntField(env, lpObject, PAINTSTRUCTFc.right);
5203         lpStruct->rcPaint.bottom = (*env)->GetIntField(env, lpObject, PAINTSTRUCTFc.bottom);
5204         lpStruct->fRestore = (*env)->GetBooleanField(env, lpObject, PAINTSTRUCTFc.fRestore);
5205         lpStruct->fIncUpdate = (*env)->GetBooleanField(env, lpObject, PAINTSTRUCTFc.fIncUpdate);
5206         {
5207         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, PAINTSTRUCTFc.rgbReserved);
5208         (*env)->GetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->rgbReserved), (jbyte *)lpStruct->rgbReserved);
5209         }
5210         return lpStruct;
5211 }
5212
5213 void setPAINTSTRUCTFields(JNIEnv *env, jobject lpObject, PAINTSTRUCT *lpStruct)
5214 {
5215         if (!PAINTSTRUCTFc.cached) cachePAINTSTRUCTFields(env, lpObject);
5216         (*env)->SetLongField(env, lpObject, PAINTSTRUCTFc.hdc, (jlong)lpStruct->hdc);
5217         (*env)->SetBooleanField(env, lpObject, PAINTSTRUCTFc.fErase, (jboolean)lpStruct->fErase);
5218         (*env)->SetIntField(env, lpObject, PAINTSTRUCTFc.left, (jint)lpStruct->rcPaint.left);
5219         (*env)->SetIntField(env, lpObject, PAINTSTRUCTFc.top, (jint)lpStruct->rcPaint.top);
5220         (*env)->SetIntField(env, lpObject, PAINTSTRUCTFc.right, (jint)lpStruct->rcPaint.right);
5221         (*env)->SetIntField(env, lpObject, PAINTSTRUCTFc.bottom, (jint)lpStruct->rcPaint.bottom);
5222         (*env)->SetBooleanField(env, lpObject, PAINTSTRUCTFc.fRestore, (jboolean)lpStruct->fRestore);
5223         (*env)->SetBooleanField(env, lpObject, PAINTSTRUCTFc.fIncUpdate, (jboolean)lpStruct->fIncUpdate);
5224         {
5225         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, PAINTSTRUCTFc.rgbReserved);
5226         (*env)->SetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->rgbReserved), (jbyte *)lpStruct->rgbReserved);
5227         }
5228 }
5229 #endif
5230
5231 #ifndef NO_PANOSE
5232 typedef struct PANOSE_FID_CACHE {
5233         int cached;
5234         jclass clazz;
5235         jfieldID bFamilyType, bSerifStyle, bWeight, bProportion, bContrast, bStrokeVariation, bArmStyle, bLetterform, bMidline, bXHeight;
5236 } PANOSE_FID_CACHE;
5237
5238 PANOSE_FID_CACHE PANOSEFc;
5239
5240 void cachePANOSEFields(JNIEnv *env, jobject lpObject)
5241 {
5242         if (PANOSEFc.cached) return;
5243         PANOSEFc.clazz = (*env)->GetObjectClass(env, lpObject);
5244         PANOSEFc.bFamilyType = (*env)->GetFieldID(env, PANOSEFc.clazz, "bFamilyType", "B");
5245         PANOSEFc.bSerifStyle = (*env)->GetFieldID(env, PANOSEFc.clazz, "bSerifStyle", "B");
5246         PANOSEFc.bWeight = (*env)->GetFieldID(env, PANOSEFc.clazz, "bWeight", "B");
5247         PANOSEFc.bProportion = (*env)->GetFieldID(env, PANOSEFc.clazz, "bProportion", "B");
5248         PANOSEFc.bContrast = (*env)->GetFieldID(env, PANOSEFc.clazz, "bContrast", "B");
5249         PANOSEFc.bStrokeVariation = (*env)->GetFieldID(env, PANOSEFc.clazz, "bStrokeVariation", "B");
5250         PANOSEFc.bArmStyle = (*env)->GetFieldID(env, PANOSEFc.clazz, "bArmStyle", "B");
5251         PANOSEFc.bLetterform = (*env)->GetFieldID(env, PANOSEFc.clazz, "bLetterform", "B");
5252         PANOSEFc.bMidline = (*env)->GetFieldID(env, PANOSEFc.clazz, "bMidline", "B");
5253         PANOSEFc.bXHeight = (*env)->GetFieldID(env, PANOSEFc.clazz, "bXHeight", "B");
5254         PANOSEFc.cached = 1;
5255 }
5256
5257 PANOSE *getPANOSEFields(JNIEnv *env, jobject lpObject, PANOSE *lpStruct)
5258 {
5259         if (!PANOSEFc.cached) cachePANOSEFields(env, lpObject);
5260         lpStruct->bFamilyType = (*env)->GetByteField(env, lpObject, PANOSEFc.bFamilyType);
5261         lpStruct->bSerifStyle = (*env)->GetByteField(env, lpObject, PANOSEFc.bSerifStyle);
5262         lpStruct->bWeight = (*env)->GetByteField(env, lpObject, PANOSEFc.bWeight);
5263         lpStruct->bProportion = (*env)->GetByteField(env, lpObject, PANOSEFc.bProportion);
5264         lpStruct->bContrast = (*env)->GetByteField(env, lpObject, PANOSEFc.bContrast);
5265         lpStruct->bStrokeVariation = (*env)->GetByteField(env, lpObject, PANOSEFc.bStrokeVariation);
5266         lpStruct->bArmStyle = (*env)->GetByteField(env, lpObject, PANOSEFc.bArmStyle);
5267         lpStruct->bLetterform = (*env)->GetByteField(env, lpObject, PANOSEFc.bLetterform);
5268         lpStruct->bMidline = (*env)->GetByteField(env, lpObject, PANOSEFc.bMidline);
5269         lpStruct->bXHeight = (*env)->GetByteField(env, lpObject, PANOSEFc.bXHeight);
5270         return lpStruct;
5271 }
5272
5273 void setPANOSEFields(JNIEnv *env, jobject lpObject, PANOSE *lpStruct)
5274 {
5275         if (!PANOSEFc.cached) cachePANOSEFields(env, lpObject);
5276         (*env)->SetByteField(env, lpObject, PANOSEFc.bFamilyType, (jbyte)lpStruct->bFamilyType);
5277         (*env)->SetByteField(env, lpObject, PANOSEFc.bSerifStyle, (jbyte)lpStruct->bSerifStyle);
5278         (*env)->SetByteField(env, lpObject, PANOSEFc.bWeight, (jbyte)lpStruct->bWeight);
5279         (*env)->SetByteField(env, lpObject, PANOSEFc.bProportion, (jbyte)lpStruct->bProportion);
5280         (*env)->SetByteField(env, lpObject, PANOSEFc.bContrast, (jbyte)lpStruct->bContrast);
5281         (*env)->SetByteField(env, lpObject, PANOSEFc.bStrokeVariation, (jbyte)lpStruct->bStrokeVariation);
5282         (*env)->SetByteField(env, lpObject, PANOSEFc.bArmStyle, (jbyte)lpStruct->bArmStyle);
5283         (*env)->SetByteField(env, lpObject, PANOSEFc.bLetterform, (jbyte)lpStruct->bLetterform);
5284         (*env)->SetByteField(env, lpObject, PANOSEFc.bMidline, (jbyte)lpStruct->bMidline);
5285         (*env)->SetByteField(env, lpObject, PANOSEFc.bXHeight, (jbyte)lpStruct->bXHeight);
5286 }
5287 #endif
5288
5289 #ifndef NO_POINT
5290 typedef struct POINT_FID_CACHE {
5291         int cached;
5292         jclass clazz;
5293         jfieldID x, y;
5294 } POINT_FID_CACHE;
5295
5296 POINT_FID_CACHE POINTFc;
5297
5298 void cachePOINTFields(JNIEnv *env, jobject lpObject)
5299 {
5300         if (POINTFc.cached) return;
5301         POINTFc.clazz = (*env)->GetObjectClass(env, lpObject);
5302         POINTFc.x = (*env)->GetFieldID(env, POINTFc.clazz, "x", "I");
5303         POINTFc.y = (*env)->GetFieldID(env, POINTFc.clazz, "y", "I");
5304         POINTFc.cached = 1;
5305 }
5306
5307 POINT *getPOINTFields(JNIEnv *env, jobject lpObject, POINT *lpStruct)
5308 {
5309         if (!POINTFc.cached) cachePOINTFields(env, lpObject);
5310         lpStruct->x = (*env)->GetIntField(env, lpObject, POINTFc.x);
5311         lpStruct->y = (*env)->GetIntField(env, lpObject, POINTFc.y);
5312         return lpStruct;
5313 }
5314
5315 void setPOINTFields(JNIEnv *env, jobject lpObject, POINT *lpStruct)
5316 {
5317         if (!POINTFc.cached) cachePOINTFields(env, lpObject);
5318         (*env)->SetIntField(env, lpObject, POINTFc.x, (jint)lpStruct->x);
5319         (*env)->SetIntField(env, lpObject, POINTFc.y, (jint)lpStruct->y);
5320 }
5321 #endif
5322
5323 #ifndef NO_PRINTDLG
5324 typedef struct PRINTDLG_FID_CACHE {
5325         int cached;
5326         jclass clazz;
5327         jfieldID lStructSize, hwndOwner, hDevMode, hDevNames, hDC, Flags, nFromPage, nToPage, nMinPage, nMaxPage, nCopies, hInstance, lCustData, lpfnPrintHook, lpfnSetupHook, lpPrintTemplateName, lpSetupTemplateName, hPrintTemplate, hSetupTemplate;
5328 } PRINTDLG_FID_CACHE;
5329
5330 PRINTDLG_FID_CACHE PRINTDLGFc;
5331
5332 void cachePRINTDLGFields(JNIEnv *env, jobject lpObject)
5333 {
5334         if (PRINTDLGFc.cached) return;
5335         PRINTDLGFc.clazz = (*env)->GetObjectClass(env, lpObject);
5336         PRINTDLGFc.lStructSize = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lStructSize", "I");
5337         PRINTDLGFc.hwndOwner = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hwndOwner", "J");
5338         PRINTDLGFc.hDevMode = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hDevMode", "J");
5339         PRINTDLGFc.hDevNames = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hDevNames", "J");
5340         PRINTDLGFc.hDC = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hDC", "J");
5341         PRINTDLGFc.Flags = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "Flags", "I");
5342         PRINTDLGFc.nFromPage = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "nFromPage", "S");
5343         PRINTDLGFc.nToPage = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "nToPage", "S");
5344         PRINTDLGFc.nMinPage = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "nMinPage", "S");
5345         PRINTDLGFc.nMaxPage = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "nMaxPage", "S");
5346         PRINTDLGFc.nCopies = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "nCopies", "S");
5347         PRINTDLGFc.hInstance = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hInstance", "J");
5348         PRINTDLGFc.lCustData = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lCustData", "J");
5349         PRINTDLGFc.lpfnPrintHook = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lpfnPrintHook", "J");
5350         PRINTDLGFc.lpfnSetupHook = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lpfnSetupHook", "J");
5351         PRINTDLGFc.lpPrintTemplateName = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lpPrintTemplateName", "J");
5352         PRINTDLGFc.lpSetupTemplateName = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "lpSetupTemplateName", "J");
5353         PRINTDLGFc.hPrintTemplate = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hPrintTemplate", "J");
5354         PRINTDLGFc.hSetupTemplate = (*env)->GetFieldID(env, PRINTDLGFc.clazz, "hSetupTemplate", "J");
5355         PRINTDLGFc.cached = 1;
5356 }
5357
5358 PRINTDLG *getPRINTDLGFields(JNIEnv *env, jobject lpObject, PRINTDLG *lpStruct)
5359 {
5360         if (!PRINTDLGFc.cached) cachePRINTDLGFields(env, lpObject);
5361         lpStruct->lStructSize = (*env)->GetIntField(env, lpObject, PRINTDLGFc.lStructSize);
5362         lpStruct->hwndOwner = (HWND)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hwndOwner);
5363         lpStruct->hDevMode = (HGLOBAL)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hDevMode);
5364         lpStruct->hDevNames = (HGLOBAL)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hDevNames);
5365         lpStruct->hDC = (HDC)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hDC);
5366         lpStruct->Flags = (*env)->GetIntField(env, lpObject, PRINTDLGFc.Flags);
5367         lpStruct->nFromPage = (*env)->GetShortField(env, lpObject, PRINTDLGFc.nFromPage);
5368         lpStruct->nToPage = (*env)->GetShortField(env, lpObject, PRINTDLGFc.nToPage);
5369         lpStruct->nMinPage = (*env)->GetShortField(env, lpObject, PRINTDLGFc.nMinPage);
5370         lpStruct->nMaxPage = (*env)->GetShortField(env, lpObject, PRINTDLGFc.nMaxPage);
5371         lpStruct->nCopies = (*env)->GetShortField(env, lpObject, PRINTDLGFc.nCopies);
5372         lpStruct->hInstance = (HINSTANCE)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hInstance);
5373         lpStruct->lCustData = (*env)->GetLongField(env, lpObject, PRINTDLGFc.lCustData);
5374         lpStruct->lpfnPrintHook = (LPPRINTHOOKPROC)(*env)->GetLongField(env, lpObject, PRINTDLGFc.lpfnPrintHook);
5375         lpStruct->lpfnSetupHook = (LPPRINTHOOKPROC)(*env)->GetLongField(env, lpObject, PRINTDLGFc.lpfnSetupHook);
5376         lpStruct->lpPrintTemplateName = (LPCTSTR)(*env)->GetLongField(env, lpObject, PRINTDLGFc.lpPrintTemplateName);
5377         lpStruct->lpSetupTemplateName = (LPCTSTR)(*env)->GetLongField(env, lpObject, PRINTDLGFc.lpSetupTemplateName);
5378         lpStruct->hPrintTemplate = (HGLOBAL)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hPrintTemplate);
5379         lpStruct->hSetupTemplate = (HGLOBAL)(*env)->GetLongField(env, lpObject, PRINTDLGFc.hSetupTemplate);
5380         return lpStruct;
5381 }
5382
5383 void setPRINTDLGFields(JNIEnv *env, jobject lpObject, PRINTDLG *lpStruct)
5384 {
5385         if (!PRINTDLGFc.cached) cachePRINTDLGFields(env, lpObject);
5386         (*env)->SetIntField(env, lpObject, PRINTDLGFc.lStructSize, (jint)lpStruct->lStructSize);
5387         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hwndOwner, (jlong)lpStruct->hwndOwner);
5388         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hDevMode, (jlong)lpStruct->hDevMode);
5389         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hDevNames, (jlong)lpStruct->hDevNames);
5390         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hDC, (jlong)lpStruct->hDC);
5391         (*env)->SetIntField(env, lpObject, PRINTDLGFc.Flags, (jint)lpStruct->Flags);
5392         (*env)->SetShortField(env, lpObject, PRINTDLGFc.nFromPage, (jshort)lpStruct->nFromPage);
5393         (*env)->SetShortField(env, lpObject, PRINTDLGFc.nToPage, (jshort)lpStruct->nToPage);
5394         (*env)->SetShortField(env, lpObject, PRINTDLGFc.nMinPage, (jshort)lpStruct->nMinPage);
5395         (*env)->SetShortField(env, lpObject, PRINTDLGFc.nMaxPage, (jshort)lpStruct->nMaxPage);
5396         (*env)->SetShortField(env, lpObject, PRINTDLGFc.nCopies, (jshort)lpStruct->nCopies);
5397         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hInstance, (jlong)lpStruct->hInstance);
5398         (*env)->SetLongField(env, lpObject, PRINTDLGFc.lCustData, (jlong)lpStruct->lCustData);
5399         (*env)->SetLongField(env, lpObject, PRINTDLGFc.lpfnPrintHook, (jlong)lpStruct->lpfnPrintHook);
5400         (*env)->SetLongField(env, lpObject, PRINTDLGFc.lpfnSetupHook, (jlong)lpStruct->lpfnSetupHook);
5401         (*env)->SetLongField(env, lpObject, PRINTDLGFc.lpPrintTemplateName, (jlong)lpStruct->lpPrintTemplateName);
5402         (*env)->SetLongField(env, lpObject, PRINTDLGFc.lpSetupTemplateName, (jlong)lpStruct->lpSetupTemplateName);
5403         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hPrintTemplate, (jlong)lpStruct->hPrintTemplate);
5404         (*env)->SetLongField(env, lpObject, PRINTDLGFc.hSetupTemplate, (jlong)lpStruct->hSetupTemplate);
5405 }
5406 #endif
5407
5408 #ifndef NO_PROCESS_INFORMATION
5409 typedef struct PROCESS_INFORMATION_FID_CACHE {
5410         int cached;
5411         jclass clazz;
5412         jfieldID hProcess, hThread, dwProcessId, dwThreadId;
5413 } PROCESS_INFORMATION_FID_CACHE;
5414
5415 PROCESS_INFORMATION_FID_CACHE PROCESS_INFORMATIONFc;
5416
5417 void cachePROCESS_INFORMATIONFields(JNIEnv *env, jobject lpObject)
5418 {
5419         if (PROCESS_INFORMATIONFc.cached) return;
5420         PROCESS_INFORMATIONFc.clazz = (*env)->GetObjectClass(env, lpObject);
5421         PROCESS_INFORMATIONFc.hProcess = (*env)->GetFieldID(env, PROCESS_INFORMATIONFc.clazz, "hProcess", "J");
5422         PROCESS_INFORMATIONFc.hThread = (*env)->GetFieldID(env, PROCESS_INFORMATIONFc.clazz, "hThread", "J");
5423         PROCESS_INFORMATIONFc.dwProcessId = (*env)->GetFieldID(env, PROCESS_INFORMATIONFc.clazz, "dwProcessId", "I");
5424         PROCESS_INFORMATIONFc.dwThreadId = (*env)->GetFieldID(env, PROCESS_INFORMATIONFc.clazz, "dwThreadId", "I");
5425         PROCESS_INFORMATIONFc.cached = 1;
5426 }
5427
5428 PROCESS_INFORMATION *getPROCESS_INFORMATIONFields(JNIEnv *env, jobject lpObject, PROCESS_INFORMATION *lpStruct)
5429 {
5430         if (!PROCESS_INFORMATIONFc.cached) cachePROCESS_INFORMATIONFields(env, lpObject);
5431         lpStruct->hProcess = (HANDLE)(*env)->GetLongField(env, lpObject, PROCESS_INFORMATIONFc.hProcess);
5432         lpStruct->hThread = (HANDLE)(*env)->GetLongField(env, lpObject, PROCESS_INFORMATIONFc.hThread);
5433         lpStruct->dwProcessId = (*env)->GetIntField(env, lpObject, PROCESS_INFORMATIONFc.dwProcessId);
5434         lpStruct->dwThreadId = (*env)->GetIntField(env, lpObject, PROCESS_INFORMATIONFc.dwThreadId);
5435         return lpStruct;
5436 }
5437
5438 void setPROCESS_INFORMATIONFields(JNIEnv *env, jobject lpObject, PROCESS_INFORMATION *lpStruct)
5439 {
5440         if (!PROCESS_INFORMATIONFc.cached) cachePROCESS_INFORMATIONFields(env, lpObject);
5441         (*env)->SetLongField(env, lpObject, PROCESS_INFORMATIONFc.hProcess, (jlong)lpStruct->hProcess);
5442         (*env)->SetLongField(env, lpObject, PROCESS_INFORMATIONFc.hThread, (jlong)lpStruct->hThread);
5443         (*env)->SetIntField(env, lpObject, PROCESS_INFORMATIONFc.dwProcessId, (jint)lpStruct->dwProcessId);
5444         (*env)->SetIntField(env, lpObject, PROCESS_INFORMATIONFc.dwThreadId, (jint)lpStruct->dwThreadId);
5445 }
5446 #endif
5447
5448 #ifndef NO_PROPERTYKEY
5449 typedef struct PROPERTYKEY_FID_CACHE {
5450         int cached;
5451         jclass clazz;
5452         jfieldID fmtid, pid;
5453 } PROPERTYKEY_FID_CACHE;
5454
5455 PROPERTYKEY_FID_CACHE PROPERTYKEYFc;
5456
5457 void cachePROPERTYKEYFields(JNIEnv *env, jobject lpObject)
5458 {
5459         if (PROPERTYKEYFc.cached) return;
5460         PROPERTYKEYFc.clazz = (*env)->GetObjectClass(env, lpObject);
5461         PROPERTYKEYFc.fmtid = (*env)->GetFieldID(env, PROPERTYKEYFc.clazz, "fmtid", "[B");
5462         PROPERTYKEYFc.pid = (*env)->GetFieldID(env, PROPERTYKEYFc.clazz, "pid", "I");
5463         PROPERTYKEYFc.cached = 1;
5464 }
5465
5466 PROPERTYKEY *getPROPERTYKEYFields(JNIEnv *env, jobject lpObject, PROPERTYKEY *lpStruct)
5467 {
5468         if (!PROPERTYKEYFc.cached) cachePROPERTYKEYFields(env, lpObject);
5469         {
5470         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, PROPERTYKEYFc.fmtid);
5471         (*env)->GetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->fmtid), (jbyte *)&lpStruct->fmtid);
5472         }
5473         lpStruct->pid = (*env)->GetIntField(env, lpObject, PROPERTYKEYFc.pid);
5474         return lpStruct;
5475 }
5476
5477 void setPROPERTYKEYFields(JNIEnv *env, jobject lpObject, PROPERTYKEY *lpStruct)
5478 {
5479         if (!PROPERTYKEYFc.cached) cachePROPERTYKEYFields(env, lpObject);
5480         {
5481         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, PROPERTYKEYFc.fmtid);
5482         (*env)->SetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->fmtid), (jbyte *)&lpStruct->fmtid);
5483         }
5484         (*env)->SetIntField(env, lpObject, PROPERTYKEYFc.pid, (jint)lpStruct->pid);
5485 }
5486 #endif
5487
5488 #ifndef NO_REBARBANDINFO
5489 typedef struct REBARBANDINFO_FID_CACHE {
5490         int cached;
5491         jclass clazz;
5492         jfieldID cbSize, fMask, fStyle, clrFore, clrBack, lpText, cch, iImage, hwndChild, cxMinChild, cyMinChild, cx, hbmBack, wID, cyChild, cyMaxChild, cyIntegral, cxIdeal, lParam, cxHeader;
5493 } REBARBANDINFO_FID_CACHE;
5494
5495 REBARBANDINFO_FID_CACHE REBARBANDINFOFc;
5496
5497 void cacheREBARBANDINFOFields(JNIEnv *env, jobject lpObject)
5498 {
5499         if (REBARBANDINFOFc.cached) return;
5500         REBARBANDINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
5501         REBARBANDINFOFc.cbSize = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cbSize", "I");
5502         REBARBANDINFOFc.fMask = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "fMask", "I");
5503         REBARBANDINFOFc.fStyle = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "fStyle", "I");
5504         REBARBANDINFOFc.clrFore = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "clrFore", "I");
5505         REBARBANDINFOFc.clrBack = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "clrBack", "I");
5506         REBARBANDINFOFc.lpText = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "lpText", "J");
5507         REBARBANDINFOFc.cch = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cch", "I");
5508         REBARBANDINFOFc.iImage = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "iImage", "I");
5509         REBARBANDINFOFc.hwndChild = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "hwndChild", "J");
5510         REBARBANDINFOFc.cxMinChild = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cxMinChild", "I");
5511         REBARBANDINFOFc.cyMinChild = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cyMinChild", "I");
5512         REBARBANDINFOFc.cx = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cx", "I");
5513         REBARBANDINFOFc.hbmBack = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "hbmBack", "J");
5514         REBARBANDINFOFc.wID = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "wID", "I");
5515         REBARBANDINFOFc.cyChild = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cyChild", "I");
5516         REBARBANDINFOFc.cyMaxChild = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cyMaxChild", "I");
5517         REBARBANDINFOFc.cyIntegral = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cyIntegral", "I");
5518         REBARBANDINFOFc.cxIdeal = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cxIdeal", "I");
5519         REBARBANDINFOFc.lParam = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "lParam", "J");
5520         REBARBANDINFOFc.cxHeader = (*env)->GetFieldID(env, REBARBANDINFOFc.clazz, "cxHeader", "I");
5521         REBARBANDINFOFc.cached = 1;
5522 }
5523
5524 REBARBANDINFO *getREBARBANDINFOFields(JNIEnv *env, jobject lpObject, REBARBANDINFO *lpStruct)
5525 {
5526         if (!REBARBANDINFOFc.cached) cacheREBARBANDINFOFields(env, lpObject);
5527         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cbSize);
5528         lpStruct->fMask = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.fMask);
5529         lpStruct->fStyle = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.fStyle);
5530         lpStruct->clrFore = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.clrFore);
5531         lpStruct->clrBack = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.clrBack);
5532         lpStruct->lpText = (LPTSTR)(*env)->GetLongField(env, lpObject, REBARBANDINFOFc.lpText);
5533         lpStruct->cch = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cch);
5534         lpStruct->iImage = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.iImage);
5535         lpStruct->hwndChild = (HWND)(*env)->GetLongField(env, lpObject, REBARBANDINFOFc.hwndChild);
5536         lpStruct->cxMinChild = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cxMinChild);
5537         lpStruct->cyMinChild = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cyMinChild);
5538         lpStruct->cx = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cx);
5539         lpStruct->hbmBack = (HBITMAP)(*env)->GetLongField(env, lpObject, REBARBANDINFOFc.hbmBack);
5540         lpStruct->wID = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.wID);
5541         lpStruct->cyChild = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cyChild);
5542         lpStruct->cyMaxChild = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cyMaxChild);
5543         lpStruct->cyIntegral = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cyIntegral);
5544         lpStruct->cxIdeal = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cxIdeal);
5545         lpStruct->lParam = (*env)->GetLongField(env, lpObject, REBARBANDINFOFc.lParam);
5546         lpStruct->cxHeader = (*env)->GetIntField(env, lpObject, REBARBANDINFOFc.cxHeader);
5547         return lpStruct;
5548 }
5549
5550 void setREBARBANDINFOFields(JNIEnv *env, jobject lpObject, REBARBANDINFO *lpStruct)
5551 {
5552         if (!REBARBANDINFOFc.cached) cacheREBARBANDINFOFields(env, lpObject);
5553         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cbSize, (jint)lpStruct->cbSize);
5554         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.fMask, (jint)lpStruct->fMask);
5555         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.fStyle, (jint)lpStruct->fStyle);
5556         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.clrFore, (jint)lpStruct->clrFore);
5557         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.clrBack, (jint)lpStruct->clrBack);
5558         (*env)->SetLongField(env, lpObject, REBARBANDINFOFc.lpText, (jlong)lpStruct->lpText);
5559         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cch, (jint)lpStruct->cch);
5560         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.iImage, (jint)lpStruct->iImage);
5561         (*env)->SetLongField(env, lpObject, REBARBANDINFOFc.hwndChild, (jlong)lpStruct->hwndChild);
5562         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cxMinChild, (jint)lpStruct->cxMinChild);
5563         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cyMinChild, (jint)lpStruct->cyMinChild);
5564         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cx, (jint)lpStruct->cx);
5565         (*env)->SetLongField(env, lpObject, REBARBANDINFOFc.hbmBack, (jlong)lpStruct->hbmBack);
5566         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.wID, (jint)lpStruct->wID);
5567         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cyChild, (jint)lpStruct->cyChild);
5568         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cyMaxChild, (jint)lpStruct->cyMaxChild);
5569         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cyIntegral, (jint)lpStruct->cyIntegral);
5570         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cxIdeal, (jint)lpStruct->cxIdeal);
5571         (*env)->SetLongField(env, lpObject, REBARBANDINFOFc.lParam, (jlong)lpStruct->lParam);
5572         (*env)->SetIntField(env, lpObject, REBARBANDINFOFc.cxHeader, (jint)lpStruct->cxHeader);
5573 }
5574 #endif
5575
5576 #ifndef NO_RECT
5577 typedef struct RECT_FID_CACHE {
5578         int cached;
5579         jclass clazz;
5580         jfieldID left, top, right, bottom;
5581 } RECT_FID_CACHE;
5582
5583 RECT_FID_CACHE RECTFc;
5584
5585 void cacheRECTFields(JNIEnv *env, jobject lpObject)
5586 {
5587         if (RECTFc.cached) return;
5588         RECTFc.clazz = (*env)->GetObjectClass(env, lpObject);
5589         RECTFc.left = (*env)->GetFieldID(env, RECTFc.clazz, "left", "I");
5590         RECTFc.top = (*env)->GetFieldID(env, RECTFc.clazz, "top", "I");
5591         RECTFc.right = (*env)->GetFieldID(env, RECTFc.clazz, "right", "I");
5592         RECTFc.bottom = (*env)->GetFieldID(env, RECTFc.clazz, "bottom", "I");
5593         RECTFc.cached = 1;
5594 }
5595
5596 RECT *getRECTFields(JNIEnv *env, jobject lpObject, RECT *lpStruct)
5597 {
5598         if (!RECTFc.cached) cacheRECTFields(env, lpObject);
5599         lpStruct->left = (*env)->GetIntField(env, lpObject, RECTFc.left);
5600         lpStruct->top = (*env)->GetIntField(env, lpObject, RECTFc.top);
5601         lpStruct->right = (*env)->GetIntField(env, lpObject, RECTFc.right);
5602         lpStruct->bottom = (*env)->GetIntField(env, lpObject, RECTFc.bottom);
5603         return lpStruct;
5604 }
5605
5606 void setRECTFields(JNIEnv *env, jobject lpObject, RECT *lpStruct)
5607 {
5608         if (!RECTFc.cached) cacheRECTFields(env, lpObject);
5609         (*env)->SetIntField(env, lpObject, RECTFc.left, (jint)lpStruct->left);
5610         (*env)->SetIntField(env, lpObject, RECTFc.top, (jint)lpStruct->top);
5611         (*env)->SetIntField(env, lpObject, RECTFc.right, (jint)lpStruct->right);
5612         (*env)->SetIntField(env, lpObject, RECTFc.bottom, (jint)lpStruct->bottom);
5613 }
5614 #endif
5615
5616 #ifndef NO_SAFEARRAY
5617 typedef struct SAFEARRAY_FID_CACHE {
5618         int cached;
5619         jclass clazz;
5620         jfieldID cDims, fFeatures, cbElements, cLocks, pvData, rgsabound;
5621 } SAFEARRAY_FID_CACHE;
5622
5623 SAFEARRAY_FID_CACHE SAFEARRAYFc;
5624
5625 void cacheSAFEARRAYFields(JNIEnv *env, jobject lpObject)
5626 {
5627         if (SAFEARRAYFc.cached) return;
5628         SAFEARRAYFc.clazz = (*env)->GetObjectClass(env, lpObject);
5629         SAFEARRAYFc.cDims = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "cDims", "S");
5630         SAFEARRAYFc.fFeatures = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "fFeatures", "S");
5631         SAFEARRAYFc.cbElements = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "cbElements", "I");
5632         SAFEARRAYFc.cLocks = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "cLocks", "I");
5633         SAFEARRAYFc.pvData = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "pvData", "J");
5634         SAFEARRAYFc.rgsabound = (*env)->GetFieldID(env, SAFEARRAYFc.clazz, "rgsabound", "Lorg/eclipse/swt/internal/win32/SAFEARRAYBOUND;");
5635         SAFEARRAYFc.cached = 1;
5636 }
5637
5638 SAFEARRAY *getSAFEARRAYFields(JNIEnv *env, jobject lpObject, SAFEARRAY *lpStruct)
5639 {
5640         if (!SAFEARRAYFc.cached) cacheSAFEARRAYFields(env, lpObject);
5641         lpStruct->cDims = (*env)->GetShortField(env, lpObject, SAFEARRAYFc.cDims);
5642         lpStruct->fFeatures = (*env)->GetShortField(env, lpObject, SAFEARRAYFc.fFeatures);
5643         lpStruct->cbElements = (*env)->GetIntField(env, lpObject, SAFEARRAYFc.cbElements);
5644         lpStruct->cLocks = (*env)->GetIntField(env, lpObject, SAFEARRAYFc.cLocks);
5645         lpStruct->pvData = (PVOID)(*env)->GetLongField(env, lpObject, SAFEARRAYFc.pvData);
5646         {
5647         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SAFEARRAYFc.rgsabound);
5648         if (lpObject1 != NULL) getSAFEARRAYBOUNDFields(env, lpObject1, &lpStruct->rgsabound[0]);
5649         }
5650         return lpStruct;
5651 }
5652
5653 void setSAFEARRAYFields(JNIEnv *env, jobject lpObject, SAFEARRAY *lpStruct)
5654 {
5655         if (!SAFEARRAYFc.cached) cacheSAFEARRAYFields(env, lpObject);
5656         (*env)->SetShortField(env, lpObject, SAFEARRAYFc.cDims, (jshort)lpStruct->cDims);
5657         (*env)->SetShortField(env, lpObject, SAFEARRAYFc.fFeatures, (jshort)lpStruct->fFeatures);
5658         (*env)->SetIntField(env, lpObject, SAFEARRAYFc.cbElements, (jint)lpStruct->cbElements);
5659         (*env)->SetIntField(env, lpObject, SAFEARRAYFc.cLocks, (jint)lpStruct->cLocks);
5660         (*env)->SetLongField(env, lpObject, SAFEARRAYFc.pvData, (jlong)lpStruct->pvData);
5661         {
5662         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SAFEARRAYFc.rgsabound);
5663         if (lpObject1 != NULL) setSAFEARRAYBOUNDFields(env, lpObject1, &lpStruct->rgsabound[0]);
5664         }
5665 }
5666 #endif
5667
5668 #ifndef NO_SAFEARRAYBOUND
5669 typedef struct SAFEARRAYBOUND_FID_CACHE {
5670         int cached;
5671         jclass clazz;
5672         jfieldID cElements, lLbound;
5673 } SAFEARRAYBOUND_FID_CACHE;
5674
5675 SAFEARRAYBOUND_FID_CACHE SAFEARRAYBOUNDFc;
5676
5677 void cacheSAFEARRAYBOUNDFields(JNIEnv *env, jobject lpObject)
5678 {
5679         if (SAFEARRAYBOUNDFc.cached) return;
5680         SAFEARRAYBOUNDFc.clazz = (*env)->GetObjectClass(env, lpObject);
5681         SAFEARRAYBOUNDFc.cElements = (*env)->GetFieldID(env, SAFEARRAYBOUNDFc.clazz, "cElements", "I");
5682         SAFEARRAYBOUNDFc.lLbound = (*env)->GetFieldID(env, SAFEARRAYBOUNDFc.clazz, "lLbound", "I");
5683         SAFEARRAYBOUNDFc.cached = 1;
5684 }
5685
5686 SAFEARRAYBOUND *getSAFEARRAYBOUNDFields(JNIEnv *env, jobject lpObject, SAFEARRAYBOUND *lpStruct)
5687 {
5688         if (!SAFEARRAYBOUNDFc.cached) cacheSAFEARRAYBOUNDFields(env, lpObject);
5689         lpStruct->cElements = (*env)->GetIntField(env, lpObject, SAFEARRAYBOUNDFc.cElements);
5690         lpStruct->lLbound = (*env)->GetIntField(env, lpObject, SAFEARRAYBOUNDFc.lLbound);
5691         return lpStruct;
5692 }
5693
5694 void setSAFEARRAYBOUNDFields(JNIEnv *env, jobject lpObject, SAFEARRAYBOUND *lpStruct)
5695 {
5696         if (!SAFEARRAYBOUNDFc.cached) cacheSAFEARRAYBOUNDFields(env, lpObject);
5697         (*env)->SetIntField(env, lpObject, SAFEARRAYBOUNDFc.cElements, (jint)lpStruct->cElements);
5698         (*env)->SetIntField(env, lpObject, SAFEARRAYBOUNDFc.lLbound, (jint)lpStruct->lLbound);
5699 }
5700 #endif
5701
5702 #ifndef NO_SCRIPT_ANALYSIS
5703 typedef struct SCRIPT_ANALYSIS_FID_CACHE {
5704         int cached;
5705         jclass clazz;
5706         jfieldID eScript, fRTL, fLayoutRTL, fLinkBefore, fLinkAfter, fLogicalOrder, fNoGlyphIndex, s;
5707 } SCRIPT_ANALYSIS_FID_CACHE;
5708
5709 SCRIPT_ANALYSIS_FID_CACHE SCRIPT_ANALYSISFc;
5710
5711 void cacheSCRIPT_ANALYSISFields(JNIEnv *env, jobject lpObject)
5712 {
5713         if (SCRIPT_ANALYSISFc.cached) return;
5714         SCRIPT_ANALYSISFc.clazz = (*env)->GetObjectClass(env, lpObject);
5715         SCRIPT_ANALYSISFc.eScript = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "eScript", "S");
5716         SCRIPT_ANALYSISFc.fRTL = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fRTL", "Z");
5717         SCRIPT_ANALYSISFc.fLayoutRTL = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fLayoutRTL", "Z");
5718         SCRIPT_ANALYSISFc.fLinkBefore = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fLinkBefore", "Z");
5719         SCRIPT_ANALYSISFc.fLinkAfter = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fLinkAfter", "Z");
5720         SCRIPT_ANALYSISFc.fLogicalOrder = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fLogicalOrder", "Z");
5721         SCRIPT_ANALYSISFc.fNoGlyphIndex = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "fNoGlyphIndex", "Z");
5722         SCRIPT_ANALYSISFc.s = (*env)->GetFieldID(env, SCRIPT_ANALYSISFc.clazz, "s", "Lorg/eclipse/swt/internal/win32/SCRIPT_STATE;");
5723         SCRIPT_ANALYSISFc.cached = 1;
5724 }
5725
5726 SCRIPT_ANALYSIS *getSCRIPT_ANALYSISFields(JNIEnv *env, jobject lpObject, SCRIPT_ANALYSIS *lpStruct)
5727 {
5728         if (!SCRIPT_ANALYSISFc.cached) cacheSCRIPT_ANALYSISFields(env, lpObject);
5729         lpStruct->eScript = (*env)->GetShortField(env, lpObject, SCRIPT_ANALYSISFc.eScript);
5730         lpStruct->fRTL = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fRTL);
5731         lpStruct->fLayoutRTL = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLayoutRTL);
5732         lpStruct->fLinkBefore = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLinkBefore);
5733         lpStruct->fLinkAfter = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLinkAfter);
5734         lpStruct->fLogicalOrder = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLogicalOrder);
5735         lpStruct->fNoGlyphIndex = (*env)->GetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fNoGlyphIndex);
5736         {
5737         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCRIPT_ANALYSISFc.s);
5738         if (lpObject1 != NULL) getSCRIPT_STATEFields(env, lpObject1, &lpStruct->s);
5739         }
5740         return lpStruct;
5741 }
5742
5743 void setSCRIPT_ANALYSISFields(JNIEnv *env, jobject lpObject, SCRIPT_ANALYSIS *lpStruct)
5744 {
5745         if (!SCRIPT_ANALYSISFc.cached) cacheSCRIPT_ANALYSISFields(env, lpObject);
5746         (*env)->SetShortField(env, lpObject, SCRIPT_ANALYSISFc.eScript, (jshort)lpStruct->eScript);
5747         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fRTL, (jboolean)lpStruct->fRTL);
5748         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLayoutRTL, (jboolean)lpStruct->fLayoutRTL);
5749         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLinkBefore, (jboolean)lpStruct->fLinkBefore);
5750         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLinkAfter, (jboolean)lpStruct->fLinkAfter);
5751         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fLogicalOrder, (jboolean)lpStruct->fLogicalOrder);
5752         (*env)->SetBooleanField(env, lpObject, SCRIPT_ANALYSISFc.fNoGlyphIndex, (jboolean)lpStruct->fNoGlyphIndex);
5753         {
5754         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCRIPT_ANALYSISFc.s);
5755         if (lpObject1 != NULL) setSCRIPT_STATEFields(env, lpObject1, &lpStruct->s);
5756         }
5757 }
5758 #endif
5759
5760 #ifndef NO_SCRIPT_CONTROL
5761 typedef struct SCRIPT_CONTROL_FID_CACHE {
5762         int cached;
5763         jclass clazz;
5764         jfieldID uDefaultLanguage, fContextDigits, fInvertPreBoundDir, fInvertPostBoundDir, fLinkStringBefore, fLinkStringAfter, fNeutralOverride, fNumericOverride, fLegacyBidiClass, fMergeNeutralItems, fUseStandardBidi, fReserved;
5765 } SCRIPT_CONTROL_FID_CACHE;
5766
5767 SCRIPT_CONTROL_FID_CACHE SCRIPT_CONTROLFc;
5768
5769 void cacheSCRIPT_CONTROLFields(JNIEnv *env, jobject lpObject)
5770 {
5771         if (SCRIPT_CONTROLFc.cached) return;
5772         SCRIPT_CONTROLFc.clazz = (*env)->GetObjectClass(env, lpObject);
5773         SCRIPT_CONTROLFc.uDefaultLanguage = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "uDefaultLanguage", "I");
5774         SCRIPT_CONTROLFc.fContextDigits = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fContextDigits", "Z");
5775         SCRIPT_CONTROLFc.fInvertPreBoundDir = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fInvertPreBoundDir", "Z");
5776         SCRIPT_CONTROLFc.fInvertPostBoundDir = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fInvertPostBoundDir", "Z");
5777         SCRIPT_CONTROLFc.fLinkStringBefore = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fLinkStringBefore", "Z");
5778         SCRIPT_CONTROLFc.fLinkStringAfter = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fLinkStringAfter", "Z");
5779         SCRIPT_CONTROLFc.fNeutralOverride = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fNeutralOverride", "Z");
5780         SCRIPT_CONTROLFc.fNumericOverride = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fNumericOverride", "Z");
5781         SCRIPT_CONTROLFc.fLegacyBidiClass = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fLegacyBidiClass", "Z");
5782         SCRIPT_CONTROLFc.fMergeNeutralItems = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fMergeNeutralItems", "Z");
5783         SCRIPT_CONTROLFc.fUseStandardBidi = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fUseStandardBidi", "Z");
5784         SCRIPT_CONTROLFc.fReserved = (*env)->GetFieldID(env, SCRIPT_CONTROLFc.clazz, "fReserved", "I");
5785         SCRIPT_CONTROLFc.cached = 1;
5786 }
5787
5788 SCRIPT_CONTROL *getSCRIPT_CONTROLFields(JNIEnv *env, jobject lpObject, SCRIPT_CONTROL *lpStruct)
5789 {
5790         if (!SCRIPT_CONTROLFc.cached) cacheSCRIPT_CONTROLFields(env, lpObject);
5791         lpStruct->uDefaultLanguage = (*env)->GetIntField(env, lpObject, SCRIPT_CONTROLFc.uDefaultLanguage);
5792         lpStruct->fContextDigits = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fContextDigits);
5793         lpStruct->fInvertPreBoundDir = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fInvertPreBoundDir);
5794         lpStruct->fInvertPostBoundDir = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fInvertPostBoundDir);
5795         lpStruct->fLinkStringBefore = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLinkStringBefore);
5796         lpStruct->fLinkStringAfter = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLinkStringAfter);
5797         lpStruct->fNeutralOverride = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fNeutralOverride);
5798         lpStruct->fNumericOverride = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fNumericOverride);
5799         lpStruct->fLegacyBidiClass = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLegacyBidiClass);
5800         lpStruct->fMergeNeutralItems = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fMergeNeutralItems);
5801         lpStruct->fUseStandardBidi = (*env)->GetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fUseStandardBidi);
5802         lpStruct->fReserved = (*env)->GetIntField(env, lpObject, SCRIPT_CONTROLFc.fReserved);
5803         return lpStruct;
5804 }
5805
5806 void setSCRIPT_CONTROLFields(JNIEnv *env, jobject lpObject, SCRIPT_CONTROL *lpStruct)
5807 {
5808         if (!SCRIPT_CONTROLFc.cached) cacheSCRIPT_CONTROLFields(env, lpObject);
5809         (*env)->SetIntField(env, lpObject, SCRIPT_CONTROLFc.uDefaultLanguage, (jint)lpStruct->uDefaultLanguage);
5810         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fContextDigits, (jboolean)lpStruct->fContextDigits);
5811         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fInvertPreBoundDir, (jboolean)lpStruct->fInvertPreBoundDir);
5812         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fInvertPostBoundDir, (jboolean)lpStruct->fInvertPostBoundDir);
5813         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLinkStringBefore, (jboolean)lpStruct->fLinkStringBefore);
5814         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLinkStringAfter, (jboolean)lpStruct->fLinkStringAfter);
5815         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fNeutralOverride, (jboolean)lpStruct->fNeutralOverride);
5816         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fNumericOverride, (jboolean)lpStruct->fNumericOverride);
5817         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fLegacyBidiClass, (jboolean)lpStruct->fLegacyBidiClass);
5818         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fMergeNeutralItems, (jboolean)lpStruct->fMergeNeutralItems);
5819         (*env)->SetBooleanField(env, lpObject, SCRIPT_CONTROLFc.fUseStandardBidi, (jboolean)lpStruct->fUseStandardBidi);
5820         (*env)->SetIntField(env, lpObject, SCRIPT_CONTROLFc.fReserved, (jint)lpStruct->fReserved);
5821 }
5822 #endif
5823
5824 #ifndef NO_SCRIPT_DIGITSUBSTITUTE
5825 typedef struct SCRIPT_DIGITSUBSTITUTE_FID_CACHE {
5826         int cached;
5827         jclass clazz;
5828         jfieldID NationalDigitLanguage, TraditionalDigitLanguage, DigitSubstitute, dwReserved;
5829 } SCRIPT_DIGITSUBSTITUTE_FID_CACHE;
5830
5831 SCRIPT_DIGITSUBSTITUTE_FID_CACHE SCRIPT_DIGITSUBSTITUTEFc;
5832
5833 void cacheSCRIPT_DIGITSUBSTITUTEFields(JNIEnv *env, jobject lpObject)
5834 {
5835         if (SCRIPT_DIGITSUBSTITUTEFc.cached) return;
5836         SCRIPT_DIGITSUBSTITUTEFc.clazz = (*env)->GetObjectClass(env, lpObject);
5837         SCRIPT_DIGITSUBSTITUTEFc.NationalDigitLanguage = (*env)->GetFieldID(env, SCRIPT_DIGITSUBSTITUTEFc.clazz, "NationalDigitLanguage", "S");
5838         SCRIPT_DIGITSUBSTITUTEFc.TraditionalDigitLanguage = (*env)->GetFieldID(env, SCRIPT_DIGITSUBSTITUTEFc.clazz, "TraditionalDigitLanguage", "S");
5839         SCRIPT_DIGITSUBSTITUTEFc.DigitSubstitute = (*env)->GetFieldID(env, SCRIPT_DIGITSUBSTITUTEFc.clazz, "DigitSubstitute", "B");
5840         SCRIPT_DIGITSUBSTITUTEFc.dwReserved = (*env)->GetFieldID(env, SCRIPT_DIGITSUBSTITUTEFc.clazz, "dwReserved", "I");
5841         SCRIPT_DIGITSUBSTITUTEFc.cached = 1;
5842 }
5843
5844 SCRIPT_DIGITSUBSTITUTE *getSCRIPT_DIGITSUBSTITUTEFields(JNIEnv *env, jobject lpObject, SCRIPT_DIGITSUBSTITUTE *lpStruct)
5845 {
5846         if (!SCRIPT_DIGITSUBSTITUTEFc.cached) cacheSCRIPT_DIGITSUBSTITUTEFields(env, lpObject);
5847         lpStruct->NationalDigitLanguage = (*env)->GetShortField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.NationalDigitLanguage);
5848         lpStruct->TraditionalDigitLanguage = (*env)->GetShortField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.TraditionalDigitLanguage);
5849         lpStruct->DigitSubstitute = (*env)->GetByteField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.DigitSubstitute);
5850         lpStruct->dwReserved = (*env)->GetIntField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.dwReserved);
5851         return lpStruct;
5852 }
5853
5854 void setSCRIPT_DIGITSUBSTITUTEFields(JNIEnv *env, jobject lpObject, SCRIPT_DIGITSUBSTITUTE *lpStruct)
5855 {
5856         if (!SCRIPT_DIGITSUBSTITUTEFc.cached) cacheSCRIPT_DIGITSUBSTITUTEFields(env, lpObject);
5857         (*env)->SetShortField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.NationalDigitLanguage, (jshort)lpStruct->NationalDigitLanguage);
5858         (*env)->SetShortField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.TraditionalDigitLanguage, (jshort)lpStruct->TraditionalDigitLanguage);
5859         (*env)->SetByteField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.DigitSubstitute, (jbyte)lpStruct->DigitSubstitute);
5860         (*env)->SetIntField(env, lpObject, SCRIPT_DIGITSUBSTITUTEFc.dwReserved, (jint)lpStruct->dwReserved);
5861 }
5862 #endif
5863
5864 #ifndef NO_SCRIPT_FONTPROPERTIES
5865 typedef struct SCRIPT_FONTPROPERTIES_FID_CACHE {
5866         int cached;
5867         jclass clazz;
5868         jfieldID cBytes, wgBlank, wgDefault, wgInvalid, wgKashida, iKashidaWidth;
5869 } SCRIPT_FONTPROPERTIES_FID_CACHE;
5870
5871 SCRIPT_FONTPROPERTIES_FID_CACHE SCRIPT_FONTPROPERTIESFc;
5872
5873 void cacheSCRIPT_FONTPROPERTIESFields(JNIEnv *env, jobject lpObject)
5874 {
5875         if (SCRIPT_FONTPROPERTIESFc.cached) return;
5876         SCRIPT_FONTPROPERTIESFc.clazz = (*env)->GetObjectClass(env, lpObject);
5877         SCRIPT_FONTPROPERTIESFc.cBytes = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "cBytes", "I");
5878         SCRIPT_FONTPROPERTIESFc.wgBlank = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "wgBlank", "S");
5879         SCRIPT_FONTPROPERTIESFc.wgDefault = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "wgDefault", "S");
5880         SCRIPT_FONTPROPERTIESFc.wgInvalid = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "wgInvalid", "S");
5881         SCRIPT_FONTPROPERTIESFc.wgKashida = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "wgKashida", "S");
5882         SCRIPT_FONTPROPERTIESFc.iKashidaWidth = (*env)->GetFieldID(env, SCRIPT_FONTPROPERTIESFc.clazz, "iKashidaWidth", "I");
5883         SCRIPT_FONTPROPERTIESFc.cached = 1;
5884 }
5885
5886 SCRIPT_FONTPROPERTIES *getSCRIPT_FONTPROPERTIESFields(JNIEnv *env, jobject lpObject, SCRIPT_FONTPROPERTIES *lpStruct)
5887 {
5888         if (!SCRIPT_FONTPROPERTIESFc.cached) cacheSCRIPT_FONTPROPERTIESFields(env, lpObject);
5889         lpStruct->cBytes = (*env)->GetIntField(env, lpObject, SCRIPT_FONTPROPERTIESFc.cBytes);
5890         lpStruct->wgBlank = (*env)->GetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgBlank);
5891         lpStruct->wgDefault = (*env)->GetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgDefault);
5892         lpStruct->wgInvalid = (*env)->GetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgInvalid);
5893         lpStruct->wgKashida = (*env)->GetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgKashida);
5894         lpStruct->iKashidaWidth = (*env)->GetIntField(env, lpObject, SCRIPT_FONTPROPERTIESFc.iKashidaWidth);
5895         return lpStruct;
5896 }
5897
5898 void setSCRIPT_FONTPROPERTIESFields(JNIEnv *env, jobject lpObject, SCRIPT_FONTPROPERTIES *lpStruct)
5899 {
5900         if (!SCRIPT_FONTPROPERTIESFc.cached) cacheSCRIPT_FONTPROPERTIESFields(env, lpObject);
5901         (*env)->SetIntField(env, lpObject, SCRIPT_FONTPROPERTIESFc.cBytes, (jint)lpStruct->cBytes);
5902         (*env)->SetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgBlank, (jshort)lpStruct->wgBlank);
5903         (*env)->SetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgDefault, (jshort)lpStruct->wgDefault);
5904         (*env)->SetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgInvalid, (jshort)lpStruct->wgInvalid);
5905         (*env)->SetShortField(env, lpObject, SCRIPT_FONTPROPERTIESFc.wgKashida, (jshort)lpStruct->wgKashida);
5906         (*env)->SetIntField(env, lpObject, SCRIPT_FONTPROPERTIESFc.iKashidaWidth, (jint)lpStruct->iKashidaWidth);
5907 }
5908 #endif
5909
5910 #ifndef NO_SCRIPT_ITEM
5911 typedef struct SCRIPT_ITEM_FID_CACHE {
5912         int cached;
5913         jclass clazz;
5914         jfieldID iCharPos, a;
5915 } SCRIPT_ITEM_FID_CACHE;
5916
5917 SCRIPT_ITEM_FID_CACHE SCRIPT_ITEMFc;
5918
5919 void cacheSCRIPT_ITEMFields(JNIEnv *env, jobject lpObject)
5920 {
5921         if (SCRIPT_ITEMFc.cached) return;
5922         SCRIPT_ITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
5923         SCRIPT_ITEMFc.iCharPos = (*env)->GetFieldID(env, SCRIPT_ITEMFc.clazz, "iCharPos", "I");
5924         SCRIPT_ITEMFc.a = (*env)->GetFieldID(env, SCRIPT_ITEMFc.clazz, "a", "Lorg/eclipse/swt/internal/win32/SCRIPT_ANALYSIS;");
5925         SCRIPT_ITEMFc.cached = 1;
5926 }
5927
5928 SCRIPT_ITEM *getSCRIPT_ITEMFields(JNIEnv *env, jobject lpObject, SCRIPT_ITEM *lpStruct)
5929 {
5930         if (!SCRIPT_ITEMFc.cached) cacheSCRIPT_ITEMFields(env, lpObject);
5931         lpStruct->iCharPos = (*env)->GetIntField(env, lpObject, SCRIPT_ITEMFc.iCharPos);
5932         {
5933         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCRIPT_ITEMFc.a);
5934         if (lpObject1 != NULL) getSCRIPT_ANALYSISFields(env, lpObject1, &lpStruct->a);
5935         }
5936         return lpStruct;
5937 }
5938
5939 void setSCRIPT_ITEMFields(JNIEnv *env, jobject lpObject, SCRIPT_ITEM *lpStruct)
5940 {
5941         if (!SCRIPT_ITEMFc.cached) cacheSCRIPT_ITEMFields(env, lpObject);
5942         (*env)->SetIntField(env, lpObject, SCRIPT_ITEMFc.iCharPos, (jint)lpStruct->iCharPos);
5943         {
5944         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCRIPT_ITEMFc.a);
5945         if (lpObject1 != NULL) setSCRIPT_ANALYSISFields(env, lpObject1, &lpStruct->a);
5946         }
5947 }
5948 #endif
5949
5950 #ifndef NO_SCRIPT_LOGATTR
5951 typedef struct SCRIPT_LOGATTR_FID_CACHE {
5952         int cached;
5953         jclass clazz;
5954         jfieldID fSoftBreak, fWhiteSpace, fCharStop, fWordStop, fInvalid, fReserved;
5955 } SCRIPT_LOGATTR_FID_CACHE;
5956
5957 SCRIPT_LOGATTR_FID_CACHE SCRIPT_LOGATTRFc;
5958
5959 void cacheSCRIPT_LOGATTRFields(JNIEnv *env, jobject lpObject)
5960 {
5961         if (SCRIPT_LOGATTRFc.cached) return;
5962         SCRIPT_LOGATTRFc.clazz = (*env)->GetObjectClass(env, lpObject);
5963         SCRIPT_LOGATTRFc.fSoftBreak = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fSoftBreak", "Z");
5964         SCRIPT_LOGATTRFc.fWhiteSpace = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fWhiteSpace", "Z");
5965         SCRIPT_LOGATTRFc.fCharStop = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fCharStop", "Z");
5966         SCRIPT_LOGATTRFc.fWordStop = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fWordStop", "Z");
5967         SCRIPT_LOGATTRFc.fInvalid = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fInvalid", "Z");
5968         SCRIPT_LOGATTRFc.fReserved = (*env)->GetFieldID(env, SCRIPT_LOGATTRFc.clazz, "fReserved", "B");
5969         SCRIPT_LOGATTRFc.cached = 1;
5970 }
5971
5972 SCRIPT_LOGATTR *getSCRIPT_LOGATTRFields(JNIEnv *env, jobject lpObject, SCRIPT_LOGATTR *lpStruct)
5973 {
5974         if (!SCRIPT_LOGATTRFc.cached) cacheSCRIPT_LOGATTRFields(env, lpObject);
5975         lpStruct->fSoftBreak = (*env)->GetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fSoftBreak);
5976         lpStruct->fWhiteSpace = (*env)->GetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fWhiteSpace);
5977         lpStruct->fCharStop = (*env)->GetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fCharStop);
5978         lpStruct->fWordStop = (*env)->GetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fWordStop);
5979         lpStruct->fInvalid = (*env)->GetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fInvalid);
5980         lpStruct->fReserved = (*env)->GetByteField(env, lpObject, SCRIPT_LOGATTRFc.fReserved);
5981         return lpStruct;
5982 }
5983
5984 void setSCRIPT_LOGATTRFields(JNIEnv *env, jobject lpObject, SCRIPT_LOGATTR *lpStruct)
5985 {
5986         if (!SCRIPT_LOGATTRFc.cached) cacheSCRIPT_LOGATTRFields(env, lpObject);
5987         (*env)->SetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fSoftBreak, (jboolean)lpStruct->fSoftBreak);
5988         (*env)->SetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fWhiteSpace, (jboolean)lpStruct->fWhiteSpace);
5989         (*env)->SetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fCharStop, (jboolean)lpStruct->fCharStop);
5990         (*env)->SetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fWordStop, (jboolean)lpStruct->fWordStop);
5991         (*env)->SetBooleanField(env, lpObject, SCRIPT_LOGATTRFc.fInvalid, (jboolean)lpStruct->fInvalid);
5992         (*env)->SetByteField(env, lpObject, SCRIPT_LOGATTRFc.fReserved, (jbyte)lpStruct->fReserved);
5993 }
5994 #endif
5995
5996 #ifndef NO_SCRIPT_PROPERTIES
5997 typedef struct SCRIPT_PROPERTIES_FID_CACHE {
5998         int cached;
5999         jclass clazz;
6000         jfieldID langid, fNumeric, fComplex, fNeedsWordBreaking, fNeedsCaretInfo, bCharSet, fControl, fPrivateUseArea, fNeedsCharacterJustify, fInvalidGlyph, fInvalidLogAttr, fCDM, fAmbiguousCharSet, fClusterSizeVaries, fRejectInvalid;
6001 } SCRIPT_PROPERTIES_FID_CACHE;
6002
6003 SCRIPT_PROPERTIES_FID_CACHE SCRIPT_PROPERTIESFc;
6004
6005 void cacheSCRIPT_PROPERTIESFields(JNIEnv *env, jobject lpObject)
6006 {
6007         if (SCRIPT_PROPERTIESFc.cached) return;
6008         SCRIPT_PROPERTIESFc.clazz = (*env)->GetObjectClass(env, lpObject);
6009         SCRIPT_PROPERTIESFc.langid = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "langid", "S");
6010         SCRIPT_PROPERTIESFc.fNumeric = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fNumeric", "Z");
6011         SCRIPT_PROPERTIESFc.fComplex = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fComplex", "Z");
6012         SCRIPT_PROPERTIESFc.fNeedsWordBreaking = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fNeedsWordBreaking", "Z");
6013         SCRIPT_PROPERTIESFc.fNeedsCaretInfo = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fNeedsCaretInfo", "Z");
6014         SCRIPT_PROPERTIESFc.bCharSet = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "bCharSet", "B");
6015         SCRIPT_PROPERTIESFc.fControl = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fControl", "Z");
6016         SCRIPT_PROPERTIESFc.fPrivateUseArea = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fPrivateUseArea", "Z");
6017         SCRIPT_PROPERTIESFc.fNeedsCharacterJustify = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fNeedsCharacterJustify", "Z");
6018         SCRIPT_PROPERTIESFc.fInvalidGlyph = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fInvalidGlyph", "Z");
6019         SCRIPT_PROPERTIESFc.fInvalidLogAttr = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fInvalidLogAttr", "Z");
6020         SCRIPT_PROPERTIESFc.fCDM = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fCDM", "Z");
6021         SCRIPT_PROPERTIESFc.fAmbiguousCharSet = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fAmbiguousCharSet", "Z");
6022         SCRIPT_PROPERTIESFc.fClusterSizeVaries = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fClusterSizeVaries", "Z");
6023         SCRIPT_PROPERTIESFc.fRejectInvalid = (*env)->GetFieldID(env, SCRIPT_PROPERTIESFc.clazz, "fRejectInvalid", "Z");
6024         SCRIPT_PROPERTIESFc.cached = 1;
6025 }
6026
6027 SCRIPT_PROPERTIES *getSCRIPT_PROPERTIESFields(JNIEnv *env, jobject lpObject, SCRIPT_PROPERTIES *lpStruct)
6028 {
6029         if (!SCRIPT_PROPERTIESFc.cached) cacheSCRIPT_PROPERTIESFields(env, lpObject);
6030         lpStruct->langid = (*env)->GetShortField(env, lpObject, SCRIPT_PROPERTIESFc.langid);
6031         lpStruct->fNumeric = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNumeric);
6032         lpStruct->fComplex = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fComplex);
6033         lpStruct->fNeedsWordBreaking = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsWordBreaking);
6034         lpStruct->fNeedsCaretInfo = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsCaretInfo);
6035         lpStruct->bCharSet = (*env)->GetByteField(env, lpObject, SCRIPT_PROPERTIESFc.bCharSet);
6036         lpStruct->fControl = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fControl);
6037         lpStruct->fPrivateUseArea = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fPrivateUseArea);
6038         lpStruct->fNeedsCharacterJustify = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsCharacterJustify);
6039         lpStruct->fInvalidGlyph = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fInvalidGlyph);
6040         lpStruct->fInvalidLogAttr = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fInvalidLogAttr);
6041         lpStruct->fCDM = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fCDM);
6042         lpStruct->fAmbiguousCharSet = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fAmbiguousCharSet);
6043         lpStruct->fClusterSizeVaries = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fClusterSizeVaries);
6044         lpStruct->fRejectInvalid = (*env)->GetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fRejectInvalid);
6045         return lpStruct;
6046 }
6047
6048 void setSCRIPT_PROPERTIESFields(JNIEnv *env, jobject lpObject, SCRIPT_PROPERTIES *lpStruct)
6049 {
6050         if (!SCRIPT_PROPERTIESFc.cached) cacheSCRIPT_PROPERTIESFields(env, lpObject);
6051         (*env)->SetShortField(env, lpObject, SCRIPT_PROPERTIESFc.langid, (jshort)lpStruct->langid);
6052         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNumeric, (jboolean)lpStruct->fNumeric);
6053         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fComplex, (jboolean)lpStruct->fComplex);
6054         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsWordBreaking, (jboolean)lpStruct->fNeedsWordBreaking);
6055         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsCaretInfo, (jboolean)lpStruct->fNeedsCaretInfo);
6056         (*env)->SetByteField(env, lpObject, SCRIPT_PROPERTIESFc.bCharSet, (jbyte)lpStruct->bCharSet);
6057         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fControl, (jboolean)lpStruct->fControl);
6058         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fPrivateUseArea, (jboolean)lpStruct->fPrivateUseArea);
6059         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fNeedsCharacterJustify, (jboolean)lpStruct->fNeedsCharacterJustify);
6060         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fInvalidGlyph, (jboolean)lpStruct->fInvalidGlyph);
6061         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fInvalidLogAttr, (jboolean)lpStruct->fInvalidLogAttr);
6062         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fCDM, (jboolean)lpStruct->fCDM);
6063         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fAmbiguousCharSet, (jboolean)lpStruct->fAmbiguousCharSet);
6064         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fClusterSizeVaries, (jboolean)lpStruct->fClusterSizeVaries);
6065         (*env)->SetBooleanField(env, lpObject, SCRIPT_PROPERTIESFc.fRejectInvalid, (jboolean)lpStruct->fRejectInvalid);
6066 }
6067 #endif
6068
6069 #ifndef NO_SCRIPT_STATE
6070 typedef struct SCRIPT_STATE_FID_CACHE {
6071         int cached;
6072         jclass clazz;
6073         jfieldID uBidiLevel, fOverrideDirection, fInhibitSymSwap, fCharShape, fDigitSubstitute, fInhibitLigate, fDisplayZWG, fArabicNumContext, fGcpClusters, fReserved, fEngineReserved;
6074 } SCRIPT_STATE_FID_CACHE;
6075
6076 SCRIPT_STATE_FID_CACHE SCRIPT_STATEFc;
6077
6078 void cacheSCRIPT_STATEFields(JNIEnv *env, jobject lpObject)
6079 {
6080         if (SCRIPT_STATEFc.cached) return;
6081         SCRIPT_STATEFc.clazz = (*env)->GetObjectClass(env, lpObject);
6082         SCRIPT_STATEFc.uBidiLevel = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "uBidiLevel", "S");
6083         SCRIPT_STATEFc.fOverrideDirection = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fOverrideDirection", "Z");
6084         SCRIPT_STATEFc.fInhibitSymSwap = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fInhibitSymSwap", "Z");
6085         SCRIPT_STATEFc.fCharShape = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fCharShape", "Z");
6086         SCRIPT_STATEFc.fDigitSubstitute = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fDigitSubstitute", "Z");
6087         SCRIPT_STATEFc.fInhibitLigate = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fInhibitLigate", "Z");
6088         SCRIPT_STATEFc.fDisplayZWG = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fDisplayZWG", "Z");
6089         SCRIPT_STATEFc.fArabicNumContext = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fArabicNumContext", "Z");
6090         SCRIPT_STATEFc.fGcpClusters = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fGcpClusters", "Z");
6091         SCRIPT_STATEFc.fReserved = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fReserved", "Z");
6092         SCRIPT_STATEFc.fEngineReserved = (*env)->GetFieldID(env, SCRIPT_STATEFc.clazz, "fEngineReserved", "S");
6093         SCRIPT_STATEFc.cached = 1;
6094 }
6095
6096 SCRIPT_STATE *getSCRIPT_STATEFields(JNIEnv *env, jobject lpObject, SCRIPT_STATE *lpStruct)
6097 {
6098         if (!SCRIPT_STATEFc.cached) cacheSCRIPT_STATEFields(env, lpObject);
6099         lpStruct->uBidiLevel = (*env)->GetShortField(env, lpObject, SCRIPT_STATEFc.uBidiLevel);
6100         lpStruct->fOverrideDirection = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fOverrideDirection);
6101         lpStruct->fInhibitSymSwap = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fInhibitSymSwap);
6102         lpStruct->fCharShape = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fCharShape);
6103         lpStruct->fDigitSubstitute = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fDigitSubstitute);
6104         lpStruct->fInhibitLigate = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fInhibitLigate);
6105         lpStruct->fDisplayZWG = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fDisplayZWG);
6106         lpStruct->fArabicNumContext = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fArabicNumContext);
6107         lpStruct->fGcpClusters = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fGcpClusters);
6108         lpStruct->fReserved = (*env)->GetBooleanField(env, lpObject, SCRIPT_STATEFc.fReserved);
6109         lpStruct->fEngineReserved = (*env)->GetShortField(env, lpObject, SCRIPT_STATEFc.fEngineReserved);
6110         return lpStruct;
6111 }
6112
6113 void setSCRIPT_STATEFields(JNIEnv *env, jobject lpObject, SCRIPT_STATE *lpStruct)
6114 {
6115         if (!SCRIPT_STATEFc.cached) cacheSCRIPT_STATEFields(env, lpObject);
6116         (*env)->SetShortField(env, lpObject, SCRIPT_STATEFc.uBidiLevel, (jshort)lpStruct->uBidiLevel);
6117         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fOverrideDirection, (jboolean)lpStruct->fOverrideDirection);
6118         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fInhibitSymSwap, (jboolean)lpStruct->fInhibitSymSwap);
6119         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fCharShape, (jboolean)lpStruct->fCharShape);
6120         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fDigitSubstitute, (jboolean)lpStruct->fDigitSubstitute);
6121         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fInhibitLigate, (jboolean)lpStruct->fInhibitLigate);
6122         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fDisplayZWG, (jboolean)lpStruct->fDisplayZWG);
6123         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fArabicNumContext, (jboolean)lpStruct->fArabicNumContext);
6124         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fGcpClusters, (jboolean)lpStruct->fGcpClusters);
6125         (*env)->SetBooleanField(env, lpObject, SCRIPT_STATEFc.fReserved, (jboolean)lpStruct->fReserved);
6126         (*env)->SetShortField(env, lpObject, SCRIPT_STATEFc.fEngineReserved, (jshort)lpStruct->fEngineReserved);
6127 }
6128 #endif
6129
6130 #ifndef NO_SCROLLBARINFO
6131 typedef struct SCROLLBARINFO_FID_CACHE {
6132         int cached;
6133         jclass clazz;
6134         jfieldID cbSize, rcScrollBar, dxyLineButton, xyThumbTop, xyThumbBottom, reserved, rgstate;
6135 } SCROLLBARINFO_FID_CACHE;
6136
6137 SCROLLBARINFO_FID_CACHE SCROLLBARINFOFc;
6138
6139 void cacheSCROLLBARINFOFields(JNIEnv *env, jobject lpObject)
6140 {
6141         if (SCROLLBARINFOFc.cached) return;
6142         SCROLLBARINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6143         SCROLLBARINFOFc.cbSize = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "cbSize", "I");
6144         SCROLLBARINFOFc.rcScrollBar = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "rcScrollBar", "Lorg/eclipse/swt/internal/win32/RECT;");
6145         SCROLLBARINFOFc.dxyLineButton = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "dxyLineButton", "I");
6146         SCROLLBARINFOFc.xyThumbTop = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "xyThumbTop", "I");
6147         SCROLLBARINFOFc.xyThumbBottom = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "xyThumbBottom", "I");
6148         SCROLLBARINFOFc.reserved = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "reserved", "I");
6149         SCROLLBARINFOFc.rgstate = (*env)->GetFieldID(env, SCROLLBARINFOFc.clazz, "rgstate", "[I");
6150         SCROLLBARINFOFc.cached = 1;
6151 }
6152
6153 SCROLLBARINFO *getSCROLLBARINFOFields(JNIEnv *env, jobject lpObject, SCROLLBARINFO *lpStruct)
6154 {
6155         if (!SCROLLBARINFOFc.cached) cacheSCROLLBARINFOFields(env, lpObject);
6156         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, SCROLLBARINFOFc.cbSize);
6157         {
6158         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCROLLBARINFOFc.rcScrollBar);
6159         if (lpObject1 != NULL) getRECTFields(env, lpObject1, &lpStruct->rcScrollBar);
6160         }
6161         lpStruct->dxyLineButton = (*env)->GetIntField(env, lpObject, SCROLLBARINFOFc.dxyLineButton);
6162         lpStruct->xyThumbTop = (*env)->GetIntField(env, lpObject, SCROLLBARINFOFc.xyThumbTop);
6163         lpStruct->xyThumbBottom = (*env)->GetIntField(env, lpObject, SCROLLBARINFOFc.xyThumbBottom);
6164         lpStruct->reserved = (*env)->GetIntField(env, lpObject, SCROLLBARINFOFc.reserved);
6165         {
6166         jintArray lpObject1 = (jintArray)(*env)->GetObjectField(env, lpObject, SCROLLBARINFOFc.rgstate);
6167         (*env)->GetIntArrayRegion(env, lpObject1, 0, sizeof(lpStruct->rgstate) / sizeof(jint), (jint *)lpStruct->rgstate);
6168         }
6169         return lpStruct;
6170 }
6171
6172 void setSCROLLBARINFOFields(JNIEnv *env, jobject lpObject, SCROLLBARINFO *lpStruct)
6173 {
6174         if (!SCROLLBARINFOFc.cached) cacheSCROLLBARINFOFields(env, lpObject);
6175         (*env)->SetIntField(env, lpObject, SCROLLBARINFOFc.cbSize, (jint)lpStruct->cbSize);
6176         {
6177         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SCROLLBARINFOFc.rcScrollBar);
6178         if (lpObject1 != NULL) setRECTFields(env, lpObject1, &lpStruct->rcScrollBar);
6179         }
6180         (*env)->SetIntField(env, lpObject, SCROLLBARINFOFc.dxyLineButton, (jint)lpStruct->dxyLineButton);
6181         (*env)->SetIntField(env, lpObject, SCROLLBARINFOFc.xyThumbTop, (jint)lpStruct->xyThumbTop);
6182         (*env)->SetIntField(env, lpObject, SCROLLBARINFOFc.xyThumbBottom, (jint)lpStruct->xyThumbBottom);
6183         (*env)->SetIntField(env, lpObject, SCROLLBARINFOFc.reserved, (jint)lpStruct->reserved);
6184         {
6185         jintArray lpObject1 = (jintArray)(*env)->GetObjectField(env, lpObject, SCROLLBARINFOFc.rgstate);
6186         (*env)->SetIntArrayRegion(env, lpObject1, 0, sizeof(lpStruct->rgstate) / sizeof(jint), (jint *)lpStruct->rgstate);
6187         }
6188 }
6189 #endif
6190
6191 #ifndef NO_SCROLLINFO
6192 typedef struct SCROLLINFO_FID_CACHE {
6193         int cached;
6194         jclass clazz;
6195         jfieldID cbSize, fMask, nMin, nMax, nPage, nPos, nTrackPos;
6196 } SCROLLINFO_FID_CACHE;
6197
6198 SCROLLINFO_FID_CACHE SCROLLINFOFc;
6199
6200 void cacheSCROLLINFOFields(JNIEnv *env, jobject lpObject)
6201 {
6202         if (SCROLLINFOFc.cached) return;
6203         SCROLLINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6204         SCROLLINFOFc.cbSize = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "cbSize", "I");
6205         SCROLLINFOFc.fMask = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "fMask", "I");
6206         SCROLLINFOFc.nMin = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "nMin", "I");
6207         SCROLLINFOFc.nMax = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "nMax", "I");
6208         SCROLLINFOFc.nPage = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "nPage", "I");
6209         SCROLLINFOFc.nPos = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "nPos", "I");
6210         SCROLLINFOFc.nTrackPos = (*env)->GetFieldID(env, SCROLLINFOFc.clazz, "nTrackPos", "I");
6211         SCROLLINFOFc.cached = 1;
6212 }
6213
6214 SCROLLINFO *getSCROLLINFOFields(JNIEnv *env, jobject lpObject, SCROLLINFO *lpStruct)
6215 {
6216         if (!SCROLLINFOFc.cached) cacheSCROLLINFOFields(env, lpObject);
6217         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.cbSize);
6218         lpStruct->fMask = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.fMask);
6219         lpStruct->nMin = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.nMin);
6220         lpStruct->nMax = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.nMax);
6221         lpStruct->nPage = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.nPage);
6222         lpStruct->nPos = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.nPos);
6223         lpStruct->nTrackPos = (*env)->GetIntField(env, lpObject, SCROLLINFOFc.nTrackPos);
6224         return lpStruct;
6225 }
6226
6227 void setSCROLLINFOFields(JNIEnv *env, jobject lpObject, SCROLLINFO *lpStruct)
6228 {
6229         if (!SCROLLINFOFc.cached) cacheSCROLLINFOFields(env, lpObject);
6230         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.cbSize, (jint)lpStruct->cbSize);
6231         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.fMask, (jint)lpStruct->fMask);
6232         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.nMin, (jint)lpStruct->nMin);
6233         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.nMax, (jint)lpStruct->nMax);
6234         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.nPage, (jint)lpStruct->nPage);
6235         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.nPos, (jint)lpStruct->nPos);
6236         (*env)->SetIntField(env, lpObject, SCROLLINFOFc.nTrackPos, (jint)lpStruct->nTrackPos);
6237 }
6238 #endif
6239
6240 #ifndef NO_SHDRAGIMAGE
6241 typedef struct SHDRAGIMAGE_FID_CACHE {
6242         int cached;
6243         jclass clazz;
6244         jfieldID sizeDragImage, ptOffset, hbmpDragImage, crColorKey;
6245 } SHDRAGIMAGE_FID_CACHE;
6246
6247 SHDRAGIMAGE_FID_CACHE SHDRAGIMAGEFc;
6248
6249 void cacheSHDRAGIMAGEFields(JNIEnv *env, jobject lpObject)
6250 {
6251         if (SHDRAGIMAGEFc.cached) return;
6252         SHDRAGIMAGEFc.clazz = (*env)->GetObjectClass(env, lpObject);
6253         SHDRAGIMAGEFc.sizeDragImage = (*env)->GetFieldID(env, SHDRAGIMAGEFc.clazz, "sizeDragImage", "Lorg/eclipse/swt/internal/win32/SIZE;");
6254         SHDRAGIMAGEFc.ptOffset = (*env)->GetFieldID(env, SHDRAGIMAGEFc.clazz, "ptOffset", "Lorg/eclipse/swt/internal/win32/POINT;");
6255         SHDRAGIMAGEFc.hbmpDragImage = (*env)->GetFieldID(env, SHDRAGIMAGEFc.clazz, "hbmpDragImage", "J");
6256         SHDRAGIMAGEFc.crColorKey = (*env)->GetFieldID(env, SHDRAGIMAGEFc.clazz, "crColorKey", "I");
6257         SHDRAGIMAGEFc.cached = 1;
6258 }
6259
6260 SHDRAGIMAGE *getSHDRAGIMAGEFields(JNIEnv *env, jobject lpObject, SHDRAGIMAGE *lpStruct)
6261 {
6262         if (!SHDRAGIMAGEFc.cached) cacheSHDRAGIMAGEFields(env, lpObject);
6263         {
6264         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SHDRAGIMAGEFc.sizeDragImage);
6265         if (lpObject1 != NULL) getSIZEFields(env, lpObject1, &lpStruct->sizeDragImage);
6266         }
6267         {
6268         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SHDRAGIMAGEFc.ptOffset);
6269         if (lpObject1 != NULL) getPOINTFields(env, lpObject1, &lpStruct->ptOffset);
6270         }
6271         lpStruct->hbmpDragImage = (HBITMAP)(*env)->GetLongField(env, lpObject, SHDRAGIMAGEFc.hbmpDragImage);
6272         lpStruct->crColorKey = (*env)->GetIntField(env, lpObject, SHDRAGIMAGEFc.crColorKey);
6273         return lpStruct;
6274 }
6275
6276 void setSHDRAGIMAGEFields(JNIEnv *env, jobject lpObject, SHDRAGIMAGE *lpStruct)
6277 {
6278         if (!SHDRAGIMAGEFc.cached) cacheSHDRAGIMAGEFields(env, lpObject);
6279         {
6280         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SHDRAGIMAGEFc.sizeDragImage);
6281         if (lpObject1 != NULL) setSIZEFields(env, lpObject1, &lpStruct->sizeDragImage);
6282         }
6283         {
6284         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, SHDRAGIMAGEFc.ptOffset);
6285         if (lpObject1 != NULL) setPOINTFields(env, lpObject1, &lpStruct->ptOffset);
6286         }
6287         (*env)->SetLongField(env, lpObject, SHDRAGIMAGEFc.hbmpDragImage, (jlong)lpStruct->hbmpDragImage);
6288         (*env)->SetIntField(env, lpObject, SHDRAGIMAGEFc.crColorKey, (jint)lpStruct->crColorKey);
6289 }
6290 #endif
6291
6292 #ifndef NO_SHELLEXECUTEINFO
6293 typedef struct SHELLEXECUTEINFO_FID_CACHE {
6294         int cached;
6295         jclass clazz;
6296         jfieldID cbSize, fMask, hwnd, lpVerb, lpFile, lpParameters, lpDirectory, nShow, hInstApp, lpIDList, lpClass, hkeyClass, dwHotKey, hIcon, hProcess;
6297 } SHELLEXECUTEINFO_FID_CACHE;
6298
6299 SHELLEXECUTEINFO_FID_CACHE SHELLEXECUTEINFOFc;
6300
6301 void cacheSHELLEXECUTEINFOFields(JNIEnv *env, jobject lpObject)
6302 {
6303         if (SHELLEXECUTEINFOFc.cached) return;
6304         SHELLEXECUTEINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6305         SHELLEXECUTEINFOFc.cbSize = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "cbSize", "I");
6306         SHELLEXECUTEINFOFc.fMask = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "fMask", "I");
6307         SHELLEXECUTEINFOFc.hwnd = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "hwnd", "J");
6308         SHELLEXECUTEINFOFc.lpVerb = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpVerb", "J");
6309         SHELLEXECUTEINFOFc.lpFile = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpFile", "J");
6310         SHELLEXECUTEINFOFc.lpParameters = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpParameters", "J");
6311         SHELLEXECUTEINFOFc.lpDirectory = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpDirectory", "J");
6312         SHELLEXECUTEINFOFc.nShow = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "nShow", "I");
6313         SHELLEXECUTEINFOFc.hInstApp = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "hInstApp", "J");
6314         SHELLEXECUTEINFOFc.lpIDList = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpIDList", "J");
6315         SHELLEXECUTEINFOFc.lpClass = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "lpClass", "J");
6316         SHELLEXECUTEINFOFc.hkeyClass = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "hkeyClass", "J");
6317         SHELLEXECUTEINFOFc.dwHotKey = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "dwHotKey", "I");
6318         SHELLEXECUTEINFOFc.hIcon = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "hIcon", "J");
6319         SHELLEXECUTEINFOFc.hProcess = (*env)->GetFieldID(env, SHELLEXECUTEINFOFc.clazz, "hProcess", "J");
6320         SHELLEXECUTEINFOFc.cached = 1;
6321 }
6322
6323 SHELLEXECUTEINFO *getSHELLEXECUTEINFOFields(JNIEnv *env, jobject lpObject, SHELLEXECUTEINFO *lpStruct)
6324 {
6325         if (!SHELLEXECUTEINFOFc.cached) cacheSHELLEXECUTEINFOFields(env, lpObject);
6326         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, SHELLEXECUTEINFOFc.cbSize);
6327         lpStruct->fMask = (*env)->GetIntField(env, lpObject, SHELLEXECUTEINFOFc.fMask);
6328         lpStruct->hwnd = (HWND)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.hwnd);
6329         lpStruct->lpVerb = (LPCTSTR)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpVerb);
6330         lpStruct->lpFile = (LPCTSTR)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpFile);
6331         lpStruct->lpParameters = (LPCTSTR)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpParameters);
6332         lpStruct->lpDirectory = (LPCTSTR)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpDirectory);
6333         lpStruct->nShow = (*env)->GetIntField(env, lpObject, SHELLEXECUTEINFOFc.nShow);
6334         lpStruct->hInstApp = (HINSTANCE)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.hInstApp);
6335         lpStruct->lpIDList = (LPVOID)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpIDList);
6336         lpStruct->lpClass = (LPCTSTR)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpClass);
6337         lpStruct->hkeyClass = (HKEY)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.hkeyClass);
6338         lpStruct->dwHotKey = (*env)->GetIntField(env, lpObject, SHELLEXECUTEINFOFc.dwHotKey);
6339         lpStruct->hIcon = (HANDLE)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.hIcon);
6340         lpStruct->hProcess = (HANDLE)(*env)->GetLongField(env, lpObject, SHELLEXECUTEINFOFc.hProcess);
6341         return lpStruct;
6342 }
6343
6344 void setSHELLEXECUTEINFOFields(JNIEnv *env, jobject lpObject, SHELLEXECUTEINFO *lpStruct)
6345 {
6346         if (!SHELLEXECUTEINFOFc.cached) cacheSHELLEXECUTEINFOFields(env, lpObject);
6347         (*env)->SetIntField(env, lpObject, SHELLEXECUTEINFOFc.cbSize, (jint)lpStruct->cbSize);
6348         (*env)->SetIntField(env, lpObject, SHELLEXECUTEINFOFc.fMask, (jint)lpStruct->fMask);
6349         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.hwnd, (jlong)lpStruct->hwnd);
6350         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpVerb, (jlong)lpStruct->lpVerb);
6351         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpFile, (jlong)lpStruct->lpFile);
6352         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpParameters, (jlong)lpStruct->lpParameters);
6353         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpDirectory, (jlong)lpStruct->lpDirectory);
6354         (*env)->SetIntField(env, lpObject, SHELLEXECUTEINFOFc.nShow, (jint)lpStruct->nShow);
6355         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.hInstApp, (jlong)lpStruct->hInstApp);
6356         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpIDList, (jlong)lpStruct->lpIDList);
6357         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.lpClass, (jlong)lpStruct->lpClass);
6358         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.hkeyClass, (jlong)lpStruct->hkeyClass);
6359         (*env)->SetIntField(env, lpObject, SHELLEXECUTEINFOFc.dwHotKey, (jint)lpStruct->dwHotKey);
6360         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.hIcon, (jlong)lpStruct->hIcon);
6361         (*env)->SetLongField(env, lpObject, SHELLEXECUTEINFOFc.hProcess, (jlong)lpStruct->hProcess);
6362 }
6363 #endif
6364
6365 #ifndef NO_SHFILEINFO
6366 typedef struct SHFILEINFO_FID_CACHE {
6367         int cached;
6368         jclass clazz;
6369         jfieldID hIcon, iIcon, dwAttributes, szDisplayName, szTypeName;
6370 } SHFILEINFO_FID_CACHE;
6371
6372 SHFILEINFO_FID_CACHE SHFILEINFOFc;
6373
6374 void cacheSHFILEINFOFields(JNIEnv *env, jobject lpObject)
6375 {
6376         if (SHFILEINFOFc.cached) return;
6377         SHFILEINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6378         SHFILEINFOFc.hIcon = (*env)->GetFieldID(env, SHFILEINFOFc.clazz, "hIcon", "J");
6379         SHFILEINFOFc.iIcon = (*env)->GetFieldID(env, SHFILEINFOFc.clazz, "iIcon", "I");
6380         SHFILEINFOFc.dwAttributes = (*env)->GetFieldID(env, SHFILEINFOFc.clazz, "dwAttributes", "I");
6381         SHFILEINFOFc.szDisplayName = (*env)->GetFieldID(env, SHFILEINFOFc.clazz, "szDisplayName", "[C");
6382         SHFILEINFOFc.szTypeName = (*env)->GetFieldID(env, SHFILEINFOFc.clazz, "szTypeName", "[C");
6383         SHFILEINFOFc.cached = 1;
6384 }
6385
6386 SHFILEINFO *getSHFILEINFOFields(JNIEnv *env, jobject lpObject, SHFILEINFO *lpStruct)
6387 {
6388         if (!SHFILEINFOFc.cached) cacheSHFILEINFOFields(env, lpObject);
6389         lpStruct->hIcon = (HICON)(*env)->GetLongField(env, lpObject, SHFILEINFOFc.hIcon);
6390         lpStruct->iIcon = (*env)->GetIntField(env, lpObject, SHFILEINFOFc.iIcon);
6391         lpStruct->dwAttributes = (*env)->GetIntField(env, lpObject, SHFILEINFOFc.dwAttributes);
6392         {
6393         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, SHFILEINFOFc.szDisplayName);
6394         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szDisplayName) / sizeof(jchar), (jchar *)lpStruct->szDisplayName);
6395         }
6396         {
6397         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, SHFILEINFOFc.szTypeName);
6398         (*env)->GetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szTypeName) / sizeof(jchar), (jchar *)lpStruct->szTypeName);
6399         }
6400         return lpStruct;
6401 }
6402
6403 void setSHFILEINFOFields(JNIEnv *env, jobject lpObject, SHFILEINFO *lpStruct)
6404 {
6405         if (!SHFILEINFOFc.cached) cacheSHFILEINFOFields(env, lpObject);
6406         (*env)->SetLongField(env, lpObject, SHFILEINFOFc.hIcon, (jlong)lpStruct->hIcon);
6407         (*env)->SetIntField(env, lpObject, SHFILEINFOFc.iIcon, (jint)lpStruct->iIcon);
6408         (*env)->SetIntField(env, lpObject, SHFILEINFOFc.dwAttributes, (jint)lpStruct->dwAttributes);
6409         {
6410         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, SHFILEINFOFc.szDisplayName);
6411         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szDisplayName) / sizeof(jchar), (jchar *)lpStruct->szDisplayName);
6412         }
6413         {
6414         jcharArray lpObject1 = (jcharArray)(*env)->GetObjectField(env, lpObject, SHFILEINFOFc.szTypeName);
6415         (*env)->SetCharArrayRegion(env, lpObject1, 0, sizeof(lpStruct->szTypeName) / sizeof(jchar), (jchar *)lpStruct->szTypeName);
6416         }
6417 }
6418 #endif
6419
6420 #ifndef NO_SIZE
6421 typedef struct SIZE_FID_CACHE {
6422         int cached;
6423         jclass clazz;
6424         jfieldID cx, cy;
6425 } SIZE_FID_CACHE;
6426
6427 SIZE_FID_CACHE SIZEFc;
6428
6429 void cacheSIZEFields(JNIEnv *env, jobject lpObject)
6430 {
6431         if (SIZEFc.cached) return;
6432         SIZEFc.clazz = (*env)->GetObjectClass(env, lpObject);
6433         SIZEFc.cx = (*env)->GetFieldID(env, SIZEFc.clazz, "cx", "I");
6434         SIZEFc.cy = (*env)->GetFieldID(env, SIZEFc.clazz, "cy", "I");
6435         SIZEFc.cached = 1;
6436 }
6437
6438 SIZE *getSIZEFields(JNIEnv *env, jobject lpObject, SIZE *lpStruct)
6439 {
6440         if (!SIZEFc.cached) cacheSIZEFields(env, lpObject);
6441         lpStruct->cx = (*env)->GetIntField(env, lpObject, SIZEFc.cx);
6442         lpStruct->cy = (*env)->GetIntField(env, lpObject, SIZEFc.cy);
6443         return lpStruct;
6444 }
6445
6446 void setSIZEFields(JNIEnv *env, jobject lpObject, SIZE *lpStruct)
6447 {
6448         if (!SIZEFc.cached) cacheSIZEFields(env, lpObject);
6449         (*env)->SetIntField(env, lpObject, SIZEFc.cx, (jint)lpStruct->cx);
6450         (*env)->SetIntField(env, lpObject, SIZEFc.cy, (jint)lpStruct->cy);
6451 }
6452 #endif
6453
6454 #ifndef NO_STARTUPINFO
6455 typedef struct STARTUPINFO_FID_CACHE {
6456         int cached;
6457         jclass clazz;
6458         jfieldID cb, lpReserved, lpDesktop, lpTitle, dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags, wShowWindow, cbReserved2, lpReserved2, hStdInput, hStdOutput, hStdError;
6459 } STARTUPINFO_FID_CACHE;
6460
6461 STARTUPINFO_FID_CACHE STARTUPINFOFc;
6462
6463 void cacheSTARTUPINFOFields(JNIEnv *env, jobject lpObject)
6464 {
6465         if (STARTUPINFOFc.cached) return;
6466         STARTUPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6467         STARTUPINFOFc.cb = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "cb", "I");
6468         STARTUPINFOFc.lpReserved = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "lpReserved", "J");
6469         STARTUPINFOFc.lpDesktop = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "lpDesktop", "J");
6470         STARTUPINFOFc.lpTitle = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "lpTitle", "J");
6471         STARTUPINFOFc.dwX = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwX", "I");
6472         STARTUPINFOFc.dwY = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwY", "I");
6473         STARTUPINFOFc.dwXSize = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwXSize", "I");
6474         STARTUPINFOFc.dwYSize = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwYSize", "I");
6475         STARTUPINFOFc.dwXCountChars = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwXCountChars", "I");
6476         STARTUPINFOFc.dwYCountChars = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwYCountChars", "I");
6477         STARTUPINFOFc.dwFillAttribute = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwFillAttribute", "I");
6478         STARTUPINFOFc.dwFlags = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "dwFlags", "I");
6479         STARTUPINFOFc.wShowWindow = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "wShowWindow", "S");
6480         STARTUPINFOFc.cbReserved2 = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "cbReserved2", "S");
6481         STARTUPINFOFc.lpReserved2 = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "lpReserved2", "J");
6482         STARTUPINFOFc.hStdInput = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "hStdInput", "J");
6483         STARTUPINFOFc.hStdOutput = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "hStdOutput", "J");
6484         STARTUPINFOFc.hStdError = (*env)->GetFieldID(env, STARTUPINFOFc.clazz, "hStdError", "J");
6485         STARTUPINFOFc.cached = 1;
6486 }
6487
6488 STARTUPINFO *getSTARTUPINFOFields(JNIEnv *env, jobject lpObject, STARTUPINFO *lpStruct)
6489 {
6490         if (!STARTUPINFOFc.cached) cacheSTARTUPINFOFields(env, lpObject);
6491         lpStruct->cb = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.cb);
6492         lpStruct->lpReserved = (LPTSTR)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.lpReserved);
6493         lpStruct->lpDesktop = (LPTSTR)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.lpDesktop);
6494         lpStruct->lpTitle = (LPTSTR)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.lpTitle);
6495         lpStruct->dwX = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwX);
6496         lpStruct->dwY = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwY);
6497         lpStruct->dwXSize = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwXSize);
6498         lpStruct->dwYSize = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwYSize);
6499         lpStruct->dwXCountChars = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwXCountChars);
6500         lpStruct->dwYCountChars = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwYCountChars);
6501         lpStruct->dwFillAttribute = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwFillAttribute);
6502         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, STARTUPINFOFc.dwFlags);
6503         lpStruct->wShowWindow = (*env)->GetShortField(env, lpObject, STARTUPINFOFc.wShowWindow);
6504         lpStruct->cbReserved2 = (*env)->GetShortField(env, lpObject, STARTUPINFOFc.cbReserved2);
6505         lpStruct->lpReserved2 = (LPBYTE)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.lpReserved2);
6506         lpStruct->hStdInput = (HANDLE)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.hStdInput);
6507         lpStruct->hStdOutput = (HANDLE)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.hStdOutput);
6508         lpStruct->hStdError = (HANDLE)(*env)->GetLongField(env, lpObject, STARTUPINFOFc.hStdError);
6509         return lpStruct;
6510 }
6511
6512 void setSTARTUPINFOFields(JNIEnv *env, jobject lpObject, STARTUPINFO *lpStruct)
6513 {
6514         if (!STARTUPINFOFc.cached) cacheSTARTUPINFOFields(env, lpObject);
6515         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.cb, (jint)lpStruct->cb);
6516         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.lpReserved, (jlong)lpStruct->lpReserved);
6517         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.lpDesktop, (jlong)lpStruct->lpDesktop);
6518         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.lpTitle, (jlong)lpStruct->lpTitle);
6519         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwX, (jint)lpStruct->dwX);
6520         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwY, (jint)lpStruct->dwY);
6521         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwXSize, (jint)lpStruct->dwXSize);
6522         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwYSize, (jint)lpStruct->dwYSize);
6523         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwXCountChars, (jint)lpStruct->dwXCountChars);
6524         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwYCountChars, (jint)lpStruct->dwYCountChars);
6525         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwFillAttribute, (jint)lpStruct->dwFillAttribute);
6526         (*env)->SetIntField(env, lpObject, STARTUPINFOFc.dwFlags, (jint)lpStruct->dwFlags);
6527         (*env)->SetShortField(env, lpObject, STARTUPINFOFc.wShowWindow, (jshort)lpStruct->wShowWindow);
6528         (*env)->SetShortField(env, lpObject, STARTUPINFOFc.cbReserved2, (jshort)lpStruct->cbReserved2);
6529         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.lpReserved2, (jlong)lpStruct->lpReserved2);
6530         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.hStdInput, (jlong)lpStruct->hStdInput);
6531         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.hStdOutput, (jlong)lpStruct->hStdOutput);
6532         (*env)->SetLongField(env, lpObject, STARTUPINFOFc.hStdError, (jlong)lpStruct->hStdError);
6533 }
6534 #endif
6535
6536 #ifndef NO_SYSTEMTIME
6537 typedef struct SYSTEMTIME_FID_CACHE {
6538         int cached;
6539         jclass clazz;
6540         jfieldID wYear, wMonth, wDayOfWeek, wDay, wHour, wMinute, wSecond, wMilliseconds;
6541 } SYSTEMTIME_FID_CACHE;
6542
6543 SYSTEMTIME_FID_CACHE SYSTEMTIMEFc;
6544
6545 void cacheSYSTEMTIMEFields(JNIEnv *env, jobject lpObject)
6546 {
6547         if (SYSTEMTIMEFc.cached) return;
6548         SYSTEMTIMEFc.clazz = (*env)->GetObjectClass(env, lpObject);
6549         SYSTEMTIMEFc.wYear = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wYear", "S");
6550         SYSTEMTIMEFc.wMonth = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wMonth", "S");
6551         SYSTEMTIMEFc.wDayOfWeek = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wDayOfWeek", "S");
6552         SYSTEMTIMEFc.wDay = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wDay", "S");
6553         SYSTEMTIMEFc.wHour = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wHour", "S");
6554         SYSTEMTIMEFc.wMinute = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wMinute", "S");
6555         SYSTEMTIMEFc.wSecond = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wSecond", "S");
6556         SYSTEMTIMEFc.wMilliseconds = (*env)->GetFieldID(env, SYSTEMTIMEFc.clazz, "wMilliseconds", "S");
6557         SYSTEMTIMEFc.cached = 1;
6558 }
6559
6560 SYSTEMTIME *getSYSTEMTIMEFields(JNIEnv *env, jobject lpObject, SYSTEMTIME *lpStruct)
6561 {
6562         if (!SYSTEMTIMEFc.cached) cacheSYSTEMTIMEFields(env, lpObject);
6563         lpStruct->wYear = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wYear);
6564         lpStruct->wMonth = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wMonth);
6565         lpStruct->wDayOfWeek = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wDayOfWeek);
6566         lpStruct->wDay = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wDay);
6567         lpStruct->wHour = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wHour);
6568         lpStruct->wMinute = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wMinute);
6569         lpStruct->wSecond = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wSecond);
6570         lpStruct->wMilliseconds = (*env)->GetShortField(env, lpObject, SYSTEMTIMEFc.wMilliseconds);
6571         return lpStruct;
6572 }
6573
6574 void setSYSTEMTIMEFields(JNIEnv *env, jobject lpObject, SYSTEMTIME *lpStruct)
6575 {
6576         if (!SYSTEMTIMEFc.cached) cacheSYSTEMTIMEFields(env, lpObject);
6577         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wYear, (jshort)lpStruct->wYear);
6578         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wMonth, (jshort)lpStruct->wMonth);
6579         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wDayOfWeek, (jshort)lpStruct->wDayOfWeek);
6580         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wDay, (jshort)lpStruct->wDay);
6581         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wHour, (jshort)lpStruct->wHour);
6582         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wMinute, (jshort)lpStruct->wMinute);
6583         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wSecond, (jshort)lpStruct->wSecond);
6584         (*env)->SetShortField(env, lpObject, SYSTEMTIMEFc.wMilliseconds, (jshort)lpStruct->wMilliseconds);
6585 }
6586 #endif
6587
6588 #ifndef NO_TBBUTTON
6589 typedef struct TBBUTTON_FID_CACHE {
6590         int cached;
6591         jclass clazz;
6592         jfieldID iBitmap, idCommand, fsState, fsStyle, dwData, iString;
6593 } TBBUTTON_FID_CACHE;
6594
6595 TBBUTTON_FID_CACHE TBBUTTONFc;
6596
6597 void cacheTBBUTTONFields(JNIEnv *env, jobject lpObject)
6598 {
6599         if (TBBUTTONFc.cached) return;
6600         TBBUTTONFc.clazz = (*env)->GetObjectClass(env, lpObject);
6601         TBBUTTONFc.iBitmap = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "iBitmap", "I");
6602         TBBUTTONFc.idCommand = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "idCommand", "I");
6603         TBBUTTONFc.fsState = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "fsState", "B");
6604         TBBUTTONFc.fsStyle = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "fsStyle", "B");
6605         TBBUTTONFc.dwData = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "dwData", "J");
6606         TBBUTTONFc.iString = (*env)->GetFieldID(env, TBBUTTONFc.clazz, "iString", "J");
6607         TBBUTTONFc.cached = 1;
6608 }
6609
6610 TBBUTTON *getTBBUTTONFields(JNIEnv *env, jobject lpObject, TBBUTTON *lpStruct)
6611 {
6612         if (!TBBUTTONFc.cached) cacheTBBUTTONFields(env, lpObject);
6613         lpStruct->iBitmap = (*env)->GetIntField(env, lpObject, TBBUTTONFc.iBitmap);
6614         lpStruct->idCommand = (*env)->GetIntField(env, lpObject, TBBUTTONFc.idCommand);
6615         lpStruct->fsState = (*env)->GetByteField(env, lpObject, TBBUTTONFc.fsState);
6616         lpStruct->fsStyle = (*env)->GetByteField(env, lpObject, TBBUTTONFc.fsStyle);
6617         lpStruct->dwData = (*env)->GetLongField(env, lpObject, TBBUTTONFc.dwData);
6618         lpStruct->iString = (*env)->GetLongField(env, lpObject, TBBUTTONFc.iString);
6619         return lpStruct;
6620 }
6621
6622 void setTBBUTTONFields(JNIEnv *env, jobject lpObject, TBBUTTON *lpStruct)
6623 {
6624         if (!TBBUTTONFc.cached) cacheTBBUTTONFields(env, lpObject);
6625         (*env)->SetIntField(env, lpObject, TBBUTTONFc.iBitmap, (jint)lpStruct->iBitmap);
6626         (*env)->SetIntField(env, lpObject, TBBUTTONFc.idCommand, (jint)lpStruct->idCommand);
6627         (*env)->SetByteField(env, lpObject, TBBUTTONFc.fsState, (jbyte)lpStruct->fsState);
6628         (*env)->SetByteField(env, lpObject, TBBUTTONFc.fsStyle, (jbyte)lpStruct->fsStyle);
6629         (*env)->SetLongField(env, lpObject, TBBUTTONFc.dwData, (jlong)lpStruct->dwData);
6630         (*env)->SetLongField(env, lpObject, TBBUTTONFc.iString, (jlong)lpStruct->iString);
6631 }
6632 #endif
6633
6634 #ifndef NO_TBBUTTONINFO
6635 typedef struct TBBUTTONINFO_FID_CACHE {
6636         int cached;
6637         jclass clazz;
6638         jfieldID cbSize, dwMask, idCommand, iImage, fsState, fsStyle, cx, lParam, pszText, cchText;
6639 } TBBUTTONINFO_FID_CACHE;
6640
6641 TBBUTTONINFO_FID_CACHE TBBUTTONINFOFc;
6642
6643 void cacheTBBUTTONINFOFields(JNIEnv *env, jobject lpObject)
6644 {
6645         if (TBBUTTONINFOFc.cached) return;
6646         TBBUTTONINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6647         TBBUTTONINFOFc.cbSize = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "cbSize", "I");
6648         TBBUTTONINFOFc.dwMask = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "dwMask", "I");
6649         TBBUTTONINFOFc.idCommand = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "idCommand", "I");
6650         TBBUTTONINFOFc.iImage = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "iImage", "I");
6651         TBBUTTONINFOFc.fsState = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "fsState", "B");
6652         TBBUTTONINFOFc.fsStyle = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "fsStyle", "B");
6653         TBBUTTONINFOFc.cx = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "cx", "S");
6654         TBBUTTONINFOFc.lParam = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "lParam", "J");
6655         TBBUTTONINFOFc.pszText = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "pszText", "J");
6656         TBBUTTONINFOFc.cchText = (*env)->GetFieldID(env, TBBUTTONINFOFc.clazz, "cchText", "I");
6657         TBBUTTONINFOFc.cached = 1;
6658 }
6659
6660 TBBUTTONINFO *getTBBUTTONINFOFields(JNIEnv *env, jobject lpObject, TBBUTTONINFO *lpStruct)
6661 {
6662         if (!TBBUTTONINFOFc.cached) cacheTBBUTTONINFOFields(env, lpObject);
6663         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, TBBUTTONINFOFc.cbSize);
6664         lpStruct->dwMask = (*env)->GetIntField(env, lpObject, TBBUTTONINFOFc.dwMask);
6665         lpStruct->idCommand = (*env)->GetIntField(env, lpObject, TBBUTTONINFOFc.idCommand);
6666         lpStruct->iImage = (*env)->GetIntField(env, lpObject, TBBUTTONINFOFc.iImage);
6667         lpStruct->fsState = (*env)->GetByteField(env, lpObject, TBBUTTONINFOFc.fsState);
6668         lpStruct->fsStyle = (*env)->GetByteField(env, lpObject, TBBUTTONINFOFc.fsStyle);
6669         lpStruct->cx = (*env)->GetShortField(env, lpObject, TBBUTTONINFOFc.cx);
6670         lpStruct->lParam = (*env)->GetLongField(env, lpObject, TBBUTTONINFOFc.lParam);
6671         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, TBBUTTONINFOFc.pszText);
6672         lpStruct->cchText = (*env)->GetIntField(env, lpObject, TBBUTTONINFOFc.cchText);
6673         return lpStruct;
6674 }
6675
6676 void setTBBUTTONINFOFields(JNIEnv *env, jobject lpObject, TBBUTTONINFO *lpStruct)
6677 {
6678         if (!TBBUTTONINFOFc.cached) cacheTBBUTTONINFOFields(env, lpObject);
6679         (*env)->SetIntField(env, lpObject, TBBUTTONINFOFc.cbSize, (jint)lpStruct->cbSize);
6680         (*env)->SetIntField(env, lpObject, TBBUTTONINFOFc.dwMask, (jint)lpStruct->dwMask);
6681         (*env)->SetIntField(env, lpObject, TBBUTTONINFOFc.idCommand, (jint)lpStruct->idCommand);
6682         (*env)->SetIntField(env, lpObject, TBBUTTONINFOFc.iImage, (jint)lpStruct->iImage);
6683         (*env)->SetByteField(env, lpObject, TBBUTTONINFOFc.fsState, (jbyte)lpStruct->fsState);
6684         (*env)->SetByteField(env, lpObject, TBBUTTONINFOFc.fsStyle, (jbyte)lpStruct->fsStyle);
6685         (*env)->SetShortField(env, lpObject, TBBUTTONINFOFc.cx, (jshort)lpStruct->cx);
6686         (*env)->SetLongField(env, lpObject, TBBUTTONINFOFc.lParam, (jlong)lpStruct->lParam);
6687         (*env)->SetLongField(env, lpObject, TBBUTTONINFOFc.pszText, (jlong)lpStruct->pszText);
6688         (*env)->SetIntField(env, lpObject, TBBUTTONINFOFc.cchText, (jint)lpStruct->cchText);
6689 }
6690 #endif
6691
6692 #ifndef NO_TCHITTESTINFO
6693 typedef struct TCHITTESTINFO_FID_CACHE {
6694         int cached;
6695         jclass clazz;
6696         jfieldID x, y, flags;
6697 } TCHITTESTINFO_FID_CACHE;
6698
6699 TCHITTESTINFO_FID_CACHE TCHITTESTINFOFc;
6700
6701 void cacheTCHITTESTINFOFields(JNIEnv *env, jobject lpObject)
6702 {
6703         if (TCHITTESTINFOFc.cached) return;
6704         TCHITTESTINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6705         TCHITTESTINFOFc.x = (*env)->GetFieldID(env, TCHITTESTINFOFc.clazz, "x", "I");
6706         TCHITTESTINFOFc.y = (*env)->GetFieldID(env, TCHITTESTINFOFc.clazz, "y", "I");
6707         TCHITTESTINFOFc.flags = (*env)->GetFieldID(env, TCHITTESTINFOFc.clazz, "flags", "I");
6708         TCHITTESTINFOFc.cached = 1;
6709 }
6710
6711 TCHITTESTINFO *getTCHITTESTINFOFields(JNIEnv *env, jobject lpObject, TCHITTESTINFO *lpStruct)
6712 {
6713         if (!TCHITTESTINFOFc.cached) cacheTCHITTESTINFOFields(env, lpObject);
6714         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, TCHITTESTINFOFc.x);
6715         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, TCHITTESTINFOFc.y);
6716         lpStruct->flags = (*env)->GetIntField(env, lpObject, TCHITTESTINFOFc.flags);
6717         return lpStruct;
6718 }
6719
6720 void setTCHITTESTINFOFields(JNIEnv *env, jobject lpObject, TCHITTESTINFO *lpStruct)
6721 {
6722         if (!TCHITTESTINFOFc.cached) cacheTCHITTESTINFOFields(env, lpObject);
6723         (*env)->SetIntField(env, lpObject, TCHITTESTINFOFc.x, (jint)lpStruct->pt.x);
6724         (*env)->SetIntField(env, lpObject, TCHITTESTINFOFc.y, (jint)lpStruct->pt.y);
6725         (*env)->SetIntField(env, lpObject, TCHITTESTINFOFc.flags, (jint)lpStruct->flags);
6726 }
6727 #endif
6728
6729 #ifndef NO_TCITEM
6730 typedef struct TCITEM_FID_CACHE {
6731         int cached;
6732         jclass clazz;
6733         jfieldID mask, dwState, dwStateMask, pszText, cchTextMax, iImage, lParam;
6734 } TCITEM_FID_CACHE;
6735
6736 TCITEM_FID_CACHE TCITEMFc;
6737
6738 void cacheTCITEMFields(JNIEnv *env, jobject lpObject)
6739 {
6740         if (TCITEMFc.cached) return;
6741         TCITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
6742         TCITEMFc.mask = (*env)->GetFieldID(env, TCITEMFc.clazz, "mask", "I");
6743         TCITEMFc.dwState = (*env)->GetFieldID(env, TCITEMFc.clazz, "dwState", "I");
6744         TCITEMFc.dwStateMask = (*env)->GetFieldID(env, TCITEMFc.clazz, "dwStateMask", "I");
6745         TCITEMFc.pszText = (*env)->GetFieldID(env, TCITEMFc.clazz, "pszText", "J");
6746         TCITEMFc.cchTextMax = (*env)->GetFieldID(env, TCITEMFc.clazz, "cchTextMax", "I");
6747         TCITEMFc.iImage = (*env)->GetFieldID(env, TCITEMFc.clazz, "iImage", "I");
6748         TCITEMFc.lParam = (*env)->GetFieldID(env, TCITEMFc.clazz, "lParam", "J");
6749         TCITEMFc.cached = 1;
6750 }
6751
6752 TCITEM *getTCITEMFields(JNIEnv *env, jobject lpObject, TCITEM *lpStruct)
6753 {
6754         if (!TCITEMFc.cached) cacheTCITEMFields(env, lpObject);
6755         lpStruct->mask = (*env)->GetIntField(env, lpObject, TCITEMFc.mask);
6756         lpStruct->dwState = (*env)->GetIntField(env, lpObject, TCITEMFc.dwState);
6757         lpStruct->dwStateMask = (*env)->GetIntField(env, lpObject, TCITEMFc.dwStateMask);
6758         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, TCITEMFc.pszText);
6759         lpStruct->cchTextMax = (*env)->GetIntField(env, lpObject, TCITEMFc.cchTextMax);
6760         lpStruct->iImage = (*env)->GetIntField(env, lpObject, TCITEMFc.iImage);
6761         lpStruct->lParam = (*env)->GetLongField(env, lpObject, TCITEMFc.lParam);
6762         return lpStruct;
6763 }
6764
6765 void setTCITEMFields(JNIEnv *env, jobject lpObject, TCITEM *lpStruct)
6766 {
6767         if (!TCITEMFc.cached) cacheTCITEMFields(env, lpObject);
6768         (*env)->SetIntField(env, lpObject, TCITEMFc.mask, (jint)lpStruct->mask);
6769         (*env)->SetIntField(env, lpObject, TCITEMFc.dwState, (jint)lpStruct->dwState);
6770         (*env)->SetIntField(env, lpObject, TCITEMFc.dwStateMask, (jint)lpStruct->dwStateMask);
6771         (*env)->SetLongField(env, lpObject, TCITEMFc.pszText, (jlong)lpStruct->pszText);
6772         (*env)->SetIntField(env, lpObject, TCITEMFc.cchTextMax, (jint)lpStruct->cchTextMax);
6773         (*env)->SetIntField(env, lpObject, TCITEMFc.iImage, (jint)lpStruct->iImage);
6774         (*env)->SetLongField(env, lpObject, TCITEMFc.lParam, (jlong)lpStruct->lParam);
6775 }
6776 #endif
6777
6778 #ifndef NO_TEXTMETRIC
6779 typedef struct TEXTMETRIC_FID_CACHE {
6780         int cached;
6781         jclass clazz;
6782         jfieldID tmHeight, tmAscent, tmDescent, tmInternalLeading, tmExternalLeading, tmAveCharWidth, tmMaxCharWidth, tmWeight, tmOverhang, tmDigitizedAspectX, tmDigitizedAspectY, tmFirstChar, tmLastChar, tmDefaultChar, tmBreakChar, tmItalic, tmUnderlined, tmStruckOut, tmPitchAndFamily, tmCharSet;
6783 } TEXTMETRIC_FID_CACHE;
6784
6785 TEXTMETRIC_FID_CACHE TEXTMETRICFc;
6786
6787 void cacheTEXTMETRICFields(JNIEnv *env, jobject lpObject)
6788 {
6789         if (TEXTMETRICFc.cached) return;
6790         TEXTMETRICFc.clazz = (*env)->GetObjectClass(env, lpObject);
6791         TEXTMETRICFc.tmHeight = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmHeight", "I");
6792         TEXTMETRICFc.tmAscent = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmAscent", "I");
6793         TEXTMETRICFc.tmDescent = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmDescent", "I");
6794         TEXTMETRICFc.tmInternalLeading = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmInternalLeading", "I");
6795         TEXTMETRICFc.tmExternalLeading = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmExternalLeading", "I");
6796         TEXTMETRICFc.tmAveCharWidth = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmAveCharWidth", "I");
6797         TEXTMETRICFc.tmMaxCharWidth = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmMaxCharWidth", "I");
6798         TEXTMETRICFc.tmWeight = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmWeight", "I");
6799         TEXTMETRICFc.tmOverhang = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmOverhang", "I");
6800         TEXTMETRICFc.tmDigitizedAspectX = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmDigitizedAspectX", "I");
6801         TEXTMETRICFc.tmDigitizedAspectY = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmDigitizedAspectY", "I");
6802         TEXTMETRICFc.tmFirstChar = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmFirstChar", "C");
6803         TEXTMETRICFc.tmLastChar = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmLastChar", "C");
6804         TEXTMETRICFc.tmDefaultChar = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmDefaultChar", "C");
6805         TEXTMETRICFc.tmBreakChar = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmBreakChar", "C");
6806         TEXTMETRICFc.tmItalic = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmItalic", "B");
6807         TEXTMETRICFc.tmUnderlined = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmUnderlined", "B");
6808         TEXTMETRICFc.tmStruckOut = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmStruckOut", "B");
6809         TEXTMETRICFc.tmPitchAndFamily = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmPitchAndFamily", "B");
6810         TEXTMETRICFc.tmCharSet = (*env)->GetFieldID(env, TEXTMETRICFc.clazz, "tmCharSet", "B");
6811         TEXTMETRICFc.cached = 1;
6812 }
6813
6814 TEXTMETRIC *getTEXTMETRICFields(JNIEnv *env, jobject lpObject, TEXTMETRIC *lpStruct)
6815 {
6816         if (!TEXTMETRICFc.cached) cacheTEXTMETRICFields(env, lpObject);
6817         lpStruct->tmHeight = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmHeight);
6818         lpStruct->tmAscent = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmAscent);
6819         lpStruct->tmDescent = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmDescent);
6820         lpStruct->tmInternalLeading = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmInternalLeading);
6821         lpStruct->tmExternalLeading = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmExternalLeading);
6822         lpStruct->tmAveCharWidth = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmAveCharWidth);
6823         lpStruct->tmMaxCharWidth = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmMaxCharWidth);
6824         lpStruct->tmWeight = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmWeight);
6825         lpStruct->tmOverhang = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmOverhang);
6826         lpStruct->tmDigitizedAspectX = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmDigitizedAspectX);
6827         lpStruct->tmDigitizedAspectY = (*env)->GetIntField(env, lpObject, TEXTMETRICFc.tmDigitizedAspectY);
6828         lpStruct->tmFirstChar = (*env)->GetCharField(env, lpObject, TEXTMETRICFc.tmFirstChar);
6829         lpStruct->tmLastChar = (*env)->GetCharField(env, lpObject, TEXTMETRICFc.tmLastChar);
6830         lpStruct->tmDefaultChar = (*env)->GetCharField(env, lpObject, TEXTMETRICFc.tmDefaultChar);
6831         lpStruct->tmBreakChar = (*env)->GetCharField(env, lpObject, TEXTMETRICFc.tmBreakChar);
6832         lpStruct->tmItalic = (*env)->GetByteField(env, lpObject, TEXTMETRICFc.tmItalic);
6833         lpStruct->tmUnderlined = (*env)->GetByteField(env, lpObject, TEXTMETRICFc.tmUnderlined);
6834         lpStruct->tmStruckOut = (*env)->GetByteField(env, lpObject, TEXTMETRICFc.tmStruckOut);
6835         lpStruct->tmPitchAndFamily = (*env)->GetByteField(env, lpObject, TEXTMETRICFc.tmPitchAndFamily);
6836         lpStruct->tmCharSet = (*env)->GetByteField(env, lpObject, TEXTMETRICFc.tmCharSet);
6837         return lpStruct;
6838 }
6839
6840 void setTEXTMETRICFields(JNIEnv *env, jobject lpObject, TEXTMETRIC *lpStruct)
6841 {
6842         if (!TEXTMETRICFc.cached) cacheTEXTMETRICFields(env, lpObject);
6843         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmHeight, (jint)lpStruct->tmHeight);
6844         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmAscent, (jint)lpStruct->tmAscent);
6845         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmDescent, (jint)lpStruct->tmDescent);
6846         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmInternalLeading, (jint)lpStruct->tmInternalLeading);
6847         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmExternalLeading, (jint)lpStruct->tmExternalLeading);
6848         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmAveCharWidth, (jint)lpStruct->tmAveCharWidth);
6849         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmMaxCharWidth, (jint)lpStruct->tmMaxCharWidth);
6850         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmWeight, (jint)lpStruct->tmWeight);
6851         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmOverhang, (jint)lpStruct->tmOverhang);
6852         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmDigitizedAspectX, (jint)lpStruct->tmDigitizedAspectX);
6853         (*env)->SetIntField(env, lpObject, TEXTMETRICFc.tmDigitizedAspectY, (jint)lpStruct->tmDigitizedAspectY);
6854         (*env)->SetCharField(env, lpObject, TEXTMETRICFc.tmFirstChar, (jchar)lpStruct->tmFirstChar);
6855         (*env)->SetCharField(env, lpObject, TEXTMETRICFc.tmLastChar, (jchar)lpStruct->tmLastChar);
6856         (*env)->SetCharField(env, lpObject, TEXTMETRICFc.tmDefaultChar, (jchar)lpStruct->tmDefaultChar);
6857         (*env)->SetCharField(env, lpObject, TEXTMETRICFc.tmBreakChar, (jchar)lpStruct->tmBreakChar);
6858         (*env)->SetByteField(env, lpObject, TEXTMETRICFc.tmItalic, (jbyte)lpStruct->tmItalic);
6859         (*env)->SetByteField(env, lpObject, TEXTMETRICFc.tmUnderlined, (jbyte)lpStruct->tmUnderlined);
6860         (*env)->SetByteField(env, lpObject, TEXTMETRICFc.tmStruckOut, (jbyte)lpStruct->tmStruckOut);
6861         (*env)->SetByteField(env, lpObject, TEXTMETRICFc.tmPitchAndFamily, (jbyte)lpStruct->tmPitchAndFamily);
6862         (*env)->SetByteField(env, lpObject, TEXTMETRICFc.tmCharSet, (jbyte)lpStruct->tmCharSet);
6863 }
6864 #endif
6865
6866 #ifndef NO_TF_DA_COLOR
6867 typedef struct TF_DA_COLOR_FID_CACHE {
6868         int cached;
6869         jclass clazz;
6870         jfieldID type, cr;
6871 } TF_DA_COLOR_FID_CACHE;
6872
6873 TF_DA_COLOR_FID_CACHE TF_DA_COLORFc;
6874
6875 void cacheTF_DA_COLORFields(JNIEnv *env, jobject lpObject)
6876 {
6877         if (TF_DA_COLORFc.cached) return;
6878         TF_DA_COLORFc.clazz = (*env)->GetObjectClass(env, lpObject);
6879         TF_DA_COLORFc.type = (*env)->GetFieldID(env, TF_DA_COLORFc.clazz, "type", "I");
6880         TF_DA_COLORFc.cr = (*env)->GetFieldID(env, TF_DA_COLORFc.clazz, "cr", "I");
6881         TF_DA_COLORFc.cached = 1;
6882 }
6883
6884 TF_DA_COLOR *getTF_DA_COLORFields(JNIEnv *env, jobject lpObject, TF_DA_COLOR *lpStruct)
6885 {
6886         if (!TF_DA_COLORFc.cached) cacheTF_DA_COLORFields(env, lpObject);
6887         lpStruct->type = (*env)->GetIntField(env, lpObject, TF_DA_COLORFc.type);
6888         lpStruct->cr = (*env)->GetIntField(env, lpObject, TF_DA_COLORFc.cr);
6889         return lpStruct;
6890 }
6891
6892 void setTF_DA_COLORFields(JNIEnv *env, jobject lpObject, TF_DA_COLOR *lpStruct)
6893 {
6894         if (!TF_DA_COLORFc.cached) cacheTF_DA_COLORFields(env, lpObject);
6895         (*env)->SetIntField(env, lpObject, TF_DA_COLORFc.type, (jint)lpStruct->type);
6896         (*env)->SetIntField(env, lpObject, TF_DA_COLORFc.cr, (jint)lpStruct->cr);
6897 }
6898 #endif
6899
6900 #ifndef NO_TF_DISPLAYATTRIBUTE
6901 typedef struct TF_DISPLAYATTRIBUTE_FID_CACHE {
6902         int cached;
6903         jclass clazz;
6904         jfieldID crText, crBk, lsStyle, fBoldLine, crLine, bAttr;
6905 } TF_DISPLAYATTRIBUTE_FID_CACHE;
6906
6907 TF_DISPLAYATTRIBUTE_FID_CACHE TF_DISPLAYATTRIBUTEFc;
6908
6909 void cacheTF_DISPLAYATTRIBUTEFields(JNIEnv *env, jobject lpObject)
6910 {
6911         if (TF_DISPLAYATTRIBUTEFc.cached) return;
6912         TF_DISPLAYATTRIBUTEFc.clazz = (*env)->GetObjectClass(env, lpObject);
6913         TF_DISPLAYATTRIBUTEFc.crText = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "crText", "Lorg/eclipse/swt/internal/win32/TF_DA_COLOR;");
6914         TF_DISPLAYATTRIBUTEFc.crBk = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "crBk", "Lorg/eclipse/swt/internal/win32/TF_DA_COLOR;");
6915         TF_DISPLAYATTRIBUTEFc.lsStyle = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "lsStyle", "I");
6916         TF_DISPLAYATTRIBUTEFc.fBoldLine = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "fBoldLine", "Z");
6917         TF_DISPLAYATTRIBUTEFc.crLine = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "crLine", "Lorg/eclipse/swt/internal/win32/TF_DA_COLOR;");
6918         TF_DISPLAYATTRIBUTEFc.bAttr = (*env)->GetFieldID(env, TF_DISPLAYATTRIBUTEFc.clazz, "bAttr", "I");
6919         TF_DISPLAYATTRIBUTEFc.cached = 1;
6920 }
6921
6922 TF_DISPLAYATTRIBUTE *getTF_DISPLAYATTRIBUTEFields(JNIEnv *env, jobject lpObject, TF_DISPLAYATTRIBUTE *lpStruct)
6923 {
6924         if (!TF_DISPLAYATTRIBUTEFc.cached) cacheTF_DISPLAYATTRIBUTEFields(env, lpObject);
6925         {
6926         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crText);
6927         if (lpObject1 != NULL) getTF_DA_COLORFields(env, lpObject1, &lpStruct->crText);
6928         }
6929         {
6930         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crBk);
6931         if (lpObject1 != NULL) getTF_DA_COLORFields(env, lpObject1, &lpStruct->crBk);
6932         }
6933         lpStruct->lsStyle = (*env)->GetIntField(env, lpObject, TF_DISPLAYATTRIBUTEFc.lsStyle);
6934         lpStruct->fBoldLine = (*env)->GetBooleanField(env, lpObject, TF_DISPLAYATTRIBUTEFc.fBoldLine);
6935         {
6936         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crLine);
6937         if (lpObject1 != NULL) getTF_DA_COLORFields(env, lpObject1, &lpStruct->crLine);
6938         }
6939         lpStruct->bAttr = (*env)->GetIntField(env, lpObject, TF_DISPLAYATTRIBUTEFc.bAttr);
6940         return lpStruct;
6941 }
6942
6943 void setTF_DISPLAYATTRIBUTEFields(JNIEnv *env, jobject lpObject, TF_DISPLAYATTRIBUTE *lpStruct)
6944 {
6945         if (!TF_DISPLAYATTRIBUTEFc.cached) cacheTF_DISPLAYATTRIBUTEFields(env, lpObject);
6946         {
6947         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crText);
6948         if (lpObject1 != NULL) setTF_DA_COLORFields(env, lpObject1, &lpStruct->crText);
6949         }
6950         {
6951         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crBk);
6952         if (lpObject1 != NULL) setTF_DA_COLORFields(env, lpObject1, &lpStruct->crBk);
6953         }
6954         (*env)->SetIntField(env, lpObject, TF_DISPLAYATTRIBUTEFc.lsStyle, (jint)lpStruct->lsStyle);
6955         (*env)->SetBooleanField(env, lpObject, TF_DISPLAYATTRIBUTEFc.fBoldLine, (jboolean)lpStruct->fBoldLine);
6956         {
6957         jobject lpObject1 = (*env)->GetObjectField(env, lpObject, TF_DISPLAYATTRIBUTEFc.crLine);
6958         if (lpObject1 != NULL) setTF_DA_COLORFields(env, lpObject1, &lpStruct->crLine);
6959         }
6960         (*env)->SetIntField(env, lpObject, TF_DISPLAYATTRIBUTEFc.bAttr, (jint)lpStruct->bAttr);
6961 }
6962 #endif
6963
6964 #ifndef NO_TOOLINFO
6965 typedef struct TOOLINFO_FID_CACHE {
6966         int cached;
6967         jclass clazz;
6968         jfieldID cbSize, uFlags, hwnd, uId, left, top, right, bottom, hinst, lpszText, lParam, lpReserved;
6969 } TOOLINFO_FID_CACHE;
6970
6971 TOOLINFO_FID_CACHE TOOLINFOFc;
6972
6973 void cacheTOOLINFOFields(JNIEnv *env, jobject lpObject)
6974 {
6975         if (TOOLINFOFc.cached) return;
6976         TOOLINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
6977         TOOLINFOFc.cbSize = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "cbSize", "I");
6978         TOOLINFOFc.uFlags = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "uFlags", "I");
6979         TOOLINFOFc.hwnd = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "hwnd", "J");
6980         TOOLINFOFc.uId = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "uId", "J");
6981         TOOLINFOFc.left = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "left", "I");
6982         TOOLINFOFc.top = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "top", "I");
6983         TOOLINFOFc.right = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "right", "I");
6984         TOOLINFOFc.bottom = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "bottom", "I");
6985         TOOLINFOFc.hinst = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "hinst", "J");
6986         TOOLINFOFc.lpszText = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "lpszText", "J");
6987         TOOLINFOFc.lParam = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "lParam", "J");
6988         TOOLINFOFc.lpReserved = (*env)->GetFieldID(env, TOOLINFOFc.clazz, "lpReserved", "J");
6989         TOOLINFOFc.cached = 1;
6990 }
6991
6992 TOOLINFO *getTOOLINFOFields(JNIEnv *env, jobject lpObject, TOOLINFO *lpStruct)
6993 {
6994         if (!TOOLINFOFc.cached) cacheTOOLINFOFields(env, lpObject);
6995         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, TOOLINFOFc.cbSize);
6996         lpStruct->uFlags = (*env)->GetIntField(env, lpObject, TOOLINFOFc.uFlags);
6997         lpStruct->hwnd = (HWND)(*env)->GetLongField(env, lpObject, TOOLINFOFc.hwnd);
6998         lpStruct->uId = (*env)->GetLongField(env, lpObject, TOOLINFOFc.uId);
6999         lpStruct->rect.left = (*env)->GetIntField(env, lpObject, TOOLINFOFc.left);
7000         lpStruct->rect.top = (*env)->GetIntField(env, lpObject, TOOLINFOFc.top);
7001         lpStruct->rect.right = (*env)->GetIntField(env, lpObject, TOOLINFOFc.right);
7002         lpStruct->rect.bottom = (*env)->GetIntField(env, lpObject, TOOLINFOFc.bottom);
7003         lpStruct->hinst = (HINSTANCE)(*env)->GetLongField(env, lpObject, TOOLINFOFc.hinst);
7004         lpStruct->lpszText = (LPTSTR)(*env)->GetLongField(env, lpObject, TOOLINFOFc.lpszText);
7005         lpStruct->lParam = (*env)->GetLongField(env, lpObject, TOOLINFOFc.lParam);
7006         lpStruct->lpReserved = (void *)(*env)->GetLongField(env, lpObject, TOOLINFOFc.lpReserved);
7007         return lpStruct;
7008 }
7009
7010 void setTOOLINFOFields(JNIEnv *env, jobject lpObject, TOOLINFO *lpStruct)
7011 {
7012         if (!TOOLINFOFc.cached) cacheTOOLINFOFields(env, lpObject);
7013         (*env)->SetIntField(env, lpObject, TOOLINFOFc.cbSize, (jint)lpStruct->cbSize);
7014         (*env)->SetIntField(env, lpObject, TOOLINFOFc.uFlags, (jint)lpStruct->uFlags);
7015         (*env)->SetLongField(env, lpObject, TOOLINFOFc.hwnd, (jlong)lpStruct->hwnd);
7016         (*env)->SetLongField(env, lpObject, TOOLINFOFc.uId, (jlong)lpStruct->uId);
7017         (*env)->SetIntField(env, lpObject, TOOLINFOFc.left, (jint)lpStruct->rect.left);
7018         (*env)->SetIntField(env, lpObject, TOOLINFOFc.top, (jint)lpStruct->rect.top);
7019         (*env)->SetIntField(env, lpObject, TOOLINFOFc.right, (jint)lpStruct->rect.right);
7020         (*env)->SetIntField(env, lpObject, TOOLINFOFc.bottom, (jint)lpStruct->rect.bottom);
7021         (*env)->SetLongField(env, lpObject, TOOLINFOFc.hinst, (jlong)lpStruct->hinst);
7022         (*env)->SetLongField(env, lpObject, TOOLINFOFc.lpszText, (jlong)lpStruct->lpszText);
7023         (*env)->SetLongField(env, lpObject, TOOLINFOFc.lParam, (jlong)lpStruct->lParam);
7024         (*env)->SetLongField(env, lpObject, TOOLINFOFc.lpReserved, (jlong)lpStruct->lpReserved);
7025 }
7026 #endif
7027
7028 #ifndef NO_TOUCHINPUT
7029 typedef struct TOUCHINPUT_FID_CACHE {
7030         int cached;
7031         jclass clazz;
7032         jfieldID x, y, hSource, dwID, dwFlags, dwMask, dwTime, dwExtraInfo, cxContact, cyContact;
7033 } TOUCHINPUT_FID_CACHE;
7034
7035 TOUCHINPUT_FID_CACHE TOUCHINPUTFc;
7036
7037 void cacheTOUCHINPUTFields(JNIEnv *env, jobject lpObject)
7038 {
7039         if (TOUCHINPUTFc.cached) return;
7040         TOUCHINPUTFc.clazz = (*env)->GetObjectClass(env, lpObject);
7041         TOUCHINPUTFc.x = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "x", "I");
7042         TOUCHINPUTFc.y = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "y", "I");
7043         TOUCHINPUTFc.hSource = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "hSource", "J");
7044         TOUCHINPUTFc.dwID = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "dwID", "I");
7045         TOUCHINPUTFc.dwFlags = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "dwFlags", "I");
7046         TOUCHINPUTFc.dwMask = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "dwMask", "I");
7047         TOUCHINPUTFc.dwTime = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "dwTime", "I");
7048         TOUCHINPUTFc.dwExtraInfo = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "dwExtraInfo", "J");
7049         TOUCHINPUTFc.cxContact = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "cxContact", "I");
7050         TOUCHINPUTFc.cyContact = (*env)->GetFieldID(env, TOUCHINPUTFc.clazz, "cyContact", "I");
7051         TOUCHINPUTFc.cached = 1;
7052 }
7053
7054 TOUCHINPUT *getTOUCHINPUTFields(JNIEnv *env, jobject lpObject, TOUCHINPUT *lpStruct)
7055 {
7056         if (!TOUCHINPUTFc.cached) cacheTOUCHINPUTFields(env, lpObject);
7057         lpStruct->x = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.x);
7058         lpStruct->y = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.y);
7059         lpStruct->hSource = (HWND)(*env)->GetLongField(env, lpObject, TOUCHINPUTFc.hSource);
7060         lpStruct->dwID = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.dwID);
7061         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.dwFlags);
7062         lpStruct->dwMask = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.dwMask);
7063         lpStruct->dwTime = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.dwTime);
7064         lpStruct->dwExtraInfo = (*env)->GetLongField(env, lpObject, TOUCHINPUTFc.dwExtraInfo);
7065         lpStruct->cxContact = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.cxContact);
7066         lpStruct->cyContact = (*env)->GetIntField(env, lpObject, TOUCHINPUTFc.cyContact);
7067         return lpStruct;
7068 }
7069
7070 void setTOUCHINPUTFields(JNIEnv *env, jobject lpObject, TOUCHINPUT *lpStruct)
7071 {
7072         if (!TOUCHINPUTFc.cached) cacheTOUCHINPUTFields(env, lpObject);
7073         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.x, (jint)lpStruct->x);
7074         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.y, (jint)lpStruct->y);
7075         (*env)->SetLongField(env, lpObject, TOUCHINPUTFc.hSource, (jlong)lpStruct->hSource);
7076         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.dwID, (jint)lpStruct->dwID);
7077         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.dwFlags, (jint)lpStruct->dwFlags);
7078         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.dwMask, (jint)lpStruct->dwMask);
7079         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.dwTime, (jint)lpStruct->dwTime);
7080         (*env)->SetLongField(env, lpObject, TOUCHINPUTFc.dwExtraInfo, (jlong)lpStruct->dwExtraInfo);
7081         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.cxContact, (jint)lpStruct->cxContact);
7082         (*env)->SetIntField(env, lpObject, TOUCHINPUTFc.cyContact, (jint)lpStruct->cyContact);
7083 }
7084 #endif
7085
7086 #ifndef NO_TRACKMOUSEEVENT
7087 typedef struct TRACKMOUSEEVENT_FID_CACHE {
7088         int cached;
7089         jclass clazz;
7090         jfieldID cbSize, dwFlags, hwndTrack, dwHoverTime;
7091 } TRACKMOUSEEVENT_FID_CACHE;
7092
7093 TRACKMOUSEEVENT_FID_CACHE TRACKMOUSEEVENTFc;
7094
7095 void cacheTRACKMOUSEEVENTFields(JNIEnv *env, jobject lpObject)
7096 {
7097         if (TRACKMOUSEEVENTFc.cached) return;
7098         TRACKMOUSEEVENTFc.clazz = (*env)->GetObjectClass(env, lpObject);
7099         TRACKMOUSEEVENTFc.cbSize = (*env)->GetFieldID(env, TRACKMOUSEEVENTFc.clazz, "cbSize", "I");
7100         TRACKMOUSEEVENTFc.dwFlags = (*env)->GetFieldID(env, TRACKMOUSEEVENTFc.clazz, "dwFlags", "I");
7101         TRACKMOUSEEVENTFc.hwndTrack = (*env)->GetFieldID(env, TRACKMOUSEEVENTFc.clazz, "hwndTrack", "J");
7102         TRACKMOUSEEVENTFc.dwHoverTime = (*env)->GetFieldID(env, TRACKMOUSEEVENTFc.clazz, "dwHoverTime", "I");
7103         TRACKMOUSEEVENTFc.cached = 1;
7104 }
7105
7106 TRACKMOUSEEVENT *getTRACKMOUSEEVENTFields(JNIEnv *env, jobject lpObject, TRACKMOUSEEVENT *lpStruct)
7107 {
7108         if (!TRACKMOUSEEVENTFc.cached) cacheTRACKMOUSEEVENTFields(env, lpObject);
7109         lpStruct->cbSize = (*env)->GetIntField(env, lpObject, TRACKMOUSEEVENTFc.cbSize);
7110         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, TRACKMOUSEEVENTFc.dwFlags);
7111         lpStruct->hwndTrack = (HWND)(*env)->GetLongField(env, lpObject, TRACKMOUSEEVENTFc.hwndTrack);
7112         lpStruct->dwHoverTime = (*env)->GetIntField(env, lpObject, TRACKMOUSEEVENTFc.dwHoverTime);
7113         return lpStruct;
7114 }
7115
7116 void setTRACKMOUSEEVENTFields(JNIEnv *env, jobject lpObject, TRACKMOUSEEVENT *lpStruct)
7117 {
7118         if (!TRACKMOUSEEVENTFc.cached) cacheTRACKMOUSEEVENTFields(env, lpObject);
7119         (*env)->SetIntField(env, lpObject, TRACKMOUSEEVENTFc.cbSize, (jint)lpStruct->cbSize);
7120         (*env)->SetIntField(env, lpObject, TRACKMOUSEEVENTFc.dwFlags, (jint)lpStruct->dwFlags);
7121         (*env)->SetLongField(env, lpObject, TRACKMOUSEEVENTFc.hwndTrack, (jlong)lpStruct->hwndTrack);
7122         (*env)->SetIntField(env, lpObject, TRACKMOUSEEVENTFc.dwHoverTime, (jint)lpStruct->dwHoverTime);
7123 }
7124 #endif
7125
7126 #ifndef NO_TRIVERTEX
7127 typedef struct TRIVERTEX_FID_CACHE {
7128         int cached;
7129         jclass clazz;
7130         jfieldID x, y, Red, Green, Blue, Alpha;
7131 } TRIVERTEX_FID_CACHE;
7132
7133 TRIVERTEX_FID_CACHE TRIVERTEXFc;
7134
7135 void cacheTRIVERTEXFields(JNIEnv *env, jobject lpObject)
7136 {
7137         if (TRIVERTEXFc.cached) return;
7138         TRIVERTEXFc.clazz = (*env)->GetObjectClass(env, lpObject);
7139         TRIVERTEXFc.x = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "x", "I");
7140         TRIVERTEXFc.y = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "y", "I");
7141         TRIVERTEXFc.Red = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "Red", "S");
7142         TRIVERTEXFc.Green = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "Green", "S");
7143         TRIVERTEXFc.Blue = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "Blue", "S");
7144         TRIVERTEXFc.Alpha = (*env)->GetFieldID(env, TRIVERTEXFc.clazz, "Alpha", "S");
7145         TRIVERTEXFc.cached = 1;
7146 }
7147
7148 TRIVERTEX *getTRIVERTEXFields(JNIEnv *env, jobject lpObject, TRIVERTEX *lpStruct)
7149 {
7150         if (!TRIVERTEXFc.cached) cacheTRIVERTEXFields(env, lpObject);
7151         lpStruct->x = (*env)->GetIntField(env, lpObject, TRIVERTEXFc.x);
7152         lpStruct->y = (*env)->GetIntField(env, lpObject, TRIVERTEXFc.y);
7153         lpStruct->Red = (*env)->GetShortField(env, lpObject, TRIVERTEXFc.Red);
7154         lpStruct->Green = (*env)->GetShortField(env, lpObject, TRIVERTEXFc.Green);
7155         lpStruct->Blue = (*env)->GetShortField(env, lpObject, TRIVERTEXFc.Blue);
7156         lpStruct->Alpha = (*env)->GetShortField(env, lpObject, TRIVERTEXFc.Alpha);
7157         return lpStruct;
7158 }
7159
7160 void setTRIVERTEXFields(JNIEnv *env, jobject lpObject, TRIVERTEX *lpStruct)
7161 {
7162         if (!TRIVERTEXFc.cached) cacheTRIVERTEXFields(env, lpObject);
7163         (*env)->SetIntField(env, lpObject, TRIVERTEXFc.x, (jint)lpStruct->x);
7164         (*env)->SetIntField(env, lpObject, TRIVERTEXFc.y, (jint)lpStruct->y);
7165         (*env)->SetShortField(env, lpObject, TRIVERTEXFc.Red, (jshort)lpStruct->Red);
7166         (*env)->SetShortField(env, lpObject, TRIVERTEXFc.Green, (jshort)lpStruct->Green);
7167         (*env)->SetShortField(env, lpObject, TRIVERTEXFc.Blue, (jshort)lpStruct->Blue);
7168         (*env)->SetShortField(env, lpObject, TRIVERTEXFc.Alpha, (jshort)lpStruct->Alpha);
7169 }
7170 #endif
7171
7172 #ifndef NO_TVHITTESTINFO
7173 typedef struct TVHITTESTINFO_FID_CACHE {
7174         int cached;
7175         jclass clazz;
7176         jfieldID x, y, flags, hItem;
7177 } TVHITTESTINFO_FID_CACHE;
7178
7179 TVHITTESTINFO_FID_CACHE TVHITTESTINFOFc;
7180
7181 void cacheTVHITTESTINFOFields(JNIEnv *env, jobject lpObject)
7182 {
7183         if (TVHITTESTINFOFc.cached) return;
7184         TVHITTESTINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
7185         TVHITTESTINFOFc.x = (*env)->GetFieldID(env, TVHITTESTINFOFc.clazz, "x", "I");
7186         TVHITTESTINFOFc.y = (*env)->GetFieldID(env, TVHITTESTINFOFc.clazz, "y", "I");
7187         TVHITTESTINFOFc.flags = (*env)->GetFieldID(env, TVHITTESTINFOFc.clazz, "flags", "I");
7188         TVHITTESTINFOFc.hItem = (*env)->GetFieldID(env, TVHITTESTINFOFc.clazz, "hItem", "J");
7189         TVHITTESTINFOFc.cached = 1;
7190 }
7191
7192 TVHITTESTINFO *getTVHITTESTINFOFields(JNIEnv *env, jobject lpObject, TVHITTESTINFO *lpStruct)
7193 {
7194         if (!TVHITTESTINFOFc.cached) cacheTVHITTESTINFOFields(env, lpObject);
7195         lpStruct->pt.x = (*env)->GetIntField(env, lpObject, TVHITTESTINFOFc.x);
7196         lpStruct->pt.y = (*env)->GetIntField(env, lpObject, TVHITTESTINFOFc.y);
7197         lpStruct->flags = (*env)->GetIntField(env, lpObject, TVHITTESTINFOFc.flags);
7198         lpStruct->hItem = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVHITTESTINFOFc.hItem);
7199         return lpStruct;
7200 }
7201
7202 void setTVHITTESTINFOFields(JNIEnv *env, jobject lpObject, TVHITTESTINFO *lpStruct)
7203 {
7204         if (!TVHITTESTINFOFc.cached) cacheTVHITTESTINFOFields(env, lpObject);
7205         (*env)->SetIntField(env, lpObject, TVHITTESTINFOFc.x, (jint)lpStruct->pt.x);
7206         (*env)->SetIntField(env, lpObject, TVHITTESTINFOFc.y, (jint)lpStruct->pt.y);
7207         (*env)->SetIntField(env, lpObject, TVHITTESTINFOFc.flags, (jint)lpStruct->flags);
7208         (*env)->SetLongField(env, lpObject, TVHITTESTINFOFc.hItem, (jlong)lpStruct->hItem);
7209 }
7210 #endif
7211
7212 #ifndef NO_TVINSERTSTRUCT
7213 typedef struct TVINSERTSTRUCT_FID_CACHE {
7214         int cached;
7215         jclass clazz;
7216         jfieldID hParent, hInsertAfter, mask, hItem, state, stateMask, pszText, cchTextMax, iImage, iSelectedImage, cChildren, lParam, iIntegral;
7217 } TVINSERTSTRUCT_FID_CACHE;
7218
7219 TVINSERTSTRUCT_FID_CACHE TVINSERTSTRUCTFc;
7220
7221 void cacheTVINSERTSTRUCTFields(JNIEnv *env, jobject lpObject)
7222 {
7223         if (TVINSERTSTRUCTFc.cached) return;
7224         TVINSERTSTRUCTFc.clazz = (*env)->GetObjectClass(env, lpObject);
7225         TVINSERTSTRUCTFc.hParent = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "hParent", "J");
7226         TVINSERTSTRUCTFc.hInsertAfter = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "hInsertAfter", "J");
7227         TVINSERTSTRUCTFc.mask = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "mask", "I");
7228         TVINSERTSTRUCTFc.hItem = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "hItem", "J");
7229         TVINSERTSTRUCTFc.state = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "state", "I");
7230         TVINSERTSTRUCTFc.stateMask = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "stateMask", "I");
7231         TVINSERTSTRUCTFc.pszText = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "pszText", "J");
7232         TVINSERTSTRUCTFc.cchTextMax = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "cchTextMax", "I");
7233         TVINSERTSTRUCTFc.iImage = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "iImage", "I");
7234         TVINSERTSTRUCTFc.iSelectedImage = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "iSelectedImage", "I");
7235         TVINSERTSTRUCTFc.cChildren = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "cChildren", "I");
7236         TVINSERTSTRUCTFc.lParam = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "lParam", "J");
7237         TVINSERTSTRUCTFc.iIntegral = (*env)->GetFieldID(env, TVINSERTSTRUCTFc.clazz, "iIntegral", "I");
7238         TVINSERTSTRUCTFc.cached = 1;
7239 }
7240
7241 TVINSERTSTRUCT *getTVINSERTSTRUCTFields(JNIEnv *env, jobject lpObject, TVINSERTSTRUCT *lpStruct)
7242 {
7243         if (!TVINSERTSTRUCTFc.cached) cacheTVINSERTSTRUCTFields(env, lpObject);
7244         lpStruct->hParent = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVINSERTSTRUCTFc.hParent);
7245         lpStruct->hInsertAfter = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVINSERTSTRUCTFc.hInsertAfter);
7246         lpStruct->item.mask = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.mask);
7247         lpStruct->item.hItem = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVINSERTSTRUCTFc.hItem);
7248         lpStruct->item.state = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.state);
7249         lpStruct->item.stateMask = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.stateMask);
7250         lpStruct->item.pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, TVINSERTSTRUCTFc.pszText);
7251         lpStruct->item.cchTextMax = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.cchTextMax);
7252         lpStruct->item.iImage = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.iImage);
7253         lpStruct->item.iSelectedImage = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.iSelectedImage);
7254         lpStruct->item.cChildren = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.cChildren);
7255         lpStruct->item.lParam = (*env)->GetLongField(env, lpObject, TVINSERTSTRUCTFc.lParam);
7256         lpStruct->itemex.iIntegral = (*env)->GetIntField(env, lpObject, TVINSERTSTRUCTFc.iIntegral);
7257         return lpStruct;
7258 }
7259
7260 void setTVINSERTSTRUCTFields(JNIEnv *env, jobject lpObject, TVINSERTSTRUCT *lpStruct)
7261 {
7262         if (!TVINSERTSTRUCTFc.cached) cacheTVINSERTSTRUCTFields(env, lpObject);
7263         (*env)->SetLongField(env, lpObject, TVINSERTSTRUCTFc.hParent, (jlong)lpStruct->hParent);
7264         (*env)->SetLongField(env, lpObject, TVINSERTSTRUCTFc.hInsertAfter, (jlong)lpStruct->hInsertAfter);
7265         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.mask, (jint)lpStruct->item.mask);
7266         (*env)->SetLongField(env, lpObject, TVINSERTSTRUCTFc.hItem, (jlong)lpStruct->item.hItem);
7267         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.state, (jint)lpStruct->item.state);
7268         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.stateMask, (jint)lpStruct->item.stateMask);
7269         (*env)->SetLongField(env, lpObject, TVINSERTSTRUCTFc.pszText, (jlong)lpStruct->item.pszText);
7270         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.cchTextMax, (jint)lpStruct->item.cchTextMax);
7271         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.iImage, (jint)lpStruct->item.iImage);
7272         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.iSelectedImage, (jint)lpStruct->item.iSelectedImage);
7273         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.cChildren, (jint)lpStruct->item.cChildren);
7274         (*env)->SetLongField(env, lpObject, TVINSERTSTRUCTFc.lParam, (jlong)lpStruct->item.lParam);
7275         (*env)->SetIntField(env, lpObject, TVINSERTSTRUCTFc.iIntegral, (jint)lpStruct->itemex.iIntegral);
7276 }
7277 #endif
7278
7279 #ifndef NO_TVITEM
7280 typedef struct TVITEM_FID_CACHE {
7281         int cached;
7282         jclass clazz;
7283         jfieldID mask, hItem, state, stateMask, pszText, cchTextMax, iImage, iSelectedImage, cChildren, lParam;
7284 } TVITEM_FID_CACHE;
7285
7286 TVITEM_FID_CACHE TVITEMFc;
7287
7288 void cacheTVITEMFields(JNIEnv *env, jobject lpObject)
7289 {
7290         if (TVITEMFc.cached) return;
7291         TVITEMFc.clazz = (*env)->GetObjectClass(env, lpObject);
7292         TVITEMFc.mask = (*env)->GetFieldID(env, TVITEMFc.clazz, "mask", "I");
7293         TVITEMFc.hItem = (*env)->GetFieldID(env, TVITEMFc.clazz, "hItem", "J");
7294         TVITEMFc.state = (*env)->GetFieldID(env, TVITEMFc.clazz, "state", "I");
7295         TVITEMFc.stateMask = (*env)->GetFieldID(env, TVITEMFc.clazz, "stateMask", "I");
7296         TVITEMFc.pszText = (*env)->GetFieldID(env, TVITEMFc.clazz, "pszText", "J");
7297         TVITEMFc.cchTextMax = (*env)->GetFieldID(env, TVITEMFc.clazz, "cchTextMax", "I");
7298         TVITEMFc.iImage = (*env)->GetFieldID(env, TVITEMFc.clazz, "iImage", "I");
7299         TVITEMFc.iSelectedImage = (*env)->GetFieldID(env, TVITEMFc.clazz, "iSelectedImage", "I");
7300         TVITEMFc.cChildren = (*env)->GetFieldID(env, TVITEMFc.clazz, "cChildren", "I");
7301         TVITEMFc.lParam = (*env)->GetFieldID(env, TVITEMFc.clazz, "lParam", "J");
7302         TVITEMFc.cached = 1;
7303 }
7304
7305 TVITEM *getTVITEMFields(JNIEnv *env, jobject lpObject, TVITEM *lpStruct)
7306 {
7307         if (!TVITEMFc.cached) cacheTVITEMFields(env, lpObject);
7308         lpStruct->mask = (*env)->GetIntField(env, lpObject, TVITEMFc.mask);
7309         lpStruct->hItem = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVITEMFc.hItem);
7310         lpStruct->state = (*env)->GetIntField(env, lpObject, TVITEMFc.state);
7311         lpStruct->stateMask = (*env)->GetIntField(env, lpObject, TVITEMFc.stateMask);
7312         lpStruct->pszText = (LPTSTR)(*env)->GetLongField(env, lpObject, TVITEMFc.pszText);
7313         lpStruct->cchTextMax = (*env)->GetIntField(env, lpObject, TVITEMFc.cchTextMax);
7314         lpStruct->iImage = (*env)->GetIntField(env, lpObject, TVITEMFc.iImage);
7315         lpStruct->iSelectedImage = (*env)->GetIntField(env, lpObject, TVITEMFc.iSelectedImage);
7316         lpStruct->cChildren = (*env)->GetIntField(env, lpObject, TVITEMFc.cChildren);
7317         lpStruct->lParam = (*env)->GetLongField(env, lpObject, TVITEMFc.lParam);
7318         return lpStruct;
7319 }
7320
7321 void setTVITEMFields(JNIEnv *env, jobject lpObject, TVITEM *lpStruct)
7322 {
7323         if (!TVITEMFc.cached) cacheTVITEMFields(env, lpObject);
7324         (*env)->SetIntField(env, lpObject, TVITEMFc.mask, (jint)lpStruct->mask);
7325         (*env)->SetLongField(env, lpObject, TVITEMFc.hItem, (jlong)lpStruct->hItem);
7326         (*env)->SetIntField(env, lpObject, TVITEMFc.state, (jint)lpStruct->state);
7327         (*env)->SetIntField(env, lpObject, TVITEMFc.stateMask, (jint)lpStruct->stateMask);
7328         (*env)->SetLongField(env, lpObject, TVITEMFc.pszText, (jlong)lpStruct->pszText);
7329         (*env)->SetIntField(env, lpObject, TVITEMFc.cchTextMax, (jint)lpStruct->cchTextMax);
7330         (*env)->SetIntField(env, lpObject, TVITEMFc.iImage, (jint)lpStruct->iImage);
7331         (*env)->SetIntField(env, lpObject, TVITEMFc.iSelectedImage, (jint)lpStruct->iSelectedImage);
7332         (*env)->SetIntField(env, lpObject, TVITEMFc.cChildren, (jint)lpStruct->cChildren);
7333         (*env)->SetLongField(env, lpObject, TVITEMFc.lParam, (jlong)lpStruct->lParam);
7334 }
7335 #endif
7336
7337 #ifndef NO_TVITEMEX
7338 typedef struct TVITEMEX_FID_CACHE {
7339         int cached;
7340         jclass clazz;
7341         jfieldID iIntegral;
7342 } TVITEMEX_FID_CACHE;
7343
7344 TVITEMEX_FID_CACHE TVITEMEXFc;
7345
7346 void cacheTVITEMEXFields(JNIEnv *env, jobject lpObject)
7347 {
7348         if (TVITEMEXFc.cached) return;
7349         cacheTVITEMFields(env, lpObject);
7350         TVITEMEXFc.clazz = (*env)->GetObjectClass(env, lpObject);
7351         TVITEMEXFc.iIntegral = (*env)->GetFieldID(env, TVITEMEXFc.clazz, "iIntegral", "I");
7352         TVITEMEXFc.cached = 1;
7353 }
7354
7355 TVITEMEX *getTVITEMEXFields(JNIEnv *env, jobject lpObject, TVITEMEX *lpStruct)
7356 {
7357         if (!TVITEMEXFc.cached) cacheTVITEMEXFields(env, lpObject);
7358         getTVITEMFields(env, lpObject, (TVITEM *)lpStruct);
7359         lpStruct->iIntegral = (*env)->GetIntField(env, lpObject, TVITEMEXFc.iIntegral);
7360         return lpStruct;
7361 }
7362
7363 void setTVITEMEXFields(JNIEnv *env, jobject lpObject, TVITEMEX *lpStruct)
7364 {
7365         if (!TVITEMEXFc.cached) cacheTVITEMEXFields(env, lpObject);
7366         setTVITEMFields(env, lpObject, (TVITEM *)lpStruct);
7367         (*env)->SetIntField(env, lpObject, TVITEMEXFc.iIntegral, (jint)lpStruct->iIntegral);
7368 }
7369 #endif
7370
7371 #ifndef NO_TVSORTCB
7372 typedef struct TVSORTCB_FID_CACHE {
7373         int cached;
7374         jclass clazz;
7375         jfieldID hParent, lpfnCompare, lParam;
7376 } TVSORTCB_FID_CACHE;
7377
7378 TVSORTCB_FID_CACHE TVSORTCBFc;
7379
7380 void cacheTVSORTCBFields(JNIEnv *env, jobject lpObject)
7381 {
7382         if (TVSORTCBFc.cached) return;
7383         TVSORTCBFc.clazz = (*env)->GetObjectClass(env, lpObject);
7384         TVSORTCBFc.hParent = (*env)->GetFieldID(env, TVSORTCBFc.clazz, "hParent", "J");
7385         TVSORTCBFc.lpfnCompare = (*env)->GetFieldID(env, TVSORTCBFc.clazz, "lpfnCompare", "J");
7386         TVSORTCBFc.lParam = (*env)->GetFieldID(env, TVSORTCBFc.clazz, "lParam", "J");
7387         TVSORTCBFc.cached = 1;
7388 }
7389
7390 TVSORTCB *getTVSORTCBFields(JNIEnv *env, jobject lpObject, TVSORTCB *lpStruct)
7391 {
7392         if (!TVSORTCBFc.cached) cacheTVSORTCBFields(env, lpObject);
7393         lpStruct->hParent = (HTREEITEM)(*env)->GetLongField(env, lpObject, TVSORTCBFc.hParent);
7394         lpStruct->lpfnCompare = (PFNTVCOMPARE)(*env)->GetLongField(env, lpObject, TVSORTCBFc.lpfnCompare);
7395         lpStruct->lParam = (LPARAM)(*env)->GetLongField(env, lpObject, TVSORTCBFc.lParam);
7396         return lpStruct;
7397 }
7398
7399 void setTVSORTCBFields(JNIEnv *env, jobject lpObject, TVSORTCB *lpStruct)
7400 {
7401         if (!TVSORTCBFc.cached) cacheTVSORTCBFields(env, lpObject);
7402         (*env)->SetLongField(env, lpObject, TVSORTCBFc.hParent, (jlong)lpStruct->hParent);
7403         (*env)->SetLongField(env, lpObject, TVSORTCBFc.lpfnCompare, (jlong)lpStruct->lpfnCompare);
7404         (*env)->SetLongField(env, lpObject, TVSORTCBFc.lParam, (jlong)lpStruct->lParam);
7405 }
7406 #endif
7407
7408 #ifndef NO_UDACCEL
7409 typedef struct UDACCEL_FID_CACHE {
7410         int cached;
7411         jclass clazz;
7412         jfieldID nSec, nInc;
7413 } UDACCEL_FID_CACHE;
7414
7415 UDACCEL_FID_CACHE UDACCELFc;
7416
7417 void cacheUDACCELFields(JNIEnv *env, jobject lpObject)
7418 {
7419         if (UDACCELFc.cached) return;
7420         UDACCELFc.clazz = (*env)->GetObjectClass(env, lpObject);
7421         UDACCELFc.nSec = (*env)->GetFieldID(env, UDACCELFc.clazz, "nSec", "I");
7422         UDACCELFc.nInc = (*env)->GetFieldID(env, UDACCELFc.clazz, "nInc", "I");
7423         UDACCELFc.cached = 1;
7424 }
7425
7426 UDACCEL *getUDACCELFields(JNIEnv *env, jobject lpObject, UDACCEL *lpStruct)
7427 {
7428         if (!UDACCELFc.cached) cacheUDACCELFields(env, lpObject);
7429         lpStruct->nSec = (*env)->GetIntField(env, lpObject, UDACCELFc.nSec);
7430         lpStruct->nInc = (*env)->GetIntField(env, lpObject, UDACCELFc.nInc);
7431         return lpStruct;
7432 }
7433
7434 void setUDACCELFields(JNIEnv *env, jobject lpObject, UDACCEL *lpStruct)
7435 {
7436         if (!UDACCELFc.cached) cacheUDACCELFields(env, lpObject);
7437         (*env)->SetIntField(env, lpObject, UDACCELFc.nSec, (jint)lpStruct->nSec);
7438         (*env)->SetIntField(env, lpObject, UDACCELFc.nInc, (jint)lpStruct->nInc);
7439 }
7440 #endif
7441
7442 #ifndef NO_WINDOWPLACEMENT
7443 typedef struct WINDOWPLACEMENT_FID_CACHE {
7444         int cached;
7445         jclass clazz;
7446         jfieldID length, flags, showCmd, ptMinPosition_x, ptMinPosition_y, ptMaxPosition_x, ptMaxPosition_y, left, top, right, bottom;
7447 } WINDOWPLACEMENT_FID_CACHE;
7448
7449 WINDOWPLACEMENT_FID_CACHE WINDOWPLACEMENTFc;
7450
7451 void cacheWINDOWPLACEMENTFields(JNIEnv *env, jobject lpObject)
7452 {
7453         if (WINDOWPLACEMENTFc.cached) return;
7454         WINDOWPLACEMENTFc.clazz = (*env)->GetObjectClass(env, lpObject);
7455         WINDOWPLACEMENTFc.length = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "length", "I");
7456         WINDOWPLACEMENTFc.flags = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "flags", "I");
7457         WINDOWPLACEMENTFc.showCmd = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "showCmd", "I");
7458         WINDOWPLACEMENTFc.ptMinPosition_x = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "ptMinPosition_x", "I");
7459         WINDOWPLACEMENTFc.ptMinPosition_y = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "ptMinPosition_y", "I");
7460         WINDOWPLACEMENTFc.ptMaxPosition_x = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "ptMaxPosition_x", "I");
7461         WINDOWPLACEMENTFc.ptMaxPosition_y = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "ptMaxPosition_y", "I");
7462         WINDOWPLACEMENTFc.left = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "left", "I");
7463         WINDOWPLACEMENTFc.top = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "top", "I");
7464         WINDOWPLACEMENTFc.right = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "right", "I");
7465         WINDOWPLACEMENTFc.bottom = (*env)->GetFieldID(env, WINDOWPLACEMENTFc.clazz, "bottom", "I");
7466         WINDOWPLACEMENTFc.cached = 1;
7467 }
7468
7469 WINDOWPLACEMENT *getWINDOWPLACEMENTFields(JNIEnv *env, jobject lpObject, WINDOWPLACEMENT *lpStruct)
7470 {
7471         if (!WINDOWPLACEMENTFc.cached) cacheWINDOWPLACEMENTFields(env, lpObject);
7472         lpStruct->length = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.length);
7473         lpStruct->flags = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.flags);
7474         lpStruct->showCmd = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.showCmd);
7475         lpStruct->ptMinPosition.x = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMinPosition_x);
7476         lpStruct->ptMinPosition.y = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMinPosition_y);
7477         lpStruct->ptMaxPosition.x = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMaxPosition_x);
7478         lpStruct->ptMaxPosition.y = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMaxPosition_y);
7479         lpStruct->rcNormalPosition.left = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.left);
7480         lpStruct->rcNormalPosition.top = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.top);
7481         lpStruct->rcNormalPosition.right = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.right);
7482         lpStruct->rcNormalPosition.bottom = (*env)->GetIntField(env, lpObject, WINDOWPLACEMENTFc.bottom);
7483         return lpStruct;
7484 }
7485
7486 void setWINDOWPLACEMENTFields(JNIEnv *env, jobject lpObject, WINDOWPLACEMENT *lpStruct)
7487 {
7488         if (!WINDOWPLACEMENTFc.cached) cacheWINDOWPLACEMENTFields(env, lpObject);
7489         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.length, (jint)lpStruct->length);
7490         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.flags, (jint)lpStruct->flags);
7491         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.showCmd, (jint)lpStruct->showCmd);
7492         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMinPosition_x, (jint)lpStruct->ptMinPosition.x);
7493         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMinPosition_y, (jint)lpStruct->ptMinPosition.y);
7494         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMaxPosition_x, (jint)lpStruct->ptMaxPosition.x);
7495         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.ptMaxPosition_y, (jint)lpStruct->ptMaxPosition.y);
7496         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.left, (jint)lpStruct->rcNormalPosition.left);
7497         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.top, (jint)lpStruct->rcNormalPosition.top);
7498         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.right, (jint)lpStruct->rcNormalPosition.right);
7499         (*env)->SetIntField(env, lpObject, WINDOWPLACEMENTFc.bottom, (jint)lpStruct->rcNormalPosition.bottom);
7500 }
7501 #endif
7502
7503 #ifndef NO_WINDOWPOS
7504 typedef struct WINDOWPOS_FID_CACHE {
7505         int cached;
7506         jclass clazz;
7507         jfieldID hwnd, hwndInsertAfter, x, y, cx, cy, flags;
7508 } WINDOWPOS_FID_CACHE;
7509
7510 WINDOWPOS_FID_CACHE WINDOWPOSFc;
7511
7512 void cacheWINDOWPOSFields(JNIEnv *env, jobject lpObject)
7513 {
7514         if (WINDOWPOSFc.cached) return;
7515         WINDOWPOSFc.clazz = (*env)->GetObjectClass(env, lpObject);
7516         WINDOWPOSFc.hwnd = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "hwnd", "J");
7517         WINDOWPOSFc.hwndInsertAfter = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "hwndInsertAfter", "J");
7518         WINDOWPOSFc.x = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "x", "I");
7519         WINDOWPOSFc.y = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "y", "I");
7520         WINDOWPOSFc.cx = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "cx", "I");
7521         WINDOWPOSFc.cy = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "cy", "I");
7522         WINDOWPOSFc.flags = (*env)->GetFieldID(env, WINDOWPOSFc.clazz, "flags", "I");
7523         WINDOWPOSFc.cached = 1;
7524 }
7525
7526 WINDOWPOS *getWINDOWPOSFields(JNIEnv *env, jobject lpObject, WINDOWPOS *lpStruct)
7527 {
7528         if (!WINDOWPOSFc.cached) cacheWINDOWPOSFields(env, lpObject);
7529         lpStruct->hwnd = (HWND)(*env)->GetLongField(env, lpObject, WINDOWPOSFc.hwnd);
7530         lpStruct->hwndInsertAfter = (HWND)(*env)->GetLongField(env, lpObject, WINDOWPOSFc.hwndInsertAfter);
7531         lpStruct->x = (*env)->GetIntField(env, lpObject, WINDOWPOSFc.x);
7532         lpStruct->y = (*env)->GetIntField(env, lpObject, WINDOWPOSFc.y);
7533         lpStruct->cx = (*env)->GetIntField(env, lpObject, WINDOWPOSFc.cx);
7534         lpStruct->cy = (*env)->GetIntField(env, lpObject, WINDOWPOSFc.cy);
7535         lpStruct->flags = (*env)->GetIntField(env, lpObject, WINDOWPOSFc.flags);
7536         return lpStruct;
7537 }
7538
7539 void setWINDOWPOSFields(JNIEnv *env, jobject lpObject, WINDOWPOS *lpStruct)
7540 {
7541         if (!WINDOWPOSFc.cached) cacheWINDOWPOSFields(env, lpObject);
7542         (*env)->SetLongField(env, lpObject, WINDOWPOSFc.hwnd, (jlong)lpStruct->hwnd);
7543         (*env)->SetLongField(env, lpObject, WINDOWPOSFc.hwndInsertAfter, (jlong)lpStruct->hwndInsertAfter);
7544         (*env)->SetIntField(env, lpObject, WINDOWPOSFc.x, (jint)lpStruct->x);
7545         (*env)->SetIntField(env, lpObject, WINDOWPOSFc.y, (jint)lpStruct->y);
7546         (*env)->SetIntField(env, lpObject, WINDOWPOSFc.cx, (jint)lpStruct->cx);
7547         (*env)->SetIntField(env, lpObject, WINDOWPOSFc.cy, (jint)lpStruct->cy);
7548         (*env)->SetIntField(env, lpObject, WINDOWPOSFc.flags, (jint)lpStruct->flags);
7549 }
7550 #endif
7551
7552 #ifndef NO_WNDCLASS
7553 typedef struct WNDCLASS_FID_CACHE {
7554         int cached;
7555         jclass clazz;
7556         jfieldID style, lpfnWndProc, cbClsExtra, cbWndExtra, hInstance, hIcon, hCursor, hbrBackground, lpszMenuName, lpszClassName;
7557 } WNDCLASS_FID_CACHE;
7558
7559 WNDCLASS_FID_CACHE WNDCLASSFc;
7560
7561 void cacheWNDCLASSFields(JNIEnv *env, jobject lpObject)
7562 {
7563         if (WNDCLASSFc.cached) return;
7564         WNDCLASSFc.clazz = (*env)->GetObjectClass(env, lpObject);
7565         WNDCLASSFc.style = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "style", "I");
7566         WNDCLASSFc.lpfnWndProc = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "lpfnWndProc", "J");
7567         WNDCLASSFc.cbClsExtra = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "cbClsExtra", "I");
7568         WNDCLASSFc.cbWndExtra = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "cbWndExtra", "I");
7569         WNDCLASSFc.hInstance = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "hInstance", "J");
7570         WNDCLASSFc.hIcon = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "hIcon", "J");
7571         WNDCLASSFc.hCursor = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "hCursor", "J");
7572         WNDCLASSFc.hbrBackground = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "hbrBackground", "J");
7573         WNDCLASSFc.lpszMenuName = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "lpszMenuName", "J");
7574         WNDCLASSFc.lpszClassName = (*env)->GetFieldID(env, WNDCLASSFc.clazz, "lpszClassName", "J");
7575         WNDCLASSFc.cached = 1;
7576 }
7577
7578 WNDCLASS *getWNDCLASSFields(JNIEnv *env, jobject lpObject, WNDCLASS *lpStruct)
7579 {
7580         if (!WNDCLASSFc.cached) cacheWNDCLASSFields(env, lpObject);
7581         lpStruct->style = (*env)->GetIntField(env, lpObject, WNDCLASSFc.style);
7582         lpStruct->lpfnWndProc = (WNDPROC)(*env)->GetLongField(env, lpObject, WNDCLASSFc.lpfnWndProc);
7583         lpStruct->cbClsExtra = (*env)->GetIntField(env, lpObject, WNDCLASSFc.cbClsExtra);
7584         lpStruct->cbWndExtra = (*env)->GetIntField(env, lpObject, WNDCLASSFc.cbWndExtra);
7585         lpStruct->hInstance = (HINSTANCE)(*env)->GetLongField(env, lpObject, WNDCLASSFc.hInstance);
7586         lpStruct->hIcon = (HICON)(*env)->GetLongField(env, lpObject, WNDCLASSFc.hIcon);
7587         lpStruct->hCursor = (HCURSOR)(*env)->GetLongField(env, lpObject, WNDCLASSFc.hCursor);
7588         lpStruct->hbrBackground = (HBRUSH)(*env)->GetLongField(env, lpObject, WNDCLASSFc.hbrBackground);
7589         lpStruct->lpszMenuName = (LPCTSTR)(*env)->GetLongField(env, lpObject, WNDCLASSFc.lpszMenuName);
7590         lpStruct->lpszClassName = (LPCTSTR)(*env)->GetLongField(env, lpObject, WNDCLASSFc.lpszClassName);
7591         return lpStruct;
7592 }
7593
7594 void setWNDCLASSFields(JNIEnv *env, jobject lpObject, WNDCLASS *lpStruct)
7595 {
7596         if (!WNDCLASSFc.cached) cacheWNDCLASSFields(env, lpObject);
7597         (*env)->SetIntField(env, lpObject, WNDCLASSFc.style, (jint)lpStruct->style);
7598         (*env)->SetLongField(env, lpObject, WNDCLASSFc.lpfnWndProc, (jlong)lpStruct->lpfnWndProc);
7599         (*env)->SetIntField(env, lpObject, WNDCLASSFc.cbClsExtra, (jint)lpStruct->cbClsExtra);
7600         (*env)->SetIntField(env, lpObject, WNDCLASSFc.cbWndExtra, (jint)lpStruct->cbWndExtra);
7601         (*env)->SetLongField(env, lpObject, WNDCLASSFc.hInstance, (jlong)lpStruct->hInstance);
7602         (*env)->SetLongField(env, lpObject, WNDCLASSFc.hIcon, (jlong)lpStruct->hIcon);
7603         (*env)->SetLongField(env, lpObject, WNDCLASSFc.hCursor, (jlong)lpStruct->hCursor);
7604         (*env)->SetLongField(env, lpObject, WNDCLASSFc.hbrBackground, (jlong)lpStruct->hbrBackground);
7605         (*env)->SetLongField(env, lpObject, WNDCLASSFc.lpszMenuName, (jlong)lpStruct->lpszMenuName);
7606         (*env)->SetLongField(env, lpObject, WNDCLASSFc.lpszClassName, (jlong)lpStruct->lpszClassName);
7607 }
7608 #endif
7609