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

/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * 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_photon_OS_##func

#ifndef NO_PfDecomposeStemToID
JNIEXPORT jint JNICALL OS_NATIVE(PfDecomposeStemToID)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfDecomposeStemToID_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	rc = (jint)PfDecomposeStemToID(lparg0);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PfDecomposeStemToID_FUNC);
	return rc;
}
#endif

#ifndef NO_PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2III
JNIEXPORT jint JNICALL OS_NATIVE(PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2III)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jint arg2, jint arg3, jint arg4)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2III_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PfExtentText(lparg0, lparg1, (const char *)arg2, (const char *)arg3, arg4);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2III_FUNC);
	return rc;
}
#endif

#ifndef NO_PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2_3B_3BI
JNIEXPORT jint JNICALL OS_NATIVE(PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2_3B_3BI)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jbyteArray arg2, jbyteArray arg3, jint arg4)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jbyte *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2_3B_3BI_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetByteArrayElements(env, arg3, NULL)) == NULL) goto fail;
	rc = (jint)PfExtentText(lparg0, lparg1, (const char *)lparg2, (const char *)lparg3, arg4);
fail:
	if (arg3 && lparg3) (*env)->ReleaseByteArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PfExtentText__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhPoint_1t_2_3B_3BI_FUNC);
	return rc;
}
#endif

#ifndef NO_PfExtentWideText
JNIEXPORT jint JNICALL OS_NATIVE(PfExtentWideText)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jbyteArray arg2, jcharArray arg3, jint arg4)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jchar *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfExtentWideText_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetCharArrayElements(env, arg3, NULL)) == NULL) goto fail;
	rc = (jint)PfExtentWideText(lparg0, lparg1, (const char *)lparg2, (const uint16_t *)lparg3, arg4);
fail:
	if (arg3 && lparg3) (*env)->ReleaseCharArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PfExtentWideText_FUNC);
	return rc;
}
#endif

#ifndef NO_PfFontDescription
JNIEXPORT jint JNICALL OS_NATIVE(PfFontDescription)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfFontDescription_FUNC);
	rc = (jint)PfFontDescription((FontID *)arg0);
	OS_NATIVE_EXIT(env, that, PfFontDescription_FUNC);
	return rc;
}
#endif

#ifndef NO_PfFontFlags
JNIEXPORT jint JNICALL OS_NATIVE(PfFontFlags)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfFontFlags_FUNC);
	rc = (jint)PfFontFlags((FontID *)arg0);
	OS_NATIVE_EXIT(env, that, PfFontFlags_FUNC);
	return rc;
}
#endif

#ifndef NO_PfFontSize
JNIEXPORT jint JNICALL OS_NATIVE(PfFontSize)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfFontSize_FUNC);
	rc = (jint)PfFontSize((FontID *)arg0);
	OS_NATIVE_EXIT(env, that, PfFontSize_FUNC);
	return rc;
}
#endif

#ifndef NO_PfFreeFont
JNIEXPORT jint JNICALL OS_NATIVE(PfFreeFont)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfFreeFont_FUNC);
	rc = (jint)PfFreeFont((FontID *)arg0);
	OS_NATIVE_EXIT(env, that, PfFreeFont_FUNC);
	return rc;
}
#endif

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

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

#ifndef NO_PfQueryFontInfo
JNIEXPORT jint JNICALL OS_NATIVE(PfQueryFontInfo)
	(JNIEnv *env, jclass that, jbyteArray arg0, jobject arg1)
{
	jbyte *lparg0=NULL;
	FontQueryInfo _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PfQueryFontInfo_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getFontQueryInfoFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PfQueryFontInfo((const char *)lparg0, (FontQueryInfo *)lparg1);
fail:
	if (arg1 && lparg1) setFontQueryInfoFields(env, arg1, lparg1);
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PfQueryFontInfo_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PgAlphaOff
JNIEXPORT void JNICALL OS_NATIVE(PgAlphaOff)
	(JNIEnv *env, jclass that)
{
	OS_NATIVE_ENTER(env, that, PgAlphaOff_FUNC);
	PgAlphaOff();
	OS_NATIVE_EXIT(env, that, PgAlphaOff_FUNC);
}
#endif

#ifndef NO_PgAlphaOn
JNIEXPORT void JNICALL OS_NATIVE(PgAlphaOn)
	(JNIEnv *env, jclass that)
{
	OS_NATIVE_ENTER(env, that, PgAlphaOn_FUNC);
	PgAlphaOn();
	OS_NATIVE_EXIT(env, that, PgAlphaOn_FUNC);
}
#endif

#ifndef NO_PgCreateGC
JNIEXPORT jint JNICALL OS_NATIVE(PgCreateGC)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgCreateGC_FUNC);
	rc = (jint)PgCreateGC(arg0);
	OS_NATIVE_EXIT(env, that, PgCreateGC_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDestroyGC
JNIEXPORT void JNICALL OS_NATIVE(PgDestroyGC)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PgDestroyGC_FUNC);
	PgDestroyGC((PhGC_t *)arg0);
	OS_NATIVE_EXIT(env, that, PgDestroyGC_FUNC);
}
#endif

#ifndef NO_PgDrawArc
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawArc)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jint arg2, jint arg3, jint arg4)
{
	PhPoint_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawArc_FUNC);
	if (arg0) if ((lparg0 = getPhPoint_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PgDrawArc(lparg0, lparg1, arg2, arg3, arg4);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhPoint_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawArc_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawArrow
JNIEXPORT void JNICALL OS_NATIVE(PgDrawArrow)
	(JNIEnv *env, jclass that, jobject arg0, jshort arg1, jint arg2, jint arg3)
{
	PhRect_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, PgDrawArrow_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	PgDrawArrow(lparg0, arg1, (PgColor_t)arg2, arg3);
fail:
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawArrow_FUNC);
}
#endif

#ifndef NO_PgDrawBitmap
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawBitmap)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2, jobject arg3, jint arg4, jint arg5)
{
	PhPoint_t _arg2, *lparg2=NULL;
	PhDim_t _arg3, *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawBitmap_FUNC);
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	if (arg3) if ((lparg3 = getPhDim_tFields(env, arg3, &_arg3)) == NULL) goto fail;
	rc = (jint)PgDrawBitmap((void const *)arg0, (int)arg1, (PhPoint_t *)lparg2, (PhPoint_t *)lparg3, (int)arg4, (long)arg5);
fail:
	if (arg3 && lparg3) setPhDim_tFields(env, arg3, lparg3);
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PgDrawBitmap_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawEllipse
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawEllipse)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jint arg2)
{
	PhPoint_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawEllipse_FUNC);
	if (arg0) if ((lparg0 = getPhPoint_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PgDrawEllipse(lparg0, lparg1, arg2);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhPoint_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawEllipse_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawGradient
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawGradient)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8, jint arg9, jbyteArray arg10)
{
	PhPoint_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg10=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawGradient_FUNC);
	if (arg0) if ((lparg0 = getPhPoint_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg10) if ((lparg10 = (*env)->GetByteArrayElements(env, arg10, NULL)) == NULL) goto fail;
	rc = (jint)PgDrawGradient(lparg0, lparg1, arg2, arg3, arg4, (PgColor_t)arg5, (PgColor_t)arg6, (PgColor_t)arg7, (PgColor_t)arg8, arg9, (unsigned char *)lparg10);
fail:
	if (arg10 && lparg10) (*env)->ReleaseByteArrayElements(env, arg10, lparg10, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhPoint_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawGradient_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PgDrawIPixel
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawIPixel)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawIPixel_FUNC);
	rc = (jint)PgDrawIPixel(arg0, arg1);
	OS_NATIVE_EXIT(env, that, PgDrawIPixel_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PgDrawImage
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawImage)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2, jobject arg3, jint arg4, jint arg5)
{
	PhPoint_t _arg2, *lparg2=NULL;
	PhDim_t _arg3, *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawImage_FUNC);
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	if (arg3) if ((lparg3 = getPhDim_tFields(env, arg3, &_arg3)) == NULL) goto fail;
	rc = (jint)PgDrawImage((void const *)arg0, arg1, lparg2, lparg3, arg4, arg5);
fail:
	if (arg3 && lparg3) setPhDim_tFields(env, arg3, lparg3);
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PgDrawImage_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawMultiTextArea
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawMultiTextArea)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jobject arg2, jint arg3, jint arg4, jint arg5)
{
	jbyte *lparg0=NULL;
	PhRect_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawMultiTextArea_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhRect_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PgDrawMultiTextArea((char *)lparg0, arg1, lparg2, arg3, arg4, arg5);
fail:
	if (arg2 && lparg2) setPhRect_tFields(env, arg2, lparg2);
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgDrawMultiTextArea_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawPhImageRectmx
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawPhImageRectmx)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jobject arg2, jint arg3)
{
	PhPoint_t _arg0, *lparg0=NULL;
	PhRect_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawPhImageRectmx_FUNC);
	if (arg0) if ((lparg0 = getPhPoint_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhRect_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PgDrawPhImageRectmx(lparg0, (PhImage_t const *)arg1, lparg2, arg3);
fail:
	if (arg2 && lparg2) setPhRect_tFields(env, arg2, lparg2);
	if (arg0 && lparg0) setPhPoint_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawPhImageRectmx_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawPolygon
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawPolygon)
	(JNIEnv *env, jclass that, jshortArray arg0, jint arg1, jobject arg2, jint arg3)
{
	jshort *lparg0=NULL;
	PhPoint_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawPolygon_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PgDrawPolygon((PhPoint_t const *)lparg0, arg1, (PhPoint_t const *)lparg2, arg3);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	if (arg0 && lparg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgDrawPolygon_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawRoundRect
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawRoundRect)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jint arg2)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawRoundRect_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PgDrawRoundRect((PhRect_t const *)lparg0, (PhPoint_t const *)lparg1, arg2);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgDrawRoundRect_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawTImage
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawTImage)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2, jobject arg3, jint arg4, jint arg5, jint arg6, jint arg7)
{
	PhPoint_t _arg2, *lparg2=NULL;
	PhDim_t _arg3, *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawTImage_FUNC);
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	if (arg3) if ((lparg3 = getPhDim_tFields(env, arg3, &_arg3)) == NULL) goto fail;
	rc = (jint)PgDrawTImage((void const *)arg0, arg1, (PhPoint_t const *)lparg2, (PhDim_t const *)lparg3, arg4, arg5, (void const *)arg6, arg7);
fail:
	if (arg3 && lparg3) setPhDim_tFields(env, arg3, lparg3);
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PgDrawTImage_FUNC);
	return rc;
}
#endif

#ifndef NO_PgDrawText
JNIEXPORT jint JNICALL OS_NATIVE(PgDrawText)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jobject arg2, jint arg3)
{
	jbyte *lparg0=NULL;
	PhPoint_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgDrawText_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PgDrawText((char const *)lparg0, arg1, (PhPoint_t *)lparg2, arg3);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgDrawText_FUNC);
	return rc;
}
#endif

#ifndef NO_PgExtentMultiText
JNIEXPORT jint JNICALL OS_NATIVE(PgExtentMultiText)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1, jbyteArray arg2, jbyteArray arg3, jint arg4, jint arg5)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jbyte *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgExtentMultiText_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetByteArrayElements(env, arg3, NULL)) == NULL) goto fail;
	rc = (jint)PgExtentMultiText((PhRect_t *)lparg0, (PhPoint_t *)lparg1, (char *)lparg2, (char *)lparg3, arg4, arg5);
fail:
	if (arg3 && lparg3) (*env)->ReleaseByteArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgExtentMultiText_FUNC);
	return rc;
}
#endif

#ifndef NO_PgFlush
JNIEXPORT jint JNICALL OS_NATIVE(PgFlush)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgFlush_FUNC);
	rc = (jint)PgFlush();
	OS_NATIVE_EXIT(env, that, PgFlush_FUNC);
	return rc;
}
#endif

#ifndef NO_PgGetVideoMode
JNIEXPORT jint JNICALL OS_NATIVE(PgGetVideoMode)
	(JNIEnv *env, jclass that, jobject arg0)
{
	PgDisplaySettings_t _arg0={0}, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgGetVideoMode_FUNC);
	if (arg0) if ((lparg0 = getPgDisplaySettings_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)PgGetVideoMode((PgDisplaySettings_t *)lparg0);
fail:
	if (arg0 && lparg0) setPgDisplaySettings_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgGetVideoMode_FUNC);
	return rc;
}
#endif

#ifndef NO_PgGetVideoModeInfo
JNIEXPORT jint JNICALL OS_NATIVE(PgGetVideoModeInfo)
	(JNIEnv *env, jclass that, jshort arg0, jobject arg1)
{
	PgVideoModeInfo_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgGetVideoModeInfo_FUNC);
	if (arg1) if ((lparg1 = getPgVideoModeInfo_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PgGetVideoModeInfo(arg0, (PgVideoModeInfo_t *)lparg1);
fail:
	if (arg1 && lparg1) setPgVideoModeInfo_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PgGetVideoModeInfo_FUNC);
	return rc;
}
#endif

#ifndef NO_PgReadScreen
JNIEXPORT jint JNICALL OS_NATIVE(PgReadScreen)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1)
{
	PhRect_t _arg0, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgReadScreen_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)PgReadScreen((PhRect_t *)lparg0, (void *)arg1);
fail:
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgReadScreen_FUNC);
	return rc;
}
#endif

#ifndef NO_PgReadScreenSize
JNIEXPORT jint JNICALL OS_NATIVE(PgReadScreenSize)
	(JNIEnv *env, jclass that, jobject arg0)
{
	PhRect_t _arg0, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgReadScreenSize_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)PgReadScreenSize((PhRect_t *)lparg0);
fail:
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgReadScreenSize_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetAlpha
JNIEXPORT void JNICALL OS_NATIVE(PgSetAlpha)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2, jbyte arg3, jbyte arg4)
{
	PgMap_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, PgSetAlpha_FUNC);
	if (arg1) if ((lparg1 = getPgMap_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	PgSetAlpha(arg0, (PgMap_t const *)lparg1, (PgGradient_t const *)arg2, arg3, arg4);
fail:
	if (arg1 && lparg1) setPgMap_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PgSetAlpha_FUNC);
}
#endif

#ifndef NO_PgSetClipping
JNIEXPORT void JNICALL OS_NATIVE(PgSetClipping)
	(JNIEnv *env, jclass that, jshort arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PgSetClipping_FUNC);
	PgSetClipping(arg0, (PhRect_t const *)arg1);
	OS_NATIVE_EXIT(env, that, PgSetClipping_FUNC);
}
#endif

#ifndef NO_PgSetDrawBufferSize
JNIEXPORT jint JNICALL OS_NATIVE(PgSetDrawBufferSize)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetDrawBufferSize_FUNC);
	rc = (jint)PgSetDrawBufferSize(arg0);
	OS_NATIVE_EXIT(env, that, PgSetDrawBufferSize_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetDrawMode
JNIEXPORT jint JNICALL OS_NATIVE(PgSetDrawMode)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetDrawMode_FUNC);
	rc = (jint)PgSetDrawMode(arg0);
	OS_NATIVE_EXIT(env, that, PgSetDrawMode_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetFillColor
JNIEXPORT jint JNICALL OS_NATIVE(PgSetFillColor)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetFillColor_FUNC);
	rc = (jint)PgSetFillColor((PgColor_t)arg0);
	OS_NATIVE_EXIT(env, that, PgSetFillColor_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetFillTransPat
JNIEXPORT void JNICALL OS_NATIVE(PgSetFillTransPat)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, PgSetFillTransPat_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	PgSetFillTransPat((PgPattern_t)lparg0);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgSetFillTransPat_FUNC);
}
#endif

#ifndef NO_PgSetFont
JNIEXPORT void JNICALL OS_NATIVE(PgSetFont)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, PgSetFont_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	PgSetFont((char const *)lparg0);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgSetFont_FUNC);
}
#endif

#ifndef NO_PgSetGC
JNIEXPORT jint JNICALL OS_NATIVE(PgSetGC)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetGC_FUNC);
	rc = (jint)PgSetGC((PhGC_t *)arg0);
	OS_NATIVE_EXIT(env, that, PgSetGC_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetMultiClip
JNIEXPORT jint JNICALL OS_NATIVE(PgSetMultiClip)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetMultiClip_FUNC);
	rc = (jint)PgSetMultiClip(arg0, (PhRect_t const *)arg1);
	OS_NATIVE_EXIT(env, that, PgSetMultiClip_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetPalette
JNIEXPORT jint JNICALL OS_NATIVE(PgSetPalette)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshort arg2, jshort arg3, jint arg4, jint arg5)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetPalette_FUNC);
	rc = (jint)PgSetPalette((PgColor_t const *)arg0, arg1, arg2, arg3, arg4, arg5);
	OS_NATIVE_EXIT(env, that, PgSetPalette_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetRegion
JNIEXPORT void JNICALL OS_NATIVE(PgSetRegion)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PgSetRegion_FUNC);
	PgSetRegion((PhRid_t)arg0);
	OS_NATIVE_EXIT(env, that, PgSetRegion_FUNC);
}
#endif

#ifndef NO_PgSetStrokeCap
JNIEXPORT jint JNICALL OS_NATIVE(PgSetStrokeCap)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetStrokeCap_FUNC);
	rc = (jint)PgSetStrokeCap(arg0);
	OS_NATIVE_EXIT(env, that, PgSetStrokeCap_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetStrokeColor
JNIEXPORT jint JNICALL OS_NATIVE(PgSetStrokeColor)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetStrokeColor_FUNC);
	rc = (jint)PgSetStrokeColor((PgColor_t)arg0);
	OS_NATIVE_EXIT(env, that, PgSetStrokeColor_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetStrokeDash
JNIEXPORT void JNICALL OS_NATIVE(PgSetStrokeDash)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2)
{
	jbyte *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, PgSetStrokeDash_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	PgSetStrokeDash((unsigned char const *)lparg0, arg1, arg2);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PgSetStrokeDash_FUNC);
}
#endif

#ifndef NO_PgSetStrokeJoin
JNIEXPORT jint JNICALL OS_NATIVE(PgSetStrokeJoin)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetStrokeJoin_FUNC);
	rc = (jint)PgSetStrokeJoin(arg0);
	OS_NATIVE_EXIT(env, that, PgSetStrokeJoin_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetStrokeWidth
JNIEXPORT jint JNICALL OS_NATIVE(PgSetStrokeWidth)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetStrokeWidth_FUNC);
	rc = (jint)PgSetStrokeWidth(arg0);
	OS_NATIVE_EXIT(env, that, PgSetStrokeWidth_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetTextColor
JNIEXPORT jint JNICALL OS_NATIVE(PgSetTextColor)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgSetTextColor_FUNC);
	rc = (jint)PgSetTextColor((PgColor_t)arg0);
	OS_NATIVE_EXIT(env, that, PgSetTextColor_FUNC);
	return rc;
}
#endif

#ifndef NO_PgSetTextXORColor
JNIEXPORT void JNICALL OS_NATIVE(PgSetTextXORColor)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PgSetTextXORColor_FUNC);
	PgSetTextXORColor((PgColor_t)arg0, (PgColor_t)arg1);
	OS_NATIVE_EXIT(env, that, PgSetTextXORColor_FUNC);
}
#endif

#ifndef NO_PgSetUserClip
JNIEXPORT void JNICALL OS_NATIVE(PgSetUserClip)
	(JNIEnv *env, jclass that, jobject arg0)
{
	PhRect_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, PgSetUserClip_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	PgSetUserClip((PhRect_t const *)lparg0);
fail:
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PgSetUserClip_FUNC);
}
#endif

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

#ifndef NO_PgShmemDestroy
JNIEXPORT jint JNICALL OS_NATIVE(PgShmemDestroy)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PgShmemDestroy_FUNC);
	rc = (jint)PgShmemDestroy((void *)arg0);
	OS_NATIVE_EXIT(env, that, PgShmemDestroy_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PhAreaToRect
JNIEXPORT void JNICALL OS_NATIVE(PhAreaToRect)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1)
{
	PhArea_t _arg0, *lparg0=NULL;
	PhRect_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, PhAreaToRect_FUNC);
	if (arg0) if ((lparg0 = getPhArea_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	PhAreaToRect((PhArea_t const *)lparg0, (PhRect_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhArea_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PhAreaToRect_FUNC);
}
#endif

#ifndef NO_PhBlit
JNIEXPORT void JNICALL OS_NATIVE(PhBlit)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jobject arg2)
{
	PhRect_t _arg1, *lparg1=NULL;
	PhPoint_t _arg2, *lparg2=NULL;
	OS_NATIVE_ENTER(env, that, PhBlit_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	PhBlit((PhRid_t)arg0, (const PhRect_t *)lparg1, (const PhPoint_t *)lparg2);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PhBlit_FUNC);
}
#endif

#ifndef NO_PhClipTilings
JNIEXPORT jint JNICALL OS_NATIVE(PhClipTilings)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhClipTilings_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)PhClipTilings((PhTile_t *)arg0, (PhTile_t *)arg1, (PhTile_t **)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, PhClipTilings_FUNC);
	return rc;
}
#endif

#ifndef NO_PhClipboardCopy
JNIEXPORT jint JNICALL OS_NATIVE(PhClipboardCopy)
	(JNIEnv *env, jclass that, jshort arg0, jint arg1, jbyteArray arg2)
{
	jbyte *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhClipboardCopy_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)PhClipboardCopy(arg0, arg1, (PhClipHeader const *)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, PhClipboardCopy_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PhClipboardPasteFinish
JNIEXPORT void JNICALL OS_NATIVE(PhClipboardPasteFinish)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PhClipboardPasteFinish_FUNC);
	PhClipboardPasteFinish((void *)arg0);
	OS_NATIVE_EXIT(env, that, PhClipboardPasteFinish_FUNC);
}
#endif

#ifndef NO_PhClipboardPasteStart
JNIEXPORT jint JNICALL OS_NATIVE(PhClipboardPasteStart)
	(JNIEnv *env, jclass that, jshort arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhClipboardPasteStart_FUNC);
	rc = (jint)PhClipboardPasteStart(arg0);
	OS_NATIVE_EXIT(env, that, PhClipboardPasteStart_FUNC);
	return rc;
}
#endif

#ifndef NO_PhClipboardPasteString
JNIEXPORT jint JNICALL OS_NATIVE(PhClipboardPasteString)
	(JNIEnv *env, jclass that, jshort arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhClipboardPasteString_FUNC);
	rc = (jint)PhClipboardPasteString(arg0);
	OS_NATIVE_EXIT(env, that, PhClipboardPasteString_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PhClipboardPasteTypeN
JNIEXPORT jint JNICALL OS_NATIVE(PhClipboardPasteTypeN)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhClipboardPasteTypeN_FUNC);
	rc = (jint)PhClipboardPasteTypeN((void *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PhClipboardPasteTypeN_FUNC);
	return rc;
}
#endif

#ifndef NO_PhCoalesceTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhCoalesceTiles)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhCoalesceTiles_FUNC);
	rc = (jint)PhCoalesceTiles((PhTile_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhCoalesceTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhCopyTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhCopyTiles)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhCopyTiles_FUNC);
	rc = (jint)PhCopyTiles((PhTile_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhCopyTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhCreateImage
JNIEXPORT jint JNICALL OS_NATIVE(PhCreateImage)
	(JNIEnv *env, jclass that, jobject arg0, jshort arg1, jshort arg2, jint arg3, jint arg4, jint arg5, jint arg6)
{
	PhImage_t _arg0, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhCreateImage_FUNC);
	if (arg0) if ((lparg0 = getPhImage_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)PhCreateImage((PhImage_t *)lparg0, arg1, arg2, arg3, (PgColor_t const *)arg4, arg5, arg6);
fail:
	if (arg0 && lparg0) setPhImage_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PhCreateImage_FUNC);
	return rc;
}
#endif

#ifndef NO_PhDCSetCurrent
JNIEXPORT jint JNICALL OS_NATIVE(PhDCSetCurrent)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhDCSetCurrent_FUNC);
	rc = (jint)PhDCSetCurrent((void *)arg0);
	OS_NATIVE_EXIT(env, that, PhDCSetCurrent_FUNC);
	return rc;
}
#endif

#ifndef NO_PhDeTranslateTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhDeTranslateTiles)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhDeTranslateTiles_FUNC);
	rc = (jint)PhDeTranslateTiles((PhTile_t *)arg0, (PhPoint_t const *)arg1);
	OS_NATIVE_EXIT(env, that, PhDeTranslateTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhEventNext
JNIEXPORT jint JNICALL OS_NATIVE(PhEventNext)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhEventNext_FUNC);
	rc = (jint)PhEventNext((void *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PhEventNext_FUNC);
	return rc;
}
#endif

#ifndef NO_PhEventPeek
JNIEXPORT jint JNICALL OS_NATIVE(PhEventPeek)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhEventPeek_FUNC);
	rc = (jint)PhEventPeek((void *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PhEventPeek_FUNC);
	return rc;
}
#endif

#ifndef NO_PhFreeTiles
JNIEXPORT void JNICALL OS_NATIVE(PhFreeTiles)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PhFreeTiles_FUNC);
	PhFreeTiles((PhTile_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhFreeTiles_FUNC);
}
#endif

#ifndef NO_PhGetData
JNIEXPORT jint JNICALL OS_NATIVE(PhGetData)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhGetData_FUNC);
	rc = (jint)PhGetData((PhEvent_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhGetData_FUNC);
	return rc;
}
#endif

#ifndef NO_PhGetMsgSize
JNIEXPORT jint JNICALL OS_NATIVE(PhGetMsgSize)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhGetMsgSize_FUNC);
	rc = (jint)PhGetMsgSize((PhEvent_t const *)arg0);
	OS_NATIVE_EXIT(env, that, PhGetMsgSize_FUNC);
	return rc;
}
#endif

#ifndef NO_PhGetRects
JNIEXPORT jint JNICALL OS_NATIVE(PhGetRects)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhGetRects_FUNC);
	rc = (jint)PhGetRects((PhEvent_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhGetRects_FUNC);
	return rc;
}
#endif

#ifndef NO_PhInitDrag
JNIEXPORT jint JNICALL OS_NATIVE(PhInitDrag)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2, jobject arg3, jint arg4, jobject arg5, jobject arg6, jobject arg7, jobject arg8, jshortArray arg9)
{
	PhRect_t _arg2, *lparg2=NULL;
	PhRect_t _arg3, *lparg3=NULL;
	PhDim_t _arg5, *lparg5=NULL;
	PhDim_t _arg6, *lparg6=NULL;
	PhDim_t _arg7, *lparg7=NULL;
	PhPoint_t _arg8, *lparg8=NULL;
	jshort *lparg9=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhInitDrag_FUNC);
	if (arg2) if ((lparg2 = getPhRect_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	if (arg3) if ((lparg3 = getPhRect_tFields(env, arg3, &_arg3)) == NULL) goto fail;
	if (arg5) if ((lparg5 = getPhDim_tFields(env, arg5, &_arg5)) == NULL) goto fail;
	if (arg6) if ((lparg6 = getPhDim_tFields(env, arg6, &_arg6)) == NULL) goto fail;
	if (arg7) if ((lparg7 = getPhDim_tFields(env, arg7, &_arg7)) == NULL) goto fail;
	if (arg8) if ((lparg8 = getPhPoint_tFields(env, arg8, &_arg8)) == NULL) goto fail;
	if (arg9) if ((lparg9 = (*env)->GetShortArrayElements(env, arg9, NULL)) == NULL) goto fail;
	rc = (jint)PhInitDrag((PhRid_t)arg0, arg1, (const PhRect_t *)lparg2, (const PhRect_t *)lparg3, arg4, (PhDim_t *)lparg5, (PhDim_t *)lparg6, (PhDim_t *)lparg7, (PhPoint_t *)lparg8, (PhCursorDescription_t *)lparg9);
fail:
	if (arg9 && lparg9) (*env)->ReleaseShortArrayElements(env, arg9, lparg9, 0);
	if (arg8 && lparg8) setPhPoint_tFields(env, arg8, lparg8);
	if (arg7 && lparg7) setPhDim_tFields(env, arg7, lparg7);
	if (arg6 && lparg6) setPhDim_tFields(env, arg6, lparg6);
	if (arg5 && lparg5) setPhDim_tFields(env, arg5, lparg5);
	if (arg3 && lparg3) setPhRect_tFields(env, arg3, lparg3);
	if (arg2 && lparg2) setPhRect_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PhInitDrag_FUNC);
	return rc;
}
#endif

#ifndef NO_PhInputGroup
JNIEXPORT jint JNICALL OS_NATIVE(PhInputGroup)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhInputGroup_FUNC);
	rc = (jint)PhInputGroup((PhEvent_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhInputGroup_FUNC);
	return rc;
}
#endif

#ifndef NO_PhIntersectTilings
JNIEXPORT jint JNICALL OS_NATIVE(PhIntersectTilings)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2)
{
	jshort *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhIntersectTilings_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)PhIntersectTilings((PhTile_t const *)arg0, (PhTile_t const *)arg1, lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, PhIntersectTilings_FUNC);
	return rc;
}
#endif

#ifndef NO_PhKeyToMb
JNIEXPORT jint JNICALL OS_NATIVE(PhKeyToMb)
	(JNIEnv *env, jclass that, jbyteArray arg0, jobject arg1)
{
	jbyte *lparg0=NULL;
	PhKeyEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhKeyToMb_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhKeyEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PhKeyToMb((char *)lparg0, lparg1);
fail:
	if (arg1 && lparg1) setPhKeyEvent_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, PhKeyToMb_FUNC);
	return rc;
}
#endif

#ifndef NO_PhMakeGhostBitmap
JNIEXPORT jint JNICALL OS_NATIVE(PhMakeGhostBitmap)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhMakeGhostBitmap_FUNC);
	rc = (jint)PhMakeGhostBitmap((PhImage_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhMakeGhostBitmap_FUNC);
	return rc;
}
#endif

#ifndef NO_PhMakeTransBitmap
JNIEXPORT jint JNICALL OS_NATIVE(PhMakeTransBitmap)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhMakeTransBitmap_FUNC);
	rc = (jint)PhMakeTransBitmap((PhImage_t *)arg0, (PgColor_t)arg1);
	OS_NATIVE_EXIT(env, that, PhMakeTransBitmap_FUNC);
	return rc;
}
#endif

#ifndef NO_PhMergeTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhMergeTiles)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhMergeTiles_FUNC);
	rc = (jint)PhMergeTiles((PhTile_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhMergeTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhMoveCursorAbs
JNIEXPORT void JNICALL OS_NATIVE(PhMoveCursorAbs)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	OS_NATIVE_ENTER(env, that, PhMoveCursorAbs_FUNC);
	PhMoveCursorAbs(arg0, arg1, arg2);
	OS_NATIVE_EXIT(env, that, PhMoveCursorAbs_FUNC);
}
#endif

#ifndef NO_PhQueryCursor
JNIEXPORT jint JNICALL OS_NATIVE(PhQueryCursor)
	(JNIEnv *env, jclass that, jshort arg0, jobject arg1)
{
	PhCursorInfo_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhQueryCursor_FUNC);
	if (arg1) if ((lparg1 = getPhCursorInfo_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PhQueryCursor(arg0, (PhCursorInfo_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhCursorInfo_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PhQueryCursor_FUNC);
	return rc;
}
#endif

#ifndef NO_PhQueryRids
JNIEXPORT jint JNICALL OS_NATIVE(PhQueryRids)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jobject arg6, jintArray arg7, jint arg8)
{
	PhRect_t _arg6, *lparg6=NULL;
	jint *lparg7=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhQueryRids_FUNC);
	if (arg6) if ((lparg6 = getPhRect_tFields(env, arg6, &_arg6)) == NULL) goto fail;
	if (arg7) if ((lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL)) == NULL) goto fail;
	rc = (jint)PhQueryRids(arg0, (PhRid_t)arg1, arg2, arg3, arg4, (PhRid_t)arg5, (const PhRect_t *)lparg6, (PhRid_t *)lparg7, arg8);
fail:
	if (arg7 && lparg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
	if (arg6 && lparg6) setPhRect_tFields(env, arg6, lparg6);
	OS_NATIVE_EXIT(env, that, PhQueryRids_FUNC);
	return rc;
}
#endif

#ifndef NO_PhRectIntersect
JNIEXPORT jint JNICALL OS_NATIVE(PhRectIntersect)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhRectIntersect_FUNC);
	rc = (jint)PhRectIntersect((PhRect_t *)arg0, (PhRect_t const *)arg1);
	OS_NATIVE_EXIT(env, that, PhRectIntersect_FUNC);
	return rc;
}
#endif

#ifndef NO_PhRectUnion__II
JNIEXPORT jint JNICALL OS_NATIVE(PhRectUnion__II)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhRectUnion__II_FUNC);
	rc = (jint)PhRectUnion((PhRect_t *)arg0, (PhRect_t const *)arg1);
	OS_NATIVE_EXIT(env, that, PhRectUnion__II_FUNC);
	return rc;
}
#endif

#ifndef NO_PhRectUnion__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhRect_1t_2
JNIEXPORT jint JNICALL OS_NATIVE(PhRectUnion__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhRect_1t_2)
	(JNIEnv *env, jclass that, jobject arg0, jobject arg1)
{
	PhRect_t _arg0, *lparg0=NULL;
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhRectUnion__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	if (arg0) if ((lparg0 = getPhRect_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PhRectUnion((PhRect_t *)lparg0, (PhRect_t const *)lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PhRectUnion__Lorg_eclipse_swt_internal_photon_PhRect_1t_2Lorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	return rc;
}
#endif

#ifndef NO_PhRectsToTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhRectsToTiles)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhRectsToTiles_FUNC);
	rc = (jint)PhRectsToTiles((PhRect_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PhRectsToTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhRegionQuery
JNIEXPORT jint JNICALL OS_NATIVE(PhRegionQuery)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jobject arg2, jint arg3, jint arg4)
{
	PhRegion_t _arg1, *lparg1=NULL;
	PhRect_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhRegionQuery_FUNC);
	if (arg1) if ((lparg1 = getPhRegion_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhRect_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PhRegionQuery((PhRid_t)arg0, (PhRegion_t *)lparg1, (PhRect_t *)lparg2, (void *)arg3, arg4);
fail:
	if (arg2 && lparg2) setPhRect_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) setPhRegion_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PhRegionQuery_FUNC);
	return rc;
}
#endif

#ifndef NO_PhReleaseImage
JNIEXPORT void JNICALL OS_NATIVE(PhReleaseImage)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PhReleaseImage_FUNC);
	PhReleaseImage((PhImage_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhReleaseImage_FUNC);
}
#endif

#ifndef NO_PhSortTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhSortTiles)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhSortTiles_FUNC);
	rc = (jint)PhSortTiles((PhTile_t *)arg0);
	OS_NATIVE_EXIT(env, that, PhSortTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhTilesToRects
JNIEXPORT jint JNICALL OS_NATIVE(PhTilesToRects)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhTilesToRects_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jint)PhTilesToRects((PhTile_t *)arg0, (int *)lparg1);
fail:
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, PhTilesToRects_FUNC);
	return rc;
}
#endif

#ifndef NO_PhTranslateTiles
JNIEXPORT jint JNICALL OS_NATIVE(PhTranslateTiles)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhTranslateTiles_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PhTranslateTiles((PhTile_t *)arg0, (PhPoint_t const *)lparg1);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PhTranslateTiles_FUNC);
	return rc;
}
#endif

#ifndef NO_PhWindowQueryVisible
JNIEXPORT jint JNICALL OS_NATIVE(PhWindowQueryVisible)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jobject arg3)
{
	PhRect_t _arg3, *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PhWindowQueryVisible_FUNC);
	if (arg3) if ((lparg3 = getPhRect_tFields(env, arg3, &_arg3)) == NULL) goto fail;
	rc = (jint)PhWindowQueryVisible(arg0, (PhRid_t)arg1, arg2, (PhRect_t *)lparg3);
fail:
	if (arg3 && lparg3) setPhRect_tFields(env, arg3, lparg3);
	OS_NATIVE_EXIT(env, that, PhWindowQueryVisible_FUNC);
	return rc;
}
#endif

#ifndef NO_PiCropImage
JNIEXPORT jint JNICALL OS_NATIVE(PiCropImage)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PiCropImage_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PiCropImage((PhImage_t *)arg0, (PhRect_t const *)lparg1, arg2);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PiCropImage_FUNC);
	return rc;
}
#endif

#ifndef NO_PiDuplicateImage
JNIEXPORT jint JNICALL OS_NATIVE(PiDuplicateImage)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PiDuplicateImage_FUNC);
	rc = (jint)PiDuplicateImage((PhImage_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PiDuplicateImage_FUNC);
	return rc;
}
#endif

#ifndef NO_PmMemCreateMC
JNIEXPORT jint JNICALL OS_NATIVE(PmMemCreateMC)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jobject arg2)
{
	PhDim_t _arg1, *lparg1=NULL;
	PhPoint_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PmMemCreateMC_FUNC);
	if (arg1) if ((lparg1 = getPhDim_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PmMemCreateMC((PhImage_t *)arg0, (PhDim_t *)lparg1, (PhPoint_t *)lparg2);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) setPhDim_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PmMemCreateMC_FUNC);
	return rc;
}
#endif

#ifndef NO_PmMemFlush
JNIEXPORT jint JNICALL OS_NATIVE(PmMemFlush)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PmMemFlush_FUNC);
	rc = (jint)PmMemFlush((PmMemoryContext_t *)arg0, (PhImage_t *)arg1);
	OS_NATIVE_EXIT(env, that, PmMemFlush_FUNC);
	return rc;
}
#endif

#ifndef NO_PmMemReleaseMC
JNIEXPORT void JNICALL OS_NATIVE(PmMemReleaseMC)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PmMemReleaseMC_FUNC);
	PmMemReleaseMC((PmMemoryContext_t *)arg0);
	OS_NATIVE_EXIT(env, that, PmMemReleaseMC_FUNC);
}
#endif

#ifndef NO_PmMemStart
JNIEXPORT jint JNICALL OS_NATIVE(PmMemStart)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PmMemStart_FUNC);
	rc = (jint)PmMemStart((PmMemoryContext_t *)arg0);
	OS_NATIVE_EXIT(env, that, PmMemStart_FUNC);
	return rc;
}
#endif

#ifndef NO_PmMemStop
JNIEXPORT jint JNICALL OS_NATIVE(PmMemStop)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PmMemStop_FUNC);
	rc = (jint)PmMemStop((PmMemoryContext_t *)arg0);
	OS_NATIVE_EXIT(env, that, PmMemStop_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAddCallback
JNIEXPORT void JNICALL OS_NATIVE(PtAddCallback)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, PtAddCallback_FUNC);
	PtAddCallback((PtWidget_t *)arg0, arg1, (PtCallbackF_t *)arg2, (void *)arg3);
	OS_NATIVE_EXIT(env, that, PtAddCallback_FUNC);
}
#endif

#ifndef NO_PtAddEventHandler
JNIEXPORT void JNICALL OS_NATIVE(PtAddEventHandler)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, PtAddEventHandler_FUNC);
	PtAddEventHandler((PtWidget_t *)arg0, arg1, (PtCallbackF_t *)arg2, (void *)arg3);
	OS_NATIVE_EXIT(env, that, PtAddEventHandler_FUNC);
}
#endif

#ifndef NO_PtAddFilterCallback
JNIEXPORT void JNICALL OS_NATIVE(PtAddFilterCallback)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, PtAddFilterCallback_FUNC);
	PtAddFilterCallback((PtWidget_t *)arg0, arg1, (PtCallbackF_t *)arg2, (void *)arg3);
	OS_NATIVE_EXIT(env, that, PtAddFilterCallback_FUNC);
}
#endif

#ifndef NO_PtAddHotkeyHandler
JNIEXPORT void JNICALL OS_NATIVE(PtAddHotkeyHandler)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jshort arg3, jint arg4, jint arg5)
{
	OS_NATIVE_ENTER(env, that, PtAddHotkeyHandler_FUNC);
	PtAddHotkeyHandler((PtWidget_t *)arg0, arg1, arg2, arg3, (void *)arg4, (PtCallbackF_t *)arg5);
	OS_NATIVE_EXIT(env, that, PtAddHotkeyHandler_FUNC);
}
#endif

#ifndef NO_PtAlert
JNIEXPORT jint JNICALL OS_NATIVE(PtAlert)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jbyteArray arg2, jint arg3, jbyteArray arg4, jbyteArray arg5, jint arg6, jintArray arg7, jintArray arg8, jint arg9, jint arg10, jint arg11)
{
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jbyte *lparg4=NULL;
	jbyte *lparg5=NULL;
	jint *lparg7=NULL;
	jint *lparg8=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAlert_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetByteArrayElements(env, arg4, NULL)) == NULL) goto fail;
	if (arg5) if ((lparg5 = (*env)->GetByteArrayElements(env, arg5, NULL)) == NULL) goto fail;
	if (arg7) if ((lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL)) == NULL) goto fail;
	if (arg8) if ((lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL)) == NULL) goto fail;
	rc = (jint)PtAlert((PtWidget_t *)arg0, (PhPoint_t const *)lparg1, (char const *)lparg2, (PhImage_t const *)arg3, (char const *)lparg4, (char const *)lparg5, arg6, (char const **)lparg7, (char const **)lparg8, arg9, arg10, arg11);
fail:
	if (arg8 && lparg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);
	if (arg7 && lparg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
	if (arg5 && lparg5) (*env)->ReleaseByteArrayElements(env, arg5, lparg5, 0);
	if (arg4 && lparg4) (*env)->ReleaseByteArrayElements(env, arg4, lparg4, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtAlert_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppAddInput
JNIEXPORT jint JNICALL OS_NATIVE(PtAppAddInput)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAppAddInput_FUNC);
	rc = (jint)PtAppAddInput((PtAppContext_t)arg0, (pid_t)arg1, (PtInputCallbackProc_t)arg2, (void *)arg3);
	OS_NATIVE_EXIT(env, that, PtAppAddInput_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppAddWorkProc
JNIEXPORT jint JNICALL OS_NATIVE(PtAppAddWorkProc)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAppAddWorkProc_FUNC);
	rc = (jint)PtAppAddWorkProc((PtAppContext_t)arg0, (PtWorkProc_t)arg1, (void *)arg2);
	OS_NATIVE_EXIT(env, that, PtAppAddWorkProc_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppCreatePulse
JNIEXPORT jint JNICALL OS_NATIVE(PtAppCreatePulse)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAppCreatePulse_FUNC);
	rc = (jint)PtAppCreatePulse((PtAppContext_t)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PtAppCreatePulse_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppDeletePulse
JNIEXPORT jint JNICALL OS_NATIVE(PtAppDeletePulse)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAppDeletePulse_FUNC);
	rc = (jint)PtAppDeletePulse((PtAppContext_t)arg0, (pid_t)arg1);
	OS_NATIVE_EXIT(env, that, PtAppDeletePulse_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppProcessEvent
JNIEXPORT void JNICALL OS_NATIVE(PtAppProcessEvent)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PtAppProcessEvent_FUNC);
	PtAppProcessEvent((PtAppContext_t)arg0);
	OS_NATIVE_EXIT(env, that, PtAppProcessEvent_FUNC);
}
#endif

#ifndef NO_PtAppPulseTrigger
JNIEXPORT jint JNICALL OS_NATIVE(PtAppPulseTrigger)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtAppPulseTrigger_FUNC);
	rc = (jint)PtAppPulseTrigger((PtAppContext_t)arg0, (pid_t)arg1);
	OS_NATIVE_EXIT(env, that, PtAppPulseTrigger_FUNC);
	return rc;
}
#endif

#ifndef NO_PtAppRemoveInput
JNIEXPORT void JNICALL OS_NATIVE(PtAppRemoveInput)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtAppRemoveInput_FUNC);
	PtAppRemoveInput((PtAppContext_t)arg0, (PtInputId_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtAppRemoveInput_FUNC);
}
#endif

#ifndef NO_PtAppRemoveWorkProc
JNIEXPORT void JNICALL OS_NATIVE(PtAppRemoveWorkProc)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtAppRemoveWorkProc_FUNC);
	PtAppRemoveWorkProc((PtAppContext_t)arg0, (PtWorkProcId_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtAppRemoveWorkProc_FUNC);
}
#endif

#ifndef NO_PtBeep
JNIEXPORT jint JNICALL OS_NATIVE(PtBeep)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtBeep_FUNC);
	rc = (jint)PtBeep();
	OS_NATIVE_EXIT(env, that, PtBeep_FUNC);
	return rc;
}
#endif

#ifndef NO_PtBlit
JNIEXPORT jint JNICALL OS_NATIVE(PtBlit)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jobject arg2)
{
	PhRect_t _arg1, *lparg1=NULL;
	PhPoint_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtBlit_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PtBlit((PtWidget_t const *)arg0, (PhRect_t const *)lparg1, (PhPoint_t const *)lparg2);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtBlit_FUNC);
	return rc;
}
#endif

#ifndef NO_PtBlockAllWindows
JNIEXPORT jint JNICALL OS_NATIVE(PtBlockAllWindows)
	(JNIEnv *env, jclass that, jint arg0, jshort arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtBlockAllWindows_FUNC);
	rc = (jint)PtBlockAllWindows((PtWidget_t *)arg0, arg1, (PgColor_t)arg2);
	OS_NATIVE_EXIT(env, that, PtBlockAllWindows_FUNC);
	return rc;
}
#endif

#ifndef NO_PtBlockWindow
JNIEXPORT jint JNICALL OS_NATIVE(PtBlockWindow)
	(JNIEnv *env, jclass that, jint arg0, jshort arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtBlockWindow_FUNC);
	rc = (jint)PtBlockWindow((PtWidget_t *)arg0, arg1, (PgColor_t)arg2);
	OS_NATIVE_EXIT(env, that, PtBlockWindow_FUNC);
	return rc;
}
#endif

#ifndef NO_PtButton
JNIEXPORT jint JNICALL OS_NATIVE(PtButton)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtButton_FUNC);
	rc = (jint)PtButton;
	OS_NATIVE_EXIT(env, that, PtButton_FUNC);
	return rc;
}
#endif

#ifndef NO_PtCalcBorder
JNIEXPORT void JNICALL OS_NATIVE(PtCalcBorder)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhRect_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, PtCalcBorder_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	PtCalcBorder((PtWidget_t *)arg0, lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtCalcBorder_FUNC);
}
#endif

#ifndef NO_PtCalcCanvas
JNIEXPORT jint JNICALL OS_NATIVE(PtCalcCanvas)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtCalcCanvas_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtCalcCanvas((PtWidget_t *)arg0, (PhRect_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtCalcCanvas_FUNC);
	return rc;
}
#endif

#ifndef NO_PtClippedBlit
JNIEXPORT jint JNICALL OS_NATIVE(PtClippedBlit)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2, jint arg3)
{
	PhPoint_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtClippedBlit_FUNC);
	if (arg2) if ((lparg2 = getPhPoint_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PtClippedBlit((PtWidget_t const *)arg0, (PhTile_t const *)arg1, (PhPoint_t const *)lparg2, (PhTile_t const *)arg3);
fail:
	if (arg2 && lparg2) setPhPoint_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PtClippedBlit_FUNC);
	return rc;
}
#endif

#ifndef NO_PtColorSelect
JNIEXPORT jint JNICALL OS_NATIVE(PtColorSelect)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jobject arg2)
{
	jbyte *lparg1=NULL;
	PtColorSelectInfo_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtColorSelect_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPtColorSelectInfo_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PtColorSelect((PtWidget_t *)arg0, (char *)lparg1, lparg2);
fail:
	if (arg2 && lparg2) setPtColorSelectInfo_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, PtColorSelect_FUNC);
	return rc;
}
#endif

#ifndef NO_PtComboBox
JNIEXPORT jint JNICALL OS_NATIVE(PtComboBox)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtComboBox_FUNC);
	rc = (jint)PtComboBox;
	OS_NATIVE_EXIT(env, that, PtComboBox_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainer
JNIEXPORT jint JNICALL OS_NATIVE(PtContainer)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainer_FUNC);
	rc = (jint)PtContainer;
	OS_NATIVE_EXIT(env, that, PtContainer_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerFindFocus
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerFindFocus)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerFindFocus_FUNC);
	rc = (jint)PtContainerFindFocus((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtContainerFindFocus_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerFocusNext
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerFocusNext)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerFocusNext_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtContainerFocusNext((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtContainerFocusNext_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerFocusPrev
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerFocusPrev)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerFocusPrev_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtContainerFocusPrev((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtContainerFocusPrev_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerGiveFocus
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerGiveFocus)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerGiveFocus_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtContainerGiveFocus((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtContainerGiveFocus_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerHold
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerHold)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerHold_FUNC);
	rc = (jint)PtContainerHold((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtContainerHold_FUNC);
	return rc;
}
#endif

#ifndef NO_PtContainerRelease
JNIEXPORT jint JNICALL OS_NATIVE(PtContainerRelease)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtContainerRelease_FUNC);
	rc = (jint)PtContainerRelease((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtContainerRelease_FUNC);
	return rc;
}
#endif

#ifndef NO_PtCreateAppContext
JNIEXPORT jint JNICALL OS_NATIVE(PtCreateAppContext)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtCreateAppContext_FUNC);
	rc = (jint)PtCreateAppContext();
	OS_NATIVE_EXIT(env, that, PtCreateAppContext_FUNC);
	return rc;
}
#endif

#ifndef NO_PtCreateWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtCreateWidget)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtCreateWidget_FUNC);
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	rc = (jint)PtCreateWidget((PtWidgetClassRef_t *)arg0, (PtWidget_t *)arg1, arg2, (PtArg_t const *)lparg3);
fail:
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	OS_NATIVE_EXIT(env, that, PtCreateWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtCreateWidgetClass
JNIEXPORT jint JNICALL OS_NATIVE(PtCreateWidgetClass)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtCreateWidgetClass_FUNC);
	if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
	rc = (jint)PtCreateWidgetClass((PtWidgetClassRef_t *)arg0, arg1, arg2, (PtArg_t const *)lparg3);
fail:
	if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	OS_NATIVE_EXIT(env, that, PtCreateWidgetClass_FUNC);
	return rc;
}
#endif

#ifndef NO_PtDamageExtent
JNIEXPORT jint JNICALL OS_NATIVE(PtDamageExtent)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtDamageExtent_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtDamageExtent((PtWidget_t *)arg0, (PhRect_t const *)lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtDamageExtent_FUNC);
	return rc;
}
#endif

#ifndef NO_PtDamageWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtDamageWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtDamageWidget_FUNC);
	rc = (jint)PtDamageWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtDamageWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtDestroyWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtDestroyWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtDestroyWidget_FUNC);
	rc = (jint)PtDestroyWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtDestroyWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtDisjoint
JNIEXPORT jint JNICALL OS_NATIVE(PtDisjoint)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtDisjoint_FUNC);
	rc = (jint)PtDisjoint;
	OS_NATIVE_EXIT(env, that, PtDisjoint_FUNC);
	return rc;
}
#endif

#ifndef NO_PtEnter
JNIEXPORT jint JNICALL OS_NATIVE(PtEnter)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtEnter_FUNC);
	rc = (jint)PtEnter(arg0);
	OS_NATIVE_EXIT(env, that, PtEnter_FUNC);
	return rc;
}
#endif

#ifndef NO_PtEventHandler
JNIEXPORT jint JNICALL OS_NATIVE(PtEventHandler)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtEventHandler_FUNC);
	rc = (jint)PtEventHandler((PhEvent_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtEventHandler_FUNC);
	return rc;
}
#endif

#ifndef NO_PtExtentWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtExtentWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtExtentWidget_FUNC);
	rc = (jint)PtExtentWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtExtentWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtExtentWidgetFamily
JNIEXPORT jint JNICALL OS_NATIVE(PtExtentWidgetFamily)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtExtentWidgetFamily_FUNC);
	rc = (jint)PtExtentWidgetFamily((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtExtentWidgetFamily_FUNC);
	return rc;
}
#endif

#ifndef NO_PtFileSelection
JNIEXPORT jint JNICALL OS_NATIVE(PtFileSelection)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jbyteArray arg2, jbyteArray arg3, jbyteArray arg4, jbyteArray arg5, jbyteArray arg6, jbyteArray arg7, jobject arg8, jint arg9)
{
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jbyte *lparg3=NULL;
	jbyte *lparg4=NULL;
	jbyte *lparg5=NULL;
	jbyte *lparg6=NULL;
	jbyte *lparg7=NULL;
	PtFileSelectionInfo_t _arg8={0}, *lparg8=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtFileSelection_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetByteArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetByteArrayElements(env, arg4, NULL)) == NULL) goto fail;
	if (arg5) if ((lparg5 = (*env)->GetByteArrayElements(env, arg5, NULL)) == NULL) goto fail;
	if (arg6) if ((lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL)) == NULL) goto fail;
	if (arg7) if ((lparg7 = (*env)->GetByteArrayElements(env, arg7, NULL)) == NULL) goto fail;
	if (arg8) if ((lparg8 = getPtFileSelectionInfo_tFields(env, arg8, &_arg8)) == NULL) goto fail;
	rc = (jint)PtFileSelection((PtWidget_t *)arg0, (PhPoint_t const *)lparg1, (char const *)lparg2, (char const *)lparg3, (char const *)lparg4, (char const *)lparg5, (char const *)lparg6, (char const *)lparg7, (PtFileSelectionInfo_t *)lparg8, arg9);
fail:
	if (arg8 && lparg8) setPtFileSelectionInfo_tFields(env, arg8, lparg8);
	if (arg7 && lparg7) (*env)->ReleaseByteArrayElements(env, arg7, lparg7, 0);
	if (arg6 && lparg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
	if (arg5 && lparg5) (*env)->ReleaseByteArrayElements(env, arg5, lparg5, 0);
	if (arg4 && lparg4) (*env)->ReleaseByteArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseByteArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtFileSelection_FUNC);
	return rc;
}
#endif

#ifndef NO_PtFindDisjoint
JNIEXPORT jint JNICALL OS_NATIVE(PtFindDisjoint)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtFindDisjoint_FUNC);
	rc = (jint)PtFindDisjoint((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtFindDisjoint_FUNC);
	return rc;
}
#endif

#ifndef NO_PtFlush
JNIEXPORT jint JNICALL OS_NATIVE(PtFlush)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtFlush_FUNC);
	rc = (jint)PtFlush();
	OS_NATIVE_EXIT(env, that, PtFlush_FUNC);
	return rc;
}
#endif

#ifndef NO_PtFontSelection
JNIEXPORT jint JNICALL OS_NATIVE(PtFontSelection)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jbyteArray arg2, jbyteArray arg3, jint arg4, jint arg5, jbyteArray arg6)
{
	PhPoint_t _arg1, *lparg1=NULL;
	jbyte *lparg2=NULL;
	jbyte *lparg3=NULL;
	jbyte *lparg6=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtFontSelection_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL)) == NULL) goto fail;
	if (arg3) if ((lparg3 = (*env)->GetByteArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg6) if ((lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL)) == NULL) goto fail;
	rc = (jint)PtFontSelection((PtWidget_t *)arg0, (const PhPoint_t *)lparg1, (const char *)lparg2, (const char *)lparg3, arg4, arg5, (const char *)lparg6);
fail:
	if (arg6 && lparg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
	if (arg3 && lparg3) (*env)->ReleaseByteArrayElements(env, arg3, lparg3, 0);
	if (arg2 && lparg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtFontSelection_FUNC);
	return rc;
}
#endif

#ifndef NO_PtForwardWindowEvent
JNIEXPORT jint JNICALL OS_NATIVE(PtForwardWindowEvent)
	(JNIEnv *env, jclass that, jobject arg0)
{
	PhWindowEvent_t _arg0, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtForwardWindowEvent_FUNC);
	if (arg0) if ((lparg0 = getPhWindowEvent_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)PtForwardWindowEvent((PhWindowEvent_t const *)lparg0);
fail:
	if (arg0 && lparg0) setPhWindowEvent_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, PtForwardWindowEvent_FUNC);
	return rc;
}
#endif

#ifndef NO_PtFrameSize
JNIEXPORT void JNICALL OS_NATIVE(PtFrameSize)
	(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;
	OS_NATIVE_ENTER(env, that, PtFrameSize_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;
	PtFrameSize(arg0, arg1, lparg2, lparg3, lparg4, 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, PtFrameSize_FUNC);
}
#endif

#ifndef NO_PtGetAbsPosition
JNIEXPORT void JNICALL OS_NATIVE(PtGetAbsPosition)
	(JNIEnv *env, jclass that, jint arg0, jshortArray arg1, jshortArray arg2)
{
	jshort *lparg1=NULL;
	jshort *lparg2=NULL;
	OS_NATIVE_ENTER(env, that, PtGetAbsPosition_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL)) == NULL) goto fail;
	if (arg2) if ((lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL)) == NULL) goto fail;
	PtGetAbsPosition((PtWidget_t *)arg0, lparg1, lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);
	if (arg1 && lparg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, PtGetAbsPosition_FUNC);
}
#endif

#ifndef NO_PtGetResources
JNIEXPORT jint JNICALL OS_NATIVE(PtGetResources)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGetResources_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)PtGetResources((PtWidget_t *)arg0, arg1, (PtArg_t *)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, PtGetResources_FUNC);
	return rc;
}
#endif

#ifndef NO_PtGlobalFocusNext
JNIEXPORT jint JNICALL OS_NATIVE(PtGlobalFocusNext)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGlobalFocusNext_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtGlobalFocusNext((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtGlobalFocusNext_FUNC);
	return rc;
}
#endif

#ifndef NO_PtGlobalFocusNextContainer
JNIEXPORT jint JNICALL OS_NATIVE(PtGlobalFocusNextContainer)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGlobalFocusNextContainer_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtGlobalFocusNextContainer((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtGlobalFocusNextContainer_FUNC);
	return rc;
}
#endif

#ifndef NO_PtGlobalFocusPrev
JNIEXPORT jint JNICALL OS_NATIVE(PtGlobalFocusPrev)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGlobalFocusPrev_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtGlobalFocusPrev((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtGlobalFocusPrev_FUNC);
	return rc;
}
#endif

#ifndef NO_PtGlobalFocusPrevContainer
JNIEXPORT jint JNICALL OS_NATIVE(PtGlobalFocusPrevContainer)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGlobalFocusPrevContainer_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtGlobalFocusPrevContainer((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtGlobalFocusPrevContainer_FUNC);
	return rc;
}
#endif

#ifndef NO_PtGroup
JNIEXPORT jint JNICALL OS_NATIVE(PtGroup)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtGroup_FUNC);
	rc = (jint)PtGroup;
	OS_NATIVE_EXIT(env, that, PtGroup_FUNC);
	return rc;
}
#endif

#ifndef NO_PtHit
JNIEXPORT jint JNICALL OS_NATIVE(PtHit)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2)
{
	PhRect_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtHit_FUNC);
	if (arg2) if ((lparg2 = getPhRect_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PtHit(( PtWidget_t *)arg0, arg1, (PhRect_t const *)lparg2);
fail:
	if (arg2 && lparg2) setPhRect_tFields(env, arg2, lparg2);
	OS_NATIVE_EXIT(env, that, PtHit_FUNC);
	return rc;
}
#endif

#ifndef NO_PtHold
JNIEXPORT jint JNICALL OS_NATIVE(PtHold)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtHold_FUNC);
	rc = (jint)PtHold();
	OS_NATIVE_EXIT(env, that, PtHold_FUNC);
	return rc;
}
#endif

#ifndef NO_PtInflateBalloon
JNIEXPORT jint JNICALL OS_NATIVE(PtInflateBalloon)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jbyteArray arg3, jbyteArray arg4, jint arg5, jint arg6)
{
	jbyte *lparg3=NULL;
	jbyte *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtInflateBalloon_FUNC);
	if (arg3) if ((lparg3 = (*env)->GetByteArrayElements(env, arg3, NULL)) == NULL) goto fail;
	if (arg4) if ((lparg4 = (*env)->GetByteArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)PtInflateBalloon((PtWidget_t *)arg0, (PtWidget_t *)arg1, arg2, (char const *)lparg3, (char const *)lparg4, (PgColor_t)arg5, (PgColor_t)arg6);
fail:
	if (arg4 && lparg4) (*env)->ReleaseByteArrayElements(env, arg4, lparg4, 0);
	if (arg3 && lparg3) (*env)->ReleaseByteArrayElements(env, arg3, lparg3, 0);
	OS_NATIVE_EXIT(env, that, PtInflateBalloon_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PtIsFocused
JNIEXPORT jint JNICALL OS_NATIVE(PtIsFocused)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtIsFocused_FUNC);
	rc = (jint)PtIsFocused((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtIsFocused_FUNC);
	return rc;
}
#endif

#ifndef NO_PtLabel
JNIEXPORT jint JNICALL OS_NATIVE(PtLabel)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtLabel_FUNC);
	rc = (jint)PtLabel;
	OS_NATIVE_EXIT(env, that, PtLabel_FUNC);
	return rc;
}
#endif

#ifndef NO_PtLeave
JNIEXPORT jint JNICALL OS_NATIVE(PtLeave)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtLeave_FUNC);
	rc = (jint)PtLeave(arg0);
	OS_NATIVE_EXIT(env, that, PtLeave_FUNC);
	return rc;
}
#endif

#ifndef NO_PtList
JNIEXPORT jint JNICALL OS_NATIVE(PtList)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtList_FUNC);
	rc = (jint)PtList;
	OS_NATIVE_EXIT(env, that, PtList_FUNC);
	return rc;
}
#endif

#ifndef NO_PtListAddItems
JNIEXPORT jint JNICALL OS_NATIVE(PtListAddItems)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jint arg2, jint arg3)
{
	jint *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtListAddItems_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jint)PtListAddItems((PtWidget_t *)arg0, (const char **)lparg1, arg2, arg3);
fail:
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, PtListAddItems_FUNC);
	return rc;
}
#endif

#ifndef NO_PtListDeleteAllItems
JNIEXPORT jint JNICALL OS_NATIVE(PtListDeleteAllItems)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtListDeleteAllItems_FUNC);
	rc = (jint)PtListDeleteAllItems((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtListDeleteAllItems_FUNC);
	return rc;
}
#endif

#ifndef NO_PtListDeleteItemPos
JNIEXPORT jint JNICALL OS_NATIVE(PtListDeleteItemPos)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtListDeleteItemPos_FUNC);
	rc = (jint)PtListDeleteItemPos((PtWidget_t *)arg0, arg1, arg2);
	OS_NATIVE_EXIT(env, that, PtListDeleteItemPos_FUNC);
	return rc;
}
#endif

#ifndef NO_PtListGotoPos
JNIEXPORT void JNICALL OS_NATIVE(PtListGotoPos)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtListGotoPos_FUNC);
	PtListGotoPos((PtWidget_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PtListGotoPos_FUNC);
}
#endif

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

#ifndef NO_PtListReplaceItemPos
JNIEXPORT jint JNICALL OS_NATIVE(PtListReplaceItemPos)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jint arg2, jint arg3)
{
	jint *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtListReplaceItemPos_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	rc = (jint)PtListReplaceItemPos((PtWidget_t *)arg0, (const char **)lparg1, arg2, arg3);
fail:
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	OS_NATIVE_EXIT(env, that, PtListReplaceItemPos_FUNC);
	return rc;
}
#endif

#ifndef NO_PtListSelectPos
JNIEXPORT void JNICALL OS_NATIVE(PtListSelectPos)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtListSelectPos_FUNC);
	PtListSelectPos((PtWidget_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PtListSelectPos_FUNC);
}
#endif

#ifndef NO_PtListUnselectPos
JNIEXPORT void JNICALL OS_NATIVE(PtListUnselectPos)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtListUnselectPos_FUNC);
	PtListUnselectPos((PtWidget_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PtListUnselectPos_FUNC);
}
#endif

#ifndef NO_PtMainLoop
JNIEXPORT void JNICALL OS_NATIVE(PtMainLoop)
	(JNIEnv *env, jclass that)
{
	OS_NATIVE_ENTER(env, that, PtMainLoop_FUNC);
	PtMainLoop();
	OS_NATIVE_EXIT(env, that, PtMainLoop_FUNC);
}
#endif

#ifndef NO_PtMenu
JNIEXPORT jint JNICALL OS_NATIVE(PtMenu)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtMenu_FUNC);
	rc = (jint)PtMenu;
	OS_NATIVE_EXIT(env, that, PtMenu_FUNC);
	return rc;
}
#endif

#ifndef NO_PtMenuBar
JNIEXPORT jint JNICALL OS_NATIVE(PtMenuBar)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtMenuBar_FUNC);
	rc = (jint)PtMenuBar;
	OS_NATIVE_EXIT(env, that, PtMenuBar_FUNC);
	return rc;
}
#endif

#ifndef NO_PtMenuButton
JNIEXPORT jint JNICALL OS_NATIVE(PtMenuButton)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtMenuButton_FUNC);
	rc = (jint)PtMenuButton;
	OS_NATIVE_EXIT(env, that, PtMenuButton_FUNC);
	return rc;
}
#endif

#ifndef NO_PtMultiText
JNIEXPORT jint JNICALL OS_NATIVE(PtMultiText)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtMultiText_FUNC);
	rc = (jint)PtMultiText;
	OS_NATIVE_EXIT(env, that, PtMultiText_FUNC);
	return rc;
}
#endif

#ifndef NO_PtNextTopLevelWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtNextTopLevelWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtNextTopLevelWidget_FUNC);
	rc = (jint)PtNextTopLevelWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtNextTopLevelWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtNumericInteger
JNIEXPORT jint JNICALL OS_NATIVE(PtNumericInteger)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtNumericInteger_FUNC);
	rc = (jint)PtNumericInteger;
	OS_NATIVE_EXIT(env, that, PtNumericInteger_FUNC);
	return rc;
}
#endif

#ifndef NO_PtPane
JNIEXPORT jint JNICALL OS_NATIVE(PtPane)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtPane_FUNC);
	rc = (jint)PtPane;
	OS_NATIVE_EXIT(env, that, PtPane_FUNC);
	return rc;
}
#endif

#ifndef NO_PtPanelGroup
JNIEXPORT jint JNICALL OS_NATIVE(PtPanelGroup)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtPanelGroup_FUNC);
	rc = (jint)PtPanelGroup;
	OS_NATIVE_EXIT(env, that, PtPanelGroup_FUNC);
	return rc;
}
#endif

#ifndef NO_PtPositionMenu
JNIEXPORT void JNICALL OS_NATIVE(PtPositionMenu)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhEvent_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, PtPositionMenu_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	PtPositionMenu((PtWidget_t *)arg0, (PhEvent_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhEvent_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtPositionMenu_FUNC);
}
#endif

#ifndef NO_PtProgress
JNIEXPORT jint JNICALL OS_NATIVE(PtProgress)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtProgress_FUNC);
	rc = (jint)PtProgress;
	OS_NATIVE_EXIT(env, that, PtProgress_FUNC);
	return rc;
}
#endif

#ifndef NO_PtReParentWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtReParentWidget)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtReParentWidget_FUNC);
	rc = (jint)PtReParentWidget((PtWidget_t *)arg0, (PtWidget_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtReParentWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtRealizeWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtRealizeWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtRealizeWidget_FUNC);
	rc = (jint)PtRealizeWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtRealizeWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtRegion
JNIEXPORT jint JNICALL OS_NATIVE(PtRegion)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtRegion_FUNC);
	rc = (jint)PtRegion;
	OS_NATIVE_EXIT(env, that, PtRegion_FUNC);
	return rc;
}
#endif

#ifndef NO_PtRelease
JNIEXPORT jint JNICALL OS_NATIVE(PtRelease)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtRelease_FUNC);
	rc = (jint)PtRelease();
	OS_NATIVE_EXIT(env, that, PtRelease_FUNC);
	return rc;
}
#endif

#ifndef NO_PtRemoveCallback
JNIEXPORT void JNICALL OS_NATIVE(PtRemoveCallback)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	OS_NATIVE_ENTER(env, that, PtRemoveCallback_FUNC);
	PtRemoveCallback((PtWidget_t *)arg0, arg1, (PtCallbackF_t *)arg2, (void *)arg3);
	OS_NATIVE_EXIT(env, that, PtRemoveCallback_FUNC);
}
#endif

#ifndef NO_PtRemoveHotkeyHandler
JNIEXPORT void JNICALL OS_NATIVE(PtRemoveHotkeyHandler)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jshort arg3, jint arg4, jint arg5)
{
	OS_NATIVE_ENTER(env, that, PtRemoveHotkeyHandler_FUNC);
	PtRemoveHotkeyHandler((PtWidget_t *)arg0, arg1, arg2, arg3, (void *)arg4, (PtCallbackF_t *)arg5);
	OS_NATIVE_EXIT(env, that, PtRemoveHotkeyHandler_FUNC);
}
#endif

#ifndef NO_PtScrollArea
JNIEXPORT jint JNICALL OS_NATIVE(PtScrollArea)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtScrollArea_FUNC);
	rc = (jint)PtScrollArea;
	OS_NATIVE_EXIT(env, that, PtScrollArea_FUNC);
	return rc;
}
#endif

#ifndef NO_PtScrollContainer
JNIEXPORT jint JNICALL OS_NATIVE(PtScrollContainer)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtScrollContainer_FUNC);
	rc = (jint)PtScrollContainer;
	OS_NATIVE_EXIT(env, that, PtScrollContainer_FUNC);
	return rc;
}
#endif

#ifndef NO_PtScrollbar
JNIEXPORT jint JNICALL OS_NATIVE(PtScrollbar)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtScrollbar_FUNC);
	rc = (jint)PtScrollbar;
	OS_NATIVE_EXIT(env, that, PtScrollbar_FUNC);
	return rc;
}
#endif

#ifndef NO_PtSendEventToWidget
JNIEXPORT void JNICALL OS_NATIVE(PtSendEventToWidget)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, PtSendEventToWidget_FUNC);
	PtSendEventToWidget((PtWidget_t *)arg0, (PhEvent_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtSendEventToWidget_FUNC);
}
#endif

#ifndef NO_PtSeparator
JNIEXPORT jint JNICALL OS_NATIVE(PtSeparator)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSeparator_FUNC);
	rc = (jint)PtSeparator;
	OS_NATIVE_EXIT(env, that, PtSeparator_FUNC);
	return rc;
}
#endif

#ifndef NO_PtSetAreaFromWidgetCanvas
JNIEXPORT jint JNICALL OS_NATIVE(PtSetAreaFromWidgetCanvas)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jobject arg2)
{
	PhRect_t _arg1, *lparg1=NULL;
	PhArea_t _arg2, *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSetAreaFromWidgetCanvas_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	if (arg2) if ((lparg2 = getPhArea_tFields(env, arg2, &_arg2)) == NULL) goto fail;
	rc = (jint)PtSetAreaFromWidgetCanvas((PtWidget_t *)arg0, lparg1, lparg2);
fail:
	if (arg2 && lparg2) setPhArea_tFields(env, arg2, lparg2);
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtSetAreaFromWidgetCanvas_FUNC);
	return rc;
}
#endif

#ifndef NO_PtSetParentWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtSetParentWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSetParentWidget_FUNC);
	rc = (jint)PtSetParentWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtSetParentWidget_FUNC);
	return rc;
}
#endif

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

#ifndef NO_PtSetResources
JNIEXPORT jint JNICALL OS_NATIVE(PtSetResources)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSetResources_FUNC);
	if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
	rc = (jint)PtSetResources((PtWidget_t *)arg0, arg1, (PtArg_t *)lparg2);
fail:
	if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	OS_NATIVE_EXIT(env, that, PtSetResources_FUNC);
	return rc;
}
#endif

#ifndef NO_PtSlider
JNIEXPORT jint JNICALL OS_NATIVE(PtSlider)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSlider_FUNC);
	rc = (jint)PtSlider;
	OS_NATIVE_EXIT(env, that, PtSlider_FUNC);
	return rc;
}
#endif

#ifndef NO_PtSuperClassDraw
JNIEXPORT void JNICALL OS_NATIVE(PtSuperClassDraw)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	OS_NATIVE_ENTER(env, that, PtSuperClassDraw_FUNC);
	PtSuperClassDraw((PtWidgetClassRef_t *)arg0, (PtWidget_t *)arg1, (PhTile_t const *)arg2);
	OS_NATIVE_EXIT(env, that, PtSuperClassDraw_FUNC);
}
#endif

#ifndef NO_PtSyncWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtSyncWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtSyncWidget_FUNC);
	rc = (jint)PtSyncWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtSyncWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtText
JNIEXPORT jint JNICALL OS_NATIVE(PtText)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtText_FUNC);
	rc = (jint)PtText;
	OS_NATIVE_EXIT(env, that, PtText_FUNC);
	return rc;
}
#endif

#ifndef NO_PtTextGetSelection
JNIEXPORT jint JNICALL OS_NATIVE(PtTextGetSelection)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
	jint *lparg1=NULL;
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtTextGetSelection_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)PtTextGetSelection((PtWidget_t *)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, PtTextGetSelection_FUNC);
	return rc;
}
#endif

#ifndef NO_PtTextModifyText__IIIIII
JNIEXPORT jint JNICALL OS_NATIVE(PtTextModifyText__IIIIII)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtTextModifyText__IIIIII_FUNC);
	rc = (jint)PtTextModifyText((PtWidget_t *)arg0, arg1, arg2, arg3, (char const *)arg4, arg5);
	OS_NATIVE_EXIT(env, that, PtTextModifyText__IIIIII_FUNC);
	return rc;
}
#endif

#ifndef NO_PtTextModifyText__IIII_3BI
JNIEXPORT jint JNICALL OS_NATIVE(PtTextModifyText__IIII_3BI)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jbyteArray arg4, jint arg5)
{
	jbyte *lparg4=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtTextModifyText__IIII_3BI_FUNC);
	if (arg4) if ((lparg4 = (*env)->GetByteArrayElements(env, arg4, NULL)) == NULL) goto fail;
	rc = (jint)PtTextModifyText((PtWidget_t *)arg0, arg1, arg2, arg3, (char const *)lparg4, arg5);
fail:
	if (arg4 && lparg4) (*env)->ReleaseByteArrayElements(env, arg4, lparg4, 0);
	OS_NATIVE_EXIT(env, that, PtTextModifyText__IIII_3BI_FUNC);
	return rc;
}
#endif

#ifndef NO_PtTextSetSelection
JNIEXPORT jint JNICALL OS_NATIVE(PtTextSetSelection)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
	jint *lparg1=NULL;
	jint *lparg2=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtTextSetSelection_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)PtTextSetSelection((PtWidget_t *)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, PtTextSetSelection_FUNC);
	return rc;
}
#endif

#ifndef NO_PtTimer
JNIEXPORT jint JNICALL OS_NATIVE(PtTimer)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtTimer_FUNC);
	rc = (jint)PtTimer;
	OS_NATIVE_EXIT(env, that, PtTimer_FUNC);
	return rc;
}
#endif

#ifndef NO_PtToggleButton
JNIEXPORT jint JNICALL OS_NATIVE(PtToggleButton)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtToggleButton_FUNC);
	rc = (jint)PtToggleButton;
	OS_NATIVE_EXIT(env, that, PtToggleButton_FUNC);
	return rc;
}
#endif

#ifndef NO_PtToolbar
JNIEXPORT jint JNICALL OS_NATIVE(PtToolbar)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtToolbar_FUNC);
	rc = (jint)PtToolbar;
	OS_NATIVE_EXIT(env, that, PtToolbar_FUNC);
	return rc;
}
#endif

#ifndef NO_PtUnblockWindows
JNIEXPORT void JNICALL OS_NATIVE(PtUnblockWindows)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PtUnblockWindows_FUNC);
	PtUnblockWindows((PtBlockedList_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtUnblockWindows_FUNC);
}
#endif

#ifndef NO_PtUnrealizeWidget
JNIEXPORT jint JNICALL OS_NATIVE(PtUnrealizeWidget)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtUnrealizeWidget_FUNC);
	rc = (jint)PtUnrealizeWidget((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtUnrealizeWidget_FUNC);
	return rc;
}
#endif

#ifndef NO_PtValidParent
JNIEXPORT jint JNICALL OS_NATIVE(PtValidParent)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtValidParent_FUNC);
	rc = (jint)PtValidParent((PtWidget_t *)arg0, (PtWidgetClassRef_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtValidParent_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWebClient
JNIEXPORT jint JNICALL OS_NATIVE(PtWebClient)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWebClient_FUNC);
	rc = (jint)PtWebClient;
	OS_NATIVE_EXIT(env, that, PtWebClient_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetArea
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetArea)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhArea_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetArea_FUNC);
	if (arg1) if ((lparg1 = getPhArea_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtWidgetArea((PtWidget_t *)arg0, (PhArea_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhArea_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtWidgetArea_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetBrotherBehind
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetBrotherBehind)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetBrotherBehind_FUNC);
	rc = (jint)PtWidgetBrotherBehind((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetBrotherBehind_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetBrotherInFront
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetBrotherInFront)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetBrotherInFront_FUNC);
	rc = (jint)PtWidgetBrotherInFront((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetBrotherInFront_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetCanvas__II
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetCanvas__II)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetCanvas__II_FUNC);
	rc = (jint)PtWidgetCanvas((PtWidget_t *)arg0, (PhRect_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtWidgetCanvas__II_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetCanvas__ILorg_eclipse_swt_internal_photon_PhRect_1t_2
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetCanvas__ILorg_eclipse_swt_internal_photon_PhRect_1t_2)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetCanvas__ILorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtWidgetCanvas((PtWidget_t *)arg0, lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtWidgetCanvas__ILorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetChildBack
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetChildBack)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetChildBack_FUNC);
	rc = (jint)PtWidgetChildBack((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetChildBack_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetChildFront
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetChildFront)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetChildFront_FUNC);
	rc = (jint)PtWidgetChildFront((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetChildFront_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetClass
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetClass)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetClass_FUNC);
	rc = (jint)PtWidgetClass((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetClass_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetExtent__II
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetExtent__II)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetExtent__II_FUNC);
	rc = (jint)PtWidgetExtent((PtWidget_t *)arg0, arg1);
	OS_NATIVE_EXIT(env, that, PtWidgetExtent__II_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetExtent__ILorg_eclipse_swt_internal_photon_PhRect_1t_2
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetExtent__ILorg_eclipse_swt_internal_photon_PhRect_1t_2)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhRect_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetExtent__ILorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtWidgetExtent((PtWidget_t *)arg0, lparg1);
fail:
	if (arg1 && lparg1) setPhRect_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtWidgetExtent__ILorg_eclipse_swt_internal_photon_PhRect_1t_2_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetFlags
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetFlags)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetFlags_FUNC);
	rc = (jint)PtWidgetFlags((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetFlags_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetInsert
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetInsert)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetInsert_FUNC);
	rc = (jint)PtWidgetInsert((PtWidget_t *)arg0, (PtWidget_t *)arg1, arg2);
	OS_NATIVE_EXIT(env, that, PtWidgetInsert_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetIsClassMember
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetIsClassMember)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetIsClassMember_FUNC);
	rc = (jint)PtWidgetIsClassMember((PtWidget_t *)arg0, (PtWidgetClassRef_t *)arg1);
	OS_NATIVE_EXIT(env, that, PtWidgetIsClassMember_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetIsRealized
JNIEXPORT jboolean JNICALL OS_NATIVE(PtWidgetIsRealized)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetIsRealized_FUNC);
	rc = (jboolean)PtWidgetIsRealized((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetIsRealized_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetOffset
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetOffset)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhPoint_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetOffset_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtWidgetOffset((PtWidget_t *)arg0, (PhPoint_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhPoint_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtWidgetOffset_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetParent
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetParent)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetParent_FUNC);
	rc = (jint)PtWidgetParent((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetParent_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetPreferredSize
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetPreferredSize)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
{
	PhDim_t _arg1, *lparg1=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetPreferredSize_FUNC);
	if (arg1) if ((lparg1 = getPhDim_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	rc = (jint)PtWidgetPreferredSize((PtWidget_t *)arg0, (PhDim_t *)lparg1);
fail:
	if (arg1 && lparg1) setPhDim_tFields(env, arg1, lparg1);
	OS_NATIVE_EXIT(env, that, PtWidgetPreferredSize_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetRid
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetRid)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetRid_FUNC);
	rc = (jint)PtWidgetRid((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetRid_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetToBack
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetToBack)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetToBack_FUNC);
	rc = (jint)PtWidgetToBack((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetToBack_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWidgetToFront
JNIEXPORT jint JNICALL OS_NATIVE(PtWidgetToFront)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWidgetToFront_FUNC);
	rc = (jint)PtWidgetToFront((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWidgetToFront_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWindow
JNIEXPORT jint JNICALL OS_NATIVE(PtWindow)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWindow_FUNC);
	rc = (jint)PtWindow;
	OS_NATIVE_EXIT(env, that, PtWindow_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWindowFocus
JNIEXPORT jint JNICALL OS_NATIVE(PtWindowFocus)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWindowFocus_FUNC);
	rc = (jint)PtWindowFocus((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWindowFocus_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWindowGetState
JNIEXPORT jint JNICALL OS_NATIVE(PtWindowGetState)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, PtWindowGetState_FUNC);
	rc = (jint)PtWindowGetState((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWindowGetState_FUNC);
	return rc;
}
#endif

#ifndef NO_PtWindowToBack
JNIEXPORT void JNICALL OS_NATIVE(PtWindowToBack)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PtWindowToBack_FUNC);
	PtWindowToBack((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWindowToBack_FUNC);
}
#endif

#ifndef NO_PtWindowToFront
JNIEXPORT void JNICALL OS_NATIVE(PtWindowToFront)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, PtWindowToFront_FUNC);
	PtWindowToFront((PtWidget_t *)arg0);
	OS_NATIVE_EXIT(env, that, PtWindowToFront_FUNC);
}
#endif

#ifndef NO_free
JNIEXPORT void JNICALL OS_NATIVE(free)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, free_FUNC);
	free((void *)arg0);
	OS_NATIVE_EXIT(env, that, free_FUNC);
}
#endif

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

#ifndef NO_malloc
JNIEXPORT jint JNICALL OS_NATIVE(malloc)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, malloc_FUNC);
	rc = (jint)malloc((size_t)arg0);
	OS_NATIVE_EXIT(env, that, malloc_FUNC);
	return rc;
}
#endif

#ifndef NO_memmove__III
JNIEXPORT void JNICALL OS_NATIVE(memmove__III)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	OS_NATIVE_ENTER(env, that, memmove__III_FUNC);
	memmove((void *)arg0, (const void *)arg1, arg2);
	OS_NATIVE_EXIT(env, that, memmove__III_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PgAlpha_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PgAlpha_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PgAlpha_t _arg1={0}, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PgAlpha_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPgAlpha_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PgAlpha_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhArea_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhArea_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhArea_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhArea_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhArea_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhArea_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhCursorDef_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhCursorDef_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhCursorDef_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhCursorDef_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhCursorDef_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhCursorDef_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhEvent_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhEvent_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhEvent_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhEvent_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhEvent_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhImage_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhImage_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhImage_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhImage_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhImage_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhImage_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhPoint_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhPoint_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhPoint_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhPoint_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhPoint_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhPoint_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhPointerEvent_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhPointerEvent_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhRect_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhRect_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhRect_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhRect_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhRect_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhRect_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PhTile_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PhTile_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PhTile_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhTile_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPhTile_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PhTile_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PtTextCallback_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PtTextCallback_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PtTextCallback_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PtTextCallback_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPtTextCallback_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PtTextCallback_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__ILorg_eclipse_swt_internal_photon_PtWebClientData_1t_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_photon_PtWebClientData_1t_2I)
	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
{
	PtWebClientData_t _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__ILorg_eclipse_swt_internal_photon_PtWebClientData_1t_2I_FUNC);
	if (arg1) if ((lparg1 = getPtWebClientData_tFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, (size_t)arg2);
fail:
	OS_NATIVE_EXIT(env, that, memmove__ILorg_eclipse_swt_internal_photon_PtWebClientData_1t_2I_FUNC);
}
#endif

#ifndef NO_memmove__I_3BI
JNIEXPORT void JNICALL OS_NATIVE(memmove__I_3BI)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jint arg2)
{
	jbyte *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__I_3BI_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetByteArrayElements(env, arg1, NULL)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	if (arg1 && lparg1) (*env)->ReleaseByteArrayElements(env, arg1, lparg1, JNI_ABORT);
	OS_NATIVE_EXIT(env, that, memmove__I_3BI_FUNC);
}
#endif

#ifndef NO_memmove__I_3II
JNIEXPORT void JNICALL OS_NATIVE(memmove__I_3II)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jint arg2)
{
	jint *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove__I_3II_FUNC);
	if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
	memmove((void *)arg0, (const void *)lparg1, arg2);
fail:
	if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, JNI_ABORT);
	OS_NATIVE_EXIT(env, that, memmove__I_3II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_FontDetails_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_FontDetails_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	FontDetails _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_FontDetails_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setFontDetailsFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_FontDetails_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PgAlpha_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PgAlpha_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PgAlpha_t _arg0={0}, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PgAlpha_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPgAlpha_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PgAlpha_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PgMap_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PgMap_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PgMap_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PgMap_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPgMap_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PgMap_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhClipHeader_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhClipHeader_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhClipHeader _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhClipHeader_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhClipHeaderFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhClipHeader_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhEvent_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhEvent_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhEvent_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhEvent_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhEvent_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhEvent_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhImage_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhImage_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhImage_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhImage_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhImage_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhImage_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhKeyEvent_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhKeyEvent_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhKeyEvent_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhKeyEvent_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhKeyEvent_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhKeyEvent_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhPointerEvent_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhPointerEvent_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhPointerEvent_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhRect_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhRect_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhRect_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhRect_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhRect_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhRect_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhTile_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhTile_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhTile_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhTile_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhTile_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhTile_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PhWindowEvent_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PhWindowEvent_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PhWindowEvent_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhWindowEvent_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPhWindowEvent_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PhWindowEvent_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtCallbackInfo_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtCallbackInfo_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtCallbackInfo_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtCallbackInfo_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtCallbackInfo_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtCallbackInfo_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtScrollbarCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtScrollbarCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtScrollbarCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtScrollbarCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtScrollbarCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtScrollbarCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtTextCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtTextCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtTextCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtTextCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = &_arg0) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtTextCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtTextCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtWebDataReqCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtWebDataReqCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtWebDataReqCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebDataReqCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = getPtWebDataReqCallback_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtWebDataReqCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebDataReqCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtWebMetaDataCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtWebMetaDataCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtWebMetaDataCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebMetaDataCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = getPtWebMetaDataCallback_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtWebMetaDataCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebMetaDataCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtWebStatusCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtWebStatusCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtWebStatusCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebStatusCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = getPtWebStatusCallback_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtWebStatusCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebStatusCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove__Lorg_eclipse_swt_internal_photon_PtWebWindowCallback_1t_2II
JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_photon_PtWebWindowCallback_1t_2II)
	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
{
	PtWebWindowCallback_t _arg0, *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebWindowCallback_1t_2II_FUNC);
	if (arg0) if ((lparg0 = getPtWebWindowCallback_tFields(env, arg0, &_arg0)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) setPtWebWindowCallback_tFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, memmove__Lorg_eclipse_swt_internal_photon_PtWebWindowCallback_1t_2II_FUNC);
}
#endif

#ifndef NO_memmove___3BII
JNIEXPORT void JNICALL OS_NATIVE(memmove___3BII)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2)
{
	jbyte *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove___3BII_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
fail:
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, memmove___3BII_FUNC);
}
#endif

#ifndef NO_memmove___3BLorg_eclipse_swt_internal_photon_PhClipHeader_2I
JNIEXPORT void JNICALL OS_NATIVE(memmove___3BLorg_eclipse_swt_internal_photon_PhClipHeader_2I)
	(JNIEnv *env, jclass that, jbyteArray arg0, jobject arg1, jint arg2)
{
	jbyte *lparg0=NULL;
	PhClipHeader _arg1, *lparg1=NULL;
	OS_NATIVE_ENTER(env, that, memmove___3BLorg_eclipse_swt_internal_photon_PhClipHeader_2I_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL)) == NULL) goto fail;
	if (arg1) if ((lparg1 = getPhClipHeaderFields(env, arg1, &_arg1)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)lparg1, arg2);
fail:
	if (arg1 && lparg1) setPhClipHeaderFields(env, arg1, lparg1);
	if (arg0 && lparg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, memmove___3BLorg_eclipse_swt_internal_photon_PhClipHeader_2I_FUNC);
}
#endif

#ifndef NO_memmove___3III
JNIEXPORT void JNICALL OS_NATIVE(memmove___3III)
	(JNIEnv *env, jclass that, jintArray arg0, jint arg1, jint arg2)
{
	jint *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove___3III_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, arg2);
fail:
	if (arg0 && lparg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, memmove___3III_FUNC);
}
#endif

#ifndef NO_memmove___3SII
JNIEXPORT void JNICALL OS_NATIVE(memmove___3SII)
	(JNIEnv *env, jclass that, jshortArray arg0, jint arg1, jint arg2)
{
	jshort *lparg0=NULL;
	OS_NATIVE_ENTER(env, that, memmove___3SII_FUNC);
	if (arg0) if ((lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL)) == NULL) goto fail;
	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
fail:
	if (arg0 && lparg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	OS_NATIVE_EXIT(env, that, memmove___3SII_FUNC);
}
#endif

#ifndef NO_memset
JNIEXPORT void JNICALL OS_NATIVE(memset)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	OS_NATIVE_ENTER(env, that, memset_FUNC);
	memset((void *)arg0, arg1, (size_t)arg2);
	OS_NATIVE_EXIT(env, that, memset_FUNC);
}
#endif

#ifndef NO_strdup
JNIEXPORT jint JNICALL OS_NATIVE(strdup)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, strdup_FUNC);
	rc = (jint)strdup((const char *)arg0);
	OS_NATIVE_EXIT(env, that, strdup_FUNC);
	return rc;
}
#endif

#ifndef NO_strlen
JNIEXPORT jint JNICALL OS_NATIVE(strlen)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, strlen_FUNC);
	rc = (jint)strlen((const char*)arg0);
	OS_NATIVE_EXIT(env, that, strlen_FUNC);
	return rc;
}
#endif

#ifndef NO_uname
JNIEXPORT jint JNICALL OS_NATIVE(uname)
	(JNIEnv *env, jclass that, jobject arg0)
{
	utsname _arg0, *lparg0=NULL;
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, uname_FUNC);
	if (arg0) if ((lparg0 = getutsnameFields(env, arg0, &_arg0)) == NULL) goto fail;
	rc = (jint)uname((utsname *)lparg0);
fail:
	if (arg0 && lparg0) setutsnameFields(env, arg0, lparg0);
	OS_NATIVE_EXIT(env, that, uname_FUNC);
	return rc;
}
#endif