static void NativeMemoryChunk_nativeMemcpy(
JNIEnv* env,
jclass clzz,
jlong dst,
jlong src,
jint count) {
UNUSED(env);
UNUSED(clzz);
memcpy(JLONG_TO_PTR(dst), JLONG_TO_PTR(src), count);
}
/*
* Class: com_sun_glass_ui_gtk_GtkPixels
* Method: _attachByte
* Signature: (JIILjava/nio/ByteBuffer;[BI)V
*/
JNIEXPORT void JNICALL Java_com_sun_glass_ui_gtk_GtkPixels__1attachByte
(JNIEnv * env, jobject obj, jlong ptr, jint w, jint h, jobject bytes, jbyteArray array, jint offset)
{
(void)obj;
jbyte *data;
GdkPixbuf **pixbuf;
guint8 *dataRGBA;
if (array == NULL) {
data = (jbyte*) env->GetDirectBufferAddress(bytes);
assert((w*h*4 + offset) == env->GetDirectBufferCapacity(bytes));
} else {
assert((w*h*4 + offset) == env->GetArrayLength(array));
data = (jbyte*) env->GetPrimitiveArrayCritical(array, 0);
}
pixbuf = (GdkPixbuf**)JLONG_TO_PTR(ptr);
dataRGBA = convert_BGRA_to_RGBA((const int*)(data + offset), w*4, h);
*pixbuf = gdk_pixbuf_new_from_data(dataRGBA, GDK_COLORSPACE_RGB, TRUE, 8,
w, h, w * 4, (GdkPixbufDestroyNotify) my_free, NULL);
if (array != NULL) {
env->ReleasePrimitiveArrayCritical(array, data, 0);
}
}
char __cdecl JavaToObjCCallHandler(DCCallback* callback, DCArgs* args, DCValue* result, void* userdata)
{
JavaToObjCCallInfo* info = (JavaToObjCCallInfo*)userdata;
CallTempStruct* call;
jobject instance = initCallHandler(args, &call, NULL, &info->fInfo);
JNIEnv* env = call->env;
BEGIN_TRY(env, call);
call->pCallIOs = info->fInfo.fCallIOs;
void* targetId = info->fNativeClass ? JLONG_TO_PTR(info->fNativeClass) : getNativeObjectPointer(env, instance, NULL);
void* callback = //objc_msgSend_stret;//
objc_msgSend;
#if defined(DC__Arch_Intel_x86)
switch (info->fInfo.fReturnType) {
case eDoubleValue:
case eFloatValue:
callback = objc_msgSend_fpret;
break;
}
#endif
dcMode(call->vm, info->fInfo.fDCMode);
dcArgPointer(call->vm, targetId);
dcArgPointer(call->vm, info->fSelector);
followArgs(call, args, info->fInfo.nParams, info->fInfo.fParamTypes, JNI_FALSE, JNI_TRUE)// TODO isVarArgs ??
&&
followCall(call, info->fInfo.fReturnType, result, callback, JNI_FALSE, JNI_FALSE);
cleanupCallHandler(call);
END_TRY_BASE(info->fInfo.fEnv, call, cleanupCallHandler(call););
/*
* Class: com_sun_glass_ui_gtk_GtkTimer
* Method: _stop
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_com_sun_glass_ui_gtk_GtkTimer__1stop
(JNIEnv * env, jobject obj, jlong ptr)
{
RunnableContext* context = (RunnableContext*) JLONG_TO_PTR(ptr);
context->flag = 1;
env->DeleteGlobalRef(context->runnable);
context->runnable = NULL;
}
static void NativeMemoryChunk_nativeFree(
JNIEnv* env,
jclass clzz,
jlong lpointer) {
UNUSED(env);
UNUSED(clzz);
free(JLONG_TO_PTR(lpointer));
}
static jbyte NativeMemoryChunk_nativeReadByte(
JNIEnv* env,
jclass clzz,
jlong lpointer){
UNUSED(env);
UNUSED(clzz);
jbyte* jbyte_ptr = JLONG_TO_PTR(lpointer);
return *jbyte_ptr;
}
static void NativeMemoryChunk_nativeCopyFromByteArray(
JNIEnv* env,
jclass clzz,
jlong lpointer,
jbyteArray byteArray,
jint offset,
jint count) {
UNUSED(clzz);
(*env)->GetByteArrayRegion(
env,
byteArray,
offset,
count,
JLONG_TO_PTR(lpointer));
}
/*
* Class: com_sun_glass_ui_gtk_GtkView
* Method: _setParent
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_com_sun_glass_ui_gtk_GtkView__1setParent
(JNIEnv * env, jobject obj, jlong ptr, jlong parent)
{
GlassView* view = JLONG_TO_GLASSVIEW(ptr);
bool is_removing = view->current_window && !parent;
view->current_window = (WindowContext*)JLONG_TO_PTR(parent);
if (is_removing) {
env->CallVoidMethod(obj, jViewNotifyView, com_sun_glass_events_ViewEvent_REMOVE);
} else {
env->CallVoidMethod(obj, jViewNotifyView, com_sun_glass_events_ViewEvent_ADD);
}
CHECK_JNI_EXCEPTION(env);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getKerning
(JNIEnv *env, jobject obj __attribute__((unused)), jint rightGlyph,
jint leftGlyph, jlong fnt, jfloatArray p)
{
FT_Face ft_face;
FT_Vector kern;
PangoFcFont *font;
font = JLONG_TO_PTR(PangoFcFont, fnt);
ft_face = pango_fc_font_lock_face( font );
g_assert (ft_face != NULL);
FT_Get_Kerning( ft_face, rightGlyph, leftGlyph, FT_KERNING_DEFAULT, &kern );
pango_fc_font_unlock_face( font );
jfloat *pelements = (*env)->GetPrimitiveArrayCritical(env, p, NULL);
pelements[0] = (jfloat)kern.x/64.0;
pelements[1] = (jfloat)kern.y/64.0;
(*env)->ReleasePrimitiveArrayCritical (env, p, pelements, 0);
}
JNIEXPORT jdoubleArray JNICALL
Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getMetricsNative
(JNIEnv *env, jobject obj __attribute__((unused)), jint glyphIndex, jlong fnt)
{
FT_Face ft_face;
jdouble *values;
jdoubleArray retArray = NULL;
PangoFcFont *font;
font = JLONG_TO_PTR(PangoFcFont, fnt);
ft_face = pango_fc_font_lock_face( font );
g_assert (ft_face != NULL);
FT_Set_Transform( ft_face, NULL, NULL );
if( FT_Load_Glyph( ft_face, glyphIndex, FT_LOAD_NO_BITMAP ) != 0 )
{
pango_fc_font_unlock_face( font );
printf("Couldn't load glyph %i\n", glyphIndex);
return NULL;
}
retArray = (*env)->NewDoubleArray (env, 8);
values = (*env)->GetDoubleArrayElements (env, retArray, NULL);
values[0] = 0;
values[1] = (jdouble)ft_face->glyph->advance.x/64.0;
values[2] = (jdouble)ft_face->glyph->advance.y/64.0;
values[3] = (jdouble)ft_face->glyph->metrics.horiBearingX/64.0;
values[4] = -(jdouble)ft_face->glyph->metrics.horiBearingY/64.0;
values[5] = (jdouble)ft_face->glyph->metrics.width/64.0;
values[6] = (jdouble)ft_face->glyph->metrics.height/64.0;
values[7] = 0;
(*env)->ReleaseDoubleArrayElements (env, retArray, values, 0);
pango_fc_font_unlock_face( font );
return retArray;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_dispose
(JNIEnv *env, jobject obj __attribute__((unused)), jlongArray fontset)
{
PangoFcFont *font;
jlong *fontArray;
int i, length;
length = (*env)->GetArrayLength (env, fontset);
fontArray = (*env)->GetLongArrayElements (env, fontset, NULL);
gdk_threads_enter();
for( i = 0; i < length; i++ )
{
font = JLONG_TO_PTR(PangoFcFont, fontArray[i]);
g_object_unref(font);
}
gdk_threads_leave();
(*env)->ReleaseLongArrayElements (env, fontset, fontArray, 0);
}
jboolean followCall(CallTempStruct* call, ValueType returnType, DCValue* result, void* callback, jboolean bCallingJava, jboolean forceVoidReturn)
{
JNIEnv* env = call->env;
switch (returnType) {
#define CALL_CASE(valueType, capCase, hiCase, uni) \
case valueType: \
result->uni = dcCall ## capCase(call->vm, callback); \
break;
CALL_CASE(eIntValue, Int, INT, i)
CALL_CASE(eLongValue, LongLong, LONGLONG, l)
CALL_CASE(eShortValue, Short, SHORT, s)
CALL_CASE(eFloatValue, Float, FLOAT, f)
CALL_CASE(eDoubleValue, Double, DOUBLE, d)
case eBooleanValue:
CALL_CASE(eByteValue, Char, CHAR, c)
case eCLongValue:
result->L = (jlong)dcCallLong(call->vm, callback);
break;
case eSizeTValue:
result->L = (size_t)dcCallPointer(call->vm, callback);
break;
#define CALL_BOXED_INTEGRAL(type, capitalized) \
if (bCallingJava) { \
time_t tt = Unbox ## capitalized(env, dcCallPointer(call->vm, callback)); \
if (sizeof(type) == 4) \
result->i = (jint)tt; \
else \
result->l = (jlong)tt; \
} else { \
type tt = (sizeof(type) == 4) ? (type)dcCallInt(call->vm, callback) : (type)dcCallLongLong(call->vm, callback); \
result->p = Box ## capitalized(env, tt); \
}
case eCLongObjectValue:
CALL_BOXED_INTEGRAL(long, CLong);
break;
case eSizeTObjectValue:
CALL_BOXED_INTEGRAL(size_t, SizeT);
break;
case eTimeTObjectValue:
CALL_BOXED_INTEGRAL(time_t, TimeT);
break;
case eVoidValue:
dcCallVoid(call->vm, callback);
break;
case eIntFlagSet:
{
int flags = dcCallInt(call->vm, callback);
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
jobject obj = createPointerFromIO(env, JLONG_TO_PTR ((jlong)flags), callIO);
result->p = obj;
}
break;
case ePointerValue:
{
void* ptr = dcCallPointer(call->vm, callback);
if (bCallingJava)
result->p = ptr ? getPointerPeer(env, ptr) : NULL;
//result->p = ptr;
else
{
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
//printf("RETURNED POINTER = %d\n", ptr);
result->p = createPointerFromIO(env, ptr, callIO);
}
}
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
result->c = dcCallChar(call->vm, callback);
break;
case 2:
result->s = dcCallShort(call->vm, callback);
break;
case 4:
result->i = dcCallInt(call->vm, callback);
break;
default:
throwException(env, "Invalid wchar_t size !");
return JNI_FALSE;
}
break;
default:
if (forceVoidReturn)
{
dcCallVoid(call->vm, callback);
break;
}
throwException(env, "Invalid return value type !");
return JNI_FALSE;
}
HACK_REFETCH_ENV();
if (bCallingJava && (*env)->ExceptionCheck(env))
return JNI_FALSE;
return JNI_TRUE;
}
JNIEXPORT jobject JNICALL
Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getGlyphOutlineNative
(JNIEnv *env, jobject obj __attribute__((unused)), jint glyphIndex, jlong fnt)
{
generalpath *path;
jobject gp;
FT_Outline_Funcs ftCallbacks =
{
(FT_Outline_MoveToFunc) _moveTo,
(FT_Outline_LineToFunc) _lineTo,
(FT_Outline_ConicToFunc) _quadTo,
(FT_Outline_CubicToFunc) _curveTo,
0,
0
};
PangoFcFont *font;
FT_Face ft_face;
FT_Glyph glyph;
font = JLONG_TO_PTR(PangoFcFont, fnt);
ft_face = pango_fc_font_lock_face( font );
g_assert (ft_face != NULL);
path = g_malloc0 (sizeof (generalpath));
g_assert(path != NULL);
path->env = env;
path->px = path->py = 0.0;
path->sx = 1.0/64.0;
path->sy = -1.0/64.0;
{ /* create a GeneralPath instance */
jclass cls;
jmethodID method;
cls = (*env)->FindClass (env, "java/awt/geom/GeneralPath");
method = (*env)->GetMethodID (env, cls, "<init>", "()V");
gp = path->obj = (*env)->NewObject (env, cls, method);
}
if(FT_Load_Glyph(ft_face,
(FT_UInt)(glyphIndex),
FT_LOAD_DEFAULT | FT_LOAD_NO_BITMAP) != 0)
{
pango_fc_font_unlock_face( font );
g_free(path);
return NULL;
}
FT_Get_Glyph( ft_face->glyph, &glyph );
if (glyph->format == FT_GLYPH_FORMAT_OUTLINE)
{
FT_Outline_Decompose (&(((FT_OutlineGlyph)glyph)->outline),
&ftCallbacks, path);
}
else
{
char format[5];
format[0] = (glyph->format & 0xFF000000) >> 24;
format[1] = (glyph->format & 0x00FF0000) >> 16;
format[2] = (glyph->format & 0x0000FF00) >> 8;
format[3] = (glyph->format & 0x000000FF);
format[4] = '\0';
printf("WARNING: Unable to create outline for font %s %s of format %s\n",
ft_face->family_name, ft_face->style_name, format);
}
FT_Done_Glyph( glyph );
pango_fc_font_unlock_face( font );
g_free(path);
return gp;
}
#include <stdlib.h>
#include <cairo.h>
static void update_pattern_transform (struct cairographics2d *gr);
/**
* Allocates the cairographics2d structure.
*/
JNIEXPORT jlong JNICALL
Java_julianwi_awtpeer_CairoGraphics2D_init
(JNIEnv *env __attribute__ ((unused)),
jobject obj __attribute__ ((unused)),
jlong cairo_t_pointer)
{
struct cairographics2d *g = NULL;
cairo_t *cr = JLONG_TO_PTR(cairo_t, cairo_t_pointer);
//g_assert(cr != NULL);
g = (struct cairographics2d *) malloc (sizeof (struct cairographics2d));
//g_assert (g != NULL);
memset (g, 0, sizeof(struct cairographics2d));
g->cr = cr;
return PTR_TO_JLONG(g);
}
/**
* Disposes of the cairographics2d structure.
*/
JNIEXPORT void JNICALL
jboolean followArgs(CallTempStruct* call, DCArgs* args, int nTypes, ValueType* pTypes, jboolean toJava, jboolean isVarArgs)
{
JNIEnv* env = call->env;
int iParam;
//printf("ARGS : %d args\n", (int)nTypes);
for (iParam = 0; iParam < nTypes; iParam++) {
ValueType type = pTypes[iParam];
switch (type) {
case eIntFlagSet:
{
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
if (toJava) {
int flags = dcbArgInt(args);
jobject obj = createPointerFromIO(env, JLONG_TO_PTR ((jlong)flags), callIO);
dcArgPointer(call->vm, obj);
} else {
int arg = (jint)getFlagValue(env, (jobject)dcbArgPointer(args));
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgInt(call->vm, arg);
}
}
break;
case eIntValue:
{
int arg = dcbArgInt(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgInt(call->vm, arg);
}
break;
#define ARG_BOXED_INTEGRAL(type, capitalized) \
{ \
if (toJava) { \
type arg = (sizeof(type) == 4) ? (type)dcbArgInt(args) : (type)dcbArgLongLong(args); \
dcArgPointer(call->vm, Box ## capitalized(env, arg)); \
} else { \
jobject parg = dcbArgPointer(args); \
jlong arg = Unbox ## capitalized(env, parg); \
if (isVarArgs) \
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg); \
else if (sizeof(type) == 4) \
dcArgInt(call->vm, (jint)arg); \
else \
dcArgLongLong(call->vm, (jlong)arg); \
} \
}
#define ARG_UNBOXED_INTEGRAL(type, capitalized) \
{ \
if (toJava) { \
type arg = (sizeof(type) == 4) ? (type)dcbArgInt(args) : (type)dcbArgLongLong(args); \
dcArgLongLong(call->vm, (jlong)arg); \
} else { \
jlong arg = dcbArgLongLong(args); \
if (isVarArgs) \
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg); \
else if (sizeof(type) == 4) \
dcArgInt(call->vm, (jint)arg); \
else \
dcArgLongLong(call->vm, (jlong)arg); \
} \
}
case eCLongValue:
ARG_UNBOXED_INTEGRAL(long, CLong);
break;
case eSizeTValue:
ARG_UNBOXED_INTEGRAL(size_t, SizeT);
break;
case eCLongObjectValue:
ARG_BOXED_INTEGRAL(long, CLong);
break;
case eSizeTObjectValue:
ARG_BOXED_INTEGRAL(size_t, SizeT);
break;
case eTimeTObjectValue:
ARG_BOXED_INTEGRAL(time_t, TimeT);
break;
case eLongValue:
dcArgLongLong(call->vm, dcbArgLongLong(args));
break;
case eShortValue:
{
short arg = dcbArgShort(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgShort(call->vm, arg);
}
break;
case eBooleanValue:
case eByteValue:
{
char arg = dcbArgChar(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgChar(call->vm, arg);
}
break;
case eFloatValue:
{
float arg = dcbArgFloat(args);
if (isVarArgs)
dcArgDouble(call->vm, arg);
else
dcArgFloat(call->vm, arg);
}
break;
case eDoubleValue:
dcArgDouble(call->vm, dcbArgDouble(args));
break;
case ePointerValue:
{
void* ptr = dcbArgPointer(args);
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
if (toJava)
{
ptr = createPointerFromIO(env, ptr, callIO);
} else {
ptr = ptr ? getPointerPeer(env, ptr) : NULL;
// printf("ARG POINTER = %d\n", ptr);
}
dcArgPointer(call->vm, ptr);
}
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
dcArgChar(call->vm, dcbArgChar(args));
break;
case 2:
dcArgShort(call->vm, dcbArgShort(args));
break;
case 4:
dcArgInt(call->vm, dcbArgInt(args));
break;
default:
throwException(env, "Invalid wchar_t size for argument !");
return JNI_FALSE;
}
break;
case eEllipsis: {
if (toJava) {
throwException(env, "Calling Java ellipsis is not supported yet !");
return JNI_FALSE;
} else {
jobjectArray arr = (jobjectArray)dcbArgPointer(args);
jsize n = (*env)->GetArrayLength(env, arr), i;
for (i = 0; i < n; i++) {
jobject arg = (*env)->GetObjectArrayElement(env, arr, i);
#define TEST_INSTANCEOF(cl, st) \
if ((*env)->IsInstanceOf(env, arg, cl)) st;
if (arg == NULL)
dcArgPointer(call->vm, getPointerPeer(env, (void*)NULL));
else
// As per the C standard for varargs, all ints are promoted to ptrdiff_t and float is promoted to double :
TEST_INSTANCEOF(gIntClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxInt(env, arg)))
else
TEST_INSTANCEOF(gLongClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxLong(env, arg)))
else
TEST_INSTANCEOF(gShortClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxShort(env, arg)))
else
TEST_INSTANCEOF(gByteClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxByte(env, arg)))
else
TEST_INSTANCEOF(gBooleanClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(char)UnboxBoolean(env, arg)))
else
TEST_INSTANCEOF(gCharClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(short)UnboxChar(env, arg)))
else
TEST_INSTANCEOF(gDoubleClass, dcArgDouble(call->vm, UnboxDouble(env, arg)))
else
TEST_INSTANCEOF(gFloatClass, dcArgDouble(call->vm, UnboxFloat(env, arg)))
else
TEST_INSTANCEOF(gCLongClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(long)UnboxCLong(env, arg)))
else
TEST_INSTANCEOF(gSizeTClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxSizeT(env, arg)))
else
TEST_INSTANCEOF(gPointerClass, dcArgPointer(call->vm, getPointerPeer(env, (void*)arg)))
else {
throwException(env, "Invalid value type in ellipsis");
return JNI_FALSE;
}
}
}
break;
}
default:
throwException(env, "Invalid argument value type !");
return JNI_FALSE;
}
}
if ((*env)->ExceptionCheck(env))
return JNI_FALSE;
return JNI_TRUE;
}
gdk_threads_leave();
g_assert( pixmap != NULL );
return PTR_TO_JLONG( pixmap );
}
/**
* Destroy the surface
*/
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkVolatileImage_destroy
(JNIEnv *env __attribute__((unused)), jobject obj __attribute__((unused)),
jlong pointer)
{
GdkPixmap* pixmap = JLONG_TO_PTR(GdkPixmap, pointer);
if( pixmap != NULL )
{
gdk_threads_enter();
g_object_unref( pixmap );
gdk_threads_leave();
}
}
/**
* Gets all pixels in an array
*/
JNIEXPORT jintArray JNICALL
Java_gnu_java_awt_peer_gtk_GtkVolatileImage_nativeGetPixels
(JNIEnv *env, jobject obj, jlong pointer)
{
static GtkWindow *gdk_window_handle_to_gtk(jlong handle) {
return (handle != 0)
? ((WindowContext*)JLONG_TO_PTR(handle))->get_gtk_window()
: NULL;
}
