native_vrml_external_Browser_createVrmlFromString(JRIEnv* env, struct vrml_external_Browser* self, struct java_lang_String *jString)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return NULL;
// get c handle
const char * str = JRI_GetStringUTFChars( env , jString );
LPUNKNOWN pVrml = ctrl->getCC3D()->createVrmlFromString(str);
void * pScene = ctrl->getNodeQIPtr(pVrml);
if (!pScene) // invalid vrml
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidVrmlException( env );
JRI_ThrowNew ( env , exClass , "Invalid VRML" );
return NULL;
}
// cc3d provides a group node instead of a mfnode so we have to read all nodes by ourself
int type;
void * pUnknown = ctrl->getEventOut(pScene, "children_changed", &type);
ctrl->release( pScene );
pScene = NULL;
if (!pUnknown) // no children
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidVrmlException( env );
JRI_ThrowNew ( env , exClass , "Invalid VRML" );
return NULL;
}
// get the size first and create java array
struct java_lang_Class * nodeClass = class_vrml_external_Node( env );
int size = ctrl->getSize(pUnknown, type);
jobjectArray jArray = (jobjectArray)JRI_NewObjectArray(env, size, nodeClass, NULL);
struct vrml_external_Node * node;
void * pNode;
for (int i = 0 ; i < size ; i++)
{
pNode = ctrl->getNode(pUnknown, i, type);
if (!pNode) // shouldn't happen
break;
node = vrml_external_Node_new(env, nodeClass, (jint)ctrl, (jint)pNode );
JRI_SetObjectArrayElement(env, jArray, i, node);
}
ctrl->release( pUnknown );
pUnknown = NULL;
return jArray;
}
register_vrml_external_Node(JRIEnv* env)
{
char* nativeNamesAndSigs[] = {
"getType()Ljava/lang/String;",
"getEventIn(Ljava/lang/String;)Lvrml/external/field/EventIn;",
"getEventOut(Ljava/lang/String;)Lvrml/external/field/EventOut;",
"nFinalize()V",
NULL
};
void* nativeProcs[] = {
(void*)native_vrml_external_Node_getType,
(void*)native_vrml_external_Node_getEventIn,
(void*)native_vrml_external_Node_getEventOut,
(void*)native_vrml_external_Node_nFinalize,
NULL
};
struct java_lang_Class* clazz = JRI_FindClass(env, classname_vrml_external_Node);
if (clazz == NULL) {
JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_vrml_external_Node);
return NULL;
}
JRI_RegisterNatives(env, clazz, nativeNamesAndSigs, nativeProcs);
use_vrml_external_Node(env);
return clazz;
}
native_vrml_external_Browser_setViewpointFollow(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node, jfloatArray ref, jint mode)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return false;
if (JRI_GetFloatArrayLength(env, ref) != 3)
return false;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef((void *)nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid Node" );
return false;
}
boolean ret = false;
float *refP = JRI_GetFloatArrayElements(env, ref);
if (ctrl->getCC3D()->setViewpointFollow(nodeHdl, refP[0], refP[1], refP[2], mode))
ret = true;
return ret;
}
native_vrml_external_Browser_getNodeBoundingBox(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node, jint mode, jfloatArray min, jfloatArray max)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return false;
if (JRI_GetFloatArrayLength(env, min) != 3
|| JRI_GetFloatArrayLength(env, max) != 3)
return false;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef((void *)nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid Node" );
return false;
}
boolean ret = false;
float *minP = JRI_GetFloatArrayElements(env, min);
float *maxP = JRI_GetFloatArrayElements(env, max);
if (ctrl->getCC3D()->getNodeBoundingBox(nodeHdl, mode, &minP[0], &minP[1], &minP[2], &maxP[0], &maxP[1], &maxP[2]))
ret = true;
return ret;
}
native_vrml_external_Browser_getNodeName(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node)
{
struct java_lang_String * retStr = NULL;
CString cStr;
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return retStr;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef(nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid Node" );
return retStr;
}
cStr = ctrl->getCC3D()->getNodeName(nodeHdl);
retStr = JRI_NewStringUTF ( env , cStr , cStr.GetLength() );
return retStr;
}
native_vrml_external_Browser_deleteRoute(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *jFromNode, struct java_lang_String *jFromEvent, struct vrml_external_Node *jToNode, struct java_lang_String *jToEvent)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return;
// check parameters
LPUNKNOWN fromNode, toNode;
bool wrongPar = false;
if (!jFromNode || !jToNode || !jFromEvent || !jToEvent )
{
wrongPar = true;
}
else
{
fromNode = (LPUNKNOWN)get_vrml_external_Node_cNode(env, jFromNode);
toNode = (LPUNKNOWN)get_vrml_external_Node_cNode(env, jToNode);
if (!ctrl->checkRef((void *)fromNode, TypeNode) || !ctrl->checkRef((void *)toNode, TypeNode)) // invalid handle
wrongPar = true;
}
if (wrongPar)
{
struct java_lang_Class * exClass = class_java_lang_IllegalArgumentException( env );
JRI_ThrowNew ( env , exClass , "Invalid Parameter" );
return;
}
const char * fromEvent = JRI_GetStringUTFChars( env , jFromEvent );
const char * toEvent = JRI_GetStringUTFChars( env , jToEvent );
// create route
ctrl->getCC3D()->deleteRoute(fromNode, fromEvent, toNode, toEvent);
return;
}
native_vrml_external_Browser_createNode(JRIEnv* env, struct vrml_external_Browser* self, struct java_lang_String *jString)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return NULL;
// get c handle
const char * str = JRI_GetStringUTFChars( env , jString );
LPUNKNOWN pNode = ctrl->getCC3D()->createNode(str);
void * pUnknown = ctrl->getNodeQIPtr(pNode);
if (!pUnknown) // invalid vrml
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidVrmlException( env );
JRI_ThrowNew ( env , exClass , "Invalid VRML" );
return NULL;
}
// convert to java
struct java_lang_Class * nodeClass = class_vrml_external_Node( env );
struct vrml_external_Node * node;
node = vrml_external_Node_new(env, nodeClass, (jint)ctrl, (jint)pUnknown );
return node;
}
register_vrml_external_field_EventOut(JRIEnv* env)
{
char* nativeNamesAndSigs[] = {
"advise()V",
"getString([Ljava/lang/String;)V",
"get1String(I)Ljava/lang/String;",
"getNode([Lvrml/external/Node;)V",
"get1Node(I)Lvrml/external/Node;",
"getInt([I)V",
"get1Int(I)I",
"getFloat(I[F)V",
"get1Float(I)F",
"getSize()I",
"getTime()D",
"getBoolean()Z",
"getByte([B)V",
"nFinalize()V",
NULL
};
void* nativeProcs[] = {
(void*)native_vrml_external_field_EventOut_advise_1,
(void*)native_vrml_external_field_EventOut_getString,
(void*)native_vrml_external_field_EventOut_get1String,
(void*)native_vrml_external_field_EventOut_getNode,
(void*)native_vrml_external_field_EventOut_get1Node,
(void*)native_vrml_external_field_EventOut_getInt,
(void*)native_vrml_external_field_EventOut_get1Int,
(void*)native_vrml_external_field_EventOut_getFloat,
(void*)native_vrml_external_field_EventOut_get1Float,
(void*)native_vrml_external_field_EventOut_getSize,
(void*)native_vrml_external_field_EventOut_getTime,
(void*)native_vrml_external_field_EventOut_getBoolean,
(void*)native_vrml_external_field_EventOut_getByte,
(void*)native_vrml_external_field_EventOut_nFinalize,
NULL
};
struct java_lang_Class* clazz = JRI_FindClass(env, classname_vrml_external_field_EventOut);
if (clazz == NULL) {
JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_vrml_external_field_EventOut);
return NULL;
}
JRI_RegisterNatives(env, clazz, nativeNamesAndSigs, nativeProcs);
use_vrml_external_field_EventOut(env);
return clazz;
}
static bool_t
enterJS(JRIEnv *env,
struct netscape_javascript_JSObject* self,
JSContext **cxp, JSObject **jsop, JSSavedState *saved)
{
#ifndef JAVA
return JS_FALSE;
#else
char *err;
JSJ_EnterJS();
/* check the internal pointer for null while holding the
* js lock to deal with shutdown issues */
if (jsop &&
(! self ||
! (*jsop = (JSObject *)
get_netscape_javascript_JSObject_internal(env, self)))) {
/* FIXME use a better exception */
JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/Exception"),
"not a JavaScript object");
JSJ_ExitJS();
return FALSE;
}
/* PR_LOG(Moja, debug, ("clearing exceptions in ee=0x%x", env)); */
exceptionClear((ExecEnv *)env);
if (! (*cxp = JSJ_CurrentContext(env, &err))) {
JSJ_ExitJS();
if (err) {
js_throwJSException(env, err);
free(err);
}
return FALSE;
}
jsj_ClearSavedErrors(*cxp);
saved->errReporter = JS_SetErrorReporter(*cxp, js_JavaErrorReporter);
return TRUE;
#endif
}
native_vrml_external_Browser_setMyAvatarNode(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef((void *)nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid Node" );
return ;
}
ctrl->getCC3D()->setMyAvatarNode(nodeHdl);
}
use_vrml_external_field_EventOut(JRIEnv* env)
{
if (_globalclass_vrml_external_field_EventOut == NULL) {
struct java_lang_Class* clazz = JRI_FindClass(env, classname_vrml_external_field_EventOut);
if (clazz == NULL) {
JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_vrml_external_field_EventOut);
return NULL;
}
use_vrml_external_field_EventOut_cBrowser(env, clazz);
use_vrml_external_field_EventOut_cEvent(env, clazz);
use_vrml_external_field_EventOut_type(env, clazz);
use_vrml_external_field_EventOut_userData(env, clazz);
use_vrml_external_field_EventOut_observer(env, clazz);
use_vrml_external_field_EventOut_new(env, clazz);
use_vrml_external_field_EventOut_getType(env, clazz);
use_vrml_external_field_EventOut_advise(env, clazz);
use_vrml_external_field_EventOut_advise_1(env, clazz);
use_vrml_external_field_EventOut_callback(env, clazz);
use_vrml_external_field_EventOut_getString(env, clazz);
use_vrml_external_field_EventOut_get1String(env, clazz);
use_vrml_external_field_EventOut_getNode(env, clazz);
use_vrml_external_field_EventOut_get1Node(env, clazz);
use_vrml_external_field_EventOut_getInt(env, clazz);
use_vrml_external_field_EventOut_get1Int(env, clazz);
use_vrml_external_field_EventOut_getFloat(env, clazz);
use_vrml_external_field_EventOut_get1Float(env, clazz);
use_vrml_external_field_EventOut_getSize(env, clazz);
use_vrml_external_field_EventOut_getTime(env, clazz);
use_vrml_external_field_EventOut_getBoolean(env, clazz);
use_vrml_external_field_EventOut_getByte(env, clazz);
use_vrml_external_field_EventOut_newEventOut(env, clazz);
use_vrml_external_field_EventOut_finalize(env, clazz);
use_vrml_external_field_EventOut_nFinalize(env, clazz);
_globalclass_vrml_external_field_EventOut = JRI_NewGlobalRef(env, clazz);
return clazz;
}
else {
return (struct java_lang_Class*)JRI_GetGlobalRef(env, _globalclass_vrml_external_field_EventOut);
}
}
native_vrml_external_Browser_removeNode(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return false;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef((void *)nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_java_lang_IllegalArgumentException( env );
JRI_ThrowNew ( env , exClass , "Invalid Parameter" );
return false;
}
return ctrl->getCC3D()->removeNode(nodeHdl);
}
native_vrml_external_Browser_getWorld(JRIEnv* env, struct vrml_external_Browser* self)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return NULL;
//!!! which method to use?
LPUNKNOWN pUnknown = ctrl->getCC3D()->getWorld();
if (!pUnknown) // invalid vrml
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid VRML" );
return NULL;
}
ctrl->addRef(pUnknown, TypeNode);
// convert to java
struct java_lang_Class * nodeClass = class_vrml_external_Node( env );
struct vrml_external_Node * node;
node = vrml_external_Node_new(env, nodeClass, (jint)ctrl, (jint)pUnknown );
return node;
}
use_vrml_external_Node(JRIEnv* env)
{
if (_globalclass_vrml_external_Node == NULL) {
struct java_lang_Class* clazz = JRI_FindClass(env, classname_vrml_external_Node);
if (clazz == NULL) {
JRI_ThrowNew(env, JRI_FindClass(env, "java/lang/ClassNotFoundException"), classname_vrml_external_Node);
return NULL;
}
use_vrml_external_Node_cBrowser(env, clazz);
use_vrml_external_Node_cNode(env, clazz);
use_vrml_external_Node_new(env, clazz);
use_vrml_external_Node_getType(env, clazz);
use_vrml_external_Node_getEventIn(env, clazz);
use_vrml_external_Node_getEventOut(env, clazz);
use_vrml_external_Node_finalize(env, clazz);
use_vrml_external_Node_nFinalize(env, clazz);
_globalclass_vrml_external_Node = JRI_NewGlobalRef(env, clazz);
return clazz;
}
else {
return (struct java_lang_Class*)JRI_GetGlobalRef(env, _globalclass_vrml_external_Node);
}
}
native_vrml_external_Browser_getMyAvatarNode(JRIEnv* env, struct vrml_external_Browser* self)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return NULL;
LPUNKNOWN pNode = ctrl->getCC3D()->getMyAvatarNode();
void * pUnknown = ctrl->getNodeQIPtr(pNode);
if (!pUnknown) // invalid vrml
{
struct java_lang_Class * exClass = class_vrml_external_exception_InvalidNodeException( env );
JRI_ThrowNew ( env , exClass , "Invalid Node" );
return NULL;
}
// convert to java
struct java_lang_Class * nodeClass = class_vrml_external_Node( env );
struct vrml_external_Node * node;
node = vrml_external_Node_new(env, nodeClass, (jint)ctrl, (jint)pUnknown );
return node;
}
native_vrml_external_Browser_setNodeName(JRIEnv* env, struct vrml_external_Browser* self, struct vrml_external_Node *node, struct java_lang_String *jName)
{
CJavaCtrl* ctrl = getController(env, self);
if (!ctrl)
return;
LPUNKNOWN nodeHdl = 0;
if (node)
{
nodeHdl = (LPUNKNOWN)get_vrml_external_Node_cNode(env, node);
if (!ctrl->checkRef((void *)nodeHdl, TypeNode)) // invalid handle
nodeHdl = 0;
}
if (!nodeHdl)
{
struct java_lang_Class * exClass = class_java_lang_IllegalArgumentException( env );
JRI_ThrowNew ( env , exClass , "Invalid Parameter" );
return;
}
const char * name = JRI_GetStringUTFChars( env , jName );
ctrl->getCC3D()->setNodeName(nodeHdl, name);
return;
}
