bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/os.c

/*******************************************************************************
 * Copyright (c) 2000, 2008 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"
#include "os_stats.h"

#define OS_NATIVE(func) Java_org_eclipse_swt_internal_gtk_OS_##func

#ifndef NO_Call
JNIEXPORT jint JNICALL OS_NATIVE(Call)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, Call_FUNC);
	rc = (jint)((jint (*)())arg0)(arg1, arg2, arg3);
	OS_NATIVE_EXIT(env, that, Call_FUNC);
	return rc;
}
#endif

#ifndef NO_GDK_1EVENT_1TYPE
JNIEXPORT jint JNICALL OS_NATIVE(GDK_1EVENT_1TYPE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GDK_1EVENT_1TYPE_FUNC);
	rc = (jint)GDK_EVENT_TYPE((GdkEvent *)arg0);
	OS_NATIVE_EXIT(env, that, GDK_1EVENT_1TYPE_FUNC);
	return rc;
}
#endif

#ifndef NO_GDK_1EVENT_1WINDOW
JNIEXPORT jint JNICALL OS_NATIVE(GDK_1EVENT_1WINDOW)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GDK_1EVENT_1WINDOW_FUNC);
	rc = (jint)GDK_EVENT_WINDOW((GdkEventAny *)arg0);
	OS_NATIVE_EXIT(env, that, GDK_1EVENT_1WINDOW_FUNC);
	return rc;
}
#endif

#ifndef NO_GInterfaceInfo_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GInterfaceInfo_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GInterfaceInfo_1sizeof_FUNC);
	rc = (jint)GInterfaceInfo_sizeof();
	OS_NATIVE_EXIT(env, that, GInterfaceInfo_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GPollFD_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GPollFD_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GPollFD_1sizeof_FUNC);
	rc = (jint)GPollFD_sizeof();
	OS_NATIVE_EXIT(env, that, GPollFD_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1ACCEL_1LABEL_1GET_1ACCEL_1STRING
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1ACCEL_1LABEL_1GET_1ACCEL_1STRING)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1ACCEL_1LABEL_1GET_1ACCEL_1STRING_FUNC);
	rc = (jint)GTK_ACCEL_LABEL_GET_ACCEL_STRING((GtkAccelLabel *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1ACCEL_1LABEL_1GET_1ACCEL_1STRING_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1ACCEL_1LABEL_1SET_1ACCEL_1STRING
JNIEXPORT void JNICALL OS_NATIVE(GTK_1ACCEL_1LABEL_1SET_1ACCEL_1STRING)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1ACCEL_1LABEL_1SET_1ACCEL_1STRING_FUNC);
	GTK_ACCEL_LABEL_SET_ACCEL_STRING((GtkAccelLabel *)arg0, (gchar *)arg1);
	OS_NATIVE_EXIT(env, that, GTK_1ACCEL_1LABEL_1SET_1ACCEL_1STRING_FUNC);
}
#endif

#ifndef NO_GTK_1ENTRY_1IM_1CONTEXT
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1ENTRY_1IM_1CONTEXT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1ENTRY_1IM_1CONTEXT_FUNC);
	rc = (jint)GTK_ENTRY_IM_CONTEXT((GtkEntry *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1ENTRY_1IM_1CONTEXT_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1SCROLLED_1WINDOW_1HSCROLLBAR
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1SCROLLED_1WINDOW_1HSCROLLBAR)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1SCROLLED_1WINDOW_1HSCROLLBAR_FUNC);
	rc = (jint)GTK_SCROLLED_WINDOW_HSCROLLBAR((GtkScrolledWindow *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1SCROLLED_1WINDOW_1HSCROLLBAR_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1SCROLLED_1WINDOW_1SCROLLBAR_1SPACING
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1SCROLLED_1WINDOW_1SCROLLBAR_1SPACING)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1SCROLLED_1WINDOW_1SCROLLBAR_1SPACING_FUNC);
	rc = (jint)GTK_SCROLLED_WINDOW_SCROLLBAR_SPACING((GtkScrolledWindow *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1SCROLLED_1WINDOW_1SCROLLBAR_1SPACING_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1SCROLLED_1WINDOW_1VSCROLLBAR
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1SCROLLED_1WINDOW_1VSCROLLBAR)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1SCROLLED_1WINDOW_1VSCROLLBAR_FUNC);
	rc = (jint)GTK_SCROLLED_WINDOW_VSCROLLBAR((GtkScrolledWindow *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1SCROLLED_1WINDOW_1VSCROLLBAR_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1TEXTVIEW_1IM_1CONTEXT
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1TEXTVIEW_1IM_1CONTEXT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1TEXTVIEW_1IM_1CONTEXT_FUNC);
	rc = (jint)GTK_TEXTVIEW_IM_CONTEXT((GtkTextView *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1TEXTVIEW_1IM_1CONTEXT_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1TOOLTIPS_1SET_1ACTIVE
JNIEXPORT void JNICALL OS_NATIVE(GTK_1TOOLTIPS_1SET_1ACTIVE)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1TOOLTIPS_1SET_1ACTIVE_FUNC);
	GTK_TOOLTIPS_SET_ACTIVE((GtkTooltips *)arg0, (GtkTooltipsData *)arg1);
	OS_NATIVE_EXIT(env, that, GTK_1TOOLTIPS_1SET_1ACTIVE_FUNC);
}
#endif

#ifndef NO_GTK_1TOOLTIPS_1TIP_1WINDOW
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1TOOLTIPS_1TIP_1WINDOW)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1TOOLTIPS_1TIP_1WINDOW_FUNC);
	rc = (jint)GTK_TOOLTIPS_TIP_WINDOW((GtkTooltips *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1TOOLTIPS_1TIP_1WINDOW_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1HEIGHT
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1HEIGHT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1HEIGHT_FUNC);
	rc = (jint)GTK_WIDGET_HEIGHT((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1HEIGHT_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1REQUISITION_1HEIGHT
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1REQUISITION_1HEIGHT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1REQUISITION_1HEIGHT_FUNC);
	rc = (jint)GTK_WIDGET_REQUISITION_HEIGHT((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1REQUISITION_1HEIGHT_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1REQUISITION_1WIDTH
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1REQUISITION_1WIDTH)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1REQUISITION_1WIDTH_FUNC);
	rc = (jint)GTK_WIDGET_REQUISITION_WIDTH((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1REQUISITION_1WIDTH_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1SET_1HEIGHT
JNIEXPORT void JNICALL OS_NATIVE(GTK_1WIDGET_1SET_1HEIGHT)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1SET_1HEIGHT_FUNC);
	GTK_WIDGET_SET_HEIGHT((GtkWidget *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1SET_1HEIGHT_FUNC);
}
#endif

#ifndef NO_GTK_1WIDGET_1SET_1WIDTH
JNIEXPORT void JNICALL OS_NATIVE(GTK_1WIDGET_1SET_1WIDTH)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1SET_1WIDTH_FUNC);
	GTK_WIDGET_SET_WIDTH((GtkWidget *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1SET_1WIDTH_FUNC);
}
#endif

#ifndef NO_GTK_1WIDGET_1SET_1X
JNIEXPORT void JNICALL OS_NATIVE(GTK_1WIDGET_1SET_1X)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1SET_1X_FUNC);
	GTK_WIDGET_SET_X((GtkWidget *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1SET_1X_FUNC);
}
#endif

#ifndef NO_GTK_1WIDGET_1SET_1Y
JNIEXPORT void JNICALL OS_NATIVE(GTK_1WIDGET_1SET_1Y)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1SET_1Y_FUNC);
	GTK_WIDGET_SET_Y((GtkWidget *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1SET_1Y_FUNC);
}
#endif

#ifndef NO_GTK_1WIDGET_1WIDTH
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1WIDTH)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1WIDTH_FUNC);
	rc = (jint)GTK_WIDGET_WIDTH((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1WIDTH_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1WINDOW
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1WINDOW)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1WINDOW_FUNC);
	rc = (jint)GTK_WIDGET_WINDOW((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1WINDOW_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1X
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1X)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1X_FUNC);
	rc = (jint)GTK_WIDGET_X((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1X_FUNC);
	return rc;
}
#endif

#ifndef NO_GTK_1WIDGET_1Y
JNIEXPORT jint JNICALL OS_NATIVE(GTK_1WIDGET_1Y)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTK_1WIDGET_1Y_FUNC);
	rc = (jint)GTK_WIDGET_Y((GtkWidget *)arg0);
	OS_NATIVE_EXIT(env, that, GTK_1WIDGET_1Y_FUNC);
	return rc;
}
#endif

#ifndef NO_GTypeInfo_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GTypeInfo_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTypeInfo_1sizeof_FUNC);
	rc = (jint)GTypeInfo_sizeof();
	OS_NATIVE_EXIT(env, that, GTypeInfo_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GTypeQuery_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GTypeQuery_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GTypeQuery_1sizeof_FUNC);
	rc = (jint)GTypeQuery_sizeof();
	OS_NATIVE_EXIT(env, that, GTypeQuery_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkColor_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkColor_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkColor_1sizeof_FUNC);
	rc = (jint)GdkColor_sizeof();
	OS_NATIVE_EXIT(env, that, GdkColor_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkDragContext_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkDragContext_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkDragContext_1sizeof_FUNC);
	rc = (jint)GdkDragContext_sizeof();
	OS_NATIVE_EXIT(env, that, GdkDragContext_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventAny_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventAny_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventAny_1sizeof_FUNC);
	rc = (jint)GdkEventAny_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventAny_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventButton_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventButton_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventButton_1sizeof_FUNC);
	rc = (jint)GdkEventButton_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventButton_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventCrossing_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventCrossing_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventCrossing_1sizeof_FUNC);
	rc = (jint)GdkEventCrossing_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventCrossing_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventExpose_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventExpose_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventExpose_1sizeof_FUNC);
	rc = (jint)GdkEventExpose_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventExpose_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventFocus_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventFocus_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventFocus_1sizeof_FUNC);
	rc = (jint)GdkEventFocus_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventFocus_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventKey_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventKey_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventKey_1sizeof_FUNC);
	rc = (jint)GdkEventKey_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventKey_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventMotion_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventMotion_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventMotion_1sizeof_FUNC);
	rc = (jint)GdkEventMotion_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventMotion_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventScroll_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventScroll_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventScroll_1sizeof_FUNC);
	rc = (jint)GdkEventScroll_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventScroll_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventVisibility_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventVisibility_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventVisibility_1sizeof_FUNC);
	rc = (jint)GdkEventVisibility_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventVisibility_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEventWindowState_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEventWindowState_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEventWindowState_1sizeof_FUNC);
	rc = (jint)GdkEventWindowState_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEventWindowState_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkEvent_1sizeof_FUNC);
	rc = (jint)GdkEvent_sizeof();
	OS_NATIVE_EXIT(env, that, GdkEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkGCValues_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkGCValues_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkGCValues_1sizeof_FUNC);
	rc = (jint)GdkGCValues_sizeof();
	OS_NATIVE_EXIT(env, that, GdkGCValues_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkGeometry_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkGeometry_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkGeometry_1sizeof_FUNC);
	rc = (jint)GdkGeometry_sizeof();
	OS_NATIVE_EXIT(env, that, GdkGeometry_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkImage_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkImage_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkImage_1sizeof_FUNC);
	rc = (jint)GdkImage_sizeof();
	OS_NATIVE_EXIT(env, that, GdkImage_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkRectangle_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkRectangle_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkRectangle_1sizeof_FUNC);
	rc = (jint)GdkRectangle_sizeof();
	OS_NATIVE_EXIT(env, that, GdkRectangle_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkVisual_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkVisual_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkVisual_1sizeof_FUNC);
	rc = (jint)GdkVisual_sizeof();
	OS_NATIVE_EXIT(env, that, GdkVisual_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GdkWindowAttr_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GdkWindowAttr_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GdkWindowAttr_1sizeof_FUNC);
	rc = (jint)GdkWindowAttr_sizeof();
	OS_NATIVE_EXIT(env, that, GdkWindowAttr_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkAdjustment_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkAdjustment_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkAdjustment_1sizeof_FUNC);
	rc = (jint)GtkAdjustment_sizeof();
	OS_NATIVE_EXIT(env, that, GtkAdjustment_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkAllocation_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkAllocation_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkAllocation_1sizeof_FUNC);
	rc = (jint)GtkAllocation_sizeof();
	OS_NATIVE_EXIT(env, that, GtkAllocation_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkBorder_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkBorder_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkBorder_1sizeof_FUNC);
	rc = (jint)GtkBorder_sizeof();
	OS_NATIVE_EXIT(env, that, GtkBorder_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererPixbufClass_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererPixbufClass_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererPixbufClass_1sizeof_FUNC);
	rc = (jint)GtkCellRendererPixbufClass_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererPixbufClass_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererPixbuf_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererPixbuf_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererPixbuf_1sizeof_FUNC);
	rc = (jint)GtkCellRendererPixbuf_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererPixbuf_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererTextClass_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererTextClass_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererTextClass_1sizeof_FUNC);
	rc = (jint)GtkCellRendererTextClass_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererTextClass_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererText_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererText_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererText_1sizeof_FUNC);
	rc = (jint)GtkCellRendererText_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererText_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererToggleClass_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererToggleClass_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererToggleClass_1sizeof_FUNC);
	rc = (jint)GtkCellRendererToggleClass_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererToggleClass_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCellRendererToggle_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCellRendererToggle_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCellRendererToggle_1sizeof_FUNC);
	rc = (jint)GtkCellRendererToggle_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCellRendererToggle_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkColorSelectionDialog_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkColorSelectionDialog_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkColorSelectionDialog_1sizeof_FUNC);
	rc = (jint)GtkColorSelectionDialog_sizeof();
	OS_NATIVE_EXIT(env, that, GtkColorSelectionDialog_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkCombo_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkCombo_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkCombo_1sizeof_FUNC);
	rc = (jint)GtkCombo_sizeof();
	OS_NATIVE_EXIT(env, that, GtkCombo_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkFileSelection_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkFileSelection_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkFileSelection_1sizeof_FUNC);
	rc = (jint)GtkFileSelection_sizeof();
	OS_NATIVE_EXIT(env, that, GtkFileSelection_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkFixedClass_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkFixedClass_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkFixedClass_1sizeof_FUNC);
	rc = (jint)GtkFixedClass_sizeof();
	OS_NATIVE_EXIT(env, that, GtkFixedClass_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkFixed_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkFixed_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkFixed_1sizeof_FUNC);
	rc = (jint)GtkFixed_sizeof();
	OS_NATIVE_EXIT(env, that, GtkFixed_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkRequisition_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkRequisition_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkRequisition_1sizeof_FUNC);
	rc = (jint)GtkRequisition_sizeof();
	OS_NATIVE_EXIT(env, that, GtkRequisition_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkSelectionData_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkSelectionData_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkSelectionData_1sizeof_FUNC);
	rc = (jint)GtkSelectionData_sizeof();
	OS_NATIVE_EXIT(env, that, GtkSelectionData_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkTargetEntry_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkTargetEntry_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkTargetEntry_1sizeof_FUNC);
	rc = (jint)GtkTargetEntry_sizeof();
	OS_NATIVE_EXIT(env, that, GtkTargetEntry_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkTargetPair_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkTargetPair_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkTargetPair_1sizeof_FUNC);
	rc = (jint)GtkTargetPair_sizeof();
	OS_NATIVE_EXIT(env, that, GtkTargetPair_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkTextIter_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkTextIter_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkTextIter_1sizeof_FUNC);
	rc = (jint)GtkTextIter_sizeof();
	OS_NATIVE_EXIT(env, that, GtkTextIter_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_GtkTreeIter_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(GtkTreeIter_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GtkTreeIter_1sizeof_FUNC);
	rc = (jint)GtkTreeIter_sizeof();
	OS_NATIVE_EXIT(env, that, GtkTreeIter_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoAttribute_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoAttribute_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoAttribute_1sizeof_FUNC);
	rc = (jint)PangoAttribute_sizeof();
	OS_NATIVE_EXIT(env, that, PangoAttribute_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoItem_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoItem_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoItem_1sizeof_FUNC);
	rc = (jint)PangoItem_sizeof();
	OS_NATIVE_EXIT(env, that, PangoItem_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoLayoutLine_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoLayoutLine_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoLayoutLine_1sizeof_FUNC);
	rc = (jint)PangoLayoutLine_sizeof();
	OS_NATIVE_EXIT(env, that, PangoLayoutLine_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoLayoutRun_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoLayoutRun_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoLayoutRun_1sizeof_FUNC);
	rc = (jint)PangoLayoutRun_sizeof();
	OS_NATIVE_EXIT(env, that, PangoLayoutRun_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoLogAttr_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoLogAttr_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoLogAttr_1sizeof_FUNC);
	rc = (jint)PangoLogAttr_sizeof();
	OS_NATIVE_EXIT(env, that, PangoLogAttr_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_PangoRectangle_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(PangoRectangle_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PangoRectangle_1sizeof_FUNC);
	rc = (jint)PangoRectangle_sizeof();
	OS_NATIVE_EXIT(env, that, PangoRectangle_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XAnyEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XAnyEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XAnyEvent_1sizeof_FUNC);
	rc = (jint)XAnyEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XAnyEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XButtonEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XButtonEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XButtonEvent_1sizeof_FUNC);
	rc = (jint)XButtonEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XButtonEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XClientMessageEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XClientMessageEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XClientMessageEvent_1sizeof_FUNC);
	rc = (jint)XClientMessageEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XClientMessageEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XCrossingEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XCrossingEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XCrossingEvent_1sizeof_FUNC);
	rc = (jint)XCrossingEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XCrossingEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XEvent_1sizeof_FUNC);
	rc = (jint)XEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XExposeEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XExposeEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XExposeEvent_1sizeof_FUNC);
	rc = (jint)XExposeEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XExposeEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XFocusChangeEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XFocusChangeEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XFocusChangeEvent_1sizeof_FUNC);
	rc = (jint)XFocusChangeEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XFocusChangeEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XRenderPictureAttributes_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XRenderPictureAttributes_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XRenderPictureAttributes_1sizeof_FUNC);
	rc = (jint)XRenderPictureAttributes_sizeof();
	OS_NATIVE_EXIT(env, that, XRenderPictureAttributes_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XVisibilityEvent_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XVisibilityEvent_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XVisibilityEvent_1sizeof_FUNC);
	rc = (jint)XVisibilityEvent_sizeof();
	OS_NATIVE_EXIT(env, that, XVisibilityEvent_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_XWindowChanges_1sizeof
JNIEXPORT jint JNICALL OS_NATIVE(XWindowChanges_1sizeof)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, XWindowChanges_1sizeof_FUNC);
	rc = (jint)XWindowChanges_sizeof();
	OS_NATIVE_EXIT(env, that, XWindowChanges_1sizeof_FUNC);
	return rc;
}
#endif

#ifndef NO_X_1EVENT_1TYPE
JNIEXPORT jint JNICALL OS_NATIVE(X_1EVENT_1TYPE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, X_1EVENT_1TYPE_FUNC);
	rc = (jint)X_EVENT_TYPE((XEvent *)arg0);
	OS_NATIVE_EXIT(env, that, X_1EVENT_1TYPE_FUNC);
	return rc;
}
#endif

#ifndef NO_X_1EVENT_1WINDOW
JNIEXPORT jint JNICALL OS_NATIVE(X_1EVENT_1WINDOW)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, X_1EVENT_1WINDOW_FUNC);
	rc = (jint)X_EVENT_WINDOW((XAnyEvent *)arg0);
	OS_NATIVE_EXIT(env, that, X_1EVENT_1WINDOW_FUNC);
	return rc;
}
#endif

#ifndef NO__1Call
JNIEXPORT jint JNICALL OS_NATIVE(_1Call)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1Call_FUNC);
	rc = (jint)((jint (*)())arg0)(arg1, arg2);
	OS_NATIVE_EXIT(env, that, _1Call_FUNC);
	return rc;
}
#endif

#ifndef NO__1FcConfigAppFontAddFile
JNIEXPORT jboolean JNICALL OS_NATIVE(_1FcConfigAppFontAddFile)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1)
{
	jbyte *lparg1=NULL;
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1FcConfigAppFontAddFile_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
/*
	rc = (jboolean)FcConfigAppFontAddFile(arg0, lparg1);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jboolean (*FPTR)(jint, jbyte *);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(FcConfigAppFontAddFile_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "FcConfigAppFontAddFile");
			initialized = 1;
		}
		if (fptr) {
			rc = (jboolean)(*fptr)(arg0, lparg1);
		}
	}
fail:
	if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1FcConfigAppFontAddFile_FUNC);
	return rc;
}
#endif

#ifndef NO__1GDK_1DISPLAY
JNIEXPORT jint JNICALL OS_NATIVE(_1GDK_1DISPLAY)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GDK_1DISPLAY_FUNC);
	rc = (jint)GDK_DISPLAY();
	OS_NATIVE_EXIT(env, that, _1GDK_1DISPLAY_FUNC);
	return rc;
}
#endif

#ifndef NO__1GDK_1PIXMAP_1XID
JNIEXPORT jint JNICALL OS_NATIVE(_1GDK_1PIXMAP_1XID)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GDK_1PIXMAP_1XID_FUNC);
	rc = (jint)GDK_PIXMAP_XID((GdkPixmap *)arg0);
	OS_NATIVE_EXIT(env, that, _1GDK_1PIXMAP_1XID_FUNC);
	return rc;
}
#endif

#ifndef NO__1GDK_1ROOT_1PARENT
JNIEXPORT jint JNICALL OS_NATIVE(_1GDK_1ROOT_1PARENT)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GDK_1ROOT_1PARENT_FUNC);
	rc = (jint)GDK_ROOT_PARENT();
	OS_NATIVE_EXIT(env, that, _1GDK_1ROOT_1PARENT_FUNC);
	return rc;
}
#endif

#ifndef NO__1GDK_1TYPE_1COLOR
JNIEXPORT jint JNICALL OS_NATIVE(_1GDK_1TYPE_1COLOR)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GDK_1TYPE_1COLOR_FUNC);
	rc = (jint)GDK_TYPE_COLOR;
	OS_NATIVE_EXIT(env, that, _1GDK_1TYPE_1COLOR_FUNC);
	return rc;
}
#endif

#ifndef NO__1GDK_1TYPE_1PIXBUF
JNIEXPORT jint JNICALL OS_NATIVE(_1GDK_1TYPE_1PIXBUF)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GDK_1TYPE_1PIXBUF_FUNC);
	rc = (jint)GDK_TYPE_PIXBUF;
	OS_NATIVE_EXIT(env, that, _1GDK_1TYPE_1PIXBUF_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1BUTTON
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1BUTTON)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1BUTTON_FUNC);
	rc = (jboolean)GTK_IS_BUTTON(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1BUTTON_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1CELL_1RENDERER_1PIXBUF
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1CELL_1RENDERER_1PIXBUF)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1CELL_1RENDERER_1PIXBUF_FUNC);
	rc = (jboolean)GTK_IS_CELL_RENDERER_PIXBUF(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1CELL_1RENDERER_1PIXBUF_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1CELL_1RENDERER_1TEXT
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1CELL_1RENDERER_1TEXT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1CELL_1RENDERER_1TEXT_FUNC);
	rc = (jboolean)GTK_IS_CELL_RENDERER_TEXT(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1CELL_1RENDERER_1TEXT_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1CELL_1RENDERER_1TOGGLE
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1CELL_1RENDERER_1TOGGLE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1CELL_1RENDERER_1TOGGLE_FUNC);
	rc = (jboolean)GTK_IS_CELL_RENDERER_TOGGLE(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1CELL_1RENDERER_1TOGGLE_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1CONTAINER
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1CONTAINER)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1CONTAINER_FUNC);
	rc = (jboolean)GTK_IS_CONTAINER(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1CONTAINER_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1IMAGE_1MENU_1ITEM
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1IMAGE_1MENU_1ITEM)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1IMAGE_1MENU_1ITEM_FUNC);
	rc = (jboolean)GTK_IS_IMAGE_MENU_ITEM(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1IMAGE_1MENU_1ITEM_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1PLUG
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1PLUG)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1PLUG_FUNC);
	rc = (jboolean)GTK_IS_PLUG(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1PLUG_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1IS_1WINDOW
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1IS_1WINDOW)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1IS_1WINDOW_FUNC);
	rc = (jboolean)GTK_IS_WINDOW(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1IS_1WINDOW_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1STOCK_1CANCEL
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1STOCK_1CANCEL)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1STOCK_1CANCEL_FUNC);
	rc = (jint)GTK_STOCK_CANCEL;
	OS_NATIVE_EXIT(env, that, _1GTK_1STOCK_1CANCEL_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1STOCK_1OK
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1STOCK_1OK)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1STOCK_1OK_FUNC);
	rc = (jint)GTK_STOCK_OK;
	OS_NATIVE_EXIT(env, that, _1GTK_1STOCK_1OK_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1CELL_1RENDERER_1PIXBUF
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1CELL_1RENDERER_1PIXBUF)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1PIXBUF_FUNC);
	rc = (jint)GTK_TYPE_CELL_RENDERER_PIXBUF;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1PIXBUF_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1CELL_1RENDERER_1TEXT
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1CELL_1RENDERER_1TEXT)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1TEXT_FUNC);
	rc = (jint)GTK_TYPE_CELL_RENDERER_TEXT;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1TEXT_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1CELL_1RENDERER_1TOGGLE
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1CELL_1RENDERER_1TOGGLE)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1TOGGLE_FUNC);
	rc = (jint)GTK_TYPE_CELL_RENDERER_TOGGLE;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1CELL_1RENDERER_1TOGGLE_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1FIXED
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1FIXED)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1FIXED_FUNC);
	rc = (jint)GTK_TYPE_FIXED;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1FIXED_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1MENU
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1MENU)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1MENU_FUNC);
	rc = (jint)GTK_TYPE_MENU;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1MENU_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1TYPE_1WIDGET
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1TYPE_1WIDGET)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1TYPE_1WIDGET_FUNC);
	rc = (jint)GTK_TYPE_WIDGET;
	OS_NATIVE_EXIT(env, that, _1GTK_1TYPE_1WIDGET_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1FLAGS
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1WIDGET_1FLAGS)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1FLAGS_FUNC);
	rc = (jint)GTK_WIDGET_FLAGS(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1FLAGS_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1HAS_1DEFAULT
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1HAS_1DEFAULT)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1HAS_1DEFAULT_FUNC);
	rc = (jboolean)GTK_WIDGET_HAS_DEFAULT(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1HAS_1DEFAULT_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1HAS_1FOCUS
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1HAS_1FOCUS)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1HAS_1FOCUS_FUNC);
	rc = (jboolean)GTK_WIDGET_HAS_FOCUS(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1HAS_1FOCUS_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1IS_1SENSITIVE
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1IS_1SENSITIVE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1IS_1SENSITIVE_FUNC);
	rc = (jboolean)GTK_WIDGET_IS_SENSITIVE(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1IS_1SENSITIVE_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1MAPPED
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1MAPPED)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1MAPPED_FUNC);
	rc = (jboolean)GTK_WIDGET_MAPPED(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1MAPPED_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1SENSITIVE
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1SENSITIVE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1SENSITIVE_FUNC);
	rc = (jboolean)GTK_WIDGET_SENSITIVE(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1SENSITIVE_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1SET_1FLAGS
JNIEXPORT void JNICALL OS_NATIVE(_1GTK_1WIDGET_1SET_1FLAGS)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1SET_1FLAGS_FUNC);
	GTK_WIDGET_SET_FLAGS(arg0, arg1);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1SET_1FLAGS_FUNC);
}
#endif

#ifndef NO__1GTK_1WIDGET_1STATE
JNIEXPORT jint JNICALL OS_NATIVE(_1GTK_1WIDGET_1STATE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1STATE_FUNC);
	rc = (jint)GTK_WIDGET_STATE(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1STATE_FUNC);
	return rc;
}
#endif

#ifndef NO__1GTK_1WIDGET_1UNSET_1FLAGS
JNIEXPORT void JNICALL OS_NATIVE(_1GTK_1WIDGET_1UNSET_1FLAGS)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1UNSET_1FLAGS_FUNC);
	GTK_WIDGET_UNSET_FLAGS(arg0, arg1);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1UNSET_1FLAGS_FUNC);
}
#endif

#ifndef NO__1GTK_1WIDGET_1VISIBLE
JNIEXPORT jboolean JNICALL OS_NATIVE(_1GTK_1WIDGET_1VISIBLE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1GTK_1WIDGET_1VISIBLE_FUNC);
	rc = (jboolean)GTK_WIDGET_VISIBLE(arg0);
	OS_NATIVE_EXIT(env, that, _1GTK_1WIDGET_1VISIBLE_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1OBJECT_1CLASS
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1OBJECT_1CLASS)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1OBJECT_1CLASS_FUNC);
	rc = (jint)G_OBJECT_CLASS(arg0);
	OS_NATIVE_EXIT(env, that, _1G_1OBJECT_1CLASS_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1OBJECT_1GET_1CLASS
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1OBJECT_1GET_1CLASS)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1OBJECT_1GET_1CLASS_FUNC);
	rc = (jint)G_OBJECT_GET_CLASS(arg0);
	OS_NATIVE_EXIT(env, that, _1G_1OBJECT_1GET_1CLASS_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1OBJECT_1TYPE
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1OBJECT_1TYPE)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1OBJECT_1TYPE_FUNC);
	rc = (jint)G_OBJECT_TYPE(arg0);
	OS_NATIVE_EXIT(env, that, _1G_1OBJECT_1TYPE_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1OBJECT_1TYPE_1NAME
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1OBJECT_1TYPE_1NAME)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1OBJECT_1TYPE_1NAME_FUNC);
	rc = (jint)G_OBJECT_TYPE_NAME(arg0);
	OS_NATIVE_EXIT(env, that, _1G_1OBJECT_1TYPE_1NAME_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1TYPE_1BOOLEAN
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1TYPE_1BOOLEAN)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1TYPE_1BOOLEAN_FUNC);
	rc = (jint)G_TYPE_BOOLEAN;
	OS_NATIVE_EXIT(env, that, _1G_1TYPE_1BOOLEAN_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1TYPE_1INT
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1TYPE_1INT)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1TYPE_1INT_FUNC);
	rc = (jint)G_TYPE_INT;
	OS_NATIVE_EXIT(env, that, _1G_1TYPE_1INT_FUNC);
	return rc;
}
#endif

#ifndef NO__1G_1TYPE_1STRING
JNIEXPORT jint JNICALL OS_NATIVE(_1G_1TYPE_1STRING)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1G_1TYPE_1STRING_FUNC);
	rc = (jint)G_TYPE_STRING;
	OS_NATIVE_EXIT(env, that, _1G_1TYPE_1STRING_FUNC);
	return rc;
}
#endif

#ifndef NO__1PANGO_1PIXELS
JNIEXPORT jint JNICALL OS_NATIVE(_1PANGO_1PIXELS)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1PANGO_1PIXELS_FUNC);
	rc = (jint)PANGO_PIXELS(arg0);
	OS_NATIVE_EXIT(env, that, _1PANGO_1PIXELS_FUNC);
	return rc;
}
#endif

#ifndef NO__1PANGO_1TYPE_1FONT_1DESCRIPTION
JNIEXPORT jint JNICALL OS_NATIVE(_1PANGO_1TYPE_1FONT_1DESCRIPTION)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1PANGO_1TYPE_1FONT_1DESCRIPTION_FUNC);
	rc = (jint)PANGO_TYPE_FONT_DESCRIPTION;
	OS_NATIVE_EXIT(env, that, _1PANGO_1TYPE_1FONT_1DESCRIPTION_FUNC);
	return rc;
}
#endif

#ifndef NO__1XCheckIfEvent
JNIEXPORT jboolean JNICALL OS_NATIVE(_1XCheckIfEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1XCheckIfEvent_FUNC);
	rc = (jboolean)XCheckIfEvent((Display *)arg0, (XEvent *)arg1, (Bool (*)())arg2, (XPointer)arg3);
	OS_NATIVE_EXIT(env, that, _1XCheckIfEvent_FUNC);
	return rc;
}
#endif

#ifndef NO__1XCheckMaskEvent
JNIEXPORT jboolean JNICALL OS_NATIVE(_1XCheckMaskEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1XCheckMaskEvent_FUNC);
	rc = (jboolean)XCheckMaskEvent((Display *)arg0, (long)arg1, (XEvent *)arg2);
	OS_NATIVE_EXIT(env, that, _1XCheckMaskEvent_FUNC);
	return rc;
}
#endif

#ifndef NO__1XCheckWindowEvent
JNIEXPORT jboolean JNICALL OS_NATIVE(_1XCheckWindowEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1XCheckWindowEvent_FUNC);
	rc = (jboolean)XCheckWindowEvent((Display *)arg0, (Window)arg1, (long)arg2, (XEvent *)arg3);
	OS_NATIVE_EXIT(env, that, _1XCheckWindowEvent_FUNC);
	return rc;
}
#endif

#ifndef NO__1XDefaultRootWindow
JNIEXPORT jint JNICALL OS_NATIVE(_1XDefaultRootWindow)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XDefaultRootWindow_FUNC);
	rc = (jint)XDefaultRootWindow((Display *)arg0);
	OS_NATIVE_EXIT(env, that, _1XDefaultRootWindow_FUNC);
	return rc;
}
#endif

#ifndef NO__1XDefaultScreen
JNIEXPORT jint JNICALL OS_NATIVE(_1XDefaultScreen)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XDefaultScreen_FUNC);
	rc = (jint)XDefaultScreen((Display *)arg0);
	OS_NATIVE_EXIT(env, that, _1XDefaultScreen_FUNC);
	return rc;
}
#endif

#ifndef NO__1XFlush
JNIEXPORT void JNICALL OS_NATIVE(_1XFlush)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1XFlush_FUNC);
	XFlush((Display *)arg0);
	OS_NATIVE_EXIT(env, that, _1XFlush_FUNC);
}
#endif

#ifndef NO__1XFree
JNIEXPORT void JNICALL OS_NATIVE(_1XFree)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1XFree_FUNC);
	XFree((void *)arg0);
	OS_NATIVE_EXIT(env, that, _1XFree_FUNC);
}
#endif

#ifndef NO__1XGetSelectionOwner
JNIEXPORT jint JNICALL OS_NATIVE(_1XGetSelectionOwner)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XGetSelectionOwner_FUNC);
	rc = (jint)XGetSelectionOwner((Display *)arg0, (Atom)arg1);
	OS_NATIVE_EXIT(env, that, _1XGetSelectionOwner_FUNC);
	return rc;
}
#endif

#ifndef NO__1XInternAtom
JNIEXPORT jint JNICALL OS_NATIVE(_1XInternAtom)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jboolean arg2)
{
	jbyte *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XInternAtom_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jint)XInternAtom((Display *)arg0, (char *)lparg1, (Bool)arg2);
fail:
	if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1XInternAtom_FUNC);
	return rc;
}
#endif

#ifndef NO__1XKeysymToKeycode
JNIEXPORT jint JNICALL OS_NATIVE(_1XKeysymToKeycode)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XKeysymToKeycode_FUNC);
	rc = (jint)XKeysymToKeycode((Display *)arg0, (KeySym)arg1);
	OS_NATIVE_EXIT(env, that, _1XKeysymToKeycode_FUNC);
	return rc;
}
#endif

#ifndef NO__1XListProperties
JNIEXPORT jint JNICALL OS_NATIVE(_1XListProperties)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XListProperties_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)XListProperties((Display *)arg0, (Window)arg1, (int *)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1XListProperties_FUNC);
	return rc;
}
#endif

#ifndef NO__1XQueryTree
JNIEXPORT jint JNICALL OS_NATIVE(_1XQueryTree)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2, jintArray arg3, jintArray arg4, jintArray arg5)
{
	jint *lparg2=NULL;
	jint *lparg3=NULL;
	jint *lparg4=NULL;
	jint *lparg5=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XQueryTree_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail;
	if (arg5) if ((lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL)) == NULL) goto fail;
	rc = (jint)XQueryTree((Display *)arg0, (Window)arg1, (Window *)lparg2, (Window *)lparg3, (Window **)lparg4, (unsigned int *)lparg5);
fail:
	if (arg5 && lparg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
	if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1XQueryTree_FUNC);
	return rc;
}
#endif

#ifndef NO__1XReconfigureWMWindow
JNIEXPORT jint JNICALL OS_NATIVE(_1XReconfigureWMWindow)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4)
{
	XWindowChanges _arg4, *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XReconfigureWMWindow_FUNC);
	if (arg4) if ((lparg4 = getXWindowChangesFields(env, arg4, &_arg4)) == NULL) goto fail;
	rc = (jint)XReconfigureWMWindow((Display *)arg0, (Window)arg1, arg2, arg3, lparg4);
fail:
	OS_NATIVE_EXIT(env, that, _1XReconfigureWMWindow_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderComposite
JNIEXPORT void JNICALL OS_NATIVE(_1XRenderComposite)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8, jint arg9, jint arg10, jint arg11, jint arg12)
{
	OS_NATIVE_ENTER(env, that, _1XRenderComposite_FUNC);
/*
	XRenderComposite(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef void (*FPTR)(jint, jint, jint, jint, jint, jint, jint, jint, jint, jint, jint, jint, jint);
		static FPTR fptr;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderComposite_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderComposite");
			initialized = 1;
		}
		if (fptr) {
			(*fptr)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
		}
	}
	OS_NATIVE_EXIT(env, that, _1XRenderComposite_FUNC);
}
#endif

#ifndef NO__1XRenderCreatePicture
JNIEXPORT jint JNICALL OS_NATIVE(_1XRenderCreatePicture)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4)
{
	XRenderPictureAttributes _arg4, *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XRenderCreatePicture_FUNC);
	if (arg4) if ((lparg4 = getXRenderPictureAttributesFields(env, arg4, &_arg4)) == NULL) goto fail;
/*
	rc = (jint)XRenderCreatePicture(arg0, arg1, arg2, arg3, lparg4);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jint (*FPTR)(jint, jint, jint, jint, XRenderPictureAttributes *);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderCreatePicture_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderCreatePicture");
			initialized = 1;
		}
		if (fptr) {
			rc = (jint)(*fptr)(arg0, arg1, arg2, arg3, lparg4);
		}
	}
fail:
	OS_NATIVE_EXIT(env, that, _1XRenderCreatePicture_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderFindStandardFormat
JNIEXPORT jint JNICALL OS_NATIVE(_1XRenderFindStandardFormat)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XRenderFindStandardFormat_FUNC);
/*
	rc = (jint)XRenderFindStandardFormat(arg0, arg1);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jint (*FPTR)(jint, jint);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderFindStandardFormat_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderFindStandardFormat");
			initialized = 1;
		}
		if (fptr) {
			rc = (jint)(*fptr)(arg0, arg1);
		}
	}
	OS_NATIVE_EXIT(env, that, _1XRenderFindStandardFormat_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderFindVisualFormat
JNIEXPORT jint JNICALL OS_NATIVE(_1XRenderFindVisualFormat)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XRenderFindVisualFormat_FUNC);
/*
	rc = (jint)XRenderFindVisualFormat(arg0, arg1);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jint (*FPTR)(jint, jint);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderFindVisualFormat_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderFindVisualFormat");
			initialized = 1;
		}
		if (fptr) {
			rc = (jint)(*fptr)(arg0, arg1);
		}
	}
	OS_NATIVE_EXIT(env, that, _1XRenderFindVisualFormat_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderFreePicture
JNIEXPORT void JNICALL OS_NATIVE(_1XRenderFreePicture)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, _1XRenderFreePicture_FUNC);
/*
	XRenderFreePicture(arg0, arg1);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef void (*FPTR)(jint, jint);
		static FPTR fptr;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderFreePicture_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderFreePicture");
			initialized = 1;
		}
		if (fptr) {
			(*fptr)(arg0, arg1);
		}
	}
	OS_NATIVE_EXIT(env, that, _1XRenderFreePicture_FUNC);
}
#endif

#ifndef NO__1XRenderQueryExtension
JNIEXPORT jboolean JNICALL OS_NATIVE(_1XRenderQueryExtension)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
	jint *lparg1=NULL;
	jint *lparg2=NULL;
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1XRenderQueryExtension_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
/*
	rc = (jboolean)XRenderQueryExtension(arg0, lparg1, lparg2);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jboolean (*FPTR)(jint, jint *, jint *);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderQueryExtension_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderQueryExtension");
			initialized = 1;
		}
		if (fptr) {
			rc = (jboolean)(*fptr)(arg0, lparg1, lparg2);
		}
	}
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1XRenderQueryExtension_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderQueryVersion
JNIEXPORT jint JNICALL OS_NATIVE(_1XRenderQueryVersion)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
	jint *lparg1=NULL;
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XRenderQueryVersion_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
/*
	rc = (jint)XRenderQueryVersion(arg0, lparg1, lparg2);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jint (*FPTR)(jint, jint *, jint *);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderQueryVersion_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderQueryVersion");
			initialized = 1;
		}
		if (fptr) {
			rc = (jint)(*fptr)(arg0, lparg1, lparg2);
		}
	}
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1XRenderQueryVersion_FUNC);
	return rc;
}
#endif

#ifndef NO__1XRenderSetPictureClipRectangles
JNIEXPORT void JNICALL OS_NATIVE(_1XRenderSetPictureClipRectangles)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jshortArray arg4, jint arg5)
{
	jshort *lparg4=NULL;
	OS_NATIVE_ENTER(env, that, _1XRenderSetPictureClipRectangles_FUNC);
	if (arg4) if ((lparg4 = (*env)->GetShortArrayElements(env, arg4, NULL)) == NULL) goto fail;
/*
	XRenderSetPictureClipRectangles(arg0, arg1, arg2, arg3, lparg4, arg5);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef void (*FPTR)(jint, jint, jint, jint, jshort *, jint);
		static FPTR fptr;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderSetPictureClipRectangles_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderSetPictureClipRectangles");
			initialized = 1;
		}
		if (fptr) {
			(*fptr)(arg0, arg1, arg2, arg3, lparg4, arg5);
		}
	}
fail:
	if (arg4 && lparg4) (*env)->ReleaseShortArrayElements(env, arg4, lparg4, 0);
	OS_NATIVE_EXIT(env, that, _1XRenderSetPictureClipRectangles_FUNC);
}
#endif

#ifndef NO__1XRenderSetPictureTransform
JNIEXPORT void JNICALL OS_NATIVE(_1XRenderSetPictureTransform)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	OS_NATIVE_ENTER(env, that, _1XRenderSetPictureTransform_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
/*
	XRenderSetPictureTransform(arg0, arg1, lparg2);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef void (*FPTR)(jint, jint, jint *);
		static FPTR fptr;
		if (!initialized) {
			if (!handle) handle = dlopen(XRenderSetPictureTransform_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "XRenderSetPictureTransform");
			initialized = 1;
		}
		if (fptr) {
			(*fptr)(arg0, arg1, lparg2);
		}
	}
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1XRenderSetPictureTransform_FUNC);
}
#endif

#ifndef NO__1XSendEvent
JNIEXPORT jint JNICALL OS_NATIVE(_1XSendEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3, jint arg4)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XSendEvent_FUNC);
	rc = (jint)XSendEvent((Display *)arg0, (Window)arg1, arg2, arg3, (XEvent *)arg4);
	OS_NATIVE_EXIT(env, that, _1XSendEvent_FUNC);
	return rc;
}
#endif

#ifndef NO__1XSetErrorHandler
JNIEXPORT jint JNICALL OS_NATIVE(_1XSetErrorHandler)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XSetErrorHandler_FUNC);
	rc = (jint)XSetErrorHandler((XErrorHandler)arg0);
	OS_NATIVE_EXIT(env, that, _1XSetErrorHandler_FUNC);
	return rc;
}
#endif

#ifndef NO__1XSetIOErrorHandler
JNIEXPORT jint JNICALL OS_NATIVE(_1XSetIOErrorHandler)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XSetIOErrorHandler_FUNC);
	rc = (jint)XSetIOErrorHandler((XIOErrorHandler)arg0);
	OS_NATIVE_EXIT(env, that, _1XSetIOErrorHandler_FUNC);
	return rc;
}
#endif

#ifndef NO__1XSetInputFocus
JNIEXPORT jint JNICALL OS_NATIVE(_1XSetInputFocus)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XSetInputFocus_FUNC);
	rc = (jint)XSetInputFocus((Display *)arg0, (Window)arg1, arg2, arg3);
	OS_NATIVE_EXIT(env, that, _1XSetInputFocus_FUNC);
	return rc;
}
#endif

#ifndef NO__1XSynchronize
JNIEXPORT jint JNICALL OS_NATIVE(_1XSynchronize)
	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XSynchronize_FUNC);
	rc = (jint)XSynchronize((Display *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, _1XSynchronize_FUNC);
	return rc;
}
#endif

#ifndef NO__1XTestFakeButtonEvent
JNIEXPORT void JNICALL OS_NATIVE(_1XTestFakeButtonEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, _1XTestFakeButtonEvent_FUNC);
	XTestFakeButtonEvent((Display *)arg0, arg1, (Bool)arg2, (unsigned long)arg3);
	OS_NATIVE_EXIT(env, that, _1XTestFakeButtonEvent_FUNC);
}
#endif

#ifndef NO__1XTestFakeKeyEvent
JNIEXPORT void JNICALL OS_NATIVE(_1XTestFakeKeyEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, _1XTestFakeKeyEvent_FUNC);
	XTestFakeKeyEvent((Display *)arg0, arg1, (Bool)arg2, (unsigned long)arg3);
	OS_NATIVE_EXIT(env, that, _1XTestFakeKeyEvent_FUNC);
}
#endif

#ifndef NO__1XTestFakeMotionEvent
JNIEXPORT void JNICALL OS_NATIVE(_1XTestFakeMotionEvent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
{
	OS_NATIVE_ENTER(env, that, _1XTestFakeMotionEvent_FUNC);
	XTestFakeMotionEvent((Display *)arg0, arg1, arg2, arg3, (unsigned long)arg4);
	OS_NATIVE_EXIT(env, that, _1XTestFakeMotionEvent_FUNC);
}
#endif

#ifndef NO__1XWarpPointer
JNIEXPORT jint JNICALL OS_NATIVE(_1XWarpPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1XWarpPointer_FUNC);
	rc = (jint)XWarpPointer((Display *)arg0, (Window)arg1, (Window)arg2, arg3, arg4, arg5, arg6, arg7, arg8);
	OS_NATIVE_EXIT(env, that, _1XWarpPointer_FUNC);
	return rc;
}
#endif

#ifndef NO__1atk_1object_1add_1relationship
JNIEXPORT jboolean JNICALL OS_NATIVE(_1atk_1object_1add_1relationship)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1atk_1object_1add_1relationship_FUNC);
/*
	rc = (jboolean)atk_object_add_relationship((AtkObject *)arg0, (AtkRelationType)arg1, (AtkObject *)arg2);
*/
	{
		static int initialized = 0;
		static void *handle = NULL;
		typedef jboolean (*FPTR)(AtkObject *, AtkRelationType, AtkObject *);
		static FPTR fptr;
		rc = 0;
		if (!initialized) {
			if (!handle) handle = dlopen(atk_object_add_relationship_LIB, RTLD_LAZY);
			if (handle) fptr = (FPTR)dlsym(handle, "atk_object_add_relationship");
			initialized = 1;
		}
		if (fptr) {
			rc = (jboolean)(*fptr)((AtkObject *)arg0, (AtkRelationType)arg1, (AtkObject *)arg2);
		}
	}
	OS_NATIVE_EXIT(env, that, _1atk_1object_1add_1relationship_FUNC);
	return rc;
}
#endif

#ifndef NO__1call
JNIEXPORT jint JNICALL OS_NATIVE(_1call)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1call_FUNC);
	rc = (jint)((jint (*)())arg0)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
	OS_NATIVE_EXIT(env, that, _1call_FUNC);
	return rc;
}
#endif

#ifndef NO__1dlclose
JNIEXPORT jint JNICALL OS_NATIVE(_1dlclose)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1dlclose_FUNC);
	rc = (jint)dlclose((void *)arg0);
	OS_NATIVE_EXIT(env, that, _1dlclose_FUNC);
	return rc;
}
#endif

#ifndef NO__1dlopen
JNIEXPORT jint JNICALL OS_NATIVE(_1dlopen)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1)
{
	jbyte *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1dlopen_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	rc = (jint)dlopen((const char *)lparg0, arg1);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, _1dlopen_FUNC);
	return rc;
}
#endif

#ifndef NO__1dlsym
JNIEXPORT jint JNICALL OS_NATIVE(_1dlsym)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1)
{
	jbyte *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1dlsym_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jint)dlsym((void *)arg0, (const char *)lparg1);
fail:
	if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1dlsym_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1cclosure_1new
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1cclosure_1new)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1cclosure_1new_FUNC);
	rc = (jint)g_cclosure_new((GCallback)arg0, (gpointer)arg1, (GClosureNotify)arg2);
	OS_NATIVE_EXIT(env, that, _1g_1cclosure_1new_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1closure_1ref
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1closure_1ref)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1closure_1ref_FUNC);
	rc = (jint)g_closure_ref((GClosure *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1closure_1ref_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1closure_1unref
JNIEXPORT void JNICALL OS_NATIVE(_1g_1closure_1unref)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1g_1closure_1unref_FUNC);
	g_closure_unref((GClosure *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1closure_1unref_FUNC);
}
#endif

#ifndef NO__1g_1filename_1from_1uri
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1filename_1from_1uri)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
	jint *lparg1=NULL;
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1filename_1from_1uri_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)g_filename_from_uri((const char *)arg0, (char **)lparg1, (GError **)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1g_1filename_1from_1uri_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1filename_1from_1utf8
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1filename_1from_1utf8)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2, jintArray arg3, jintArray arg4)
{
	jint *lparg2=NULL;
	jint *lparg3=NULL;
	jint *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1filename_1from_1utf8_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)g_filename_from_utf8((const gchar *)arg0, (gssize)arg1, (gsize *)lparg2, (gsize *)lparg3, (GError **)lparg4);
fail:
	if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1g_1filename_1from_1utf8_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1filename_1to_1uri
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1filename_1to_1uri)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1filename_1to_1uri_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)g_filename_to_uri((const char *)arg0, (const char *)arg1, (GError **)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1g_1filename_1to_1uri_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1filename_1to_1utf8
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1filename_1to_1utf8)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2, jintArray arg3, jintArray arg4)
{
	jint *lparg2=NULL;
	jint *lparg3=NULL;
	jint *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1filename_1to_1utf8_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)g_filename_to_utf8((const gchar *)arg0, (gssize)arg1, (gsize *)lparg2, (gsize *)lparg3, (GError **)lparg4);
fail:
	if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1g_1filename_1to_1utf8_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1free
JNIEXPORT void JNICALL OS_NATIVE(_1g_1free)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1g_1free_FUNC);
	g_free((gpointer)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1free_FUNC);
}
#endif

#ifndef NO__1g_1idle_1add
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1idle_1add)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1idle_1add_FUNC);
	rc = (jint)g_idle_add((GSourceFunc)arg0, (gpointer)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1idle_1add_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1append
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1append)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1append_FUNC);
	rc = (jint)g_list_append((GList *)arg0, (gpointer)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1append_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1data
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1data)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1data_FUNC);
	rc = (jint)g_list_data((GList *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1data_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1free
JNIEXPORT void JNICALL OS_NATIVE(_1g_1list_1free)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1g_1list_1free_FUNC);
	g_list_free((GList *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1free_FUNC);
}
#endif

#ifndef NO__1g_1list_1free_11
JNIEXPORT void JNICALL OS_NATIVE(_1g_1list_1free_11)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, _1g_1list_1free_11_FUNC);
	g_list_free_1((GList *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1free_11_FUNC);
}
#endif

#ifndef NO__1g_1list_1length
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1length)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1length_FUNC);
	rc = (jint)g_list_length((GList *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1length_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1next
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1next)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1next_FUNC);
	rc = (jint)g_list_next(arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1next_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1nth
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1nth)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1nth_FUNC);
	rc = (jint)g_list_nth((GList *)arg0, (guint)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1nth_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1nth_1data
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1nth_1data)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1nth_1data_FUNC);
	rc = (jint)g_list_nth_data((GList *)arg0, (guint)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1nth_1data_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1prepend
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1prepend)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1prepend_FUNC);
	rc = (jint)g_list_prepend((GList *)arg0, (gpointer)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1prepend_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1previous
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1previous)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1previous_FUNC);
	rc = (jint)g_list_previous(arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1previous_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1remove_1link
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1remove_1link)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1remove_1link_FUNC);
	rc = (jint)g_list_remove_link((GList *)arg0, (GList *)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1remove_1link_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1reverse
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1list_1reverse)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1list_1reverse_FUNC);
	rc = (jint)g_list_reverse((GList *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1list_1reverse_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1list_1set_1next
JNIEXPORT void JNICALL OS_NATIVE(_1g_1list_1set_1next)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, _1g_1list_1set_1next_FUNC);
	g_list_set_next((GList *)arg0, (GList *)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1set_1next_FUNC);
}
#endif

#ifndef NO__1g_1list_1set_1previous
JNIEXPORT void JNICALL OS_NATIVE(_1g_1list_1set_1previous)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, _1g_1list_1set_1previous_FUNC);
	g_list_set_previous((GList *)arg0, (GList *)arg1);
	OS_NATIVE_EXIT(env, that, _1g_1list_1set_1previous_FUNC);
}
#endif

#ifndef NO__1g_1locale_1from_1utf8
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1locale_1from_1utf8)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2, jintArray arg3, jintArray arg4)
{
	jint *lparg2=NULL;
	jint *lparg3=NULL;
	jint *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1locale_1from_1utf8_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)g_locale_from_utf8((const gchar *)arg0, (gssize)arg1, (gsize *)lparg2, (gsize *)lparg3, (GError **)lparg4);
fail:
	if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1g_1locale_1from_1utf8_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1locale_1to_1utf8
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1locale_1to_1utf8)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2, jintArray arg3, jintArray arg4)
{
	jint *lparg2=NULL;
	jint *lparg3=NULL;
	jint *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1locale_1to_1utf8_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)g_locale_to_utf8((const gchar *)arg0, (gssize)arg1, (gsize *)lparg2, (gsize *)lparg3, (GError **)lparg4);
fail:
	if (arg4 && lparg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, _1g_1locale_1to_1utf8_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1log_1default_1handler
JNIEXPORT void JNICALL OS_NATIVE(_1g_1log_1default_1handler)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, _1g_1log_1default_1handler_FUNC);
	g_log_default_handler((gchar *)arg0, (GLogLevelFlags)arg1, (gchar *)arg2, (gpointer)arg3);
	OS_NATIVE_EXIT(env, that, _1g_1log_1default_1handler_FUNC);
}
#endif

#ifndef NO__1g_1log_1remove_1handler
JNIEXPORT void JNICALL OS_NATIVE(_1g_1log_1remove_1handler)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1)
{
	jbyte *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, _1g_1log_1remove_1handler_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	g_log_remove_handler((gchar *)lparg0, (gint)arg1);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, JNI_ABORT);
	OS_NATIVE_EXIT(env, that, _1g_1log_1remove_1handler_FUNC);
}
#endif

#ifndef NO__1g_1log_1set_1handler
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1log_1set_1handler)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2, jint arg3)
{
	jbyte *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1log_1set_1handler_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	rc = (jint)g_log_set_handler((gchar *)lparg0, (GLogLevelFlags)arg1, (GLogFunc)arg2, (gpointer)arg3);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, JNI_ABORT);
	OS_NATIVE_EXIT(env, that, _1g_1log_1set_1handler_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1acquire
JNIEXPORT jboolean JNICALL OS_NATIVE(_1g_1main_1context_1acquire)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1acquire_FUNC);
	rc = (jboolean)g_main_context_acquire((GMainContext *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1acquire_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1check
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1main_1context_1check)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1check_FUNC);
	rc = (jint)g_main_context_check((GMainContext *)arg0, arg1, (GPollFD *)arg2, arg3);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1check_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1default
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1main_1context_1default)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1default_FUNC);
	rc = (jint)g_main_context_default();
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1default_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1get_1poll_1func
JNIEXPORT jint JNICALL OS_NATIVE(_1g_1main_1context_1get_1poll_1func)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1get_1poll_1func_FUNC);
	rc = (jint)g_main_context_get_poll_func((GMainContext *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1get_1poll_1func_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1iteration
JNIEXPORT jboolean JNICALL OS_NATIVE(_1g_1main_1context_1iteration)
	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1iteration_FUNC);
	rc = (jboolean)g_main_context_iteration((GMainContext *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1iteration_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1pending
JNIEXPORT jboolean JNICALL OS_NATIVE(_1g_1main_1context_1pending)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1pending_FUNC);
	rc = (jboolean)g_main_context_pending((GMainContext *)arg0);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1pending_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1prepare
JNIEXPORT jboolean JNICALL OS_NATIVE(_1g_1main_1context_1prepare)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, _1g_1main_1context_1prepare_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jboolean)g_main_context_prepare((GMainContext *)arg0, lparg1);
fail:
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, _1g_1main_1context_1prepare_FUNC);
	return rc;
}
#endif

#ifndef NO__1g_1main_1context_1query