/******************************************************************************* * Copyright (c) 2000, 2013 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_GdkEventVisibility typedef struct GdkEventVisibility_FID_CACHE { int cached; jclass clazz; jfieldID window, send_event, state; } GdkEventVisibility_FID_CACHE; GdkEventVisibility_FID_CACHE GdkEventVisibilityFc; void cacheGdkEventVisibilityFields(JNIEnv *env, jobject lpObject) { if (GdkEventVisibilityFc.cached) return; cacheGdkEventFields(env, lpObject); GdkEventVisibilityFc.clazz = (*env)->GetObjectClass(env, lpObject); GdkEventVisibilityFc.window = (*env)->GetFieldID(env, GdkEventVisibilityFc.clazz, "window", I_J); GdkEventVisibilityFc.send_event = (*env)->GetFieldID(env, GdkEventVisibilityFc.clazz, "send_event", "B"); GdkEventVisibilityFc.state = (*env)->GetFieldID(env, GdkEventVisibilityFc.clazz, "state", "I"); GdkEventVisibilityFc.cached = 1; } GdkEventVisibility *getGdkEventVisibilityFields(JNIEnv *env, jobject lpObject, GdkEventVisibility *lpStruct) { if (!GdkEventVisibilityFc.cached) cacheGdkEventVisibilityFields(env, lpObject); getGdkEventFields(env, lpObject, (GdkEvent *)lpStruct); lpStruct->window = (GdkWindow *)(*env)->GetIntLongField(env, lpObject, GdkEventVisibilityFc.window); lpStruct->send_event = (gint8)(*env)->GetByteField(env, lpObject, GdkEventVisibilityFc.send_event); lpStruct->state = (GdkVisibilityState)(*env)->GetIntField(env, lpObject, GdkEventVisibilityFc.state); return lpStruct; } void setGdkEventVisibilityFields(JNIEnv *env, jobject lpObject, GdkEventVisibility *lpStruct) { if (!GdkEventVisibilityFc.cached) cacheGdkEventVisibilityFields(env, lpObject); setGdkEventFields(env, lpObject, (GdkEvent *)lpStruct); (*env)->SetIntLongField(env, lpObject, GdkEventVisibilityFc.window, (jintLong)lpStruct->window); (*env)->SetByteField(env, lpObject, GdkEventVisibilityFc.send_event, (jbyte)lpStruct->send_event); (*env)->SetIntField(env, lpObject, GdkEventVisibilityFc.state, (jint)lpStruct->state); } #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_GtkColorSelectionDialog typedef struct GtkColorSelectionDialog_FID_CACHE { int cached; jclass clazz; jfieldID colorsel, ok_button, cancel_button, help_button; } GtkColorSelectionDialog_FID_CACHE; GtkColorSelectionDialog_FID_CACHE GtkColorSelectionDialogFc; void cacheGtkColorSelectionDialogFields(JNIEnv *env, jobject lpObject) { if (GtkColorSelectionDialogFc.cached) return; GtkColorSelectionDialogFc.clazz = (*env)->GetObjectClass(env, lpObject); GtkColorSelectionDialogFc.colorsel = (*env)->GetFieldID(env, GtkColorSelectionDialogFc.clazz, "colorsel", I_J); GtkColorSelectionDialogFc.ok_button = (*env)->GetFieldID(env, GtkColorSelectionDialogFc.clazz, "ok_button", I_J); GtkColorSelectionDialogFc.cancel_button = (*env)->GetFieldID(env, GtkColorSelectionDialogFc.clazz, "cancel_button", I_J); GtkColorSelectionDialogFc.help_button = (*env)->GetFieldID(env, GtkColorSelectionDialogFc.clazz, "help_button", I_J); GtkColorSelectionDialogFc.cached = 1; } GtkColorSelectionDialog *getGtkColorSelectionDialogFields(JNIEnv *env, jobject lpObject, GtkColorSelectionDialog *lpStruct) { if (!GtkColorSelectionDialogFc.cached) cacheGtkColorSelectionDialogFields(env, lpObject); lpStruct->colorsel = (GtkWidget *)(*env)->GetIntLongField(env, lpObject, GtkColorSelectionDialogFc.colorsel); lpStruct->ok_button = (GtkWidget *)(*env)->GetIntLongField(env, lpObject, GtkColorSelectionDialogFc.ok_button); lpStruct->cancel_button = (GtkWidget *)(*env)->GetIntLongField(env, lpObject, GtkColorSelectionDialogFc.cancel_button); lpStruct->help_button = (GtkWidget *)(*env)->GetIntLongField(env, lpObject, GtkColorSelectionDialogFc.help_button); return lpStruct; } void setGtkColorSelectionDialogFields(JNIEnv *env, jobject lpObject, GtkColorSelectionDialog *lpStruct) { if (!GtkColorSelectionDialogFc.cached) cacheGtkColorSelectionDialogFields(env, lpObject); (*env)->SetIntLongField(env, lpObject, GtkColorSelectionDialogFc.colorsel, (jintLong)lpStruct->colorsel); (*env)->SetIntLongField(env, lpObject, GtkColorSelectionDialogFc.ok_button, (jintLong)lpStruct->ok_button); (*env)->SetIntLongField(env, lpObject, GtkColorSelectionDialogFc.cancel_button, (jintLong)lpStruct->cancel_button); (*env)->SetIntLongField(env, lpObject, GtkColorSelectionDialogFc.help_button, (jintLong)lpStruct->help_button); } #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_GtkSelectionData typedef struct GtkSelectionData_FID_CACHE { int cached; jclass clazz; jfieldID selection, target, type, format, data, length; } GtkSelectionData_FID_CACHE; GtkSelectionData_FID_CACHE GtkSelectionDataFc; void cacheGtkSelectionDataFields(JNIEnv *env, jobject lpObject) { if (GtkSelectionDataFc.cached) return; GtkSelectionDataFc.clazz = (*env)->GetObjectClass(env, lpObject); GtkSelectionDataFc.selection = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "selection", I_J); GtkSelectionDataFc.target = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "target", I_J); GtkSelectionDataFc.type = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "type", I_J); GtkSelectionDataFc.format = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "format", "I"); GtkSelectionDataFc.data = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "data", I_J); GtkSelectionDataFc.length = (*env)->GetFieldID(env, GtkSelectionDataFc.clazz, "length", "I"); GtkSelectionDataFc.cached = 1; } GtkSelectionData *getGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct) { if (!GtkSelectionDataFc.cached) cacheGtkSelectionDataFields(env, lpObject); lpStruct->selection = (GdkAtom)(*env)->GetIntLongField(env, lpObject, GtkSelectionDataFc.selection); lpStruct->target = (GdkAtom)(*env)->GetIntLongField(env, lpObject, GtkSelectionDataFc.target); lpStruct->type = (GdkAtom)(*env)->GetIntLongField(env, lpObject, GtkSelectionDataFc.type); lpStruct->format = (gint)(*env)->GetIntField(env, lpObject, GtkSelectionDataFc.format); lpStruct->data = (guchar *)(*env)->GetIntLongField(env, lpObject, GtkSelectionDataFc.data); lpStruct->length = (gint)(*env)->GetIntField(env, lpObject, GtkSelectionDataFc.length); return lpStruct; } void setGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct) { if (!GtkSelectionDataFc.cached) cacheGtkSelectionDataFields(env, lpObject); (*env)->SetIntLongField(env, lpObject, GtkSelectionDataFc.selection, (jintLong)lpStruct->selection); (*env)->SetIntLongField(env, lpObject, GtkSelectionDataFc.target, (jintLong)lpStruct->target); (*env)->SetIntLongField(env, lpObject, GtkSelectionDataFc.type, (jintLong)lpStruct->type); (*env)->SetIntField(env, lpObject, GtkSelectionDataFc.format, (jint)lpStruct->format); (*env)->SetIntLongField(env, lpObject, GtkSelectionDataFc.data, (jintLong)lpStruct->data); (*env)->SetIntField(env, lpObject, GtkSelectionDataFc.length, (jint)lpStruct->length); } #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 *)(*env)->GetIntLongField(env, lpObject, PangoItemFc.analysis_extra_attrs); return lpStruct; } void setPangoItemFields(JNIEnv *env, jobject lpObject, PangoItem *lpStruct) { if (!PangoItemFc.cached) cachePangoItemFields(env, lpObject); (*env)->SetIntField(env, lpObject, PangoItemFc.offset, (jint)lpStruct->offset); (*env)->SetIntField(env, lpObject, PangoItemFc.length, (jint)lpStruct->length); (*env)->SetIntField(env, lpObject, PangoItemFc.num_chars, (jint)lpStruct->num_chars); (*env)->SetIntLongField(env, lpObject, PangoItemFc.analysis_shape_engine, (jintLong)lpStruct->analysis.shape_engine); (*env)->SetIntLongField(env, lpObject, PangoItemFc.analysis_lang_engine, (jintLong)lpStruct->analysis.lang_engine); (*env)->SetIntLongField(env, lpObject, PangoItemFc.analysis_font, (jintLong)lpStruct->analysis.font); (*env)->SetByteField(env, lpObject, PangoItemFc.analysis_level, (jbyte)lpStruct->analysis.level); (*env)->SetIntLongField(env, lpObject, PangoItemFc.analysis_language, (jintLong)lpStruct->analysis.language); (*env)->SetIntLongField(env, lpObject, PangoItemFc.analysis_extra_attrs, (jintLong)lpStruct->analysis.extra_attrs); } #endif #ifndef NO_PangoLayoutLine typedef struct PangoLayoutLine_FID_CACHE { int cached; jclass clazz; jfieldID layout, start_index, length, runs; } PangoLayoutLine_FID_CACHE; PangoLayoutLine_FID_CACHE PangoLayoutLineFc; void cachePangoLayoutLineFields(JNIEnv *env, jobject lpObject) { if (PangoLayoutLineFc.cached) return; PangoLayoutLineFc.clazz = (*env)->GetObjectClass(env, lpObject); PangoLayoutLineFc.layout = (*env)->GetFieldID(env, PangoLayoutLineFc.clazz, "layout", I_J); PangoLayoutLineFc.start_index = (*env)->GetFieldID(env, PangoLayoutLineFc.clazz, "start_index", "I"); PangoLayoutLineFc.length = (*env)->GetFieldID(env, PangoLayoutLineFc.clazz, "length", "I"); PangoLayoutLineFc.runs = (*env)->GetFieldID(env, PangoLayoutLineFc.clazz, "runs", I_J); PangoLayoutLineFc.cached = 1; } PangoLayoutLine *getPangoLayoutLineFields(JNIEnv *env, jobject lpObject, PangoLayoutLine *lpStruct) { if (!PangoLayoutLineFc.cached) cachePangoLayoutLineFields(env, lpObject); lpStruct->layout = (PangoLayout *)(*env)->GetIntLongField(env, lpObject, PangoLayoutLineFc.layout); lpStruct->start_index = (*env)->GetIntField(env, lpObject, PangoLayoutLineFc.start_index); lpStruct->length = (*env)->GetIntField(env, lpObject, PangoLayoutLineFc.length); lpStruct->runs = (GSList *)(*env)->GetIntLongField(env, lpObject, PangoLayoutLineFc.runs); return lpStruct; } void setPangoLayoutLineFields(JNIEnv *env, jobject lpObject, PangoLayoutLine *lpStruct) { if (!PangoLayoutLineFc.cached) cachePangoLayoutLineFields(env, lpObject); (*env)->SetIntLongField(env, lpObject, PangoLayoutLineFc.layout, (jintLong)lpStruct->layout); (*env)->SetIntField(env, lpObject, PangoLayoutLineFc.start_index, (jint)lpStruct->start_index); (*env)->SetIntField(env, lpObject, PangoLayoutLineFc.length, (jint)lpStruct->length); (*env)->SetIntLongField(env, lpObject, PangoLayoutLineFc.runs, (jintLong)lpStruct->runs); } #endif #ifndef NO_PangoLayoutRun typedef struct PangoLayoutRun_FID_CACHE { int cached; jclass clazz; jfieldID item, glyphs; } PangoLayoutRun_FID_CACHE; PangoLayoutRun_FID_CACHE PangoLayoutRunFc; void cachePangoLayoutRunFields(JNIEnv *env, jobject lpObject) { if (PangoLayoutRunFc.cached) return; PangoLayoutRunFc.clazz = (*env)->GetObjectClass(env, lpObject); PangoLayoutRunFc.item = (*env)->GetFieldID(env, PangoLayoutRunFc.clazz, "item", I_J); PangoLayoutRunFc.glyphs = (*env)->GetFieldID(env, PangoLayoutRunFc.clazz, "glyphs", I_J); PangoLayoutRunFc.cached = 1; } PangoLayoutRun *getPangoLayoutRunFields(JNIEnv *env, jobject lpObject, PangoLayoutRun *lpStruct) { if (!PangoLayoutRunFc.cached) cachePangoLayoutRunFields(env, lpObject); lpStruct->item = (PangoItem *)(*env)->GetIntLongField(env, lpObject, PangoLayoutRunFc.item); lpStruct->glyphs = (PangoGlyphString *)(*env)->GetIntLongField(env, lpObject, PangoLayoutRunFc.glyphs); return lpStruct; } void setPangoLayoutRunFields(JNIEnv *env, jobject lpObject, PangoLayoutRun *lpStruct) { if (!PangoLayoutRunFc.cached) cachePangoLayoutRunFields(env, lpObject); (*env)->SetIntLongField(env, lpObject, PangoLayoutRunFc.item, (jintLong)lpStruct->item); (*env)->SetIntLongField(env, lpObject, PangoLayoutRunFc.glyphs, (jintLong)lpStruct->glyphs); } #endif #ifndef NO_PangoLogAttr typedef struct PangoLogAttr_FID_CACHE { int cached; jclass clazz; jfieldID is_line_break, is_mandatory_break, is_char_break, is_white, is_cursor_position, is_word_start, is_word_end, is_sentence_boundary, is_sentence_start, is_sentence_end; } PangoLogAttr_FID_CACHE; PangoLogAttr_FID_CACHE PangoLogAttrFc; void cachePangoLogAttrFields(JNIEnv *env, jobject lpObject) { if (PangoLogAttrFc.cached) return; PangoLogAttrFc.clazz = (*env)->GetObjectClass(env, lpObject); PangoLogAttrFc.is_line_break = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_line_break", "Z"); PangoLogAttrFc.is_mandatory_break = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_mandatory_break", "Z"); PangoLogAttrFc.is_char_break = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_char_break", "Z"); PangoLogAttrFc.is_white = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_white", "Z"); PangoLogAttrFc.is_cursor_position = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_cursor_position", "Z"); PangoLogAttrFc.is_word_start = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_word_start", "Z"); PangoLogAttrFc.is_word_end = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_word_end", "Z"); PangoLogAttrFc.is_sentence_boundary = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_sentence_boundary", "Z"); PangoLogAttrFc.is_sentence_start = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_sentence_start", "Z"); PangoLogAttrFc.is_sentence_end = (*env)->GetFieldID(env, PangoLogAttrFc.clazz, "is_sentence_end", "Z"); PangoLogAttrFc.cached = 1; } PangoLogAttr *getPangoLogAttrFields(JNIEnv *env, jobject lpObject, PangoLogAttr *lpStruct) { if (!PangoLogAttrFc.cached) cachePangoLogAttrFields(env, lpObject); lpStruct->is_line_break = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_line_break); lpStruct->is_mandatory_break = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_mandatory_break); lpStruct->is_char_break = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_char_break); lpStruct->is_white = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_white); lpStruct->is_cursor_position = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_cursor_position); lpStruct->is_word_start = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_word_start); lpStruct->is_word_end = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_word_end); lpStruct->is_sentence_boundary = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_boundary); lpStruct->is_sentence_start = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_start); lpStruct->is_sentence_end = (*env)->GetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_end); return lpStruct; } void setPangoLogAttrFields(JNIEnv *env, jobject lpObject, PangoLogAttr *lpStruct) { if (!PangoLogAttrFc.cached) cachePangoLogAttrFields(env, lpObject); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_line_break, (jboolean)lpStruct->is_line_break); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_mandatory_break, (jboolean)lpStruct->is_mandatory_break); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_char_break, (jboolean)lpStruct->is_char_break); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_white, (jboolean)lpStruct->is_white); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_cursor_position, (jboolean)lpStruct->is_cursor_position); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_word_start, (jboolean)lpStruct->is_word_start); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_word_end, (jboolean)lpStruct->is_word_end); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_boundary, (jboolean)lpStruct->is_sentence_boundary); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_start, (jboolean)lpStruct->is_sentence_start); (*env)->SetBooleanField(env, lpObject, PangoLogAttrFc.is_sentence_end, (jboolean)lpStruct->is_sentence_end); } #endif #ifndef NO_PangoRectangle typedef struct PangoRectangle_FID_CACHE { int cached; jclass clazz; jfieldID x, y, width, height; } PangoRectangle_FID_CACHE; PangoRectangle_FID_CACHE PangoRectangleFc; void cachePangoRectangleFields(JNIEnv *env, jobject lpObject) { if (PangoRectangleFc.cached) return; PangoRectangleFc.clazz = (*env)->GetObjectClass(env, lpObject); PangoRectangleFc.x = (*env)->GetFieldID(env, PangoRectangleFc.clazz, "x", "I"); PangoRectangleFc.y = (*env)->GetFieldID(env, PangoRectangleFc.clazz, "y", "I"); PangoRectangleFc.width = (*env)->GetFieldID(env, PangoRectangleFc.clazz, "width", "I"); PangoRectangleFc.height = (*env)->GetFieldID(env, PangoRectangleFc.clazz, "height", "I"); PangoRectangleFc.cached = 1; } PangoRectangle *getPangoRectangleFields(JNIEnv *env, jobject lpObject, PangoRectangle *lpStruct) { if (!PangoRectangleFc.cached) cachePangoRectangleFields(env, lpObject); lpStruct->x = (*env)->GetIntField(env, lpObject, PangoRectangleFc.x); lpStruct->y = (*env)->GetIntField(env, lpObject, PangoRectangleFc.y); lpStruct->width = (*env)->GetIntField(env, lpObject, PangoRectangleFc.width); lpStruct->height = (*env)->GetIntField(env, lpObject, PangoRectangleFc.height); return lpStruct; } void setPangoRectangleFields(JNIEnv *env, jobject lpObject, PangoRectangle *lpStruct) { if (!PangoRectangleFc.cached) cachePangoRectangleFields(env, lpObject); (*env)->SetIntField(env, lpObject, PangoRectangleFc.x, (jint)lpStruct->x); (*env)->SetIntField(env, lpObject, PangoRectangleFc.y, (jint)lpStruct->y); (*env)->SetIntField(env, lpObject, PangoRectangleFc.width, (jint)lpStruct->width); (*env)->SetIntField(env, lpObject, PangoRectangleFc.height, (jint)lpStruct->height); } #endif #ifndef NO_XAnyEvent typedef struct XAnyEvent_FID_CACHE { int cached; jclass clazz; jfieldID serial, send_event, display, window; } XAnyEvent_FID_CACHE; XAnyEvent_FID_CACHE XAnyEventFc; void cacheXAnyEventFields(JNIEnv *env, jobject lpObject) { if (XAnyEventFc.cached) return; cacheXEventFields(env, lpObject); XAnyEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XAnyEventFc.serial = (*env)->GetFieldID(env, XAnyEventFc.clazz, "serial", I_J); XAnyEventFc.send_event = (*env)->GetFieldID(env, XAnyEventFc.clazz, "send_event", "I"); XAnyEventFc.display = (*env)->GetFieldID(env, XAnyEventFc.clazz, "display", I_J); XAnyEventFc.window = (*env)->GetFieldID(env, XAnyEventFc.clazz, "window", I_J); XAnyEventFc.cached = 1; } XAnyEvent *getXAnyEventFields(JNIEnv *env, jobject lpObject, XAnyEvent *lpStruct) { if (!XAnyEventFc.cached) cacheXAnyEventFields(env, lpObject); getXEventFields(env, lpObject, (XEvent *)lpStruct); lpStruct->serial = (*env)->GetIntLongField(env, lpObject, XAnyEventFc.serial); lpStruct->send_event = (*env)->GetIntField(env, lpObject, XAnyEventFc.send_event); lpStruct->display = (Display *)(*env)->GetIntLongField(env, lpObject, XAnyEventFc.display); lpStruct->window = (Window)(*env)->GetIntLongField(env, lpObject, XAnyEventFc.window); return lpStruct; } void setXAnyEventFields(JNIEnv *env, jobject lpObject, XAnyEvent *lpStruct) { if (!XAnyEventFc.cached) cacheXAnyEventFields(env, lpObject); setXEventFields(env, lpObject, (XEvent *)lpStruct); (*env)->SetIntLongField(env, lpObject, XAnyEventFc.serial, (jintLong)lpStruct->serial); (*env)->SetIntField(env, lpObject, XAnyEventFc.send_event, (jint)lpStruct->send_event); (*env)->SetIntLongField(env, lpObject, XAnyEventFc.display, (jintLong)lpStruct->display); (*env)->SetIntLongField(env, lpObject, XAnyEventFc.window, (jintLong)lpStruct->window); } #endif #ifndef NO_XClientMessageEvent typedef struct XClientMessageEvent_FID_CACHE { int cached; jclass clazz; jfieldID type, serial, send_event, display, window, message_type, format, data; } XClientMessageEvent_FID_CACHE; XClientMessageEvent_FID_CACHE XClientMessageEventFc; void cacheXClientMessageEventFields(JNIEnv *env, jobject lpObject) { if (XClientMessageEventFc.cached) return; XClientMessageEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XClientMessageEventFc.type = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "type", "I"); XClientMessageEventFc.serial = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "serial", I_J); XClientMessageEventFc.send_event = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "send_event", "Z"); XClientMessageEventFc.display = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "display", I_J); XClientMessageEventFc.window = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "window", I_J); XClientMessageEventFc.message_type = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "message_type", I_J); XClientMessageEventFc.format = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "format", "I"); XClientMessageEventFc.data = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "data", I_JArray); XClientMessageEventFc.cached = 1; } XClientMessageEvent *getXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct) { if (!XClientMessageEventFc.cached) cacheXClientMessageEventFields(env, lpObject); lpStruct->type = (*env)->GetIntField(env, lpObject, XClientMessageEventFc.type); lpStruct->serial = (*env)->GetIntLongField(env, lpObject, XClientMessageEventFc.serial); lpStruct->send_event = (*env)->GetBooleanField(env, lpObject, XClientMessageEventFc.send_event); lpStruct->display = (Display *)(*env)->GetIntLongField(env, lpObject, XClientMessageEventFc.display); lpStruct->window = (Window)(*env)->GetIntLongField(env, lpObject, XClientMessageEventFc.window); lpStruct->message_type = (Atom)(*env)->GetIntLongField(env, lpObject, XClientMessageEventFc.message_type); lpStruct->format = (*env)->GetIntField(env, lpObject, XClientMessageEventFc.format); { jintLongArray lpObject1 = (jintLongArray)(*env)->GetObjectField(env, lpObject, XClientMessageEventFc.data); (*env)->GetIntLongArrayRegion(env, lpObject1, 0, sizeof(lpStruct->data.l) / sizeof(jintLong), (jintLong *)lpStruct->data.l); } return lpStruct; } void setXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct) { if (!XClientMessageEventFc.cached) cacheXClientMessageEventFields(env, lpObject); (*env)->SetIntField(env, lpObject, XClientMessageEventFc.type, (jint)lpStruct->type); (*env)->SetIntLongField(env, lpObject, XClientMessageEventFc.serial, (jintLong)lpStruct->serial); (*env)->SetBooleanField(env, lpObject, XClientMessageEventFc.send_event, (jboolean)lpStruct->send_event); (*env)->SetIntLongField(env, lpObject, XClientMessageEventFc.display, (jintLong)lpStruct->display); (*env)->SetIntLongField(env, lpObject, XClientMessageEventFc.window, (jintLong)lpStruct->window); (*env)->SetIntLongField(env, lpObject, XClientMessageEventFc.message_type, (jintLong)lpStruct->message_type); (*env)->SetIntField(env, lpObject, XClientMessageEventFc.format, (jint)lpStruct->format); { jintLongArray lpObject1 = (jintLongArray)(*env)->GetObjectField(env, lpObject, XClientMessageEventFc.data); (*env)->SetIntLongArrayRegion(env, lpObject1, 0, sizeof(lpStruct->data.l) / sizeof(jintLong), (jintLong *)lpStruct->data.l); } } #endif #ifndef NO_XCrossingEvent typedef struct XCrossingEvent_FID_CACHE { int cached; jclass clazz; jfieldID root, subwindow, time, x, y, x_root, y_root, mode, detail, same_screen, focus, state; } XCrossingEvent_FID_CACHE; XCrossingEvent_FID_CACHE XCrossingEventFc; void cacheXCrossingEventFields(JNIEnv *env, jobject lpObject) { if (XCrossingEventFc.cached) return; cacheXAnyEventFields(env, lpObject); XCrossingEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XCrossingEventFc.root = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "root", I_J); XCrossingEventFc.subwindow = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "subwindow", I_J); XCrossingEventFc.time = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "time", "I"); XCrossingEventFc.x = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "x", "I"); XCrossingEventFc.y = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "y", "I"); XCrossingEventFc.x_root = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "x_root", "I"); XCrossingEventFc.y_root = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "y_root", "I"); XCrossingEventFc.mode = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "mode", "I"); XCrossingEventFc.detail = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "detail", "I"); XCrossingEventFc.same_screen = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "same_screen", "Z"); XCrossingEventFc.focus = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "focus", "Z"); XCrossingEventFc.state = (*env)->GetFieldID(env, XCrossingEventFc.clazz, "state", "I"); XCrossingEventFc.cached = 1; } XCrossingEvent *getXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpStruct) { if (!XCrossingEventFc.cached) cacheXCrossingEventFields(env, lpObject); getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); lpStruct->root = (Window)(*env)->GetIntLongField(env, lpObject, XCrossingEventFc.root); lpStruct->subwindow = (Window)(*env)->GetIntLongField(env, lpObject, XCrossingEventFc.subwindow); lpStruct->time = (Time)(*env)->GetIntField(env, lpObject, XCrossingEventFc.time); lpStruct->x = (*env)->GetIntField(env, lpObject, XCrossingEventFc.x); lpStruct->y = (*env)->GetIntField(env, lpObject, XCrossingEventFc.y); lpStruct->x_root = (*env)->GetIntField(env, lpObject, XCrossingEventFc.x_root); lpStruct->y_root = (*env)->GetIntField(env, lpObject, XCrossingEventFc.y_root); lpStruct->mode = (*env)->GetIntField(env, lpObject, XCrossingEventFc.mode); lpStruct->detail = (*env)->GetIntField(env, lpObject, XCrossingEventFc.detail); lpStruct->same_screen = (Bool)(*env)->GetBooleanField(env, lpObject, XCrossingEventFc.same_screen); lpStruct->focus = (Bool)(*env)->GetBooleanField(env, lpObject, XCrossingEventFc.focus); lpStruct->state = (unsigned int)(*env)->GetIntField(env, lpObject, XCrossingEventFc.state); return lpStruct; } void setXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpStruct) { if (!XCrossingEventFc.cached) cacheXCrossingEventFields(env, lpObject); setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); (*env)->SetIntLongField(env, lpObject, XCrossingEventFc.root, (jintLong)lpStruct->root); (*env)->SetIntLongField(env, lpObject, XCrossingEventFc.subwindow, (jintLong)lpStruct->subwindow); (*env)->SetIntField(env, lpObject, XCrossingEventFc.time, (jint)lpStruct->time); (*env)->SetIntField(env, lpObject, XCrossingEventFc.x, (jint)lpStruct->x); (*env)->SetIntField(env, lpObject, XCrossingEventFc.y, (jint)lpStruct->y); (*env)->SetIntField(env, lpObject, XCrossingEventFc.x_root, (jint)lpStruct->x_root); (*env)->SetIntField(env, lpObject, XCrossingEventFc.y_root, (jint)lpStruct->y_root); (*env)->SetIntField(env, lpObject, XCrossingEventFc.mode, (jint)lpStruct->mode); (*env)->SetIntField(env, lpObject, XCrossingEventFc.detail, (jint)lpStruct->detail); (*env)->SetBooleanField(env, lpObject, XCrossingEventFc.same_screen, (jboolean)lpStruct->same_screen); (*env)->SetBooleanField(env, lpObject, XCrossingEventFc.focus, (jboolean)lpStruct->focus); (*env)->SetIntField(env, lpObject, XCrossingEventFc.state, (jint)lpStruct->state); } #endif #ifndef NO_XEvent typedef struct XEvent_FID_CACHE { int cached; jclass clazz; jfieldID type; } XEvent_FID_CACHE; XEvent_FID_CACHE XEventFc; void cacheXEventFields(JNIEnv *env, jobject lpObject) { if (XEventFc.cached) return; XEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XEventFc.type = (*env)->GetFieldID(env, XEventFc.clazz, "type", "I"); XEventFc.cached = 1; } XEvent *getXEventFields(JNIEnv *env, jobject lpObject, XEvent *lpStruct) { if (!XEventFc.cached) cacheXEventFields(env, lpObject); lpStruct->type = (*env)->GetIntField(env, lpObject, XEventFc.type); return lpStruct; } void setXEventFields(JNIEnv *env, jobject lpObject, XEvent *lpStruct) { if (!XEventFc.cached) cacheXEventFields(env, lpObject); (*env)->SetIntField(env, lpObject, XEventFc.type, (jint)lpStruct->type); } #endif #ifndef NO_XExposeEvent typedef struct XExposeEvent_FID_CACHE { int cached; jclass clazz; jfieldID x, y, width, height, count; } XExposeEvent_FID_CACHE; XExposeEvent_FID_CACHE XExposeEventFc; void cacheXExposeEventFields(JNIEnv *env, jobject lpObject) { if (XExposeEventFc.cached) return; cacheXAnyEventFields(env, lpObject); XExposeEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XExposeEventFc.x = (*env)->GetFieldID(env, XExposeEventFc.clazz, "x", "I"); XExposeEventFc.y = (*env)->GetFieldID(env, XExposeEventFc.clazz, "y", "I"); XExposeEventFc.width = (*env)->GetFieldID(env, XExposeEventFc.clazz, "width", "I"); XExposeEventFc.height = (*env)->GetFieldID(env, XExposeEventFc.clazz, "height", "I"); XExposeEventFc.count = (*env)->GetFieldID(env, XExposeEventFc.clazz, "count", "I"); XExposeEventFc.cached = 1; } XExposeEvent *getXExposeEventFields(JNIEnv *env, jobject lpObject, XExposeEvent *lpStruct) { if (!XExposeEventFc.cached) cacheXExposeEventFields(env, lpObject); getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); lpStruct->x = (*env)->GetIntField(env, lpObject, XExposeEventFc.x); lpStruct->y = (*env)->GetIntField(env, lpObject, XExposeEventFc.y); lpStruct->width = (*env)->GetIntField(env, lpObject, XExposeEventFc.width); lpStruct->height = (*env)->GetIntField(env, lpObject, XExposeEventFc.height); lpStruct->count = (*env)->GetIntField(env, lpObject, XExposeEventFc.count); return lpStruct; } void setXExposeEventFields(JNIEnv *env, jobject lpObject, XExposeEvent *lpStruct) { if (!XExposeEventFc.cached) cacheXExposeEventFields(env, lpObject); setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); (*env)->SetIntField(env, lpObject, XExposeEventFc.x, (jint)lpStruct->x); (*env)->SetIntField(env, lpObject, XExposeEventFc.y, (jint)lpStruct->y); (*env)->SetIntField(env, lpObject, XExposeEventFc.width, (jint)lpStruct->width); (*env)->SetIntField(env, lpObject, XExposeEventFc.height, (jint)lpStruct->height); (*env)->SetIntField(env, lpObject, XExposeEventFc.count, (jint)lpStruct->count); } #endif #ifndef NO_XFocusChangeEvent typedef struct XFocusChangeEvent_FID_CACHE { int cached; jclass clazz; jfieldID mode, detail; } XFocusChangeEvent_FID_CACHE; XFocusChangeEvent_FID_CACHE XFocusChangeEventFc; void cacheXFocusChangeEventFields(JNIEnv *env, jobject lpObject) { if (XFocusChangeEventFc.cached) return; cacheXAnyEventFields(env, lpObject); XFocusChangeEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XFocusChangeEventFc.mode = (*env)->GetFieldID(env, XFocusChangeEventFc.clazz, "mode", "I"); XFocusChangeEventFc.detail = (*env)->GetFieldID(env, XFocusChangeEventFc.clazz, "detail", "I"); XFocusChangeEventFc.cached = 1; } XFocusChangeEvent *getXFocusChangeEventFields(JNIEnv *env, jobject lpObject, XFocusChangeEvent *lpStruct) { if (!XFocusChangeEventFc.cached) cacheXFocusChangeEventFields(env, lpObject); getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); lpStruct->mode = (*env)->GetIntField(env, lpObject, XFocusChangeEventFc.mode); lpStruct->detail = (*env)->GetIntField(env, lpObject, XFocusChangeEventFc.detail); return lpStruct; } void setXFocusChangeEventFields(JNIEnv *env, jobject lpObject, XFocusChangeEvent *lpStruct) { if (!XFocusChangeEventFc.cached) cacheXFocusChangeEventFields(env, lpObject); setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); (*env)->SetIntField(env, lpObject, XFocusChangeEventFc.mode, (jint)lpStruct->mode); (*env)->SetIntField(env, lpObject, XFocusChangeEventFc.detail, (jint)lpStruct->detail); } #endif #ifndef NO_XRenderPictureAttributes typedef struct XRenderPictureAttributes_FID_CACHE { int cached; jclass clazz; jfieldID repeat, alpha_map, alpha_x_origin, alpha_y_origin, clip_x_origin, clip_y_origin, clip_mask, graphics_exposures, subwindow_mode, poly_edge, poly_mode, dither, component_alpha; } XRenderPictureAttributes_FID_CACHE; XRenderPictureAttributes_FID_CACHE XRenderPictureAttributesFc; void cacheXRenderPictureAttributesFields(JNIEnv *env, jobject lpObject) { if (XRenderPictureAttributesFc.cached) return; XRenderPictureAttributesFc.clazz = (*env)->GetObjectClass(env, lpObject); XRenderPictureAttributesFc.repeat = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "repeat", "Z"); XRenderPictureAttributesFc.alpha_map = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "alpha_map", I_J); XRenderPictureAttributesFc.alpha_x_origin = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "alpha_x_origin", "I"); XRenderPictureAttributesFc.alpha_y_origin = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "alpha_y_origin", "I"); XRenderPictureAttributesFc.clip_x_origin = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "clip_x_origin", "I"); XRenderPictureAttributesFc.clip_y_origin = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "clip_y_origin", "I"); XRenderPictureAttributesFc.clip_mask = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "clip_mask", I_J); XRenderPictureAttributesFc.graphics_exposures = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "graphics_exposures", "Z"); XRenderPictureAttributesFc.subwindow_mode = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "subwindow_mode", "I"); XRenderPictureAttributesFc.poly_edge = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "poly_edge", "I"); XRenderPictureAttributesFc.poly_mode = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "poly_mode", "I"); XRenderPictureAttributesFc.dither = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "dither", I_J); XRenderPictureAttributesFc.component_alpha = (*env)->GetFieldID(env, XRenderPictureAttributesFc.clazz, "component_alpha", "Z"); XRenderPictureAttributesFc.cached = 1; } XRenderPictureAttributes *getXRenderPictureAttributesFields(JNIEnv *env, jobject lpObject, XRenderPictureAttributes *lpStruct) { if (!XRenderPictureAttributesFc.cached) cacheXRenderPictureAttributesFields(env, lpObject); lpStruct->repeat = (*env)->GetBooleanField(env, lpObject, XRenderPictureAttributesFc.repeat); lpStruct->alpha_map = (*env)->GetIntLongField(env, lpObject, XRenderPictureAttributesFc.alpha_map); lpStruct->alpha_x_origin = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.alpha_x_origin); lpStruct->alpha_y_origin = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.alpha_y_origin); lpStruct->clip_x_origin = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.clip_x_origin); lpStruct->clip_y_origin = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.clip_y_origin); lpStruct->clip_mask = (*env)->GetIntLongField(env, lpObject, XRenderPictureAttributesFc.clip_mask); lpStruct->graphics_exposures = (*env)->GetBooleanField(env, lpObject, XRenderPictureAttributesFc.graphics_exposures); lpStruct->subwindow_mode = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.subwindow_mode); lpStruct->poly_edge = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.poly_edge); lpStruct->poly_mode = (*env)->GetIntField(env, lpObject, XRenderPictureAttributesFc.poly_mode); lpStruct->dither = (*env)->GetIntLongField(env, lpObject, XRenderPictureAttributesFc.dither); lpStruct->component_alpha = (*env)->GetBooleanField(env, lpObject, XRenderPictureAttributesFc.component_alpha); return lpStruct; } void setXRenderPictureAttributesFields(JNIEnv *env, jobject lpObject, XRenderPictureAttributes *lpStruct) { if (!XRenderPictureAttributesFc.cached) cacheXRenderPictureAttributesFields(env, lpObject); (*env)->SetBooleanField(env, lpObject, XRenderPictureAttributesFc.repeat, (jboolean)lpStruct->repeat); (*env)->SetIntLongField(env, lpObject, XRenderPictureAttributesFc.alpha_map, (jintLong)lpStruct->alpha_map); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.alpha_x_origin, (jint)lpStruct->alpha_x_origin); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.alpha_y_origin, (jint)lpStruct->alpha_y_origin); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.clip_x_origin, (jint)lpStruct->clip_x_origin); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.clip_y_origin, (jint)lpStruct->clip_y_origin); (*env)->SetIntLongField(env, lpObject, XRenderPictureAttributesFc.clip_mask, (jintLong)lpStruct->clip_mask); (*env)->SetBooleanField(env, lpObject, XRenderPictureAttributesFc.graphics_exposures, (jboolean)lpStruct->graphics_exposures); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.subwindow_mode, (jint)lpStruct->subwindow_mode); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.poly_edge, (jint)lpStruct->poly_edge); (*env)->SetIntField(env, lpObject, XRenderPictureAttributesFc.poly_mode, (jint)lpStruct->poly_mode); (*env)->SetIntLongField(env, lpObject, XRenderPictureAttributesFc.dither, (jintLong)lpStruct->dither); (*env)->SetBooleanField(env, lpObject, XRenderPictureAttributesFc.component_alpha, (jboolean)lpStruct->component_alpha); } #endif #ifndef NO_XVisibilityEvent typedef struct XVisibilityEvent_FID_CACHE { int cached; jclass clazz; jfieldID state; } XVisibilityEvent_FID_CACHE; XVisibilityEvent_FID_CACHE XVisibilityEventFc; void cacheXVisibilityEventFields(JNIEnv *env, jobject lpObject) { if (XVisibilityEventFc.cached) return; cacheXAnyEventFields(env, lpObject); XVisibilityEventFc.clazz = (*env)->GetObjectClass(env, lpObject); XVisibilityEventFc.state = (*env)->GetFieldID(env, XVisibilityEventFc.clazz, "state", "I"); XVisibilityEventFc.cached = 1; } XVisibilityEvent *getXVisibilityEventFields(JNIEnv *env, jobject lpObject, XVisibilityEvent *lpStruct) { if (!XVisibilityEventFc.cached) cacheXVisibilityEventFields(env, lpObject); getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); lpStruct->state = (*env)->GetIntField(env, lpObject, XVisibilityEventFc.state); return lpStruct; } void setXVisibilityEventFields(JNIEnv *env, jobject lpObject, XVisibilityEvent *lpStruct) { if (!XVisibilityEventFc.cached) cacheXVisibilityEventFields(env, lpObject); setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct); (*env)->SetIntField(env, lpObject, XVisibilityEventFc.state, (jint)lpStruct->state); } #endif #ifndef NO_XWindowChanges typedef struct XWindowChanges_FID_CACHE { int cached; jclass clazz; jfieldID x, y, width, height, border_width, sibling, stack_mode; } XWindowChanges_FID_CACHE; XWindowChanges_FID_CACHE XWindowChangesFc; void cacheXWindowChangesFields(JNIEnv *env, jobject lpObject) { if (XWindowChangesFc.cached) return; XWindowChangesFc.clazz = (*env)->GetObjectClass(env, lpObject); XWindowChangesFc.x = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "x", "I"); XWindowChangesFc.y = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "y", "I"); XWindowChangesFc.width = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "width", "I"); XWindowChangesFc.height = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "height", "I"); XWindowChangesFc.border_width = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "border_width", "I"); XWindowChangesFc.sibling = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "sibling", I_J); XWindowChangesFc.stack_mode = (*env)->GetFieldID(env, XWindowChangesFc.clazz, "stack_mode", "I"); XWindowChangesFc.cached = 1; } XWindowChanges *getXWindowChangesFields(JNIEnv *env, jobject lpObject, XWindowChanges *lpStruct) { if (!XWindowChangesFc.cached) cacheXWindowChangesFields(env, lpObject); lpStruct->x = (*env)->GetIntField(env, lpObject, XWindowChangesFc.x); lpStruct->y = (*env)->GetIntField(env, lpObject, XWindowChangesFc.y); lpStruct->width = (*env)->GetIntField(env, lpObject, XWindowChangesFc.width); lpStruct->height = (*env)->GetIntField(env, lpObject, XWindowChangesFc.height); lpStruct->border_width = (*env)->GetIntField(env, lpObject, XWindowChangesFc.border_width); lpStruct->sibling = (*env)->GetIntLongField(env, lpObject, XWindowChangesFc.sibling); lpStruct->stack_mode = (*env)->GetIntField(env, lpObject, XWindowChangesFc.stack_mode); return lpStruct; } void setXWindowChangesFields(JNIEnv *env, jobject lpObject, XWindowChanges *lpStruct) { if (!XWindowChangesFc.cached) cacheXWindowChangesFields(env, lpObject); (*env)->SetIntField(env, lpObject, XWindowChangesFc.x, (jint)lpStruct->x); (*env)->SetIntField(env, lpObject, XWindowChangesFc.y, (jint)lpStruct->y); (*env)->SetIntField(env, lpObject, XWindowChangesFc.width, (jint)lpStruct->width); (*env)->SetIntField(env, lpObject, XWindowChangesFc.height, (jint)lpStruct->height); (*env)->SetIntField(env, lpObject, XWindowChangesFc.border_width, (jint)lpStruct->border_width); (*env)->SetIntLongField(env, lpObject, XWindowChangesFc.sibling, (jintLong)lpStruct->sibling); (*env)->SetIntField(env, lpObject, XWindowChangesFc.stack_mode, (jint)lpStruct->stack_mode); } #endif