/cygdrive/d/src/svn/vrut/trunk/modules/scripting/jsenvironment.cpp

Go to the documentation of this file.

/*
 * $Id: $
 *
 * Description  : JSEnvironment defines API for scripts.
 * Author       : Jakub Zelenka <jakub.zelenka@gmail.com>
 *
 * Purpose      :
 *     JSEnvironment defines API for the scripts.
 */

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <jsapi.h>

#include "../../core/src/kernel.h"
#include "jsenvironment.h"
#include "jshandler.h"
#include "jsprivate.h"
#include "scriptexception.h"
#include "scriptscenemanager.h"
#include "scriptscene.h"
#include "scriptnode.h"

using namespace VRUT;
using namespace std;

#ifdef _WINDOWS
#pragma warning(disable:4312) 
#pragma warning(disable:4311) 
#endif

#include "jsevents.h"
#include "jsmemory.h"

#define MATRIX_SIZE 16

#define VECTOR_SIZE 3

#define JSE_FS {NULL, NULL, 0, 0, 0}
#define JSE_PS {NULL, 0, 0, NULL, NULL}

#define JSE_LOG_TO_CONSOLE 0

#define JSE_TEST_DD 1

#if JSE_TEST_DD
#include "../../core/src/evtstructs.h"
#endif /* JSE_TEST_DD */


enum TRANS_TYPE {TRANSLATE_ABS, TRANSLATE, ROTATE, SCALE};


static JSHandler *jsHandler;

static Kernel *kernel;

static ScriptSceneManager *ssm = NULL;

static bool realError;


// JS FUNCTIONS

// Callbacks prototypes

static void reportError(JSContext *cx, const char *asciiMsg, JSErrorReport *report);

static JSBool globalLog(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool globalWarning(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool globalError(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool globalExit(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool globalInclude(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool globalSleep(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetRoot(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetRootID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetNode(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetNodeID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetNodeIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneSetTransformation(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneTransform(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneTranslateAbs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneTranslate(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneRotate(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneScale(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneUpdateTransformation(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetScene(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneGetSceneIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool sceneToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static void scene_Finalize(JSContext *cx, JSObject *obj);

static JSBool nodeGetName(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetUid(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetLocalTransMatrix(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetWorldTransMatrix(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetChildren(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetChildrenIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetParent(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetParentID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeIsValid(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeIsActive(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeGetType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeIsOfType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool nodeToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool node_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);

static void node_Finalize(JSContext *cx, JSObject *obj);

static JSBool matrixConstructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool matrixToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static void matrix_Finalize(JSContext *cx, JSObject *obj);

static JSBool vectorConstructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool vectorToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static void vector_Finalize(JSContext *cx, JSObject *obj);

static JSBool eventPost(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventPostToKernel(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventGetArgument(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventSetArgument(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventGet(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventWait(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool eventToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool event_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);

static void event_Finalize(JSContext *cx, JSObject *obj);

static JSBool memorySlice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool memoryAlloc(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool memoryToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool memory_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);

static void memory_Finalize(JSContext *cx, JSObject *obj);

static JSBool chunkGetType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool chunkToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);

static JSBool chunkValueGetter(JSContext *cx, JSObject *obj, jsval id, jsval *vp);

static JSBool chunkValueSetter(JSContext *cx, JSObject *obj, jsval id, jsval *vp);

static void chunk_Finalize(JSContext *cx, JSObject *obj);

// Funtion Spec

static JSFunctionSpec globalFunctions[] = {
       {"log", globalLog, 0, 0, 0},
       {"warning", globalWarning, 0, 0, 0},
       {"error", globalError, 0, 0, 0},
       {"exit", globalExit, 0, 0, 0},
       {"include", globalInclude, 0, 0, 0},
       {"sleep", globalSleep, 0, 0, 0},
       JSE_FS
};

static JSFunctionSpec sceneFunctions[] = {
       {"GetID", sceneGetID, 0, 0, 0},
       {"GetRoot", sceneGetRoot, 0, 0, 0},
       {"GetRootID", sceneGetRootID, 0, 0, 0},
       {"GetNode", sceneGetNode, 0, 0, 0},
       {"GetNodeID", sceneGetNodeID , 0, 0, 0},
       {"GetNodeIDs", sceneGetNodeIDs , 0, 0, 0},
       {"SetTransformation", sceneSetTransformation, 0, 0, 0},
       {"Transform", sceneTransform, 0, 0, 0},
       {"UpdateTransformation", sceneUpdateTransformation, 0, 0, 0},
       {"TranslateAbs", sceneTranslateAbs, 0, 0, 0},
       {"Translate", sceneTranslate, 0, 0, 0},
       {"Rotate", sceneRotate, 0, 0, 0},
       {"Scale", sceneScale, 0, 0, 0},
       {"toString", sceneToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec sceneStaticFunctions[] = {
       {"GetScene", sceneGetScene, 0, 0, 0},
       {"GetSceneIDs", sceneGetSceneIDs, 0, 0, 0},
       JSE_FS
};

static JSFunctionSpec nodeFunctions[] = {
       {"GetID", nodeGetID, 0, 0, 0},
       {"GetName", nodeGetName, 0, 0, 0},
       {"GetUid", nodeGetUid, 0, 0, 0},
       {"GetLocalTransMatrix", nodeGetLocalTransMatrix, 0, 0, 0},
       {"GetWorldTransMatrix", nodeGetWorldTransMatrix, 0, 0, 0},
       {"GetChildren", nodeGetChildren, 0, 0, 0},
       {"GetChildrenIDs", nodeGetChildrenIDs, 0, 0, 0},
       {"GetParent", nodeGetParent, 0, 0, 0},
       {"GetParentID", nodeGetParentID, 0, 0, 0},
       {"IsValid", nodeIsValid, 0, 0, 0},
       {"IsActive", nodeIsActive, 0, 0, 0},
       {"GetType", nodeGetType, 0, 0, 0},
       {"IsOfType", nodeIsOfType, 0, 0, 0},
       {"toString", nodeToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec matrixFunctions[] = {
       {"toString", matrixToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec vectorFunctions[] = {
       {"toString", vectorToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec eventFunctions[] = {
       {"Post", eventPost, 0, 0, 0},
       {"PostToKernel", eventPostToKernel, 0, 0, 0},
       {"GetArgument", eventGetArgument, 0, 0, 0},
       {"SetArgument", eventSetArgument, 0, 0, 0},
       {"toString", eventToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec eventStaticFunctions[] = {
       {"Get", eventGet, 0, 0, 0},
       {"Wait", eventWait, 0, 0, 0},
       JSE_FS
};

static JSFunctionSpec memoryFunctions[] = {
       {"Slice", memorySlice, 0, 0, 0},
       {"toString", memoryToString, 0, 0, 0}, // from object
       JSE_FS
};

static JSFunctionSpec memoryStaticFunctions[] = {
       {"Alloc", memoryAlloc, 0, 0, 0},
       JSE_FS
};

static JSFunctionSpec chunkFunctions[] = {
       {"GetType", chunkGetType, 0, 0, 0},
       JSE_FS
};


// JS PROPERTIES

static JSPropertySpec nodeStaticProps[] = {
       {"ASSEMBLY", SceneNode::ASSEMBLY, JSPROP_READONLY, NULL, NULL},
       {"ROOT", SceneNode::ROOT, JSPROP_READONLY, NULL, NULL},
       {"CAMERA", SceneNode::CAMERA, JSPROP_READONLY, NULL, NULL},
       {"GEOMETRY", SceneNode::GEOMETRY, JSPROP_READONLY, NULL, NULL},
       {"LIGHT", SceneNode::LIGHT, JSPROP_READONLY, NULL, NULL},
       JSE_PS
};

static JSPropertySpec eventStaticProps[JSEVT_ARG_COUNT + JSEVT_EVT_COUNT + 1];

static JSPropertySpec memoryStaticProps[JSMEM_TYPES_COUNT + 1];

static JSPropertySpec chunkProps[] = {
       {"value", 1, JSPROP_ENUMERATE, chunkValueGetter, chunkValueSetter},
       JSE_PS
};


// JS CLASSES

static JSClass GlobalClass = {
       "VRUT", JSCLASS_GLOBAL_FLAGS,
       JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass SceneClass = {
       "Scene", JSCLASS_HAS_PRIVATE,
       JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, scene_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass NodeClass = {
       "Node", JSCLASS_HAS_PRIVATE,
       JS_PropertyStub, JS_PropertyStub, node_GetProperty, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, node_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass MatrixClass = {
       "Matrix", JSCLASS_HAS_PRIVATE /*| JSCLASS_CONSTRUCT_PROTOTYPE*/,
       JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, matrix_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass VectorClass = {
       "Vector", JSCLASS_HAS_PRIVATE /*| JSCLASS_CONSTRUCT_PROTOTYPE*/,
       JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, vector_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass EventClass = {
       "Event", JSCLASS_HAS_PRIVATE,
       JS_PropertyStub, JS_PropertyStub, event_GetProperty, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, event_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass MemoryClass = {
       "Memory", JSCLASS_HAS_PRIVATE,
       JS_PropertyStub, JS_PropertyStub, memory_GetProperty, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, memory_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

static JSClass ChunkClass = {
       "Chunk", JSCLASS_HAS_PRIVATE,
       JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
       JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, chunk_Finalize,
       JSCLASS_NO_OPTIONAL_MEMBERS
};

// ----------------------------------
// FUNCTION DEFINITIONS

// UTILITY

static void log(int type, const char *asciiMsg)
{
       wxString msg(asciiMsg, wxConvUTF8);
       VRUT::FlexiLog::LogMessageFlexi(wxT("<JSScriptingModule>") + msg, type);
}

#define logMsg(_msg) log(wxLOG_Message, _msg)

#define logError(_msg) log(wxLOG_Error, _msg)

#define logWarning(_msg) log(wxLOG_Warning, _msg)

static JSString *getJSString(JSContext *cx, const char *str)
{
       JSString *jsStr = JS_NewStringCopyZ(cx, str);
       if (!jsStr)
              JS_ReportError(cx, "The String object cannot be created");
       return jsStr;
}

static void fillArray(float *a, unsigned size, uintN argc, jsval *argv)
{
       unsigned i, count = int((argc > size)? size: argc);
       for (i = 0; i < count; i++)
       {
              if (JSVAL_IS_DOUBLE(argv[i]))
              {
                     jsdouble *value = JSVAL_TO_DOUBLE(argv[i]);
                     a[i] = float(*value);
              }
              else if (JSVAL_IS_INT(argv[i]))
                     a[i] = float(JSVAL_TO_INT(argv[i]));
              else
                     a[i] = 0;
       }
       for (; i < size; i++)
              a[i] = 0;
}

static VECTOR3 makeVector(JSContext *cx, uintN argc, jsval *argv) throw(ScriptException)
{
       if (JSVAL_IS_OBJECT(argv[0]))
       {
              JSObject *vectorObj = JSVAL_TO_OBJECT(argv[0]);
              if (!JS_InstanceOf(cx, vectorObj, &VectorClass, NULL))
                     throw(ScriptException("Second argument in function %s isn't Vector or Number instance"));
              VectorData *data = (VectorData *) JS_GetPrivate(cx, vectorObj);
              if (!data)
                     throw(ScriptException("Second argurment in function %s is incorrect Vector object"));
              return data->v;
       }
       else
       {
              jsdouble x, y, z;
              if (!JS_ConvertArguments(cx, argc, argv, "ddd", &x, &y, &z))
                     throw(ScriptException("Bad arguments in function %s"));

              return VECTOR3(float(x), float(y), float(z));
       }
}

static void *getMemoryAddr(JSContext *cx, JSObject *obj)
{
       MemoryData *data = (MemoryData *) JS_GetPrivate(cx, obj);
       if (!data)
       {
              JS_ReportWarning(cx, "Memory object doesn't have private data (it was probably explicitly created)");
              return NULL;
       }
       return data->memAddr;
}

// REPORT

static void reportError(JSContext *cx, const char *asciiMsg, JSErrorReport *report)
{
       wxString msg(asciiMsg, wxConvUTF8);
       wxString fileName = (report->filename? wxString(report->filename, wxConvUTF8): wxT("console"));
       wxString line = wxString::Format(wxT(":%d:"), report->lineno);

       VRUT::FlexiLog::LogMessageFlexi(wxT("<JSScriptingModule>") + fileName + line + msg,
        JSREPORT_IS_WARNING(report->flags)? wxLOG_Warning: wxLOG_Error);

#if JSE_LOG_TO_CONSOLE
       cerr << (report->filename? report->filename: "<no filename>")
              << ':' << report->lineno << ':' << asciiMsg << endl;
#endif

}

// GLOBAL

static JSBool globalLog(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;  // return undefined

       if (argc == 0)
              return JS_TRUE;

       char *asciiMsg;
       if (!JS_ConvertArguments(cx, argc, argv, "s", &asciiMsg))
       {
              JS_ReportError(cx, "Function log requires string argument");
              return JS_FALSE;
       }

       logMsg(asciiMsg);

#if JSE_LOG_TO_CONSOLE
       cout << asciiMsg << endl;
#endif

       return JS_TRUE;
}

static JSBool globalWarning(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;  // return undefined

       if (argc == 0)
              return JS_TRUE;

       char *asciiMsg;
       if (!JS_ConvertArguments(cx, argc, argv, "s", &asciiMsg))
       {
              JS_ReportError(cx, "Function warning requires string argument");
              return JS_FALSE;
       }

       logWarning(asciiMsg);

#if JSE_LOG_TO_CONSOLE
       cout << asciiMsg << endl;
#endif

       return JS_TRUE;
}

static JSBool globalError(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       realError = false;

       if (argc == 0)
              return JS_FALSE;

       char *asciiMsg;
       if (!JS_ConvertArguments(cx, argc, argv, "s", &asciiMsg))
       {
              JS_ReportError(cx, "Function error requires a string argument");
              return JS_FALSE;
       }

       logError(asciiMsg);

#if JSE_LOG_TO_CONSOLE
       cerr << asciiMsg << endl;
#endif

       return JS_FALSE;
}

static JSBool globalExit(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       realError = false;
       return JS_FALSE;
}


static JSBool globalInclude(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       if (argc == 0)
       {
              *rval = JSVAL_VOID;
              return JS_TRUE;
       }

       char *filePath;
       if (!JS_ConvertArguments(cx, argc, argv, "s", &filePath))
       {
              JS_ReportError(cx, "Function include requires a string with file path");
              return JS_FALSE;
       }

       FILE *file = fopen(filePath, "r");
       if (file == NULL)
       {
              JS_ReportError(cx, "File %s not found or cannot be read", filePath);
              return JS_FALSE;
       }

       bool rc = true;

       JSScript *script = JS_CompileFileHandle(cx, JS_GetGlobalObject(cx), filePath, file);
       if (!script)
       {
              JS_ReportError(cx, "The file %s with included script cannot be compilated", filePath);
              return JS_FALSE;
       }
       JSObject *scriptObj = JS_NewScriptObject(cx, script);
       if (scriptObj == NULL)
       {
              JS_DestroyScript(cx, script);
              JS_ReportError(cx, "The included script object cannot be created");
              return JS_FALSE;
       }
       if (!JS_AddNamedRoot(cx, &scriptObj, "IncludedScript"))
       {
              JS_ReportError(cx, "The included script object cannot be added to root");
              return JS_FALSE;
       }

       rc = JS_ExecuteScript(cx,  JS_GetGlobalObject(cx), script, rval) == JS_TRUE;
       JS_RemoveRoot(cx, &scriptObj);
       if (!rc)
       {
              JS_ReportError(cx, "Unsuccessfull executing the script file %s", filePath);
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool globalSleep(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       if (argc == 0)
       {
              JS_ReportError(cx, "The function sleep needs one argument (sleeping time in milis)");
              return JS_FALSE;
       }

       uint32 jsTime;
       if (!JS_ConvertArguments(cx, argc, argv, "u", &jsTime))
       {
              JS_ReportError(cx, "The function sleep requires a number argument");
              return JS_FALSE;
       }

       if (!jsHandler->Sleep(jsTime))
       {
              logError("Script was terminated");
              return JS_FALSE;
       }

       return JS_TRUE;
}


// SCENE

static SCENE_ID getSceneID(JSContext *cx, JSObject *obj)
{
       SceneData *sceneData = (SceneData *) JS_GetPrivate(cx, obj);
       if (!sceneData) // check the private data existence
       {
              JS_ReportWarning(cx, "Scene object doesn't have private data (it was probably explicitly created)");
              return SCENE_ID_NONE;
       }
       return sceneData->GetSceneID();
}

static ScriptScene *getScene(JSContext *cx, JSObject *obj, SCENE_ID *idp = NULL)
{
       SCENE_ID sceneID = getSceneID(cx, obj);
       if (idp)
              *idp = sceneID;
       if (sceneID == SCENE_ID_NONE)
              return NULL;

       ScriptScene *scene = ssm->GetScene(sceneID);
       if (scene)
              return scene;

       JS_ReportWarning(cx, "Invalid scene ID");
       return NULL;
}


static JSBool sceneGetID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       SCENE_ID sceneID = getSceneID(cx, obj);
       if (sceneID == SCENE_ID_NONE)
       {
              *rval = JSVAL_VOID;
              return JS_TRUE;
       }
       *rval = INT_TO_JSVAL(int(sceneID));
       return JS_TRUE;
}

static JSBool sceneGetRoot(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              SCENE_ID sceneID;
              ScriptScene *scene = getScene(cx, obj, &sceneID);

              if (!scene)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              NODE_ID rootID = scene->GetRootID();
              if (rootID == NODE_ID_NONE)
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }

              JSObject *rootObj = JS_NewObject(cx, &NodeClass, NULL, NULL);
              if (!JS_SetPrivate(cx, rootObj, (void *) new NodeData(sceneID, rootID)))
                     throw ScriptException("Node data cannot be set");

              *rval = OBJECT_TO_JSVAL(rootObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneGetRootID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              NODE_ID rootID = scene->GetRootID();
              if (rootID == NODE_ID_NONE)
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }

              *rval = INT_TO_JSVAL(int(rootID));
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneGetNode(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              if (argc == 0)
                     throw ScriptException("The function GetNodeID needs argument (node uid or node id)");

              SCENE_ID sceneID;
              ScriptScene *scene = getScene(cx, obj, &sceneID);
              if (!scene)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              NODE_ID nodeID;
              if (JSVAL_IS_STRING(argv[0]))
              {
                     char *asciiUid = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
                     wxString uid(asciiUid, wxConvUTF8);
                     nodeID = scene->GetNodeID(uid);
              }
              else if (JSVAL_IS_INT(argv[0]))
                     nodeID = NODE_ID(JSVAL_TO_INT(argv[0]));
              else
                     throw ScriptException("Function Scene.GetNode() requires a string argument");

              if (!scene->GetNode(NODE_ID(nodeID)))
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }

              JSObject *nodeObj = JS_NewObject(cx, &NodeClass, NULL, NULL);
              if (!JS_SetPrivate(cx, nodeObj, (void *) new NodeData(sceneID, nodeID)))
                     throw ScriptException("Node data cannot be set");

              *rval = OBJECT_TO_JSVAL(nodeObj);

       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneGetNodeID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              if (argc == 0)
                     throw ScriptException("The function Scene.GetNodeID needs one argument");

              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              char *asciiUid;
              if (!JS_ConvertArguments(cx, argc, argv, "s", &asciiUid))
                     throw ScriptException("Function Scene.GetNode() requires a string argument");

              wxString uid(asciiUid, wxConvUTF8);
              NODE_ID nodeID = scene->GetNodeID(uid);

              *rval = INT_TO_JSVAL(int(nodeID));
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneGetNodeIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              vector<NODE_ID> nodeIDs;
              scene->GetNodeIDs(&nodeIDs);
              if (nodeIDs.size())
              {
                     JSObject *nodesObj = JS_NewArrayObject(cx, 0, NULL);
                     if (!nodesObj)
                            throw ScriptException("Nodes array object cannot be created");

                     for (unsigned i = 0; i < nodeIDs.size(); i++)
                     {
                            jsval id = INT_TO_JSVAL(int(nodeIDs[i]));
                            if (!JS_SetElement(cx, nodesObj, i, &id))
                                   throw ScriptException("Scenes array object cannot be created");
                     }
                     *rval = OBJECT_TO_JSVAL(nodesObj);
              }
              else
                     *rval = JSVAL_NULL;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

    return JS_TRUE;
}

static JSBool sceneUpdateTransformation(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              *rval = JSVAL_VOID;

              if (argc == 0 || !JSVAL_IS_INT(argv[0]))
                     throw ScriptException("Invalid arguments in function Scene.UpdateTransformation");

              NODE_ID nodeID = NODE_ID(JSVAL_TO_INT(argv[0]));

              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
                     return JS_TRUE;

              scene->UpdateTransformation(nodeID);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool _sceneTransMatrix(bool isTransform, JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;
       JSObject *matrixObj;

       if (argc <= 1 || !JSVAL_IS_INT(argv[0]) || !JSVAL_IS_OBJECT(argv[1])
                     || !JS_InstanceOf(cx, matrixObj = JSVAL_TO_OBJECT(argv[1]), &MatrixClass, NULL))
       {
              JS_ReportError(cx, "Invalid arguments for function Scene.%s",
                     isTransform? "Transform": "SetTransformation");
              return JS_FALSE;
       }
       NODE_ID nodeID = NODE_ID(JSVAL_TO_INT(argv[0]));

       try
       {
              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
                     return JS_TRUE;

              MatrixData *data = (MatrixData *) JS_GetPrivate(cx, matrixObj);
              if (data && isTransform)
                     scene->Transform(nodeID, data->m);
              else if (data && !isTransform)
                     scene->SetTransformation(nodeID, data->m);
              else
                     JS_ReportWarning(cx, "Private data for Matrix object wasn't set");
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneSetTransformation(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransMatrix(false, cx, obj, argc, argv, rval);
}

static JSBool sceneTransform(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransMatrix(true, cx, obj, argc, argv, rval);
}


static JSBool _sceneTransVector(TRANS_TYPE type, const char *fceName,
              JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;

       if (int(argc) <= ((type == ROTATE)? 2: 1) || !JSVAL_IS_INT(argv[0]))
       {
              JS_ReportError(cx, "Invalid arguments in function %s", fceName);
              return JS_FALSE;
       }

       NODE_ID nodeID = NODE_ID(JSVAL_TO_INT(argv[0]));

       try
       {
              ScriptScene *scene = getScene(cx, obj);
              if (!scene)
                     return JS_TRUE;

              if (type == TRANSLATE_ABS)
              {
                     scene->TranslateAbs(nodeID, makeVector(cx, argc-1, argv+1));
                     return JS_TRUE;
              }

              ScriptNode *node = scene->GetNode(nodeID);
              if (!node)
              {
                     JS_ReportWarning(cx, "No node with ID %u", unsigned(nodeID));
                     return JS_TRUE;
              }

              MATRIX m;
              switch (type)
              {
              case TRANSLATE:
                     m.Translate(makeVector(cx, argc-1, argv+1));
                     break;
              case SCALE:
                     m.Scale(makeVector(cx, argc-1, argv+1));
                     break;
              case ROTATE:
                     float angle;
                     if (JSVAL_IS_DOUBLE(argv[1]))
                     {
                            jsdouble *jsAngle = JSVAL_TO_DOUBLE(argv[1]);
                            angle = float(*jsAngle);
                     }
                     else if (JSVAL_IS_INT(argv[1]))
                            angle = float(JSVAL_TO_INT(argv[1]));
                     else
                            break;

                     angle = angle * M_PI / 180;

                     m = m.RotationAxis(makeVector(cx, argc-2, argv+2), angle);
                     break;
              }
              scene->Transform(nodeID, m);
              scene->UpdateTransformation(nodeID);

       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what(), fceName);
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool sceneTranslateAbs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransVector(TRANSLATE_ABS, "Scene.TranslateAbs", cx, obj, argc, argv, rval);
}

static JSBool sceneTranslate(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransVector(TRANSLATE, "Scene.Translate", cx, obj, argc, argv, rval);
}

static JSBool sceneRotate(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransVector(ROTATE, "Scene.Rotate", cx, obj, argc, argv, rval);
}

static JSBool sceneScale(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _sceneTransVector(SCALE, "Scene.Scale", cx, obj, argc, argv, rval);
}


static JSBool sceneGetScene(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       if (argc == 0 || !JSVAL_IS_INT(argv[0]))
       {
              JS_ReportError(cx, "Invalid arguments in static function Scene.GetScene");
              return JS_FALSE;
       }
       SCENE_ID sceneID = SCENE_ID(JSVAL_TO_INT(argv[0]));

       vector<SCENE_ID> sceneIDs;
       size_t size = kernel->sceneManager->GetSceneIDs(sceneIDs);
       if (size == 0 || find(sceneIDs.begin(), sceneIDs.end(), sceneID) == sceneIDs.end())
       {
              JS_ReportWarning(cx, "No scene with ID %u", unsigned(sceneID));
              *rval = JSVAL_NULL;
              return JS_TRUE;
       }

       JSObject *sceneObj = JS_NewObject(cx, &SceneClass, NULL, NULL);
       if (!sceneObj || !JS_SetPrivate(cx, sceneObj, (void *) new SceneData(sceneID)))
       {
              JS_ReportError(cx, "Scene object cannot be created");
              return JS_FALSE;
       }

       *rval = OBJECT_TO_JSVAL(sceneObj);
       return JS_TRUE;
}

static JSBool sceneGetSceneIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       vector<SCENE_ID> sceneIDs;
       size_t size = kernel->sceneManager->GetSceneIDs(sceneIDs);
       if (size)
       {
              JSObject *scenesObj = JS_NewArrayObject(cx, 0, NULL);
              if (!scenesObj)
              {
                     JS_ReportError(cx, "Scenes array object cannot be created");
                     return JS_FALSE;
              }
              for (unsigned i = 0; i < size; i++)
              {
                     jsval id = INT_TO_JSVAL((int) sceneIDs[i]);
                     if (!JS_SetElement(cx, scenesObj, i, &id))
                     {
                            JS_ReportError(cx, "Scenes array object cannot be created");
                            return JS_FALSE;
                     }
              }
              *rval = OBJECT_TO_JSVAL(scenesObj);
       }
       else
              *rval = JSVAL_NULL;
       return JS_TRUE;
}

static JSBool sceneToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       char buff[64];
       SCENE_ID id = getSceneID(cx, obj);
       if (id == SCENE_ID_NONE)
              strcpy(buff, "[object Scene(sceneId=undefined)]");
       else
              sprintf(buff, "[object Scene(sceneId=%u)]", unsigned(id));

       JSString *msgStr = getJSString(cx, buff);
       if (!msgStr)
              return JS_FALSE;

       *rval = STRING_TO_JSVAL(msgStr);

       return JS_TRUE;
}

static void scene_Finalize(JSContext *cx, JSObject *obj)
{
       SceneData *data = (SceneData *) JS_GetPrivate(cx, obj);
       if (data)
              delete data;
}


// NODE

static NodeData *getNodeData(JSContext *cx, JSObject *obj)
{
       NodeData *nodeData = (NodeData *) JS_GetPrivate(cx, obj);
       if (!nodeData) // check the private data existence
       {
              JS_ReportWarning(cx, "Node object doesn't have the private data (it was probably explicitly created)");
              return NULL;
       }
       return nodeData;
}

static ScriptNode *getNode(JSContext *cx, JSObject *obj, SCENE_ID *sid = NULL, NODE_ID *nid = NULL)
              throw(ScriptException)
{
       NodeData *nodeData = getNodeData(cx, obj);
       if (!nodeData)
              return NULL;

       SCENE_ID sceneID = nodeData->GetSceneID();
       NODE_ID nodeID = nodeData->GetNodeID();
       if (sid)
              *sid = sceneID;
       if (nid)
              *nid = nodeID;

       ScriptScene *scene = ssm->GetScene(sceneID);
       if (!scene)
              throw ScriptException("Invalid scene ID");

       ScriptNode *node = scene->GetNode(nodeID);
       if (!node)
              throw ScriptException("Invalid node ID");

       return node;

}

static JSBool nodeGetName(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              if (!node)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              JSString *nameStr = getJSString(cx, node->GetName().mb_str());
              if (!nameStr)
                     return JS_FALSE;

              *rval = STRING_TO_JSVAL(nameStr);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetUid(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              if (!node)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              JSString *uidStr = getJSString(cx, node->GetUid().mb_str());
              if (!uidStr)
                     return JS_FALSE;

              *rval = STRING_TO_JSVAL(uidStr);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {

              ScriptNode *node = getNode(cx, obj);
              if (!node)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }
              *rval = INT_TO_JSVAL(int(node->GetID()));
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool _nodeGetTransMatrix(bool isLocal, JSContext *cx, JSObject *obj, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              if (!node)
              {
                     *rval = JSVAL_VOID;
                     return JS_TRUE;
              }

              MATRIX m(*(isLocal? node->GetLocalTransMatrix(): node->GetWorldTransMatrix()));
              JSObject *matrixObj = JS_NewObject(cx, &MatrixClass, NULL, NULL);
              if (!matrixObj || !JS_SetPrivate(cx, matrixObj, (void *) new MatrixData(m)))
                     throw ScriptException("Matrix object cannot be created");

              *rval = OBJECT_TO_JSVAL(matrixObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetLocalTransMatrix(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _nodeGetTransMatrix(true, cx, obj, rval);
}

static JSBool nodeGetWorldTransMatrix(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       return _nodeGetTransMatrix(false, cx, obj, rval);
}

static JSBool nodeGetChildren(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {

              SCENE_ID sceneID;
              const SceneNode::NodeIDList *children;
              ScriptNode *node = getNode(cx, obj, &sceneID);
              if (!node || !(children = node->GetChildren()))
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }

              JSObject *childrenObj = JS_NewArrayObject(cx, 0, NULL);
              if (!childrenObj)
                     throw ScriptException("The array with node's children cannot be created");

              SceneNode::NodeIDList::const_iterator it = children->begin();
              for (jsint i = 0; it != children->end(); it++, i++)
              {
                     JSObject *childObj = JS_NewObject(cx, &NodeClass, NULL, NULL);
                     if (!childObj || !JS_SetPrivate(cx, childObj, new NodeData(sceneID, *it)))
                            throw ScriptException("Node child object cannot be create");

                     jsval value = OBJECT_TO_JSVAL(childObj);
                     if (!JS_SetElement(cx, childrenObj, i, &value))
                            throw ScriptException("Node child object element cannot be set");
              }

              *rval = OBJECT_TO_JSVAL(childrenObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetChildrenIDs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              const SceneNode::NodeIDList *children;
              ScriptNode *node = getNode(cx, obj);
              if (!node || !(children = node->GetChildren()))
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }
              JSObject *childrenObj = JS_NewArrayObject(cx, 0, NULL);
              if (!childrenObj)
                     throw ScriptException("The array with node's children cannot be created");

              SceneNode::NodeIDList::const_iterator it = children->begin();
              for (jsint i = 0; it != children->end(); it++, i++)
              {
                     jsval value = INT_TO_JSVAL(*it);
                     if (!JS_SetElement(cx, childrenObj, i, &value))
                            throw ScriptException("Children ID element cannot be created");
              }

              *rval = OBJECT_TO_JSVAL(childrenObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetParent(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              SCENE_ID sceneID;
              ScriptNode *node = getNode(cx, obj, &sceneID);
              if (!node || node->GetParent() == NODE_ID_NONE)
              {
                     *rval = JSVAL_NULL;
                     return JS_TRUE;
              }

              JSObject *parentObj = JS_NewObject(cx, &NodeClass, NULL, NULL);
              if (!parentObj || !JS_SetPrivate(cx, parentObj, new NodeData(sceneID, node->GetParent())))
                     throw ScriptException("Parent object cannot be created");

              *rval = OBJECT_TO_JSVAL(parentObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeGetParentID(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              *rval = (node && node->GetParent() != NODE_ID_NONE)? INT_TO_JSVAL(node->GetParent()): JSVAL_NULL;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeIsValid(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              *rval = (node && node->IsValid())? JSVAL_TRUE: JSVAL_FALSE;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeIsActive(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              *rval = (node && node->IsActive())? JSVAL_TRUE: JSVAL_FALSE;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }
       return JS_TRUE;
}

static JSBool nodeGetType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node = getNode(cx, obj);
              *rval = (node)? INT_TO_JSVAL(node->GetType()): JSVAL_NULL;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeIsOfType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              ScriptNode *node;
              *rval = (argc > 0 && JSVAL_IS_INT(argv[0]) && (node = getNode(cx, obj))
                     && node->IsOfType(SceneNode::SCENENODE_TYPE(JSVAL_TO_INT(argv[0]))))? JSVAL_TRUE: JSVAL_FALSE;
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool nodeToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       char buff[64];
       NodeData *data = getNodeData(cx, obj);
       if (!data)
              strcpy(buff, "[object Node(sceneId=undefined, nodeId=undefined)]");
       else
       {
              sprintf(buff, "[object Node(sceneId=%u, nodeId=%u)]",
                     unsigned(data->GetSceneID()), unsigned(data->GetNodeID()));
       }

       JSString *msgStr = getJSString(cx, buff);
       if (!msgStr)
              return JS_FALSE;

       *rval = STRING_TO_JSVAL(msgStr);

       return JS_TRUE;
}

static JSBool node_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
       if (JSVAL_IS_INT(id))
       {
              switch (JSVAL_TO_INT(id))
              {
              case SceneNode::ASSEMBLY:
                     *vp = INT_TO_JSVAL(int(SceneNode::ASSEMBLY));
                     break;
              case SceneNode::ROOT:
                     *vp = INT_TO_JSVAL(int(SceneNode::ROOT));
                     break;
              case SceneNode::CAMERA:
                     *vp = INT_TO_JSVAL(int(SceneNode::CAMERA));
                     break;
              case SceneNode::GEOMETRY:
                     *vp = INT_TO_JSVAL(int(SceneNode::GEOMETRY));
                     break;
              case SceneNode::LIGHT:
                     *vp = INT_TO_JSVAL(int(SceneNode::LIGHT));
                     break;
              }
       }
       return JS_TRUE;
}

static void node_Finalize(JSContext *cx, JSObject *obj)
{
       NodeData *data = (NodeData *) JS_GetPrivate(cx, obj);
       delete data;
}


// MATRIX

static JSBool matrixConstructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       float m[MATRIX_SIZE];
       fillArray(m, MATRIX_SIZE, argc, argv);

       if (!JS_SetPrivate(cx, obj, new MatrixData(m)))
       {
              JS_ReportError(cx, "Matrix data couldn't be set");
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool matrixToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       JSString *msg;
       MatrixData *data = (MatrixData *) JS_GetPrivate(cx, obj);
       if (data)
       {
              wxString str(wxT("[object Matrix(\n") + data->m.ToString() + wxT(")]"));
              msg = getJSString(cx, str.mb_str());
       }
       else
              msg = getJSString(cx, "[object Matrix(undefined)]");

       if (!msg)
              return FALSE;

       *rval = STRING_TO_JSVAL(msg);
       return JS_TRUE;
}

static void matrix_Finalize(JSContext *cx, JSObject *obj)
{
       MatrixData *data = (MatrixData *) JS_GetPrivate(cx, obj);
       delete data;
}


// VECTOR

static JSBool vectorConstructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       float v[VECTOR_SIZE];
       fillArray(v, VECTOR_SIZE, argc, argv);

       if (!JS_SetPrivate(cx, obj, new VectorData(v)))
       {
              JS_ReportError(cx, "Vector data couldn't be set");
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool vectorToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       JSString *msg;
       VectorData *data = (VectorData *) JS_GetPrivate(cx, obj);
       if (data)
       {
              wxString str(wxT("[object Vector") + data->v.ToString() + wxT("]"));
              msg = getJSString(cx, str.mb_str());
       }
       else
              msg = getJSString(cx, "[object Vecto(undefined)]");

       if (!msg)
              return JS_FALSE;

       *rval = STRING_TO_JSVAL(msg);
       return JS_TRUE;
}

static void vector_Finalize(JSContext *cx, JSObject *obj)
{
       VectorData *data = (VectorData *) JS_GetPrivate(cx, obj);
       delete data;
}


// EVENT

static JSBool eventPost(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;
       EventData *data = (EventData *) JS_GetPrivate(cx, obj);
       if (!data)
              return JS_TRUE;

       jsHandler->PostEvent(*data->evt);

       return JS_TRUE;
}

static JSBool eventPostToKernel(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_VOID;
       EventData *data = (EventData *) JS_GetPrivate(cx, obj);
       if (!data)
              return JS_TRUE;

       jsHandler->PostToKernel(*data->evt);

       return JS_TRUE;
}

static int getArgumentType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, EventData **data) throw(ScriptException)
{
       *data = (EventData *) JS_GetPrivate(cx, obj);
       if (!data)
              throw ScriptException("The method %s is called in the incorrect Event object (no private data)");

       int argType;
       if (!JSVAL_IS_INT(argv[0]) || getEventArgIdxByType(argType = JSVAL_TO_INT(argv[0])) < 0)
              throw ScriptException("The first argument for %s method isn't argument type");

       unsigned nparams = (*data)->info->nparams;
       JSEVT_PARAM_TYPE *params =  (*data)->info->params;
       bool correct = false;
       for (unsigned i = 0; i < nparams; i++)
       {
              //cout << params[i] << ":" << argType << endl;
              if (params[i] == argType)
              {
                     correct = true;
                     break;
              }
       }
       if (!correct)
              throw ScriptException("The first argument for %s method isn't correct argument type");

       return argType;
}

static JSBool eventGetArgument(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       try
       {
              if (argc == 0)
                     throw ScriptException("The method %s needs one argument");

              EventData *data;
              int argType = getArgumentType(cx, obj, argc, argv, &data);

              if (JSEVT_PARAM_IS_JSSTRING(argType))
              {
                     JSString *str = getJSString(cx, data->evt->GetString().mb_str());
                     if (!str)
                            return JS_FALSE;
                     *rval = STRING_TO_JSVAL(str);
              }
              else if (JSEVT_PARAM_IS_JSBOOL(argType))
                     *rval = (data->evt->GetInt()? JSVAL_TRUE: JSVAL_FALSE);
              else if (JSEVT_PARAM_IS_JSINT(argType))
              {
                     int value;
                     if (JSEVT_PARAM_IS_ID(argType))
                            value = data->evt->GetId();
                     else if (JSEVT_PARAM_IS_INT(argType))
                            value = value = data->evt->GetInt();
                     else
                            throw ScriptException("Unknown JSINT type in method %s");
                     *rval = INT_TO_JSVAL(value);
              }
              else if (JSEVT_PARAM_IS_JSMEMORY(argType))
              {
                     void *addr = data->evt->GetClientData();
                     if (!addr)
                            throw ScriptException("NULL client data in method %s");

                     MemoryData *memData = new MemoryData(addr);
                     JSObject *memObj = JS_NewObject(cx, &MemoryClass, NULL, NULL);
                     if (!memObj || !JS_SetPrivate(cx, memObj, (void *) memData))
                     {
                            JS_ReportError(cx, "Memory object cannot be correctly created");
                            return JS_FALSE;
                     }

                     *rval = OBJECT_TO_JSVAL(memObj);
              }
              else
                     throw ScriptException("Not supported EVT_PARAM_TYPE type in method %s");

       }
       catch (ScriptException & exc)
       {
              JS_ReportWarning(cx, exc.what(), "GetArgument");
              *rval = JSVAL_NULL;
       }

       return JS_TRUE;
}

static JSBool eventSetArgument(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       *rval = JSVAL_TRUE;

       try
       {
              if (argc < 2)
                     throw ScriptException("The method %s needs two arguments");

              EventData *data;
              int argType = getArgumentType(cx, obj, argc, argv, &data);

              if (JSEVT_PARAM_IS_JSINT(argType))
              {
                     if (!JSVAL_IS_INT(argv[1]))
                     {
                            JS_ReportError(cx, "It is required integer second argument");
                            return JS_FALSE;
                     }
                     if (JSEVT_PARAM_IS_ID(argType))
                            data->evt->SetId(JSVAL_TO_INT(argv[1]));
                     else if (JSEVT_PARAM_IS_INT(argType))
                            data->evt->SetInt(JSVAL_TO_INT(argv[1]));
                     else
                            throw ScriptException("Unknown JSINT type in method %s");

              }
              else if (JSEVT_PARAM_IS_JSSTRING(argType))
              {
                     char *asciiStr;
                     if (!JS_ConvertArguments(cx, 1, argv + 1, "s", &asciiStr))
                     {
                            JS_ReportError(cx, "It is required string second argument");
                            return JS_FALSE;
                     }
                     wxString str(asciiStr, wxConvUTF8);
                     data->evt->SetString(str);
              }
              else if (JSEVT_PARAM_IS_JSBOOL(argType))
              {
                     if (!JSVAL_IS_BOOLEAN(argv[1]))
                     {
                            JS_ReportError(cx, "It is required boolean second argument");
                            return JS_FALSE;
                     }
                     data->evt->SetInt(int(argv[1] == JSVAL_TRUE));
              }
              else if (JSEVT_PARAM_IS_JSMEMORY(argType))
              {
                     JSObject *memObj;
                     if (!JSVAL_IS_OBJECT(argv[1])
                                   || !JS_InstanceOf(cx, memObj = JSVAL_TO_OBJECT(argv[1]), &MemoryClass, NULL))
                     {
                            JS_ReportError(cx, "It is required Memory object as second argument");
                            return JS_FALSE;
                     }

                     void *memAddr = getMemoryAddr(cx, memObj);
                     if (!memAddr)
                     {
                            *rval = JSVAL_FALSE;
                            return JS_TRUE;
                     }
                     data->evt->SetClientData(memAddr);
              }
              else
              {
                     JS_ReportError(cx, "Invalid type of the second argument");
                     return JS_FALSE;
              }

       }
       catch (ScriptException & exc)
       {
              JS_ReportWarning(cx, exc.what(), "SetArgument");
              *rval = JSVAL_FALSE;
       }

       return JS_TRUE;
}

static JSBool eventGet(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       if (argc == 0)
              return JS_TRUE;

       int idx;
       if (!JSVAL_IS_INT(argv[0]) || (idx = getEventIdxByType(JSVAL_TO_INT(argv[0]))) < 0)
       {
              JS_ReportError(cx, "The first argument in Event constructor must be correct EVENT_TYPE");
              return JS_FALSE;
       }

       if (argc <= events[idx].nparams)
       {
              JS_ReportError(cx, "The event %s requires %u arguments", events[idx].name, events[idx].nparams);
              return JS_FALSE;
       }

       wxCommandEvent *evt = new wxCommandEvent(events[idx].type);

       for (unsigned i = 0; i < events[idx].nparams; i++)
       {
              if (JSEVT_PARAM_IS_JSINT(events[idx].params[i]))
              {
                     if (!JSVAL_IS_INT(argv[i+1]))
                     {
                            JS_ReportError(cx, "The argument %u for event %s must be integer", i, events[idx].name);
                            return JS_FALSE;
                     }
                     if (JSEVT_PARAM_IS_ID(events[idx].params[i]))
                            evt->SetId(JSVAL_TO_INT(argv[i+1]));
                     else if (JSEVT_PARAM_IS_INT(events[idx].params[i]))
                            evt->SetInt(JSVAL_TO_INT(argv[i+1]));
                     else
                            JS_ReportWarning(cx, "The argument %u for event %s is undefined integer type", i, events[idx].name);

              }
              else if (JSEVT_PARAM_IS_JSSTRING(events[idx].params[i]))
              {
                     char *asciiStr;
                     if (!JS_ConvertArguments(cx, 1, argv + 1 + i, "s", &asciiStr))
                     {
                            JS_ReportError(cx, "The argument %u for event %s must be string", i, events[idx].name);
                            return JS_FALSE;
                     }
                     wxString str(asciiStr, wxConvUTF8);
                     evt->SetString(str);
              }
              else if (JSEVT_PARAM_IS_JSBOOL(events[idx].params[i]))
              {
                     if (!JSVAL_IS_BOOLEAN(argv[i+1]))
                     {
                            JS_ReportError(cx, "The argument %u for event %s must be boolean", i, events[idx].name);
                            return JS_FALSE;
                     }
                     evt->SetInt(int(argv[i+1] == JSVAL_TRUE));
              }
              else if (JSEVT_PARAM_IS_JSMEMORY(events[idx].params[i]))
              {
                     JSObject *memObj;
                     if (!JSVAL_IS_OBJECT(argv[i+1])
                                   || !JS_InstanceOf(cx, memObj = JSVAL_TO_OBJECT(argv[i+1]), &MemoryClass, NULL))
                     {
                            JS_ReportError(cx, "It is required Memory object as second argument");
                            return JS_FALSE;
                     }

                     void *memAddr = getMemoryAddr(cx, memObj);
                     if (!memAddr)
                     {
                            *rval = JSVAL_FALSE;
                            return JS_TRUE;
                     }
                     evt->SetClientData(memAddr);
              }
              else
              {
                     JS_ReportError(cx, "The argument %u for event %s is invalid type", i, events[idx].name);
                     return JS_FALSE;
              }
       }

       JSObject *eventObj = JS_NewObject(cx, &EventClass, NULL, NULL);
       if (!eventObj)
       {
              JS_ReportError(cx, "Event object cannot be created");
              return JS_FALSE;
       }

       EventData *data = new EventData(evt, &events[idx]);
       if (!JS_SetPrivate(cx, eventObj, (void *) data))
       {
              JS_ReportError(cx, "The private data for event object cannot be set");
              return JS_FALSE;
       }

       *rval = OBJECT_TO_JSVAL(eventObj);

       return JS_TRUE;
}

static JSBool eventWait(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       int idx;
       if (argc == 0 || !JSVAL_IS_INT(argv[0]) || (idx = getEventIdxByType(JSVAL_TO_INT(argv[0]))) < 0)
       {
              *rval = JSVAL_NULL;
              return JS_TRUE;
       }

       unsigned long milis = 0;
       bool waitFromNow = false;
       if (argc > 1)
       {
              if (JSVAL_IS_INT(argv[1]))
                     milis = (unsigned long) JSVAL_TO_INT(argv[1]);
              if (argc > 2 && JSVAL_IS_BOOLEAN(argv[2]))
                     waitFromNow = (JSVAL_TRUE == argv[2]);
       }

       wxCommandEvent *evt = jsHandler->WaitForEvent(events[idx].type, milis, waitFromNow);
       if (jsHandler->IsEnd())
       {
              logError("Script was terminated");
              return JS_FALSE;
       }


       JSObject *eventObj = JS_NewObject(cx, &EventClass, NULL, NULL);
       if (!eventObj)
       {
              JS_ReportError(cx, "Event object cannot be created");
              return JS_FALSE;
       }

       EventData *data = new EventData(evt, &events[idx]);
       if (!JS_SetPrivate(cx, eventObj, (void *) data))
       {
              JS_ReportError(cx, "The private data for event object cannot be set");
              return JS_FALSE;
       }
       return JS_TRUE;
}


static JSBool eventToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       JSString *msg;
       char ptr[16];
       EventData *data = (EventData *) JS_GetPrivate(cx, obj);
       if (data)
       {
              JSEventStruct *es = data->info;
              stringstream oss;
              oss << "[object Event(" << es->name;
              for (unsigned i = 0; i < es->nparams; i++)
              {
                     if (JSEVT_PARAM_IS_ID(es->params[i]))
                            oss << "," << data->evt->GetId();
                     else if (JSEVT_PARAM_IS_INT(es->params[i]))
                            oss << "," << data->evt->GetInt();
                     else if (JSEVT_PARAM_IS_STRING(es->params[i]))
                            oss << "," << data->evt->GetString().mb_str();
                     else if (JSEVT_PARAM_IS_CD(es->params[i]))
                     {
                            sprintf(ptr, "%p", data->evt->GetClientData());
                            oss << "," << ptr;
                     }
                     else
                            JS_ReportWarning(cx, "Unknown event argument");
              }
              oss << ")]";
              msg = getJSString(cx, oss.str().c_str());
       }
       else
              msg = getJSString(cx, "[object Event(undefined)]");

       if (!msg)
       {
              JS_ReportWarning(cx, "String couldn't be created");
              *rval = JSVAL_NULL;
              return JS_TRUE;
       }

       *rval = STRING_TO_JSVAL(msg);

       return JS_TRUE;
}

static JSBool event_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
       if (JSVAL_IS_INT(id))
       {
              int i = getEventIdxById(JSVAL_TO_INT(id));
              if (i >= 0)
                     *vp = INT_TO_JSVAL(int(events[i].type));
              else if ((i = getEventArgIdxById(JSVAL_TO_INT(id))) >= 0)
                     *vp = INT_TO_JSVAL(int(eventArgs[i].type));
       }
       return JS_TRUE;
}

static void event_Finalize(JSContext *cx, JSObject *obj)
{
       EventData *data = (EventData *) JS_GetPrivate(cx, obj);
       delete data;
}


// MEMORY

static JSBool memorySlice(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       void *mAddr, *chAddr;
       if (argc == 0 || !(mAddr = chAddr = getMemoryAddr(cx, obj)))
       {
              *rval = JSVAL_NULL;
              return JS_TRUE;
       }

       try
       {
              JSObject *chunksObj = JS_NewArrayObject(cx, 0, NULL);
              if (!chunksObj)
                     throw ScriptException("Chunks array cannot be created");

              for (unsigned i = 0; i < argc; i++)
              {
                     JSMemoryStruct *mType;
                     if (!JSVAL_IS_INT(argv[i]) || !(mType = getMemoryType(JSVAL_TO_INT(argv[i]))))
                            throw ScriptException("Incorrect memory type");

                     JSObject *chunkObj = JS_NewObject(cx, &ChunkClass, NULL, NULL);
                     if (!chunkObj)
                            throw ScriptException("Chunk object cannot be created");

                     ChunkData *chunkData = new ChunkData(mAddr, chAddr, mType);
                     if (!chunkData || !JS_SetPrivate(cx, chunkObj, (void *) chunkData))
                            throw ScriptException("Chunk private data cannot be set");

                     jsval chunkVal = OBJECT_TO_JSVAL(chunkObj);
                     if (!JS_SetElement(cx, chunksObj, i, &chunkVal))
                            throw ScriptException("Chunk element cannot be set to chunks array");

                     chAddr = (void *) ((char *) chAddr + mType->size);
              }
              *rval = OBJECT_TO_JSVAL(chunksObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}


static JSBool memoryAlloc(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       int size;
#if JSE_TEST_DD
       if (argc == 0)
       {
              try
              {
                     DeviceData *dd = new DeviceData;
                     dd->id = 1;
                     dd->type = 2;
                     dd->matrix = MATRIX();
                     dd->buttons = 3;
                     dd->control1 = 1.2;
                     dd->control2 = 2.3;

                     MemoryData *dataTest = new MemoryData((void *) dd);
                     if (!dataTest || !dd)
                            throw ScriptException("The memory cannot be allocated");

                     JSObject *memTestObj = JS_NewObject(cx, &MemoryClass, NULL, NULL);
                     if (!memTestObj || !JS_SetPrivate(cx, memTestObj, (void *) dataTest))
                            throw ScriptException("Memory object cannot be created");

                     *rval = OBJECT_TO_JSVAL(memTestObj);
                     return JS_TRUE;
              }
              catch (ScriptException & exc)
              {
                     JS_ReportError(cx, exc.what());
                     return JS_FALSE;
              }
       }
       else if (!JSVAL_IS_INT(argv[0]) || !(size = JSVAL_TO_INT(argv[0])))
#else
       if (argc == 0 || !JSVAL_IS_INT(argv[0]) || !(size = JSVAL_TO_INT(argv[0])))
#endif /* JS_TEST_DD */
       {
              *rval = JSVAL_NULL;
              return JS_TRUE;
       }

       try
       {
              void *addr = new char[size];
              MemoryData *data = new MemoryData(addr);
              if (!data || !addr)
                     throw ScriptException("The memory cannot be allocated");

              JSObject *memObj = JS_NewObject(cx, &MemoryClass, NULL, NULL);
              if (!memObj || !JS_SetPrivate(cx, memObj, (void *) data))
                     throw ScriptException("Memory object cannot be created");

              *rval = OBJECT_TO_JSVAL(memObj);
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool memoryToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       JSString *str;
       MemoryData *data =  (MemoryData *) JS_GetPrivate(cx, obj);
       if (data)
       {
              char ptr[32];
              sprintf(ptr, "[object Memory(%p)]", data->memAddr);
              str = getJSString(cx, ptr);
       }
       else
              str = getJSString(cx, "[object Memory(undefined)]");

       *rval = (str? STRING_TO_JSVAL(str): JSVAL_NULL);

       return JS_TRUE;
}

static JSBool memory_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
       if (JSVAL_IS_INT(id) && IS_JSMEM_TYPE(JSVAL_TO_INT(id)))
       {
              *vp = id;
       }
       return JS_TRUE;
}

static void memory_Finalize(JSContext *cx, JSObject *obj)
{
       MemoryData *data = (MemoryData *) JS_GetPrivate(cx, obj);
       delete data;
}


// CHUNK

static ChunkData *getChunkData(JSContext *cx, JSObject *obj)
{
       ChunkData *data = (ChunkData *) JS_GetPrivate(cx, obj);
       if (!data)
              JS_ReportWarning(cx, "Chunk object doesn't have private data (it was probably explicitly created)");
       return data;
}

static JSBool chunkGetType(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       ChunkData *data = getChunkData(cx, obj);

       *rval = (data? INT_TO_JSVAL(data->info->type): JSVAL_NULL);

       return JS_TRUE;
}

static JSBool chunkToString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
       JSString *str;
       ChunkData *data = getChunkData(cx, obj);
       if (data)
       {
              ostringstream oss;
              oss << "[object Chunk(" << data->info->name << ")]";
              str = getJSString(cx, oss.str().c_str());
       }
       else
              str = getJSString(cx, "[object Chunk(undefined)]");

       if (str)
       {
              *rval = STRING_TO_JSVAL(str);
              return JS_TRUE;
       }
       else
              return JS_FALSE;
}

static JSBool chunkValueGetter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
       ChunkData *data = getChunkData(cx, obj);
       if (!data)
              return JS_TRUE;

       try
       {
              switch (data->info->type)
              {
              case JSMEM_INT:
                     int iValue;
                     memcpy(&iValue, data->chunkAddr, data->info->size);
                     *vp = INT_TO_JSVAL(iValue);
                     break;
              case JSMEM_FLOAT:
                     float fValue;
                     jsdouble dValue;
                     memcpy(&fValue, data->chunkAddr, 4);
                     dValue = jsdouble(fValue);
                     if (!JS_NewNumberValue(cx, dValue, vp))
                            ScriptException("Double value wasn't correctly converted");
                     break;
              case JSMEM_MATRIX:
                     MATRIX m;
                     memcpy(&m, data->chunkAddr, data->info->size);

                     JSObject *matrixObj = JS_NewObject(cx, &MatrixClass, NULL, NULL);
                     if (!matrixObj || !JS_SetPrivate(cx, matrixObj, new MatrixData(m)))
                            ScriptException("Matrix object cannot be correctly created");

                     *vp = OBJECT_TO_JSVAL(matrixObj);
                     break;
              }
       }
       catch (ScriptException & exc)
       {
              JS_ReportError(cx, exc.what());
              return JS_FALSE;
       }

       return JS_TRUE;
}

static JSBool chunkValueSetter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
       ChunkData *data = getChunkData(cx, obj);
       if (!data)
              return JS_TRUE;

       try
       {
              int iValue;
              switch (data->info->type)
              {
              case JSMEM_INT:
                     if (!JSVAL_IS_INT(*vp))
                            ScriptException("This chunk value has to be integer");
                     iValue = JSVAL_TO_INT(*vp);
                     memcpy(data->chunkAddr, &iValue, data->info->size);
                     break;
              case JSMEM_FLOAT:
                     if (!JSVAL_IS_NUMBER(*vp))
                            ScriptException("This chunk value has to be float");

                     float fValue;
                     if (JSVAL_IS_INT(*vp))
                            fValue = float(JSVAL_TO_INT(*vp));
                     else if (JSVAL_IS_DOUBLE(*vp))
                     {
                            jsdouble *dValue = JSVAL_TO_DOUBLE(*vp);
                            fValue = float(*dValue);
                     }
                     else
                            ScriptException("Unknown number value");

                     memcpy(data->chunkAddr, &fValue, data->info->size);
                     break;
              case JSMEM_MATRIX:
                     JSObject *matrixObj;
                     if (!JSVAL_IS_OBJECT(*vp) || !JS_InstanceOf(cx, matrixObj = JSVAL_TO_OBJECT(*vp), &MatrixClass, NULL))
                            ScriptException("This chunk value has to be Matrix object");
                     MatrixData *matrixData = (MatrixData *) JS_GetPrivate(cx, matrixObj);
                     if (!matrixData)
                            ScriptException("Matrix object doesn't have private data, it's not possible to set it");
                     memcpy(data->chunkAddr, &matrixData->m, data->info->size);
                     break;
              }
       }
       catch (ScriptException & exc)
       {
              JS_ReportWarning(cx, exc.what());
       }

       return JS_TRUE;
}

static void chunk_Finalize(JSContext *cx, JSObject *obj)
{
       ChunkData *data = (ChunkData *) JS_GetPrivate(cx, obj);
       delete data;
}

// -----------------------------------------

// JSEnvironment METHODS

static void initJSEvents()
{
       unsigned i, evtCount = JSEVT_EVT_COUNT, argCount = JSEVT_ARG_COUNT;
       for (i = 0; i < evtCount; i++)
       {
              eventStaticProps[i].name = events[i].name;
              eventStaticProps[i].tinyid = events[i].id = i + 1;
              eventStaticProps[i].flags = JSPROP_READONLY;
              eventStaticProps[i].getter = NULL;
              eventStaticProps[i].setter = NULL;
       }
       for (unsigned j = 0; j < argCount; i++, j++)
       {
              eventStaticProps[i].name = eventArgs[j].name;
              eventStaticProps[i].tinyid = eventArgs[j].id = i + 1;
              eventStaticProps[i].flags = JSPROP_READONLY;
              eventStaticProps[i].getter = NULL;
              eventStaticProps[i].setter = NULL;
       }
       eventStaticProps[i].name = NULL;
       eventStaticProps[i].tinyid = 0;
       eventStaticProps[i].flags = 0;
       eventStaticProps[i].getter = NULL;
       eventStaticProps[i].setter = NULL;
}

static void initJSMemory()
{
       unsigned i;
       for (i = 0; i < JSMEM_TYPES_COUNT; i++)
       {
              memoryStaticProps[i].name = memoryTypes[i].name;
              memoryStaticProps[i].tinyid = memoryTypes[i].type;
              memoryStaticProps[i].flags = JSPROP_READONLY;
              memoryStaticProps[i].getter = NULL;
              memoryStaticProps[i].setter = NULL;
       }
       memoryStaticProps[i].name = NULL;
       memoryStaticProps[i].tinyid = 0;
       memoryStaticProps[i].flags = 0;
       memoryStaticProps[i].getter = NULL;
       memoryStaticProps[i].setter = NULL;
}

JSEnvironment::JSEnvironment(JSHandler *_handler)
{
       rt = JS_NewRuntime(8L * 1024L * 1024L);

       jsHandler = handler = _handler;
       kernel = NULL;

       initJSEvents();
       initJSMemory();

}

JSEnvironment::~JSEnvironment()
{
       JS_DestroyRuntime(rt);
       JS_ShutDown();
}


void JSEnvironment::initJSClasses() throw(ScriptException)
{
       if (!JS_InitClass(cx, globalObj, NULL, &SceneClass,
                     NULL, 0, /* constructor */
                     NULL, sceneFunctions, /* non-static */
                     NULL, sceneStaticFunctions /* static */ ))
              throw ScriptException("The Scene class cannot be created");

       if (!JS_InitClass(cx, globalObj, NULL, &NodeClass,
                     NULL, 0, /* constructor */
                     NULL, nodeFunctions, /* non-static */
                     nodeStaticProps, NULL /* static */ ))
              throw ScriptException("The Scene class cannot be created");

       if (!JS_InitClass(cx, globalObj, NULL, &MatrixClass,
                     matrixConstructor, MATRIX_SIZE, /* constructor */
                     NULL, matrixFunctions, /* non-static */
                     NULL, NULL /* static */ ))
              throw ScriptException("The Scene class cannot be created");

       if (!JS_InitClass(cx, globalObj, NULL, &VectorClass,
                     vectorConstructor, VECTOR_SIZE, /* constructor */
                     NULL, vectorFunctions, /* non-static */
                     NULL, NULL /* static */ ))
              throw ScriptException("The Scene class cannot be created");

       /*
       JSObject *eventProtoObj = JS_NewObject(cx, &EventProto, NULL, NULL);
       JS_DefineProperties(cx, eventProtoObj, eventStaticProps);
       JS_DefineFunctions(cx, eventProtoObj, eventStaticFunctions
       */
       if (!JS_InitClass(cx, globalObj, NULL, &EventClass,
                     NULL, 0, /* constructor */
                     NULL, eventFunctions, /* non-static */
                     eventStaticProps, eventStaticFunctions /* static */ ))
              throw ScriptException("The Event class cannot be created");

       if (!JS_InitClass(cx, globalObj, NULL, &MemoryClass,
                     NULL, 0, /* constructor */
                     NULL, memoryFunctions, /* non-static */
                     memoryStaticProps, memoryStaticFunctions /* static */ ))
              throw ScriptException("The Memory class cannot be created");

       if (!JS_InitClass(cx, globalObj, NULL, &ChunkClass,
                     NULL, 0, /* constructor */
                     chunkProps, chunkFunctions, /* non-static */
                     NULL, NULL /* static */ ))
              throw ScriptException("The Chunk class cannot be created");
}

bool JSEnvironment::RunScript(Kernel *_kernel, const char *fileName, SCENE_ID sceneID)
{
       if (rt == NULL || _kernel == NULL)
              return false;

       FILE *file = fopen(fileName, "r");
       if (file == NULL)
       {
              logError("File couldn't be read");
              return false;
       }

       if ((cx = JS_NewContext(rt, 8192)) == NULL)
              return false;

       JS_SetOptions(cx, JSOPTION_VAROBJFIX);
       JS_SetVersion(cx, JSVERSION_1_7);
       JS_SetErrorReporter(cx, reportError);

       bool rc = true;
       realError = true;

       kernel = _kernel;

       ssm = new ScriptSceneManager(_kernel);

       try
       {
              globalObj = JS_NewObject(cx, &GlobalClass, NULL, NULL);
              if (globalObj == NULL || !JS_InitStandardClasses(cx, globalObj))
                     throw ScriptException("The global object can't be created");

              if (!JS_DefineFunctions(cx, globalObj, globalFunctions))
                     throw ScriptException("The global functions can't be defined");

              initJSClasses();

              if (sceneID != SCENE_ID_NONE) {
                     if (!(sceneObj = JS_DefineObject(cx, globalObj, "scene", &SceneClass, NULL, JSPROP_ENUMERATE)))
                            throw ScriptException("The scene object cannot be created");

                     if (!JS_SetPrivate(cx, sceneObj, (void *) new SceneData(sceneID)))
                            throw ScriptException("The scene data cannot be set");
              }
              else {
                     if (!JS_DefineProperty(cx, globalObj, "scene",
                                   JSVAL_VOID, NULL, NULL, 0))
                     {
                            throw ScriptException(
                                   "The scene object cannot be created");
                     }
              }
              JSScript *script = JS_CompileFileHandle(cx, globalObj, fileName, file);
              if (!script)
                     throw ScriptException("The script cannot be compilated");
              JSObject *scriptObj = JS_NewScriptObject(cx, script);
              if (scriptObj == NULL) {
                     JS_DestroyScript(cx, script);
                     throw ScriptException("The script object cannot be created");
              }
              if (!JS_AddNamedRoot(cx, &scriptObj, "mainScript"))
                     throw ScriptException("The script object cannot be added to root");

              jsval rval;
              rc = JS_ExecuteScript(cx, globalObj, script, &rval) == JS_TRUE;
              JS_RemoveRoot(cx, &scriptObj);
              if (!rc && realError)
                     throw ScriptException("Unsuccessfull executing the script");
       }
       catch (const ScriptException & exc)
       {
              rc = false;
              logError(exc.what());

#if JSE_LOG_TO_CONSOLE
              cerr << exc.what() << endl;
#endif
       }

       JS_DestroyContext(cx);
       delete ssm;

       return rc;
}

---