bundles/org.eclipse.swt.win32.win32.x86_64/library/gdip_structs.cpp

   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 "gdip_structs.h"
  20
  21 #ifndef NO_BitmapData
  22 typedef struct BitmapData_FID_CACHE {
  23         int cached;
  24         jclass clazz;
  25         jfieldID Width, Height, Stride, PixelFormat, Scan0, Reserved;
  26 } BitmapData_FID_CACHE;
  27
  28 BitmapData_FID_CACHE BitmapDataFc;
  29
  30 void cacheBitmapDataFields(JNIEnv *env, jobject lpObject)
  31 {
  32         if (BitmapDataFc.cached) return;
  33         BitmapDataFc.clazz = env->GetObjectClass(lpObject);
  34         BitmapDataFc.Width = env->GetFieldID(BitmapDataFc.clazz, "Width", "I");
  35         BitmapDataFc.Height = env->GetFieldID(BitmapDataFc.clazz, "Height", "I");
  36         BitmapDataFc.Stride = env->GetFieldID(BitmapDataFc.clazz, "Stride", "I");
  37         BitmapDataFc.PixelFormat = env->GetFieldID(BitmapDataFc.clazz, "PixelFormat", "I");
  38         BitmapDataFc.Scan0 = env->GetFieldID(BitmapDataFc.clazz, "Scan0", "J");
  39         BitmapDataFc.Reserved = env->GetFieldID(BitmapDataFc.clazz, "Reserved", "J");
  40         BitmapDataFc.cached = 1;
  41 }
  42
  43 BitmapData *getBitmapDataFields(JNIEnv *env, jobject lpObject, BitmapData *lpStruct)
  44 {
  45         if (!BitmapDataFc.cached) cacheBitmapDataFields(env, lpObject);
  46         lpStruct->Width = env->GetIntField(lpObject, BitmapDataFc.Width);
  47         lpStruct->Height = env->GetIntField(lpObject, BitmapDataFc.Height);
  48         lpStruct->Stride = env->GetIntField(lpObject, BitmapDataFc.Stride);
  49         lpStruct->PixelFormat = (PixelFormat)env->GetIntField(lpObject, BitmapDataFc.PixelFormat);
  50         lpStruct->Scan0 = (void*)env->GetLongField(lpObject, BitmapDataFc.Scan0);
  51         lpStruct->Reserved = (UINT_PTR)env->GetLongField(lpObject, BitmapDataFc.Reserved);
  52         return lpStruct;
  53 }
  54
  55 void setBitmapDataFields(JNIEnv *env, jobject lpObject, BitmapData *lpStruct)
  56 {
  57         if (!BitmapDataFc.cached) cacheBitmapDataFields(env, lpObject);
  58         env->SetIntField(lpObject, BitmapDataFc.Width, (jint)lpStruct->Width);
  59         env->SetIntField(lpObject, BitmapDataFc.Height, (jint)lpStruct->Height);
  60         env->SetIntField(lpObject, BitmapDataFc.Stride, (jint)lpStruct->Stride);
  61         env->SetIntField(lpObject, BitmapDataFc.PixelFormat, (jint)lpStruct->PixelFormat);
  62         env->SetLongField(lpObject, BitmapDataFc.Scan0, (jlong)lpStruct->Scan0);
  63         env->SetLongField(lpObject, BitmapDataFc.Reserved, (jlong)lpStruct->Reserved);
  64 }
  65 #endif
  66
  67 #ifndef NO_ColorPalette
  68 typedef struct ColorPalette_FID_CACHE {
  69         int cached;
  70         jclass clazz;
  71         jfieldID Flags, Count, Entries;
  72 } ColorPalette_FID_CACHE;
  73
  74 ColorPalette_FID_CACHE ColorPaletteFc;
  75
  76 void cacheColorPaletteFields(JNIEnv *env, jobject lpObject)
  77 {
  78         if (ColorPaletteFc.cached) return;
  79         ColorPaletteFc.clazz = env->GetObjectClass(lpObject);
  80         ColorPaletteFc.Flags = env->GetFieldID(ColorPaletteFc.clazz, "Flags", "I");
  81         ColorPaletteFc.Count = env->GetFieldID(ColorPaletteFc.clazz, "Count", "I");
  82         ColorPaletteFc.Entries = env->GetFieldID(ColorPaletteFc.clazz, "Entries", "[I");
  83         ColorPaletteFc.cached = 1;
  84 }
  85
  86 ColorPalette *getColorPaletteFields(JNIEnv *env, jobject lpObject, ColorPalette *lpStruct)
  87 {
  88         if (!ColorPaletteFc.cached) cacheColorPaletteFields(env, lpObject);
  89         lpStruct->Flags = env->GetIntField(lpObject, ColorPaletteFc.Flags);
  90         lpStruct->Count = env->GetIntField(lpObject, ColorPaletteFc.Count);
  91         {
  92         jintArray lpObject1 = (jintArray)env->GetObjectField(lpObject, ColorPaletteFc.Entries);
  93         env->GetIntArrayRegion(lpObject1, 0, sizeof(lpStruct->Entries) / sizeof(jint), (jint *)lpStruct->Entries);
  94         }
  95         return lpStruct;
  96 }
  97
  98 void setColorPaletteFields(JNIEnv *env, jobject lpObject, ColorPalette *lpStruct)
  99 {
 100         if (!ColorPaletteFc.cached) cacheColorPaletteFields(env, lpObject);
 101         env->SetIntField(lpObject, ColorPaletteFc.Flags, (jint)lpStruct->Flags);
 102         env->SetIntField(lpObject, ColorPaletteFc.Count, (jint)lpStruct->Count);
 103         {
 104         jintArray lpObject1 = (jintArray)env->GetObjectField(lpObject, ColorPaletteFc.Entries);
 105         env->SetIntArrayRegion(lpObject1, 0, sizeof(lpStruct->Entries) / sizeof(jint), (jint *)lpStruct->Entries);
 106         }
 107 }
 108 #endif
 109
 110 #ifndef NO_GdiplusStartupInput
 111 typedef struct GdiplusStartupInput_FID_CACHE {
 112         int cached;
 113         jclass clazz;
 114         jfieldID GdiplusVersion, DebugEventCallback, SuppressBackgroundThread, SuppressExternalCodecs;
 115 } GdiplusStartupInput_FID_CACHE;
 116
 117 GdiplusStartupInput_FID_CACHE GdiplusStartupInputFc;
 118
 119 void cacheGdiplusStartupInputFields(JNIEnv *env, jobject lpObject)
 120 {
 121         if (GdiplusStartupInputFc.cached) return;
 122         GdiplusStartupInputFc.clazz = env->GetObjectClass(lpObject);
 123         GdiplusStartupInputFc.GdiplusVersion = env->GetFieldID(GdiplusStartupInputFc.clazz, "GdiplusVersion", "I");
 124         GdiplusStartupInputFc.DebugEventCallback = env->GetFieldID(GdiplusStartupInputFc.clazz, "DebugEventCallback", "J");
 125         GdiplusStartupInputFc.SuppressBackgroundThread = env->GetFieldID(GdiplusStartupInputFc.clazz, "SuppressBackgroundThread", "Z");
 126         GdiplusStartupInputFc.SuppressExternalCodecs = env->GetFieldID(GdiplusStartupInputFc.clazz, "SuppressExternalCodecs", "Z");
 127         GdiplusStartupInputFc.cached = 1;
 128 }
 129
 130 GdiplusStartupInput *getGdiplusStartupInputFields(JNIEnv *env, jobject lpObject, GdiplusStartupInput *lpStruct)
 131 {
 132         if (!GdiplusStartupInputFc.cached) cacheGdiplusStartupInputFields(env, lpObject);
 133         lpStruct->GdiplusVersion = env->GetIntField(lpObject, GdiplusStartupInputFc.GdiplusVersion);
 134         lpStruct->DebugEventCallback = (DebugEventProc)env->GetLongField(lpObject, GdiplusStartupInputFc.DebugEventCallback);
 135         lpStruct->SuppressBackgroundThread = (BOOL)env->GetBooleanField(lpObject, GdiplusStartupInputFc.SuppressBackgroundThread);
 136         lpStruct->SuppressExternalCodecs = (BOOL)env->GetBooleanField(lpObject, GdiplusStartupInputFc.SuppressExternalCodecs);
 137         return lpStruct;
 138 }
 139
 140 void setGdiplusStartupInputFields(JNIEnv *env, jobject lpObject, GdiplusStartupInput *lpStruct)
 141 {
 142         if (!GdiplusStartupInputFc.cached) cacheGdiplusStartupInputFields(env, lpObject);
 143         env->SetIntField(lpObject, GdiplusStartupInputFc.GdiplusVersion, (jint)lpStruct->GdiplusVersion);
 144         env->SetLongField(lpObject, GdiplusStartupInputFc.DebugEventCallback, (jlong)lpStruct->DebugEventCallback);
 145         env->SetBooleanField(lpObject, GdiplusStartupInputFc.SuppressBackgroundThread, (jboolean)lpStruct->SuppressBackgroundThread);
 146         env->SetBooleanField(lpObject, GdiplusStartupInputFc.SuppressExternalCodecs, (jboolean)lpStruct->SuppressExternalCodecs);
 147 }
 148 #endif
 149
 150 #ifndef NO_PointF
 151 typedef struct PointF_FID_CACHE {
 152         int cached;
 153         jclass clazz;
 154         jfieldID X, Y;
 155 } PointF_FID_CACHE;
 156
 157 PointF_FID_CACHE PointFFc;
 158
 159 void cachePointFFields(JNIEnv *env, jobject lpObject)
 160 {
 161         if (PointFFc.cached) return;
 162         PointFFc.clazz = env->GetObjectClass(lpObject);
 163         PointFFc.X = env->GetFieldID(PointFFc.clazz, "X", "F");
 164         PointFFc.Y = env->GetFieldID(PointFFc.clazz, "Y", "F");
 165         PointFFc.cached = 1;
 166 }
 167
 168 PointF *getPointFFields(JNIEnv *env, jobject lpObject, PointF *lpStruct)
 169 {
 170         if (!PointFFc.cached) cachePointFFields(env, lpObject);
 171         lpStruct->X = (REAL)env->GetFloatField(lpObject, PointFFc.X);
 172         lpStruct->Y = (REAL)env->GetFloatField(lpObject, PointFFc.Y);
 173         return lpStruct;
 174 }
 175
 176 void setPointFFields(JNIEnv *env, jobject lpObject, PointF *lpStruct)
 177 {
 178         if (!PointFFc.cached) cachePointFFields(env, lpObject);
 179         env->SetFloatField(lpObject, PointFFc.X, (jfloat)lpStruct->X);
 180         env->SetFloatField(lpObject, PointFFc.Y, (jfloat)lpStruct->Y);
 181 }
 182 #endif
 183
 184 #ifndef NO_Rect
 185 typedef struct Rect_FID_CACHE {
 186         int cached;
 187         jclass clazz;
 188         jfieldID X, Y, Width, Height;
 189 } Rect_FID_CACHE;
 190
 191 Rect_FID_CACHE RectFc;
 192
 193 void cacheRectFields(JNIEnv *env, jobject lpObject)
 194 {
 195         if (RectFc.cached) return;
 196         RectFc.clazz = env->GetObjectClass(lpObject);
 197         RectFc.X = env->GetFieldID(RectFc.clazz, "X", "I");
 198         RectFc.Y = env->GetFieldID(RectFc.clazz, "Y", "I");
 199         RectFc.Width = env->GetFieldID(RectFc.clazz, "Width", "I");
 200         RectFc.Height = env->GetFieldID(RectFc.clazz, "Height", "I");
 201         RectFc.cached = 1;
 202 }
 203
 204 Rect *getRectFields(JNIEnv *env, jobject lpObject, Rect *lpStruct)
 205 {
 206         if (!RectFc.cached) cacheRectFields(env, lpObject);
 207         lpStruct->X = env->GetIntField(lpObject, RectFc.X);
 208         lpStruct->Y = env->GetIntField(lpObject, RectFc.Y);
 209         lpStruct->Width = env->GetIntField(lpObject, RectFc.Width);
 210         lpStruct->Height = env->GetIntField(lpObject, RectFc.Height);
 211         return lpStruct;
 212 }
 213
 214 void setRectFields(JNIEnv *env, jobject lpObject, Rect *lpStruct)
 215 {
 216         if (!RectFc.cached) cacheRectFields(env, lpObject);
 217         env->SetIntField(lpObject, RectFc.X, (jint)lpStruct->X);
 218         env->SetIntField(lpObject, RectFc.Y, (jint)lpStruct->Y);
 219         env->SetIntField(lpObject, RectFc.Width, (jint)lpStruct->Width);
 220         env->SetIntField(lpObject, RectFc.Height, (jint)lpStruct->Height);
 221 }
 222 #endif
 223
 224 #ifndef NO_RectF
 225 typedef struct RectF_FID_CACHE {
 226         int cached;
 227         jclass clazz;
 228         jfieldID X, Y, Width, Height;
 229 } RectF_FID_CACHE;
 230
 231 RectF_FID_CACHE RectFFc;
 232
 233 void cacheRectFFields(JNIEnv *env, jobject lpObject)
 234 {
 235         if (RectFFc.cached) return;
 236         RectFFc.clazz = env->GetObjectClass(lpObject);
 237         RectFFc.X = env->GetFieldID(RectFFc.clazz, "X", "F");
 238         RectFFc.Y = env->GetFieldID(RectFFc.clazz, "Y", "F");
 239         RectFFc.Width = env->GetFieldID(RectFFc.clazz, "Width", "F");
 240         RectFFc.Height = env->GetFieldID(RectFFc.clazz, "Height", "F");
 241         RectFFc.cached = 1;
 242 }
 243
 244 RectF *getRectFFields(JNIEnv *env, jobject lpObject, RectF *lpStruct)
 245 {
 246         if (!RectFFc.cached) cacheRectFFields(env, lpObject);
 247         lpStruct->X = env->GetFloatField(lpObject, RectFFc.X);
 248         lpStruct->Y = env->GetFloatField(lpObject, RectFFc.Y);
 249         lpStruct->Width = env->GetFloatField(lpObject, RectFFc.Width);
 250         lpStruct->Height = env->GetFloatField(lpObject, RectFFc.Height);
 251         return lpStruct;
 252 }
 253
 254 void setRectFFields(JNIEnv *env, jobject lpObject, RectF *lpStruct)
 255 {
 256         if (!RectFFc.cached) cacheRectFFields(env, lpObject);
 257         env->SetFloatField(lpObject, RectFFc.X, (jfloat)lpStruct->X);
 258         env->SetFloatField(lpObject, RectFFc.Y, (jfloat)lpStruct->Y);
 259         env->SetFloatField(lpObject, RectFFc.Width, (jfloat)lpStruct->Width);
 260         env->SetFloatField(lpObject, RectFFc.Height, (jfloat)lpStruct->Height);
 261 }
 262 #endif
 263