blob: 9ee917c8ed26cd9aa15c5d412d00be0aac28a136 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation and others. All rights reserved.
* The contents of this file are made available under the terms
* of the GNU Lesser General Public License (LGPL) Version 2.1 that
* accompanies this distribution (lgpl-v21.txt). The LGPL is also
* available at http://www.gnu.org/licenses/lgpl.html. If the version
* of the LGPL at http://www.gnu.org is different to the version of
* the LGPL accompanying this distribution and there is any conflict
* between the two license versions, the terms of the LGPL accompanying
* this distribution shall govern.
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
#include "swt.h"
#include "os_structs.h"
#ifndef NO_GInterfaceInfo
typedef struct GInterfaceInfo_FID_CACHE {
int cached;
jclass clazz;
jfieldID interface_init, interface_finalize, interface_data;
} GInterfaceInfo_FID_CACHE;
GInterfaceInfo_FID_CACHE GInterfaceInfoFc;
void cacheGInterfaceInfoFields(JNIEnv *env, jobject lpObject)
{
if (GInterfaceInfoFc.cached) return;
GInterfaceInfoFc.clazz = (*env)->GetObjectClass(env, lpObject);
GInterfaceInfoFc.interface_init = (*env)->GetFieldID(env, GInterfaceInfoFc.clazz, "interface_init", I_J);
GInterfaceInfoFc.interface_finalize = (*env)->GetFieldID(env, GInterfaceInfoFc.clazz, "interface_finalize", I_J);
GInterfaceInfoFc.interface_data = (*env)->GetFieldID(env, GInterfaceInfoFc.clazz, "interface_data", I_J);
GInterfaceInfoFc.cached = 1;
}
GInterfaceInfo *getGInterfaceInfoFields(JNIEnv *env, jobject lpObject, GInterfaceInfo *lpStruct)
{
if (!GInterfaceInfoFc.cached) cacheGInterfaceInfoFields(env, lpObject);
lpStruct->interface_init = (GInterfaceInitFunc)(*env)->GetIntLongField(env, lpObject, GInterfaceInfoFc.interface_init);
lpStruct->interface_finalize = (GInterfaceFinalizeFunc)(*env)->GetIntLongField(env, lpObject, GInterfaceInfoFc.interface_finalize);
lpStruct->interface_data = (gpointer)(*env)->GetIntLongField(env, lpObject, GInterfaceInfoFc.interface_data);
return lpStruct;
}
void setGInterfaceInfoFields(JNIEnv *env, jobject lpObject, GInterfaceInfo *lpStruct)
{
if (!GInterfaceInfoFc.cached) cacheGInterfaceInfoFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GInterfaceInfoFc.interface_init, (jintLong)lpStruct->interface_init);
(*env)->SetIntLongField(env, lpObject, GInterfaceInfoFc.interface_finalize, (jintLong)lpStruct->interface_finalize);
(*env)->SetIntLongField(env, lpObject, GInterfaceInfoFc.interface_data, (jintLong)lpStruct->interface_data);
}
#endif
#ifndef NO_GObjectClass
typedef struct GObjectClass_FID_CACHE {
int cached;
jclass clazz;
jfieldID constructor, set_property, get_property, dispose, finalize, dispatch_properties_changed, notify;
} GObjectClass_FID_CACHE;
GObjectClass_FID_CACHE GObjectClassFc;
void cacheGObjectClassFields(JNIEnv *env, jobject lpObject)
{
if (GObjectClassFc.cached) return;
GObjectClassFc.clazz = (*env)->GetObjectClass(env, lpObject);
GObjectClassFc.constructor = (*env)->GetFieldID(env, GObjectClassFc.clazz, "constructor", I_J);
GObjectClassFc.set_property = (*env)->GetFieldID(env, GObjectClassFc.clazz, "set_property", I_J);
GObjectClassFc.get_property = (*env)->GetFieldID(env, GObjectClassFc.clazz, "get_property", I_J);
GObjectClassFc.dispose = (*env)->GetFieldID(env, GObjectClassFc.clazz, "dispose", I_J);
GObjectClassFc.finalize = (*env)->GetFieldID(env, GObjectClassFc.clazz, "finalize", I_J);
GObjectClassFc.dispatch_properties_changed = (*env)->GetFieldID(env, GObjectClassFc.clazz, "dispatch_properties_changed", I_J);
GObjectClassFc.notify = (*env)->GetFieldID(env, GObjectClassFc.clazz, "notify", I_J);
GObjectClassFc.cached = 1;
}
GObjectClass *getGObjectClassFields(JNIEnv *env, jobject lpObject, GObjectClass *lpStruct)
{
if (!GObjectClassFc.cached) cacheGObjectClassFields(env, lpObject);
lpStruct->constructor = (GObject *(*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.constructor);
lpStruct->set_property = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.set_property);
lpStruct->get_property = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.get_property);
lpStruct->dispose = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.dispose);
lpStruct->finalize = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.finalize);
lpStruct->dispatch_properties_changed = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.dispatch_properties_changed);
lpStruct->notify = (void (*)())(*env)->GetIntLongField(env, lpObject, GObjectClassFc.notify);
return lpStruct;
}
void setGObjectClassFields(JNIEnv *env, jobject lpObject, GObjectClass *lpStruct)
{
if (!GObjectClassFc.cached) cacheGObjectClassFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.constructor, (jintLong)lpStruct->constructor);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.set_property, (jintLong)lpStruct->set_property);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.get_property, (jintLong)lpStruct->get_property);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.dispose, (jintLong)lpStruct->dispose);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.finalize, (jintLong)lpStruct->finalize);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.dispatch_properties_changed, (jintLong)lpStruct->dispatch_properties_changed);
(*env)->SetIntLongField(env, lpObject, GObjectClassFc.notify, (jintLong)lpStruct->notify);
}
#endif
#ifndef NO_GTypeInfo
typedef struct GTypeInfo_FID_CACHE {
int cached;
jclass clazz;
jfieldID class_size, base_init, base_finalize, class_init, class_finalize, class_data, instance_size, n_preallocs, instance_init, value_table;
} GTypeInfo_FID_CACHE;
GTypeInfo_FID_CACHE GTypeInfoFc;
void cacheGTypeInfoFields(JNIEnv *env, jobject lpObject)
{
if (GTypeInfoFc.cached) return;
GTypeInfoFc.clazz = (*env)->GetObjectClass(env, lpObject);
GTypeInfoFc.class_size = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "class_size", "S");
GTypeInfoFc.base_init = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "base_init", I_J);
GTypeInfoFc.base_finalize = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "base_finalize", I_J);
GTypeInfoFc.class_init = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "class_init", I_J);
GTypeInfoFc.class_finalize = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "class_finalize", I_J);
GTypeInfoFc.class_data = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "class_data", I_J);
GTypeInfoFc.instance_size = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "instance_size", "S");
GTypeInfoFc.n_preallocs = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "n_preallocs", "S");
GTypeInfoFc.instance_init = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "instance_init", I_J);
GTypeInfoFc.value_table = (*env)->GetFieldID(env, GTypeInfoFc.clazz, "value_table", I_J);
GTypeInfoFc.cached = 1;
}
GTypeInfo *getGTypeInfoFields(JNIEnv *env, jobject lpObject, GTypeInfo *lpStruct)
{
if (!GTypeInfoFc.cached) cacheGTypeInfoFields(env, lpObject);
lpStruct->class_size = (guint16)(*env)->GetShortField(env, lpObject, GTypeInfoFc.class_size);
lpStruct->base_init = (GBaseInitFunc)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.base_init);
lpStruct->base_finalize = (GBaseFinalizeFunc)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.base_finalize);
lpStruct->class_init = (GClassInitFunc)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.class_init);
lpStruct->class_finalize = (GClassFinalizeFunc)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.class_finalize);
lpStruct->class_data = (gconstpointer)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.class_data);
lpStruct->instance_size = (guint16)(*env)->GetShortField(env, lpObject, GTypeInfoFc.instance_size);
lpStruct->n_preallocs = (guint16)(*env)->GetShortField(env, lpObject, GTypeInfoFc.n_preallocs);
lpStruct->instance_init = (GInstanceInitFunc)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.instance_init);
lpStruct->value_table = (GTypeValueTable *)(*env)->GetIntLongField(env, lpObject, GTypeInfoFc.value_table);
return lpStruct;
}
void setGTypeInfoFields(JNIEnv *env, jobject lpObject, GTypeInfo *lpStruct)
{
if (!GTypeInfoFc.cached) cacheGTypeInfoFields(env, lpObject);
(*env)->SetShortField(env, lpObject, GTypeInfoFc.class_size, (jshort)lpStruct->class_size);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.base_init, (jintLong)lpStruct->base_init);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.base_finalize, (jintLong)lpStruct->base_finalize);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.class_init, (jintLong)lpStruct->class_init);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.class_finalize, (jintLong)lpStruct->class_finalize);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.class_data, (jintLong)lpStruct->class_data);
(*env)->SetShortField(env, lpObject, GTypeInfoFc.instance_size, (jshort)lpStruct->instance_size);
(*env)->SetShortField(env, lpObject, GTypeInfoFc.n_preallocs, (jshort)lpStruct->n_preallocs);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.instance_init, (jintLong)lpStruct->instance_init);
(*env)->SetIntLongField(env, lpObject, GTypeInfoFc.value_table, (jintLong)lpStruct->value_table);
}
#endif
#ifndef NO_GTypeQuery
typedef struct GTypeQuery_FID_CACHE {
int cached;
jclass clazz;
jfieldID type, type_name, class_size, instance_size;
} GTypeQuery_FID_CACHE;
GTypeQuery_FID_CACHE GTypeQueryFc;
void cacheGTypeQueryFields(JNIEnv *env, jobject lpObject)
{
if (GTypeQueryFc.cached) return;
GTypeQueryFc.clazz = (*env)->GetObjectClass(env, lpObject);
GTypeQueryFc.type = (*env)->GetFieldID(env, GTypeQueryFc.clazz, "type", "I");
GTypeQueryFc.type_name = (*env)->GetFieldID(env, GTypeQueryFc.clazz, "type_name", I_J);
GTypeQueryFc.class_size = (*env)->GetFieldID(env, GTypeQueryFc.clazz, "class_size", "I");
GTypeQueryFc.instance_size = (*env)->GetFieldID(env, GTypeQueryFc.clazz, "instance_size", "I");
GTypeQueryFc.cached = 1;
}
GTypeQuery *getGTypeQueryFields(JNIEnv *env, jobject lpObject, GTypeQuery *lpStruct)
{
if (!GTypeQueryFc.cached) cacheGTypeQueryFields(env, lpObject);
lpStruct->type = (GType)(*env)->GetIntField(env, lpObject, GTypeQueryFc.type);
lpStruct->type_name = (const gchar *)(*env)->GetIntLongField(env, lpObject, GTypeQueryFc.type_name);
lpStruct->class_size = (guint)(*env)->GetIntField(env, lpObject, GTypeQueryFc.class_size);
lpStruct->instance_size = (guint)(*env)->GetIntField(env, lpObject, GTypeQueryFc.instance_size);
return lpStruct;
}
void setGTypeQueryFields(JNIEnv *env, jobject lpObject, GTypeQuery *lpStruct)
{
if (!GTypeQueryFc.cached) cacheGTypeQueryFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GTypeQueryFc.type, (jint)lpStruct->type);
(*env)->SetIntLongField(env, lpObject, GTypeQueryFc.type_name, (jintLong)lpStruct->type_name);
(*env)->SetIntField(env, lpObject, GTypeQueryFc.class_size, (jint)lpStruct->class_size);
(*env)->SetIntField(env, lpObject, GTypeQueryFc.instance_size, (jint)lpStruct->instance_size);
}
#endif
#ifndef NO_GdkColor
typedef struct GdkColor_FID_CACHE {
int cached;
jclass clazz;
jfieldID pixel, red, green, blue;
} GdkColor_FID_CACHE;
GdkColor_FID_CACHE GdkColorFc;
void cacheGdkColorFields(JNIEnv *env, jobject lpObject)
{
if (GdkColorFc.cached) return;
GdkColorFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkColorFc.pixel = (*env)->GetFieldID(env, GdkColorFc.clazz, "pixel", "I");
GdkColorFc.red = (*env)->GetFieldID(env, GdkColorFc.clazz, "red", "S");
GdkColorFc.green = (*env)->GetFieldID(env, GdkColorFc.clazz, "green", "S");
GdkColorFc.blue = (*env)->GetFieldID(env, GdkColorFc.clazz, "blue", "S");
GdkColorFc.cached = 1;
}
GdkColor *getGdkColorFields(JNIEnv *env, jobject lpObject, GdkColor *lpStruct)
{
if (!GdkColorFc.cached) cacheGdkColorFields(env, lpObject);
lpStruct->pixel = (guint32)(*env)->GetIntField(env, lpObject, GdkColorFc.pixel);
lpStruct->red = (guint16)(*env)->GetShortField(env, lpObject, GdkColorFc.red);
lpStruct->green = (guint16)(*env)->GetShortField(env, lpObject, GdkColorFc.green);
lpStruct->blue = (guint16)(*env)->GetShortField(env, lpObject, GdkColorFc.blue);
return lpStruct;
}
void setGdkColorFields(JNIEnv *env, jobject lpObject, GdkColor *lpStruct)
{
if (!GdkColorFc.cached) cacheGdkColorFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkColorFc.pixel, (jint)lpStruct->pixel);
(*env)->SetShortField(env, lpObject, GdkColorFc.red, (jshort)lpStruct->red);
(*env)->SetShortField(env, lpObject, GdkColorFc.green, (jshort)lpStruct->green);
(*env)->SetShortField(env, lpObject, GdkColorFc.blue, (jshort)lpStruct->blue);
}
#endif
#ifndef NO_GdkDragContext
typedef struct GdkDragContext_FID_CACHE {
int cached;
jclass clazz;
jfieldID protocol, is_source, source_window, dest_window, targets, actions, suggested_action, action, start_time;
} GdkDragContext_FID_CACHE;
GdkDragContext_FID_CACHE GdkDragContextFc;
void cacheGdkDragContextFields(JNIEnv *env, jobject lpObject)
{
if (GdkDragContextFc.cached) return;
GdkDragContextFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkDragContextFc.protocol = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "protocol", "I");
GdkDragContextFc.is_source = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "is_source", "Z");
GdkDragContextFc.source_window = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "source_window", I_J);
GdkDragContextFc.dest_window = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "dest_window", I_J);
GdkDragContextFc.targets = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "targets", I_J);
GdkDragContextFc.actions = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "actions", "I");
GdkDragContextFc.suggested_action = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "suggested_action", "I");
GdkDragContextFc.action = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "action", "I");
GdkDragContextFc.start_time = (*env)->GetFieldID(env, GdkDragContextFc.clazz, "start_time", "I");
GdkDragContextFc.cached = 1;
}
GdkDragContext *getGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct)
{
if (!GdkDragContextFc.cached) cacheGdkDragContextFields(env, lpObject);
lpStruct->protocol = (GdkDragProtocol)(*env)->GetIntField(env, lpObject, GdkDragContextFc.protocol);
lpStruct->is_source = (gboolean)(*env)->GetBooleanField(env, lpObject, GdkDragContextFc.is_source);
lpStruct->source_window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkDragContextFc.source_window);
lpStruct->dest_window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkDragContextFc.dest_window);
lpStruct->targets = (GList *)(*env)->GetIntLongField(env, lpObject, GdkDragContextFc.targets);
lpStruct->actions = (GdkDragAction)(*env)->GetIntField(env, lpObject, GdkDragContextFc.actions);
lpStruct->suggested_action = (GdkDragAction)(*env)->GetIntField(env, lpObject, GdkDragContextFc.suggested_action);
lpStruct->action = (GdkDragAction)(*env)->GetIntField(env, lpObject, GdkDragContextFc.action);
lpStruct->start_time = (guint32)(*env)->GetIntField(env, lpObject, GdkDragContextFc.start_time);
return lpStruct;
}
void setGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct)
{
if (!GdkDragContextFc.cached) cacheGdkDragContextFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkDragContextFc.protocol, (jint)lpStruct->protocol);
(*env)->SetBooleanField(env, lpObject, GdkDragContextFc.is_source, (jboolean)lpStruct->is_source);
(*env)->SetIntLongField(env, lpObject, GdkDragContextFc.source_window, (jintLong)lpStruct->source_window);
(*env)->SetIntLongField(env, lpObject, GdkDragContextFc.dest_window, (jintLong)lpStruct->dest_window);
(*env)->SetIntLongField(env, lpObject, GdkDragContextFc.targets, (jintLong)lpStruct->targets);
(*env)->SetIntField(env, lpObject, GdkDragContextFc.actions, (jint)lpStruct->actions);
(*env)->SetIntField(env, lpObject, GdkDragContextFc.suggested_action, (jint)lpStruct->suggested_action);
(*env)->SetIntField(env, lpObject, GdkDragContextFc.action, (jint)lpStruct->action);
(*env)->SetIntField(env, lpObject, GdkDragContextFc.start_time, (jint)lpStruct->start_time);
}
#endif
#ifndef NO_GdkEvent
typedef struct GdkEvent_FID_CACHE {
int cached;
jclass clazz;
jfieldID type;
} GdkEvent_FID_CACHE;
GdkEvent_FID_CACHE GdkEventFc;
void cacheGdkEventFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventFc.cached) return;
GdkEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventFc.type = (*env)->GetFieldID(env, GdkEventFc.clazz, "type", "I");
GdkEventFc.cached = 1;
}
GdkEvent *getGdkEventFields(JNIEnv *env, jobject lpObject, GdkEvent *lpStruct)
{
if (!GdkEventFc.cached) cacheGdkEventFields(env, lpObject);
lpStruct->type = (GdkEventType)(*env)->GetIntField(env, lpObject, GdkEventFc.type);
return lpStruct;
}
void setGdkEventFields(JNIEnv *env, jobject lpObject, GdkEvent *lpStruct)
{
if (!GdkEventFc.cached) cacheGdkEventFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkEventFc.type, (jint)lpStruct->type);
}
#endif
#ifndef NO_GdkEventAny
typedef struct GdkEventAny_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event;
} GdkEventAny_FID_CACHE;
GdkEventAny_FID_CACHE GdkEventAnyFc;
void cacheGdkEventAnyFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventAnyFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventAnyFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventAnyFc.window = (*env)->GetFieldID(env, GdkEventAnyFc.clazz, "window", I_J);
GdkEventAnyFc.send_event = (*env)->GetFieldID(env, GdkEventAnyFc.clazz, "send_event", "B");
GdkEventAnyFc.cached = 1;
}
GdkEventAny *getGdkEventAnyFields(JNIEnv *env, jobject lpObject, GdkEventAny *lpStruct)
{
if (!GdkEventAnyFc.cached) cacheGdkEventAnyFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventAnyFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventAnyFc.send_event);
return lpStruct;
}
void setGdkEventAnyFields(JNIEnv *env, jobject lpObject, GdkEventAny *lpStruct)
{
if (!GdkEventAnyFc.cached) cacheGdkEventAnyFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventAnyFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventAnyFc.send_event, (jbyte)lpStruct->send_event);
}
#endif
#ifndef NO_GdkEventButton
typedef struct GdkEventButton_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, time, x, y, axes, state, button, device, x_root, y_root;
} GdkEventButton_FID_CACHE;
GdkEventButton_FID_CACHE GdkEventButtonFc;
void cacheGdkEventButtonFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventButtonFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventButtonFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventButtonFc.window = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "window", I_J);
GdkEventButtonFc.send_event = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "send_event", "B");
GdkEventButtonFc.time = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "time", "I");
GdkEventButtonFc.x = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "x", "D");
GdkEventButtonFc.y = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "y", "D");
GdkEventButtonFc.axes = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "axes", I_J);
GdkEventButtonFc.state = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "state", "I");
GdkEventButtonFc.button = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "button", "I");
GdkEventButtonFc.device = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "device", I_J);
GdkEventButtonFc.x_root = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "x_root", "D");
GdkEventButtonFc.y_root = (*env)->GetFieldID(env, GdkEventButtonFc.clazz, "y_root", "D");
GdkEventButtonFc.cached = 1;
}
GdkEventButton *getGdkEventButtonFields(JNIEnv *env, jobject lpObject, GdkEventButton *lpStruct)
{
if (!GdkEventButtonFc.cached) cacheGdkEventButtonFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventButtonFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventButtonFc.send_event);
lpStruct->time = (guint32)(*env)->GetIntField(env, lpObject, GdkEventButtonFc.time);
lpStruct->x = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventButtonFc.x);
lpStruct->y = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventButtonFc.y);
lpStruct->axes = (gdouble *)(*env)->GetIntLongField(env, lpObject, GdkEventButtonFc.axes);
lpStruct->state = (guint)(*env)->GetIntField(env, lpObject, GdkEventButtonFc.state);
lpStruct->button = (guint)(*env)->GetIntField(env, lpObject, GdkEventButtonFc.button);
lpStruct->device = (GdkDevice *)(*env)->GetIntLongField(env, lpObject, GdkEventButtonFc.device);
lpStruct->x_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventButtonFc.x_root);
lpStruct->y_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventButtonFc.y_root);
return lpStruct;
}
void setGdkEventButtonFields(JNIEnv *env, jobject lpObject, GdkEventButton *lpStruct)
{
if (!GdkEventButtonFc.cached) cacheGdkEventButtonFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventButtonFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventButtonFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventButtonFc.time, (jint)lpStruct->time);
(*env)->SetDoubleField(env, lpObject, GdkEventButtonFc.x, (jdouble)lpStruct->x);
(*env)->SetDoubleField(env, lpObject, GdkEventButtonFc.y, (jdouble)lpStruct->y);
(*env)->SetIntLongField(env, lpObject, GdkEventButtonFc.axes, (jintLong)lpStruct->axes);
(*env)->SetIntField(env, lpObject, GdkEventButtonFc.state, (jint)lpStruct->state);
(*env)->SetIntField(env, lpObject, GdkEventButtonFc.button, (jint)lpStruct->button);
(*env)->SetIntLongField(env, lpObject, GdkEventButtonFc.device, (jintLong)lpStruct->device);
(*env)->SetDoubleField(env, lpObject, GdkEventButtonFc.x_root, (jdouble)lpStruct->x_root);
(*env)->SetDoubleField(env, lpObject, GdkEventButtonFc.y_root, (jdouble)lpStruct->y_root);
}
#endif
#ifndef NO_GdkEventCrossing
typedef struct GdkEventCrossing_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, subwindow, time, x, y, x_root, y_root, mode, detail, focus, state;
} GdkEventCrossing_FID_CACHE;
GdkEventCrossing_FID_CACHE GdkEventCrossingFc;
void cacheGdkEventCrossingFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventCrossingFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventCrossingFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventCrossingFc.window = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "window", I_J);
GdkEventCrossingFc.send_event = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "send_event", "B");
GdkEventCrossingFc.subwindow = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "subwindow", I_J);
GdkEventCrossingFc.time = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "time", "I");
GdkEventCrossingFc.x = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "x", "D");
GdkEventCrossingFc.y = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "y", "D");
GdkEventCrossingFc.x_root = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "x_root", "D");
GdkEventCrossingFc.y_root = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "y_root", "D");
GdkEventCrossingFc.mode = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "mode", "I");
GdkEventCrossingFc.detail = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "detail", "I");
GdkEventCrossingFc.focus = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "focus", "Z");
GdkEventCrossingFc.state = (*env)->GetFieldID(env, GdkEventCrossingFc.clazz, "state", "I");
GdkEventCrossingFc.cached = 1;
}
GdkEventCrossing *getGdkEventCrossingFields(JNIEnv *env, jobject lpObject, GdkEventCrossing *lpStruct)
{
if (!GdkEventCrossingFc.cached) cacheGdkEventCrossingFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventCrossingFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventCrossingFc.send_event);
lpStruct->subwindow = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventCrossingFc.subwindow);
lpStruct->time = (*env)->GetIntField(env, lpObject, GdkEventCrossingFc.time);
lpStruct->x = (*env)->GetDoubleField(env, lpObject, GdkEventCrossingFc.x);
lpStruct->y = (*env)->GetDoubleField(env, lpObject, GdkEventCrossingFc.y);
lpStruct->x_root = (*env)->GetDoubleField(env, lpObject, GdkEventCrossingFc.x_root);
lpStruct->y_root = (*env)->GetDoubleField(env, lpObject, GdkEventCrossingFc.y_root);
lpStruct->mode = (GdkCrossingMode)(*env)->GetIntField(env, lpObject, GdkEventCrossingFc.mode);
lpStruct->detail = (GdkNotifyType)(*env)->GetIntField(env, lpObject, GdkEventCrossingFc.detail);
lpStruct->focus = (gboolean)(*env)->GetBooleanField(env, lpObject, GdkEventCrossingFc.focus);
lpStruct->state = (*env)->GetIntField(env, lpObject, GdkEventCrossingFc.state);
return lpStruct;
}
void setGdkEventCrossingFields(JNIEnv *env, jobject lpObject, GdkEventCrossing *lpStruct)
{
if (!GdkEventCrossingFc.cached) cacheGdkEventCrossingFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventCrossingFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventCrossingFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntLongField(env, lpObject, GdkEventCrossingFc.subwindow, (jintLong)lpStruct->subwindow);
(*env)->SetIntField(env, lpObject, GdkEventCrossingFc.time, (jint)lpStruct->time);
(*env)->SetDoubleField(env, lpObject, GdkEventCrossingFc.x, (jdouble)lpStruct->x);
(*env)->SetDoubleField(env, lpObject, GdkEventCrossingFc.y, (jdouble)lpStruct->y);
(*env)->SetDoubleField(env, lpObject, GdkEventCrossingFc.x_root, (jdouble)lpStruct->x_root);
(*env)->SetDoubleField(env, lpObject, GdkEventCrossingFc.y_root, (jdouble)lpStruct->y_root);
(*env)->SetIntField(env, lpObject, GdkEventCrossingFc.mode, (jint)lpStruct->mode);
(*env)->SetIntField(env, lpObject, GdkEventCrossingFc.detail, (jint)lpStruct->detail);
(*env)->SetBooleanField(env, lpObject, GdkEventCrossingFc.focus, (jboolean)lpStruct->focus);
(*env)->SetIntField(env, lpObject, GdkEventCrossingFc.state, (jint)lpStruct->state);
}
#endif
#ifndef NO_GdkEventExpose
typedef struct GdkEventExpose_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, area_x, area_y, area_width, area_height, region, count;
} GdkEventExpose_FID_CACHE;
GdkEventExpose_FID_CACHE GdkEventExposeFc;
void cacheGdkEventExposeFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventExposeFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventExposeFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventExposeFc.window = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "window", I_J);
GdkEventExposeFc.send_event = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "send_event", "B");
GdkEventExposeFc.area_x = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "area_x", "I");
GdkEventExposeFc.area_y = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "area_y", "I");
GdkEventExposeFc.area_width = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "area_width", "I");
GdkEventExposeFc.area_height = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "area_height", "I");
GdkEventExposeFc.region = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "region", I_J);
GdkEventExposeFc.count = (*env)->GetFieldID(env, GdkEventExposeFc.clazz, "count", "I");
GdkEventExposeFc.cached = 1;
}
GdkEventExpose *getGdkEventExposeFields(JNIEnv *env, jobject lpObject, GdkEventExpose *lpStruct)
{
if (!GdkEventExposeFc.cached) cacheGdkEventExposeFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventExposeFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventExposeFc.send_event);
lpStruct->area.x = (*env)->GetIntField(env, lpObject, GdkEventExposeFc.area_x);
lpStruct->area.y = (*env)->GetIntField(env, lpObject, GdkEventExposeFc.area_y);
lpStruct->area.width = (*env)->GetIntField(env, lpObject, GdkEventExposeFc.area_width);
lpStruct->area.height = (*env)->GetIntField(env, lpObject, GdkEventExposeFc.area_height);
lpStruct->region = (void *)(*env)->GetIntLongField(env, lpObject, GdkEventExposeFc.region);
lpStruct->count = (gint)(*env)->GetIntField(env, lpObject, GdkEventExposeFc.count);
return lpStruct;
}
void setGdkEventExposeFields(JNIEnv *env, jobject lpObject, GdkEventExpose *lpStruct)
{
if (!GdkEventExposeFc.cached) cacheGdkEventExposeFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventExposeFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventExposeFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventExposeFc.area_x, (jint)lpStruct->area.x);
(*env)->SetIntField(env, lpObject, GdkEventExposeFc.area_y, (jint)lpStruct->area.y);
(*env)->SetIntField(env, lpObject, GdkEventExposeFc.area_width, (jint)lpStruct->area.width);
(*env)->SetIntField(env, lpObject, GdkEventExposeFc.area_height, (jint)lpStruct->area.height);
(*env)->SetIntLongField(env, lpObject, GdkEventExposeFc.region, (jintLong)lpStruct->region);
(*env)->SetIntField(env, lpObject, GdkEventExposeFc.count, (jint)lpStruct->count);
}
#endif
#ifndef NO_GdkEventFocus
typedef struct GdkEventFocus_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, in;
} GdkEventFocus_FID_CACHE;
GdkEventFocus_FID_CACHE GdkEventFocusFc;
void cacheGdkEventFocusFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventFocusFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventFocusFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventFocusFc.window = (*env)->GetFieldID(env, GdkEventFocusFc.clazz, "window", I_J);
GdkEventFocusFc.send_event = (*env)->GetFieldID(env, GdkEventFocusFc.clazz, "send_event", "B");
GdkEventFocusFc.in = (*env)->GetFieldID(env, GdkEventFocusFc.clazz, "in", "S");
GdkEventFocusFc.cached = 1;
}
GdkEventFocus *getGdkEventFocusFields(JNIEnv *env, jobject lpObject, GdkEventFocus *lpStruct)
{
if (!GdkEventFocusFc.cached) cacheGdkEventFocusFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventFocusFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventFocusFc.send_event);
lpStruct->in = (gint16)(*env)->GetShortField(env, lpObject, GdkEventFocusFc.in);
return lpStruct;
}
void setGdkEventFocusFields(JNIEnv *env, jobject lpObject, GdkEventFocus *lpStruct)
{
if (!GdkEventFocusFc.cached) cacheGdkEventFocusFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventFocusFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventFocusFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetShortField(env, lpObject, GdkEventFocusFc.in, (jshort)lpStruct->in);
}
#endif
#ifndef NO_GdkEventKey
typedef struct GdkEventKey_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, time, state, keyval, length, string, hardware_keycode, group;
} GdkEventKey_FID_CACHE;
GdkEventKey_FID_CACHE GdkEventKeyFc;
void cacheGdkEventKeyFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventKeyFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventKeyFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventKeyFc.window = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "window", I_J);
GdkEventKeyFc.send_event = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "send_event", "B");
GdkEventKeyFc.time = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "time", "I");
GdkEventKeyFc.state = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "state", "I");
GdkEventKeyFc.keyval = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "keyval", "I");
GdkEventKeyFc.length = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "length", "I");
GdkEventKeyFc.string = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "string", I_J);
GdkEventKeyFc.hardware_keycode = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "hardware_keycode", "S");
GdkEventKeyFc.group = (*env)->GetFieldID(env, GdkEventKeyFc.clazz, "group", "B");
GdkEventKeyFc.cached = 1;
}
GdkEventKey *getGdkEventKeyFields(JNIEnv *env, jobject lpObject, GdkEventKey *lpStruct)
{
if (!GdkEventKeyFc.cached) cacheGdkEventKeyFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventKeyFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventKeyFc.send_event);
lpStruct->time = (guint32)(*env)->GetIntField(env, lpObject, GdkEventKeyFc.time);
lpStruct->state = (guint)(*env)->GetIntField(env, lpObject, GdkEventKeyFc.state);
lpStruct->keyval = (guint)(*env)->GetIntField(env, lpObject, GdkEventKeyFc.keyval);
lpStruct->length = (gint)(*env)->GetIntField(env, lpObject, GdkEventKeyFc.length);
lpStruct->string = (gchar *)(*env)->GetIntLongField(env, lpObject, GdkEventKeyFc.string);
lpStruct->hardware_keycode = (guint16)(*env)->GetShortField(env, lpObject, GdkEventKeyFc.hardware_keycode);
lpStruct->group = (guint8)(*env)->GetByteField(env, lpObject, GdkEventKeyFc.group);
return lpStruct;
}
void setGdkEventKeyFields(JNIEnv *env, jobject lpObject, GdkEventKey *lpStruct)
{
if (!GdkEventKeyFc.cached) cacheGdkEventKeyFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventKeyFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventKeyFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventKeyFc.time, (jint)lpStruct->time);
(*env)->SetIntField(env, lpObject, GdkEventKeyFc.state, (jint)lpStruct->state);
(*env)->SetIntField(env, lpObject, GdkEventKeyFc.keyval, (jint)lpStruct->keyval);
(*env)->SetIntField(env, lpObject, GdkEventKeyFc.length, (jint)lpStruct->length);
(*env)->SetIntLongField(env, lpObject, GdkEventKeyFc.string, (jintLong)lpStruct->string);
(*env)->SetShortField(env, lpObject, GdkEventKeyFc.hardware_keycode, (jshort)lpStruct->hardware_keycode);
(*env)->SetByteField(env, lpObject, GdkEventKeyFc.group, (jbyte)lpStruct->group);
}
#endif
#ifndef NO_GdkEventMotion
typedef struct GdkEventMotion_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, time, x, y, axes, state, is_hint, device, x_root, y_root;
} GdkEventMotion_FID_CACHE;
GdkEventMotion_FID_CACHE GdkEventMotionFc;
void cacheGdkEventMotionFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventMotionFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventMotionFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventMotionFc.window = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "window", I_J);
GdkEventMotionFc.send_event = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "send_event", "B");
GdkEventMotionFc.time = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "time", "I");
GdkEventMotionFc.x = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "x", "D");
GdkEventMotionFc.y = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "y", "D");
GdkEventMotionFc.axes = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "axes", I_J);
GdkEventMotionFc.state = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "state", "I");
GdkEventMotionFc.is_hint = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "is_hint", "S");
GdkEventMotionFc.device = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "device", I_J);
GdkEventMotionFc.x_root = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "x_root", "D");
GdkEventMotionFc.y_root = (*env)->GetFieldID(env, GdkEventMotionFc.clazz, "y_root", "D");
GdkEventMotionFc.cached = 1;
}
GdkEventMotion *getGdkEventMotionFields(JNIEnv *env, jobject lpObject, GdkEventMotion *lpStruct)
{
if (!GdkEventMotionFc.cached) cacheGdkEventMotionFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventMotionFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventMotionFc.send_event);
lpStruct->time = (guint32)(*env)->GetIntField(env, lpObject, GdkEventMotionFc.time);
lpStruct->x = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventMotionFc.x);
lpStruct->y = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventMotionFc.y);
lpStruct->axes = (gdouble *)(*env)->GetIntLongField(env, lpObject, GdkEventMotionFc.axes);
lpStruct->state = (guint)(*env)->GetIntField(env, lpObject, GdkEventMotionFc.state);
lpStruct->is_hint = (gint16)(*env)->GetShortField(env, lpObject, GdkEventMotionFc.is_hint);
lpStruct->device = (GdkDevice *)(*env)->GetIntLongField(env, lpObject, GdkEventMotionFc.device);
lpStruct->x_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventMotionFc.x_root);
lpStruct->y_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventMotionFc.y_root);
return lpStruct;
}
void setGdkEventMotionFields(JNIEnv *env, jobject lpObject, GdkEventMotion *lpStruct)
{
if (!GdkEventMotionFc.cached) cacheGdkEventMotionFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventMotionFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventMotionFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventMotionFc.time, (jint)lpStruct->time);
(*env)->SetDoubleField(env, lpObject, GdkEventMotionFc.x, (jdouble)lpStruct->x);
(*env)->SetDoubleField(env, lpObject, GdkEventMotionFc.y, (jdouble)lpStruct->y);
(*env)->SetIntLongField(env, lpObject, GdkEventMotionFc.axes, (jintLong)lpStruct->axes);
(*env)->SetIntField(env, lpObject, GdkEventMotionFc.state, (jint)lpStruct->state);
(*env)->SetShortField(env, lpObject, GdkEventMotionFc.is_hint, (jshort)lpStruct->is_hint);
(*env)->SetIntLongField(env, lpObject, GdkEventMotionFc.device, (jintLong)lpStruct->device);
(*env)->SetDoubleField(env, lpObject, GdkEventMotionFc.x_root, (jdouble)lpStruct->x_root);
(*env)->SetDoubleField(env, lpObject, GdkEventMotionFc.y_root, (jdouble)lpStruct->y_root);
}
#endif
#ifndef NO_GdkEventProperty
typedef struct GdkEventProperty_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, atom, time, state;
} GdkEventProperty_FID_CACHE;
GdkEventProperty_FID_CACHE GdkEventPropertyFc;
void cacheGdkEventPropertyFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventPropertyFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventPropertyFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventPropertyFc.window = (*env)->GetFieldID(env, GdkEventPropertyFc.clazz, "window", I_J);
GdkEventPropertyFc.send_event = (*env)->GetFieldID(env, GdkEventPropertyFc.clazz, "send_event", "B");
GdkEventPropertyFc.atom = (*env)->GetFieldID(env, GdkEventPropertyFc.clazz, "atom", I_J);
GdkEventPropertyFc.time = (*env)->GetFieldID(env, GdkEventPropertyFc.clazz, "time", "I");
GdkEventPropertyFc.state = (*env)->GetFieldID(env, GdkEventPropertyFc.clazz, "state", "I");
GdkEventPropertyFc.cached = 1;
}
GdkEventProperty *getGdkEventPropertyFields(JNIEnv *env, jobject lpObject, GdkEventProperty *lpStruct)
{
if (!GdkEventPropertyFc.cached) cacheGdkEventPropertyFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventPropertyFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventPropertyFc.send_event);
lpStruct->atom = (GdkAtom)(*env)->GetIntLongField(env, lpObject, GdkEventPropertyFc.atom);
lpStruct->time = (guint32)(*env)->GetIntField(env, lpObject, GdkEventPropertyFc.time);
lpStruct->state = (guint)(*env)->GetIntField(env, lpObject, GdkEventPropertyFc.state);
return lpStruct;
}
void setGdkEventPropertyFields(JNIEnv *env, jobject lpObject, GdkEventProperty *lpStruct)
{
if (!GdkEventPropertyFc.cached) cacheGdkEventPropertyFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventPropertyFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventPropertyFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntLongField(env, lpObject, GdkEventPropertyFc.atom, (jintLong)lpStruct->atom);
(*env)->SetIntField(env, lpObject, GdkEventPropertyFc.time, (jint)lpStruct->time);
(*env)->SetIntField(env, lpObject, GdkEventPropertyFc.state, (jint)lpStruct->state);
}
#endif
#ifndef NO_GdkEventScroll
typedef struct GdkEventScroll_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, time, x, y, state, direction, device, x_root, y_root;
} GdkEventScroll_FID_CACHE;
GdkEventScroll_FID_CACHE GdkEventScrollFc;
void cacheGdkEventScrollFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventScrollFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventScrollFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventScrollFc.window = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "window", I_J);
GdkEventScrollFc.send_event = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "send_event", "B");
GdkEventScrollFc.time = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "time", "I");
GdkEventScrollFc.x = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "x", "D");
GdkEventScrollFc.y = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "y", "D");
GdkEventScrollFc.state = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "state", "I");
GdkEventScrollFc.direction = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "direction", "I");
GdkEventScrollFc.device = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "device", I_J);
GdkEventScrollFc.x_root = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "x_root", "D");
GdkEventScrollFc.y_root = (*env)->GetFieldID(env, GdkEventScrollFc.clazz, "y_root", "D");
GdkEventScrollFc.cached = 1;
}
GdkEventScroll *getGdkEventScrollFields(JNIEnv *env, jobject lpObject, GdkEventScroll *lpStruct)
{
if (!GdkEventScrollFc.cached) cacheGdkEventScrollFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventScrollFc.window);
lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventScrollFc.send_event);
lpStruct->time = (guint32)(*env)->GetIntField(env, lpObject, GdkEventScrollFc.time);
lpStruct->x = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventScrollFc.x);
lpStruct->y = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventScrollFc.y);
lpStruct->state = (guint)(*env)->GetIntField(env, lpObject, GdkEventScrollFc.state);
lpStruct->direction = (GdkScrollDirection)(*env)->GetIntField(env, lpObject, GdkEventScrollFc.direction);
lpStruct->device = (GdkDevice *)(*env)->GetIntLongField(env, lpObject, GdkEventScrollFc.device);
lpStruct->x_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventScrollFc.x_root);
lpStruct->y_root = (gdouble)(*env)->GetDoubleField(env, lpObject, GdkEventScrollFc.y_root);
return lpStruct;
}
void setGdkEventScrollFields(JNIEnv *env, jobject lpObject, GdkEventScroll *lpStruct)
{
if (!GdkEventScrollFc.cached) cacheGdkEventScrollFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventScrollFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventScrollFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventScrollFc.time, (jint)lpStruct->time);
(*env)->SetDoubleField(env, lpObject, GdkEventScrollFc.x, (jdouble)lpStruct->x);
(*env)->SetDoubleField(env, lpObject, GdkEventScrollFc.y, (jdouble)lpStruct->y);
(*env)->SetIntField(env, lpObject, GdkEventScrollFc.state, (jint)lpStruct->state);
(*env)->SetIntField(env, lpObject, GdkEventScrollFc.direction, (jint)lpStruct->direction);
(*env)->SetIntLongField(env, lpObject, GdkEventScrollFc.device, (jintLong)lpStruct->device);
(*env)->SetDoubleField(env, lpObject, GdkEventScrollFc.x_root, (jdouble)lpStruct->x_root);
(*env)->SetDoubleField(env, lpObject, GdkEventScrollFc.y_root, (jdouble)lpStruct->y_root);
}
#endif
#ifndef NO_GdkEventWindowState
typedef struct GdkEventWindowState_FID_CACHE {
int cached;
jclass clazz;
jfieldID window, send_event, changed_mask, new_window_state;
} GdkEventWindowState_FID_CACHE;
GdkEventWindowState_FID_CACHE GdkEventWindowStateFc;
void cacheGdkEventWindowStateFields(JNIEnv *env, jobject lpObject)
{
if (GdkEventWindowStateFc.cached) return;
cacheGdkEventFields(env, lpObject);
GdkEventWindowStateFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkEventWindowStateFc.window = (*env)->GetFieldID(env, GdkEventWindowStateFc.clazz, "window", I_J);
GdkEventWindowStateFc.send_event = (*env)->GetFieldID(env, GdkEventWindowStateFc.clazz, "send_event", "B");
GdkEventWindowStateFc.changed_mask = (*env)->GetFieldID(env, GdkEventWindowStateFc.clazz, "changed_mask", "I");
GdkEventWindowStateFc.new_window_state = (*env)->GetFieldID(env, GdkEventWindowStateFc.clazz, "new_window_state", "I");
GdkEventWindowStateFc.cached = 1;
}
GdkEventWindowState *getGdkEventWindowStateFields(JNIEnv *env, jobject lpObject, GdkEventWindowState *lpStruct)
{
if (!GdkEventWindowStateFc.cached) cacheGdkEventWindowStateFields(env, lpObject);
getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventWindowStateFc.window);
lpStruct->send_event = (*env)->GetByteField(env, lpObject, GdkEventWindowStateFc.send_event);
lpStruct->changed_mask = (*env)->GetIntField(env, lpObject, GdkEventWindowStateFc.changed_mask);
lpStruct->new_window_state = (*env)->GetIntField(env, lpObject, GdkEventWindowStateFc.new_window_state);
return lpStruct;
}
void setGdkEventWindowStateFields(JNIEnv *env, jobject lpObject, GdkEventWindowState *lpStruct)
{
if (!GdkEventWindowStateFc.cached) cacheGdkEventWindowStateFields(env, lpObject);
setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GdkEventWindowStateFc.window, (jintLong)lpStruct->window);
(*env)->SetByteField(env, lpObject, GdkEventWindowStateFc.send_event, (jbyte)lpStruct->send_event);
(*env)->SetIntField(env, lpObject, GdkEventWindowStateFc.changed_mask, (jint)lpStruct->changed_mask);
(*env)->SetIntField(env, lpObject, GdkEventWindowStateFc.new_window_state, (jint)lpStruct->new_window_state);
}
#endif
#ifndef NO_GdkGCValues
typedef struct GdkGCValues_FID_CACHE {
int cached;
jclass clazz;
jfieldID foreground_pixel, foreground_red, foreground_green, foreground_blue, background_pixel, background_red, background_green, background_blue, font, function, fill, tile, stipple, clip_mask, subwindow_mode, ts_x_origin, ts_y_origin, clip_x_origin, clip_y_origin, graphics_exposures, line_width, line_style, cap_style, join_style;
} GdkGCValues_FID_CACHE;
GdkGCValues_FID_CACHE GdkGCValuesFc;
void cacheGdkGCValuesFields(JNIEnv *env, jobject lpObject)
{
if (GdkGCValuesFc.cached) return;
GdkGCValuesFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkGCValuesFc.foreground_pixel = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "foreground_pixel", "I");
GdkGCValuesFc.foreground_red = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "foreground_red", "S");
GdkGCValuesFc.foreground_green = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "foreground_green", "S");
GdkGCValuesFc.foreground_blue = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "foreground_blue", "S");
GdkGCValuesFc.background_pixel = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "background_pixel", "I");
GdkGCValuesFc.background_red = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "background_red", "S");
GdkGCValuesFc.background_green = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "background_green", "S");
GdkGCValuesFc.background_blue = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "background_blue", "S");
GdkGCValuesFc.font = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "font", I_J);
GdkGCValuesFc.function = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "function", I_J);
GdkGCValuesFc.fill = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "fill", "I");
GdkGCValuesFc.tile = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "tile", I_J);
GdkGCValuesFc.stipple = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "stipple", I_J);
GdkGCValuesFc.clip_mask = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "clip_mask", I_J);
GdkGCValuesFc.subwindow_mode = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "subwindow_mode", "I");
GdkGCValuesFc.ts_x_origin = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "ts_x_origin", "I");
GdkGCValuesFc.ts_y_origin = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "ts_y_origin", "I");
GdkGCValuesFc.clip_x_origin = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "clip_x_origin", "I");
GdkGCValuesFc.clip_y_origin = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "clip_y_origin", "I");
GdkGCValuesFc.graphics_exposures = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "graphics_exposures", "I");
GdkGCValuesFc.line_width = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "line_width", "I");
GdkGCValuesFc.line_style = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "line_style", "I");
GdkGCValuesFc.cap_style = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "cap_style", "I");
GdkGCValuesFc.join_style = (*env)->GetFieldID(env, GdkGCValuesFc.clazz, "join_style", "I");
GdkGCValuesFc.cached = 1;
}
GdkGCValues *getGdkGCValuesFields(JNIEnv *env, jobject lpObject, GdkGCValues *lpStruct)
{
if (!GdkGCValuesFc.cached) cacheGdkGCValuesFields(env, lpObject);
lpStruct->foreground.pixel = (guint32)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.foreground_pixel);
lpStruct->foreground.red = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.foreground_red);
lpStruct->foreground.green = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.foreground_green);
lpStruct->foreground.blue = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.foreground_blue);
lpStruct->background.pixel = (guint32)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.background_pixel);
lpStruct->background.red = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.background_red);
lpStruct->background.green = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.background_green);
lpStruct->background.blue = (guint16)(*env)->GetShortField(env, lpObject, GdkGCValuesFc.background_blue);
lpStruct->font = (GdkFont *)(*env)->GetIntLongField(env, lpObject, GdkGCValuesFc.font);
lpStruct->function = (GdkFunction)(*env)->GetIntLongField(env, lpObject, GdkGCValuesFc.function);
lpStruct->fill = (GdkFill)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.fill);
lpStruct->tile = (GdkPixmap *)(*env)->GetIntLongField(env, lpObject, GdkGCValuesFc.tile);
lpStruct->stipple = (GdkPixmap *)(*env)->GetIntLongField(env, lpObject, GdkGCValuesFc.stipple);
lpStruct->clip_mask = (GdkPixmap *)(*env)->GetIntLongField(env, lpObject, GdkGCValuesFc.clip_mask);
lpStruct->subwindow_mode = (GdkSubwindowMode)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.subwindow_mode);
lpStruct->ts_x_origin = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.ts_x_origin);
lpStruct->ts_y_origin = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.ts_y_origin);
lpStruct->clip_x_origin = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.clip_x_origin);
lpStruct->clip_y_origin = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.clip_y_origin);
lpStruct->graphics_exposures = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.graphics_exposures);
lpStruct->line_width = (gint)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.line_width);
lpStruct->line_style = (GdkLineStyle)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.line_style);
lpStruct->cap_style = (GdkCapStyle)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.cap_style);
lpStruct->join_style = (GdkJoinStyle)(*env)->GetIntField(env, lpObject, GdkGCValuesFc.join_style);
return lpStruct;
}
void setGdkGCValuesFields(JNIEnv *env, jobject lpObject, GdkGCValues *lpStruct)
{
if (!GdkGCValuesFc.cached) cacheGdkGCValuesFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.foreground_pixel, (jint)lpStruct->foreground.pixel);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.foreground_red, (jshort)lpStruct->foreground.red);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.foreground_green, (jshort)lpStruct->foreground.green);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.foreground_blue, (jshort)lpStruct->foreground.blue);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.background_pixel, (jint)lpStruct->background.pixel);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.background_red, (jshort)lpStruct->background.red);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.background_green, (jshort)lpStruct->background.green);
(*env)->SetShortField(env, lpObject, GdkGCValuesFc.background_blue, (jshort)lpStruct->background.blue);
(*env)->SetIntLongField(env, lpObject, GdkGCValuesFc.font, (jintLong)lpStruct->font);
(*env)->SetIntLongField(env, lpObject, GdkGCValuesFc.function, (jintLong)lpStruct->function);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.fill, (jint)lpStruct->fill);
(*env)->SetIntLongField(env, lpObject, GdkGCValuesFc.tile, (jintLong)lpStruct->tile);
(*env)->SetIntLongField(env, lpObject, GdkGCValuesFc.stipple, (jintLong)lpStruct->stipple);
(*env)->SetIntLongField(env, lpObject, GdkGCValuesFc.clip_mask, (jintLong)lpStruct->clip_mask);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.subwindow_mode, (jint)lpStruct->subwindow_mode);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.ts_x_origin, (jint)lpStruct->ts_x_origin);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.ts_y_origin, (jint)lpStruct->ts_y_origin);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.clip_x_origin, (jint)lpStruct->clip_x_origin);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.clip_y_origin, (jint)lpStruct->clip_y_origin);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.graphics_exposures, (jint)lpStruct->graphics_exposures);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.line_width, (jint)lpStruct->line_width);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.line_style, (jint)lpStruct->line_style);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.cap_style, (jint)lpStruct->cap_style);
(*env)->SetIntField(env, lpObject, GdkGCValuesFc.join_style, (jint)lpStruct->join_style);
}
#endif
#ifndef NO_GdkGeometry
typedef struct GdkGeometry_FID_CACHE {
int cached;
jclass clazz;
jfieldID min_width, min_height, max_width, max_height, base_width, base_height, width_inc, height_inc, min_aspect, max_aspect, win_gravity;
} GdkGeometry_FID_CACHE;
GdkGeometry_FID_CACHE GdkGeometryFc;
void cacheGdkGeometryFields(JNIEnv *env, jobject lpObject)
{
if (GdkGeometryFc.cached) return;
GdkGeometryFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkGeometryFc.min_width = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "min_width", "I");
GdkGeometryFc.min_height = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "min_height", "I");
GdkGeometryFc.max_width = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "max_width", "I");
GdkGeometryFc.max_height = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "max_height", "I");
GdkGeometryFc.base_width = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "base_width", "I");
GdkGeometryFc.base_height = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "base_height", "I");
GdkGeometryFc.width_inc = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "width_inc", "I");
GdkGeometryFc.height_inc = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "height_inc", "I");
GdkGeometryFc.min_aspect = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "min_aspect", "D");
GdkGeometryFc.max_aspect = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "max_aspect", "D");
GdkGeometryFc.win_gravity = (*env)->GetFieldID(env, GdkGeometryFc.clazz, "win_gravity", "I");
GdkGeometryFc.cached = 1;
}
GdkGeometry *getGdkGeometryFields(JNIEnv *env, jobject lpObject, GdkGeometry *lpStruct)
{
if (!GdkGeometryFc.cached) cacheGdkGeometryFields(env, lpObject);
lpStruct->min_width = (*env)->GetIntField(env, lpObject, GdkGeometryFc.min_width);
lpStruct->min_height = (*env)->GetIntField(env, lpObject, GdkGeometryFc.min_height);
lpStruct->max_width = (*env)->GetIntField(env, lpObject, GdkGeometryFc.max_width);
lpStruct->max_height = (*env)->GetIntField(env, lpObject, GdkGeometryFc.max_height);
lpStruct->base_width = (*env)->GetIntField(env, lpObject, GdkGeometryFc.base_width);
lpStruct->base_height = (*env)->GetIntField(env, lpObject, GdkGeometryFc.base_height);
lpStruct->width_inc = (*env)->GetIntField(env, lpObject, GdkGeometryFc.width_inc);
lpStruct->height_inc = (*env)->GetIntField(env, lpObject, GdkGeometryFc.height_inc);
lpStruct->min_aspect = (*env)->GetDoubleField(env, lpObject, GdkGeometryFc.min_aspect);
lpStruct->max_aspect = (*env)->GetDoubleField(env, lpObject, GdkGeometryFc.max_aspect);
lpStruct->win_gravity = (*env)->GetIntField(env, lpObject, GdkGeometryFc.win_gravity);
return lpStruct;
}
void setGdkGeometryFields(JNIEnv *env, jobject lpObject, GdkGeometry *lpStruct)
{
if (!GdkGeometryFc.cached) cacheGdkGeometryFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.min_width, (jint)lpStruct->min_width);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.min_height, (jint)lpStruct->min_height);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.max_width, (jint)lpStruct->max_width);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.max_height, (jint)lpStruct->max_height);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.base_width, (jint)lpStruct->base_width);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.base_height, (jint)lpStruct->base_height);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.width_inc, (jint)lpStruct->width_inc);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.height_inc, (jint)lpStruct->height_inc);
(*env)->SetDoubleField(env, lpObject, GdkGeometryFc.min_aspect, (jdouble)lpStruct->min_aspect);
(*env)->SetDoubleField(env, lpObject, GdkGeometryFc.max_aspect, (jdouble)lpStruct->max_aspect);
(*env)->SetIntField(env, lpObject, GdkGeometryFc.win_gravity, (jint)lpStruct->win_gravity);
}
#endif
#ifndef NO_GdkImage
typedef struct GdkImage_FID_CACHE {
int cached;
jclass clazz;
jfieldID type, visual, byte_order, width, height, depth, bpp, bpl, bits_per_pixel, mem, colormap, windowing_data;
} GdkImage_FID_CACHE;
GdkImage_FID_CACHE GdkImageFc;
void cacheGdkImageFields(JNIEnv *env, jobject lpObject)
{
if (GdkImageFc.cached) return;
GdkImageFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkImageFc.type = (*env)->GetFieldID(env, GdkImageFc.clazz, "type", "I");
GdkImageFc.visual = (*env)->GetFieldID(env, GdkImageFc.clazz, "visual", I_J);
GdkImageFc.byte_order = (*env)->GetFieldID(env, GdkImageFc.clazz, "byte_order", "I");
GdkImageFc.width = (*env)->GetFieldID(env, GdkImageFc.clazz, "width", "I");
GdkImageFc.height = (*env)->GetFieldID(env, GdkImageFc.clazz, "height", "I");
GdkImageFc.depth = (*env)->GetFieldID(env, GdkImageFc.clazz, "depth", "S");
GdkImageFc.bpp = (*env)->GetFieldID(env, GdkImageFc.clazz, "bpp", "S");
GdkImageFc.bpl = (*env)->GetFieldID(env, GdkImageFc.clazz, "bpl", "S");
GdkImageFc.bits_per_pixel = (*env)->GetFieldID(env, GdkImageFc.clazz, "bits_per_pixel", "S");
GdkImageFc.mem = (*env)->GetFieldID(env, GdkImageFc.clazz, "mem", I_J);
GdkImageFc.colormap = (*env)->GetFieldID(env, GdkImageFc.clazz, "colormap", I_J);
GdkImageFc.windowing_data = (*env)->GetFieldID(env, GdkImageFc.clazz, "windowing_data", I_J);
GdkImageFc.cached = 1;
}
GdkImage *getGdkImageFields(JNIEnv *env, jobject lpObject, GdkImage *lpStruct)
{
if (!GdkImageFc.cached) cacheGdkImageFields(env, lpObject);
lpStruct->type = (GdkImageType)(*env)->GetIntField(env, lpObject, GdkImageFc.type);
lpStruct->visual = (GdkVisual *)(*env)->GetIntLongField(env, lpObject, GdkImageFc.visual);
lpStruct->byte_order = (GdkByteOrder)(*env)->GetIntField(env, lpObject, GdkImageFc.byte_order);
lpStruct->width = (gint)(*env)->GetIntField(env, lpObject, GdkImageFc.width);
lpStruct->height = (gint)(*env)->GetIntField(env, lpObject, GdkImageFc.height);
lpStruct->depth = (guint16)(*env)->GetShortField(env, lpObject, GdkImageFc.depth);
lpStruct->bpp = (guint16)(*env)->GetShortField(env, lpObject, GdkImageFc.bpp);
lpStruct->bpl = (guint16)(*env)->GetShortField(env, lpObject, GdkImageFc.bpl);
lpStruct->bits_per_pixel = (guint16)(*env)->GetShortField(env, lpObject, GdkImageFc.bits_per_pixel);
lpStruct->mem = (gpointer)(*env)->GetIntLongField(env, lpObject, GdkImageFc.mem);
lpStruct->colormap = (GdkColormap *)(*env)->GetIntLongField(env, lpObject, GdkImageFc.colormap);
lpStruct->windowing_data = (gpointer)(*env)->GetIntLongField(env, lpObject, GdkImageFc.windowing_data);
return lpStruct;
}
void setGdkImageFields(JNIEnv *env, jobject lpObject, GdkImage *lpStruct)
{
if (!GdkImageFc.cached) cacheGdkImageFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkImageFc.type, (jint)lpStruct->type);
(*env)->SetIntLongField(env, lpObject, GdkImageFc.visual, (jintLong)lpStruct->visual);
(*env)->SetIntField(env, lpObject, GdkImageFc.byte_order, (jint)lpStruct->byte_order);
(*env)->SetIntField(env, lpObject, GdkImageFc.width, (jint)lpStruct->width);
(*env)->SetIntField(env, lpObject, GdkImageFc.height, (jint)lpStruct->height);
(*env)->SetShortField(env, lpObject, GdkImageFc.depth, (jshort)lpStruct->depth);
(*env)->SetShortField(env, lpObject, GdkImageFc.bpp, (jshort)lpStruct->bpp);
(*env)->SetShortField(env, lpObject, GdkImageFc.bpl, (jshort)lpStruct->bpl);
(*env)->SetShortField(env, lpObject, GdkImageFc.bits_per_pixel, (jshort)lpStruct->bits_per_pixel);
(*env)->SetIntLongField(env, lpObject, GdkImageFc.mem, (jintLong)lpStruct->mem);
(*env)->SetIntLongField(env, lpObject, GdkImageFc.colormap, (jintLong)lpStruct->colormap);
(*env)->SetIntLongField(env, lpObject, GdkImageFc.windowing_data, (jintLong)lpStruct->windowing_data);
}
#endif
#ifndef NO_GdkRGBA
typedef struct GdkRGBA_FID_CACHE {
int cached;
jclass clazz;
jfieldID red, green, blue, alpha;
} GdkRGBA_FID_CACHE;
GdkRGBA_FID_CACHE GdkRGBAFc;
void cacheGdkRGBAFields(JNIEnv *env, jobject lpObject)
{
if (GdkRGBAFc.cached) return;
GdkRGBAFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkRGBAFc.red = (*env)->GetFieldID(env, GdkRGBAFc.clazz, "red", "D");
GdkRGBAFc.green = (*env)->GetFieldID(env, GdkRGBAFc.clazz, "green", "D");
GdkRGBAFc.blue = (*env)->GetFieldID(env, GdkRGBAFc.clazz, "blue", "D");
GdkRGBAFc.alpha = (*env)->GetFieldID(env, GdkRGBAFc.clazz, "alpha", "D");
GdkRGBAFc.cached = 1;
}
GdkRGBA *getGdkRGBAFields(JNIEnv *env, jobject lpObject, GdkRGBA *lpStruct)
{
if (!GdkRGBAFc.cached) cacheGdkRGBAFields(env, lpObject);
lpStruct->red = (*env)->GetDoubleField(env, lpObject, GdkRGBAFc.red);
lpStruct->green = (*env)->GetDoubleField(env, lpObject, GdkRGBAFc.green);
lpStruct->blue = (*env)->GetDoubleField(env, lpObject, GdkRGBAFc.blue);
lpStruct->alpha = (*env)->GetDoubleField(env, lpObject, GdkRGBAFc.alpha);
return lpStruct;
}
void setGdkRGBAFields(JNIEnv *env, jobject lpObject, GdkRGBA *lpStruct)
{
if (!GdkRGBAFc.cached) cacheGdkRGBAFields(env, lpObject);
(*env)->SetDoubleField(env, lpObject, GdkRGBAFc.red, (jdouble)lpStruct->red);
(*env)->SetDoubleField(env, lpObject, GdkRGBAFc.green, (jdouble)lpStruct->green);
(*env)->SetDoubleField(env, lpObject, GdkRGBAFc.blue, (jdouble)lpStruct->blue);
(*env)->SetDoubleField(env, lpObject, GdkRGBAFc.alpha, (jdouble)lpStruct->alpha);
}
#endif
#ifndef NO_GdkRectangle
typedef struct GdkRectangle_FID_CACHE {
int cached;
jclass clazz;
jfieldID x, y, width, height;
} GdkRectangle_FID_CACHE;
GdkRectangle_FID_CACHE GdkRectangleFc;
void cacheGdkRectangleFields(JNIEnv *env, jobject lpObject)
{
if (GdkRectangleFc.cached) return;
GdkRectangleFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkRectangleFc.x = (*env)->GetFieldID(env, GdkRectangleFc.clazz, "x", "I");
GdkRectangleFc.y = (*env)->GetFieldID(env, GdkRectangleFc.clazz, "y", "I");
GdkRectangleFc.width = (*env)->GetFieldID(env, GdkRectangleFc.clazz, "width", "I");
GdkRectangleFc.height = (*env)->GetFieldID(env, GdkRectangleFc.clazz, "height", "I");
GdkRectangleFc.cached = 1;
}
GdkRectangle *getGdkRectangleFields(JNIEnv *env, jobject lpObject, GdkRectangle *lpStruct)
{
if (!GdkRectangleFc.cached) cacheGdkRectangleFields(env, lpObject);
lpStruct->x = (gint)(*env)->GetIntField(env, lpObject, GdkRectangleFc.x);
lpStruct->y = (gint)(*env)->GetIntField(env, lpObject, GdkRectangleFc.y);
lpStruct->width = (gint)(*env)->GetIntField(env, lpObject, GdkRectangleFc.width);
lpStruct->height = (gint)(*env)->GetIntField(env, lpObject, GdkRectangleFc.height);
return lpStruct;
}
void setGdkRectangleFields(JNIEnv *env, jobject lpObject, GdkRectangle *lpStruct)
{
if (!GdkRectangleFc.cached) cacheGdkRectangleFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkRectangleFc.x, (jint)lpStruct->x);
(*env)->SetIntField(env, lpObject, GdkRectangleFc.y, (jint)lpStruct->y);
(*env)->SetIntField(env, lpObject, GdkRectangleFc.width, (jint)lpStruct->width);
(*env)->SetIntField(env, lpObject, GdkRectangleFc.height, (jint)lpStruct->height);
}
#endif
#ifndef NO_GdkVisual
typedef struct GdkVisual_FID_CACHE {
int cached;
jclass clazz;
jfieldID type, depth, byte_order, colormap_size, bits_per_rgb, red_mask, red_shift, red_prec, green_mask, green_shift, green_prec, blue_mask, blue_shift, blue_prec;
} GdkVisual_FID_CACHE;
GdkVisual_FID_CACHE GdkVisualFc;
void cacheGdkVisualFields(JNIEnv *env, jobject lpObject)
{
if (GdkVisualFc.cached) return;
GdkVisualFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkVisualFc.type = (*env)->GetFieldID(env, GdkVisualFc.clazz, "type", "I");
GdkVisualFc.depth = (*env)->GetFieldID(env, GdkVisualFc.clazz, "depth", "I");
GdkVisualFc.byte_order = (*env)->GetFieldID(env, GdkVisualFc.clazz, "byte_order", "I");
GdkVisualFc.colormap_size = (*env)->GetFieldID(env, GdkVisualFc.clazz, "colormap_size", "I");
GdkVisualFc.bits_per_rgb = (*env)->GetFieldID(env, GdkVisualFc.clazz, "bits_per_rgb", "I");
GdkVisualFc.red_mask = (*env)->GetFieldID(env, GdkVisualFc.clazz, "red_mask", "I");
GdkVisualFc.red_shift = (*env)->GetFieldID(env, GdkVisualFc.clazz, "red_shift", "I");
GdkVisualFc.red_prec = (*env)->GetFieldID(env, GdkVisualFc.clazz, "red_prec", "I");
GdkVisualFc.green_mask = (*env)->GetFieldID(env, GdkVisualFc.clazz, "green_mask", "I");
GdkVisualFc.green_shift = (*env)->GetFieldID(env, GdkVisualFc.clazz, "green_shift", "I");
GdkVisualFc.green_prec = (*env)->GetFieldID(env, GdkVisualFc.clazz, "green_prec", "I");
GdkVisualFc.blue_mask = (*env)->GetFieldID(env, GdkVisualFc.clazz, "blue_mask", "I");
GdkVisualFc.blue_shift = (*env)->GetFieldID(env, GdkVisualFc.clazz, "blue_shift", "I");
GdkVisualFc.blue_prec = (*env)->GetFieldID(env, GdkVisualFc.clazz, "blue_prec", "I");
GdkVisualFc.cached = 1;
}
GdkVisual *getGdkVisualFields(JNIEnv *env, jobject lpObject, GdkVisual *lpStruct)
{
if (!GdkVisualFc.cached) cacheGdkVisualFields(env, lpObject);
lpStruct->type = (GdkVisualType)(*env)->GetIntField(env, lpObject, GdkVisualFc.type);
lpStruct->depth = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.depth);
lpStruct->byte_order = (GdkByteOrder)(*env)->GetIntField(env, lpObject, GdkVisualFc.byte_order);
lpStruct->colormap_size = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.colormap_size);
lpStruct->bits_per_rgb = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.bits_per_rgb);
lpStruct->red_mask = (guint32)(*env)->GetIntField(env, lpObject, GdkVisualFc.red_mask);
lpStruct->red_shift = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.red_shift);
lpStruct->red_prec = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.red_prec);
lpStruct->green_mask = (guint32)(*env)->GetIntField(env, lpObject, GdkVisualFc.green_mask);
lpStruct->green_shift = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.green_shift);
lpStruct->green_prec = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.green_prec);
lpStruct->blue_mask = (guint32)(*env)->GetIntField(env, lpObject, GdkVisualFc.blue_mask);
lpStruct->blue_shift = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.blue_shift);
lpStruct->blue_prec = (gint)(*env)->GetIntField(env, lpObject, GdkVisualFc.blue_prec);
return lpStruct;
}
void setGdkVisualFields(JNIEnv *env, jobject lpObject, GdkVisual *lpStruct)
{
if (!GdkVisualFc.cached) cacheGdkVisualFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GdkVisualFc.type, (jint)lpStruct->type);
(*env)->SetIntField(env, lpObject, GdkVisualFc.depth, (jint)lpStruct->depth);
(*env)->SetIntField(env, lpObject, GdkVisualFc.byte_order, (jint)lpStruct->byte_order);
(*env)->SetIntField(env, lpObject, GdkVisualFc.colormap_size, (jint)lpStruct->colormap_size);
(*env)->SetIntField(env, lpObject, GdkVisualFc.bits_per_rgb, (jint)lpStruct->bits_per_rgb);
(*env)->SetIntField(env, lpObject, GdkVisualFc.red_mask, (jint)lpStruct->red_mask);
(*env)->SetIntField(env, lpObject, GdkVisualFc.red_shift, (jint)lpStruct->red_shift);
(*env)->SetIntField(env, lpObject, GdkVisualFc.red_prec, (jint)lpStruct->red_prec);
(*env)->SetIntField(env, lpObject, GdkVisualFc.green_mask, (jint)lpStruct->green_mask);
(*env)->SetIntField(env, lpObject, GdkVisualFc.green_shift, (jint)lpStruct->green_shift);
(*env)->SetIntField(env, lpObject, GdkVisualFc.green_prec, (jint)lpStruct->green_prec);
(*env)->SetIntField(env, lpObject, GdkVisualFc.blue_mask, (jint)lpStruct->blue_mask);
(*env)->SetIntField(env, lpObject, GdkVisualFc.blue_shift, (jint)lpStruct->blue_shift);
(*env)->SetIntField(env, lpObject, GdkVisualFc.blue_prec, (jint)lpStruct->blue_prec);
}
#endif
#ifndef NO_GdkWindowAttr
typedef struct GdkWindowAttr_FID_CACHE {
int cached;
jclass clazz;
jfieldID title, event_mask, x, y, width, height, wclass, visual, colormap, window_type, cursor, wmclass_name, wmclass_class, override_redirect;
} GdkWindowAttr_FID_CACHE;
GdkWindowAttr_FID_CACHE GdkWindowAttrFc;
void cacheGdkWindowAttrFields(JNIEnv *env, jobject lpObject)
{
if (GdkWindowAttrFc.cached) return;
GdkWindowAttrFc.clazz = (*env)->GetObjectClass(env, lpObject);
GdkWindowAttrFc.title = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "title", I_J);
GdkWindowAttrFc.event_mask = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "event_mask", "I");
GdkWindowAttrFc.x = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "x", "I");
GdkWindowAttrFc.y = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "y", "I");
GdkWindowAttrFc.width = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "width", "I");
GdkWindowAttrFc.height = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "height", "I");
GdkWindowAttrFc.wclass = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "wclass", "I");
GdkWindowAttrFc.visual = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "visual", I_J);
GdkWindowAttrFc.colormap = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "colormap", I_J);
GdkWindowAttrFc.window_type = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "window_type", "I");
GdkWindowAttrFc.cursor = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "cursor", I_J);
GdkWindowAttrFc.wmclass_name = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "wmclass_name", I_J);
GdkWindowAttrFc.wmclass_class = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "wmclass_class", I_J);
GdkWindowAttrFc.override_redirect = (*env)->GetFieldID(env, GdkWindowAttrFc.clazz, "override_redirect", "Z");
GdkWindowAttrFc.cached = 1;
}
GdkWindowAttr *getGdkWindowAttrFields(JNIEnv *env, jobject lpObject, GdkWindowAttr *lpStruct)
{
if (!GdkWindowAttrFc.cached) cacheGdkWindowAttrFields(env, lpObject);
lpStruct->title = (gchar *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.title);
lpStruct->event_mask = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.event_mask);
lpStruct->x = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.x);
lpStruct->y = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.y);
lpStruct->width = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.width);
lpStruct->height = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.height);
lpStruct->wclass = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.wclass);
lpStruct->visual = (GdkVisual *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.visual);
#ifndef GTK3
lpStruct->colormap = (GdkColormap *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.colormap);
#endif
lpStruct->window_type = (*env)->GetIntField(env, lpObject, GdkWindowAttrFc.window_type);
lpStruct->cursor = (GdkCursor *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.cursor);
lpStruct->wmclass_name = (gchar *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.wmclass_name);
lpStruct->wmclass_class = (gchar *)(*env)->GetIntLongField(env, lpObject, GdkWindowAttrFc.wmclass_class);
lpStruct->override_redirect = (*env)->GetBooleanField(env, lpObject, GdkWindowAttrFc.override_redirect);
return lpStruct;
}
void setGdkWindowAttrFields(JNIEnv *env, jobject lpObject, GdkWindowAttr *lpStruct)
{
if (!GdkWindowAttrFc.cached) cacheGdkWindowAttrFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.title, (jintLong)lpStruct->title);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.event_mask, (jint)lpStruct->event_mask);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.x, (jint)lpStruct->x);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.y, (jint)lpStruct->y);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.width, (jint)lpStruct->width);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.height, (jint)lpStruct->height);
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.wclass, (jint)lpStruct->wclass);
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.visual, (jintLong)lpStruct->visual);
#ifndef GTK3
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.colormap, (jintLong)lpStruct->colormap);
#endif
(*env)->SetIntField(env, lpObject, GdkWindowAttrFc.window_type, (jint)lpStruct->window_type);
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.cursor, (jintLong)lpStruct->cursor);
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.wmclass_name, (jintLong)lpStruct->wmclass_name);
(*env)->SetIntLongField(env, lpObject, GdkWindowAttrFc.wmclass_class, (jintLong)lpStruct->wmclass_class);
(*env)->SetBooleanField(env, lpObject, GdkWindowAttrFc.override_redirect, (jboolean)lpStruct->override_redirect);
}
#endif
#ifndef NO_GtkAdjustment
typedef struct GtkAdjustment_FID_CACHE {
int cached;
jclass clazz;
jfieldID lower, upper, value, step_increment, page_increment, page_size;
} GtkAdjustment_FID_CACHE;
GtkAdjustment_FID_CACHE GtkAdjustmentFc;
void cacheGtkAdjustmentFields(JNIEnv *env, jobject lpObject)
{
if (GtkAdjustmentFc.cached) return;
GtkAdjustmentFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkAdjustmentFc.lower = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "lower", "D");
GtkAdjustmentFc.upper = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "upper", "D");
GtkAdjustmentFc.value = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "value", "D");
GtkAdjustmentFc.step_increment = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "step_increment", "D");
GtkAdjustmentFc.page_increment = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "page_increment", "D");
GtkAdjustmentFc.page_size = (*env)->GetFieldID(env, GtkAdjustmentFc.clazz, "page_size", "D");
GtkAdjustmentFc.cached = 1;
}
GtkAdjustment *getGtkAdjustmentFields(JNIEnv *env, jobject lpObject, GtkAdjustment *lpStruct)
{
if (!GtkAdjustmentFc.cached) cacheGtkAdjustmentFields(env, lpObject);
lpStruct->lower = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.lower);
lpStruct->upper = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.upper);
lpStruct->value = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.value);
lpStruct->step_increment = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.step_increment);
lpStruct->page_increment = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.page_increment);
lpStruct->page_size = (gdouble)(*env)->GetDoubleField(env, lpObject, GtkAdjustmentFc.page_size);
return lpStruct;
}
void setGtkAdjustmentFields(JNIEnv *env, jobject lpObject, GtkAdjustment *lpStruct)
{
if (!GtkAdjustmentFc.cached) cacheGtkAdjustmentFields(env, lpObject);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.lower, (jdouble)lpStruct->lower);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.upper, (jdouble)lpStruct->upper);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.value, (jdouble)lpStruct->value);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.step_increment, (jdouble)lpStruct->step_increment);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.page_increment, (jdouble)lpStruct->page_increment);
(*env)->SetDoubleField(env, lpObject, GtkAdjustmentFc.page_size, (jdouble)lpStruct->page_size);
}
#endif
#ifndef NO_GtkAllocation
typedef struct GtkAllocation_FID_CACHE {
int cached;
jclass clazz;
jfieldID x, y, width, height;
} GtkAllocation_FID_CACHE;
GtkAllocation_FID_CACHE GtkAllocationFc;
void cacheGtkAllocationFields(JNIEnv *env, jobject lpObject)
{
if (GtkAllocationFc.cached) return;
GtkAllocationFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkAllocationFc.x = (*env)->GetFieldID(env, GtkAllocationFc.clazz, "x", "I");
GtkAllocationFc.y = (*env)->GetFieldID(env, GtkAllocationFc.clazz, "y", "I");
GtkAllocationFc.width = (*env)->GetFieldID(env, GtkAllocationFc.clazz, "width", "I");
GtkAllocationFc.height = (*env)->GetFieldID(env, GtkAllocationFc.clazz, "height", "I");
GtkAllocationFc.cached = 1;
}
GtkAllocation *getGtkAllocationFields(JNIEnv *env, jobject lpObject, GtkAllocation *lpStruct)
{
if (!GtkAllocationFc.cached) cacheGtkAllocationFields(env, lpObject);
lpStruct->x = (*env)->GetIntField(env, lpObject, GtkAllocationFc.x);
lpStruct->y = (*env)->GetIntField(env, lpObject, GtkAllocationFc.y);
lpStruct->width = (*env)->GetIntField(env, lpObject, GtkAllocationFc.width);
lpStruct->height = (*env)->GetIntField(env, lpObject, GtkAllocationFc.height);
return lpStruct;
}
void setGtkAllocationFields(JNIEnv *env, jobject lpObject, GtkAllocation *lpStruct)
{
if (!GtkAllocationFc.cached) cacheGtkAllocationFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GtkAllocationFc.x, (jint)lpStruct->x);
(*env)->SetIntField(env, lpObject, GtkAllocationFc.y, (jint)lpStruct->y);
(*env)->SetIntField(env, lpObject, GtkAllocationFc.width, (jint)lpStruct->width);
(*env)->SetIntField(env, lpObject, GtkAllocationFc.height, (jint)lpStruct->height);
}
#endif
#ifndef NO_GtkBorder
typedef struct GtkBorder_FID_CACHE {
int cached;
jclass clazz;
jfieldID left, right, top, bottom;
} GtkBorder_FID_CACHE;
GtkBorder_FID_CACHE GtkBorderFc;
void cacheGtkBorderFields(JNIEnv *env, jobject lpObject)
{
if (GtkBorderFc.cached) return;
GtkBorderFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkBorderFc.left = (*env)->GetFieldID(env, GtkBorderFc.clazz, "left", "I");
GtkBorderFc.right = (*env)->GetFieldID(env, GtkBorderFc.clazz, "right", "I");
GtkBorderFc.top = (*env)->GetFieldID(env, GtkBorderFc.clazz, "top", "I");
GtkBorderFc.bottom = (*env)->GetFieldID(env, GtkBorderFc.clazz, "bottom", "I");
GtkBorderFc.cached = 1;
}
GtkBorder *getGtkBorderFields(JNIEnv *env, jobject lpObject, GtkBorder *lpStruct)
{
if (!GtkBorderFc.cached) cacheGtkBorderFields(env, lpObject);
lpStruct->left = (*env)->GetIntField(env, lpObject, GtkBorderFc.left);
lpStruct->right = (*env)->GetIntField(env, lpObject, GtkBorderFc.right);
lpStruct->top = (*env)->GetIntField(env, lpObject, GtkBorderFc.top);
lpStruct->bottom = (*env)->GetIntField(env, lpObject, GtkBorderFc.bottom);
return lpStruct;
}
void setGtkBorderFields(JNIEnv *env, jobject lpObject, GtkBorder *lpStruct)
{
if (!GtkBorderFc.cached) cacheGtkBorderFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GtkBorderFc.left, (jint)lpStruct->left);
(*env)->SetIntField(env, lpObject, GtkBorderFc.right, (jint)lpStruct->right);
(*env)->SetIntField(env, lpObject, GtkBorderFc.top, (jint)lpStruct->top);
(*env)->SetIntField(env, lpObject, GtkBorderFc.bottom, (jint)lpStruct->bottom);
}
#endif
#ifndef NO_GtkCellRendererClass
typedef struct GtkCellRendererClass_FID_CACHE {
int cached;
jclass clazz;
jfieldID render, get_size, get_preferred_width;
} GtkCellRendererClass_FID_CACHE;
GtkCellRendererClass_FID_CACHE GtkCellRendererClassFc;
void cacheGtkCellRendererClassFields(JNIEnv *env, jobject lpObject)
{
if (GtkCellRendererClassFc.cached) return;
GtkCellRendererClassFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkCellRendererClassFc.render = (*env)->GetFieldID(env, GtkCellRendererClassFc.clazz, "render", I_J);
GtkCellRendererClassFc.get_size = (*env)->GetFieldID(env, GtkCellRendererClassFc.clazz, "get_size", I_J);
GtkCellRendererClassFc.get_preferred_width = (*env)->GetFieldID(env, GtkCellRendererClassFc.clazz, "get_preferred_width", I_J);
GtkCellRendererClassFc.cached = 1;
}
GtkCellRendererClass *getGtkCellRendererClassFields(JNIEnv *env, jobject lpObject, GtkCellRendererClass *lpStruct)
{
if (!GtkCellRendererClassFc.cached) cacheGtkCellRendererClassFields(env, lpObject);
lpStruct->render = (void(*)())(*env)->GetIntLongField(env, lpObject, GtkCellRendererClassFc.render);
#ifndef GTK3
lpStruct->get_size = (void(*)())(*env)->GetIntLongField(env, lpObject, GtkCellRendererClassFc.get_size);
#endif
#ifdef GTK3
lpStruct->get_preferred_width = (void(*)())(*env)->GetIntLongField(env, lpObject, GtkCellRendererClassFc.get_preferred_width);
#endif
return lpStruct;
}
void setGtkCellRendererClassFields(JNIEnv *env, jobject lpObject, GtkCellRendererClass *lpStruct)
{
if (!GtkCellRendererClassFc.cached) cacheGtkCellRendererClassFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GtkCellRendererClassFc.render, (jintLong)lpStruct->render);
#ifndef GTK3
(*env)->SetIntLongField(env, lpObject, GtkCellRendererClassFc.get_size, (jintLong)lpStruct->get_size);
#endif
#ifdef GTK3
(*env)->SetIntLongField(env, lpObject, GtkCellRendererClassFc.get_preferred_width, (jintLong)lpStruct->get_preferred_width);
#endif
}
#endif
#ifndef NO_GtkFixed
typedef struct GtkFixed_FID_CACHE {
int cached;
jclass clazz;
jfieldID children;
} GtkFixed_FID_CACHE;
GtkFixed_FID_CACHE GtkFixedFc;
void cacheGtkFixedFields(JNIEnv *env, jobject lpObject)
{
if (GtkFixedFc.cached) return;
GtkFixedFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkFixedFc.children = (*env)->GetFieldID(env, GtkFixedFc.clazz, "children", I_J);
GtkFixedFc.cached = 1;
}
GtkFixed *getGtkFixedFields(JNIEnv *env, jobject lpObject, GtkFixed *lpStruct)
{
if (!GtkFixedFc.cached) cacheGtkFixedFields(env, lpObject);
lpStruct->children = (GList *)(*env)->GetIntLongField(env, lpObject, GtkFixedFc.children);
return lpStruct;
}
void setGtkFixedFields(JNIEnv *env, jobject lpObject, GtkFixed *lpStruct)
{
if (!GtkFixedFc.cached) cacheGtkFixedFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GtkFixedFc.children, (jintLong)lpStruct->children);
}
#endif
#ifndef NO_GtkRequisition
typedef struct GtkRequisition_FID_CACHE {
int cached;
jclass clazz;
jfieldID width, height;
} GtkRequisition_FID_CACHE;
GtkRequisition_FID_CACHE GtkRequisitionFc;
void cacheGtkRequisitionFields(JNIEnv *env, jobject lpObject)
{
if (GtkRequisitionFc.cached) return;
GtkRequisitionFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkRequisitionFc.width = (*env)->GetFieldID(env, GtkRequisitionFc.clazz, "width", "I");
GtkRequisitionFc.height = (*env)->GetFieldID(env, GtkRequisitionFc.clazz, "height", "I");
GtkRequisitionFc.cached = 1;
}
GtkRequisition *getGtkRequisitionFields(JNIEnv *env, jobject lpObject, GtkRequisition *lpStruct)
{
if (!GtkRequisitionFc.cached) cacheGtkRequisitionFields(env, lpObject);
lpStruct->width = (*env)->GetIntField(env, lpObject, GtkRequisitionFc.width);
lpStruct->height = (*env)->GetIntField(env, lpObject, GtkRequisitionFc.height);
return lpStruct;
}
void setGtkRequisitionFields(JNIEnv *env, jobject lpObject, GtkRequisition *lpStruct)
{
if (!GtkRequisitionFc.cached) cacheGtkRequisitionFields(env, lpObject);
(*env)->SetIntField(env, lpObject, GtkRequisitionFc.width, (jint)lpStruct->width);
(*env)->SetIntField(env, lpObject, GtkRequisitionFc.height, (jint)lpStruct->height);
}
#endif
#ifndef NO_GtkTargetEntry
typedef struct GtkTargetEntry_FID_CACHE {
int cached;
jclass clazz;
jfieldID target, flags, info;
} GtkTargetEntry_FID_CACHE;
GtkTargetEntry_FID_CACHE GtkTargetEntryFc;
void cacheGtkTargetEntryFields(JNIEnv *env, jobject lpObject)
{
if (GtkTargetEntryFc.cached) return;
GtkTargetEntryFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkTargetEntryFc.target = (*env)->GetFieldID(env, GtkTargetEntryFc.clazz, "target", I_J);
GtkTargetEntryFc.flags = (*env)->GetFieldID(env, GtkTargetEntryFc.clazz, "flags", "I");
GtkTargetEntryFc.info = (*env)->GetFieldID(env, GtkTargetEntryFc.clazz, "info", "I");
GtkTargetEntryFc.cached = 1;
}
GtkTargetEntry *getGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct)
{
if (!GtkTargetEntryFc.cached) cacheGtkTargetEntryFields(env, lpObject);
lpStruct->target = (gchar *)(*env)->GetIntLongField(env, lpObject, GtkTargetEntryFc.target);
lpStruct->flags = (guint)(*env)->GetIntField(env, lpObject, GtkTargetEntryFc.flags);
lpStruct->info = (guint)(*env)->GetIntField(env, lpObject, GtkTargetEntryFc.info);
return lpStruct;
}
void setGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct)
{
if (!GtkTargetEntryFc.cached) cacheGtkTargetEntryFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, GtkTargetEntryFc.target, (jintLong)lpStruct->target);
(*env)->SetIntField(env, lpObject, GtkTargetEntryFc.flags, (jint)lpStruct->flags);
(*env)->SetIntField(env, lpObject, GtkTargetEntryFc.info, (jint)lpStruct->info);
}
#endif
#ifndef NO_GtkWidgetClass
typedef struct GtkWidgetClass_FID_CACHE {
int cached;
jclass clazz;
jfieldID map, size_allocate;
} GtkWidgetClass_FID_CACHE;
GtkWidgetClass_FID_CACHE GtkWidgetClassFc;
void cacheGtkWidgetClassFields(JNIEnv *env, jobject lpObject)
{
if (GtkWidgetClassFc.cached) return;
cacheGObjectClassFields(env, lpObject);
GtkWidgetClassFc.clazz = (*env)->GetObjectClass(env, lpObject);
GtkWidgetClassFc.map = (*env)->GetFieldID(env, GtkWidgetClassFc.clazz, "map", I_J);
GtkWidgetClassFc.size_allocate = (*env)->GetFieldID(env, GtkWidgetClassFc.clazz, "size_allocate", I_J);
GtkWidgetClassFc.cached = 1;
}
GtkWidgetClass *getGtkWidgetClassFields(JNIEnv *env, jobject lpObject, GtkWidgetClass *lpStruct)
{
if (!GtkWidgetClassFc.cached) cacheGtkWidgetClassFields(env, lpObject);
getGObjectClassFields(env, lpObject, (GObjectClass *)lpStruct);
lpStruct->map = (void(*)())(*env)->GetIntLongField(env, lpObject, GtkWidgetClassFc.map);
lpStruct->size_allocate = (void(*)())(*env)->GetIntLongField(env, lpObject, GtkWidgetClassFc.size_allocate);
return lpStruct;
}
void setGtkWidgetClassFields(JNIEnv *env, jobject lpObject, GtkWidgetClass *lpStruct)
{
if (!GtkWidgetClassFc.cached) cacheGtkWidgetClassFields(env, lpObject);
setGObjectClassFields(env, lpObject, (GObjectClass *)lpStruct);
(*env)->SetIntLongField(env, lpObject, GtkWidgetClassFc.map, (jintLong)lpStruct->map);
(*env)->SetIntLongField(env, lpObject, GtkWidgetClassFc.size_allocate, (jintLong)lpStruct->size_allocate);
}
#endif
#ifndef NO_PangoAttrColor
typedef struct PangoAttrColor_FID_CACHE {
int cached;
jclass clazz;
jfieldID color_red, color_green, color_blue;
} PangoAttrColor_FID_CACHE;
PangoAttrColor_FID_CACHE PangoAttrColorFc;
void cachePangoAttrColorFields(JNIEnv *env, jobject lpObject)
{
if (PangoAttrColorFc.cached) return;
cachePangoAttributeFields(env, lpObject);
PangoAttrColorFc.clazz = (*env)->GetObjectClass(env, lpObject);
PangoAttrColorFc.color_red = (*env)->GetFieldID(env, PangoAttrColorFc.clazz, "color_red", "S");
PangoAttrColorFc.color_green = (*env)->GetFieldID(env, PangoAttrColorFc.clazz, "color_green", "S");
PangoAttrColorFc.color_blue = (*env)->GetFieldID(env, PangoAttrColorFc.clazz, "color_blue", "S");
PangoAttrColorFc.cached = 1;
}
PangoAttrColor *getPangoAttrColorFields(JNIEnv *env, jobject lpObject, PangoAttrColor *lpStruct)
{
if (!PangoAttrColorFc.cached) cachePangoAttrColorFields(env, lpObject);
getPangoAttributeFields(env, lpObject, (PangoAttribute *)lpStruct);
lpStruct->color.red = (*env)->GetShortField(env, lpObject, PangoAttrColorFc.color_red);
lpStruct->color.green = (*env)->GetShortField(env, lpObject, PangoAttrColorFc.color_green);
lpStruct->color.blue = (*env)->GetShortField(env, lpObject, PangoAttrColorFc.color_blue);
return lpStruct;
}
void setPangoAttrColorFields(JNIEnv *env, jobject lpObject, PangoAttrColor *lpStruct)
{
if (!PangoAttrColorFc.cached) cachePangoAttrColorFields(env, lpObject);
setPangoAttributeFields(env, lpObject, (PangoAttribute *)lpStruct);
(*env)->SetShortField(env, lpObject, PangoAttrColorFc.color_red, (jshort)lpStruct->color.red);
(*env)->SetShortField(env, lpObject, PangoAttrColorFc.color_green, (jshort)lpStruct->color.green);
(*env)->SetShortField(env, lpObject, PangoAttrColorFc.color_blue, (jshort)lpStruct->color.blue);
}
#endif
#ifndef NO_PangoAttrInt
typedef struct PangoAttrInt_FID_CACHE {
int cached;
jclass clazz;
jfieldID value;
} PangoAttrInt_FID_CACHE;
PangoAttrInt_FID_CACHE PangoAttrIntFc;
void cachePangoAttrIntFields(JNIEnv *env, jobject lpObject)
{
if (PangoAttrIntFc.cached) return;
cachePangoAttributeFields(env, lpObject);
PangoAttrIntFc.clazz = (*env)->GetObjectClass(env, lpObject);
PangoAttrIntFc.value = (*env)->GetFieldID(env, PangoAttrIntFc.clazz, "value", "I");
PangoAttrIntFc.cached = 1;
}
PangoAttrInt *getPangoAttrIntFields(JNIEnv *env, jobject lpObject, PangoAttrInt *lpStruct)
{
if (!PangoAttrIntFc.cached) cachePangoAttrIntFields(env, lpObject);
getPangoAttributeFields(env, lpObject, (PangoAttribute *)lpStruct);
lpStruct->value = (*env)->GetIntField(env, lpObject, PangoAttrIntFc.value);
return lpStruct;
}
void setPangoAttrIntFields(JNIEnv *env, jobject lpObject, PangoAttrInt *lpStruct)
{
if (!PangoAttrIntFc.cached) cachePangoAttrIntFields(env, lpObject);
setPangoAttributeFields(env, lpObject, (PangoAttribute *)lpStruct);
(*env)->SetIntField(env, lpObject, PangoAttrIntFc.value, (jint)lpStruct->value);
}
#endif
#ifndef NO_PangoAttribute
typedef struct PangoAttribute_FID_CACHE {
int cached;
jclass clazz;
jfieldID klass, start_index, end_index;
} PangoAttribute_FID_CACHE;
PangoAttribute_FID_CACHE PangoAttributeFc;
void cachePangoAttributeFields(JNIEnv *env, jobject lpObject)
{
if (PangoAttributeFc.cached) return;
PangoAttributeFc.clazz = (*env)->GetObjectClass(env, lpObject);
PangoAttributeFc.klass = (*env)->GetFieldID(env, PangoAttributeFc.clazz, "klass", I_J);
PangoAttributeFc.start_index = (*env)->GetFieldID(env, PangoAttributeFc.clazz, "start_index", "I");
PangoAttributeFc.end_index = (*env)->GetFieldID(env, PangoAttributeFc.clazz, "end_index", "I");
PangoAttributeFc.cached = 1;
}
PangoAttribute *getPangoAttributeFields(JNIEnv *env, jobject lpObject, PangoAttribute *lpStruct)
{
if (!PangoAttributeFc.cached) cachePangoAttributeFields(env, lpObject);
lpStruct->klass = (const PangoAttrClass *)(*env)->GetIntLongField(env, lpObject, PangoAttributeFc.klass);
lpStruct->start_index = (*env)->GetIntField(env, lpObject, PangoAttributeFc.start_index);
lpStruct->end_index = (*env)->GetIntField(env, lpObject, PangoAttributeFc.end_index);
return lpStruct;
}
void setPangoAttributeFields(JNIEnv *env, jobject lpObject, PangoAttribute *lpStruct)
{
if (!PangoAttributeFc.cached) cachePangoAttributeFields(env, lpObject);
(*env)->SetIntLongField(env, lpObject, PangoAttributeFc.klass, (jintLong)lpStruct->klass);
(*env)->SetIntField(env, lpObject, PangoAttributeFc.start_index, (jint)lpStruct->start_index);
(*env)->SetIntField(env, lpObject, PangoAttributeFc.end_index, (jint)lpStruct->end_index);
}
#endif
#ifndef NO_PangoItem
typedef struct PangoItem_FID_CACHE {
int cached;
jclass clazz;
jfieldID offset, length, num_chars, analysis_shape_engine, analysis_lang_engine, analysis_font, analysis_level, analysis_language, analysis_extra_attrs;
} PangoItem_FID_CACHE;
PangoItem_FID_CACHE PangoItemFc;
void cachePangoItemFields(JNIEnv *env, jobject lpObject)
{
if (PangoItemFc.cached) return;
PangoItemFc.clazz = (*env)->GetObjectClass(env, lpObject);
PangoItemFc.offset = (*env)->GetFieldID(env, PangoItemFc.clazz, "offset", "I");
PangoItemFc.length = (*env)->GetFieldID(env, PangoItemFc.clazz, "length", "I");
PangoItemFc.num_chars = (*env)->GetFieldID(env, PangoItemFc.clazz, "num_chars", "I");
PangoItemFc.analysis_shape_engine = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_shape_engine", I_J);
PangoItemFc.analysis_lang_engine = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_lang_engine", I_J);
PangoItemFc.analysis_font = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_font", I_J);
PangoItemFc.analysis_level = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_level", "B");
PangoItemFc.analysis_language = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_language", I_J);
PangoItemFc.analysis_extra_attrs = (*env)->GetFieldID(env, PangoItemFc.clazz, "analysis_extra_attrs", I_J);
PangoItemFc.cached = 1;
}
PangoItem *getPangoItemFields(JNIEnv *env, jobject lpObject, PangoItem *lpStruct)
{
if (!PangoItemFc.cached) cachePangoItemFields(env, lpObject);
lpStruct->offset = (*env)->GetIntField(env, lpObject, PangoItemFc.offset);
lpStruct->length = (*env)->GetIntField(env, lpObject, PangoItemFc.length);
lpStruct->num_chars = (*env)->GetIntField(env, lpObject, PangoItemFc.num_chars);
lpStruct->analysis.shape_engine = (PangoEngineShape *)(*env)->GetIntLongField(env, lpObject, PangoItemFc.analysis_shape_engine);
lpStruct->analysis.lang_engine = (PangoEngineLang *)(*env)->GetIntLongField(env, lpObject, PangoItemFc.analysis_lang_engine);
lpStruct->analysis.font = (PangoFont *)(*env)->GetIntLongField(env, lpObject, PangoItemFc.analysis_font);
lpStruct->analysis.level = (*env)->GetByteField(env, lpObject, PangoItemFc.analysis_level);
lpStruct->analysis.language = (PangoLanguage *)(*env)->GetIntLongField(env, lpObject, PangoItemFc.analysis_language);
lpStruct->analysis.extra_attrs = (GSList *)(