bool Module::load(const Common::UString &module) {
unload();
_module = module;
try {
load();
} catch (Common::Exception &e) {
e.add("Failed loading module \"%s\"", _module.c_str());
printException(e);
_module.clear();
return false;
}
return true;
}
void SaveLoadMenu::addSavedGameItems(WidgetListBox *listBox) {
Common::FileList dirs;
Common::UString savesDir = Common::FilePath::normalize(ConfigMan.getString("path") + "/saves");
dirs.addSubDirectories(savesDir);
Common::UString slotTextFormat = TalkMan.getString(1594);
dirs.sort(true);
for (Common::FileList::const_iterator it = dirs.begin(); it != dirs.end(); ++it) {
Common::UString saveDir = *it;
Common::UString baseName;
try {
baseName = getBaseNameFromDirectory(saveDir);
} catch (Common::Exception &e) {
e.add("Failed to get save base name from directory \"%s\"", saveDir.c_str());
printException(e, "WARNING: ");
continue;
}
if (_type == kSaveLoadMenuTypeSave && !baseName.contains("Game"))
continue;
_saveDirs.push_back(saveDir);
SavedGame *save = SavedGame::load(saveDir);
uint32 timePlayed = save->getTimePlayed();
Common::UString slotText(slotTextFormat);
slotText.replaceAll("Game <CUSTOM0>", baseName);
slotText.replaceAll("<CUSTOM1>", Common::composeString(timePlayed / 3600));
slotText.replaceAll("<CUSTOM2>", Common::composeString(timePlayed % 3600 / 60));
if (baseName.contains("Game"))
slotText += "\r\n" + save->getName();
delete save;
listBox->addItem(slotText);
}
}
void Module::run() {
if (!enter())
return;
EventMan.enableUnicode(true);
EventMan.enableKeyRepeat();
_ingameGUI->show();
try {
EventMan.flushEvents();
while (!EventMan.quitRequested() && !_exit && !_newArea.empty()) {
replaceModule();
enterArea();
if (_exit)
break;
handleEvents();
handleActions();
_ingameGUI->updatePartyMember(0, *_pc);
if (!EventMan.quitRequested() && !_exit && !_newArea.empty())
EventMan.delay(10);
}
} catch (Common::Exception &e) {
e.add("Failed running module \"%s\"", _ifo.getName().getString().c_str());
printException(e, "WARNING: ");
}
_ingameGUI->stopConversation();
_ingameGUI->hide();
EventMan.enableUnicode(false);
EventMan.enableKeyRepeat(0);
}
void MySqlImpl::init(string url, string username, string password)
{
try
{
sql::SQLString DB_HOST(url.c_str());
sql::SQLString DB_USER(username.c_str());
sql::SQLString DB_PWD(password.c_str());
driver = get_driver_instance();
conn = driver->connect(DB_HOST, DB_USER, DB_PWD);
conn->setSchema("hci");
bool reconnect = true;
conn->setClientOption("MYSQL_OPT_RECONNECT", &reconnect);
sucess = !conn->isClosed();
}
catch(sql::SQLException &e)
{
printException(e);
sucess = false;
}
}
void Object::optixInit(optix::Context context) {
try {
// Make geometry group
Optix.geometryGroup = context->createGeometryGroup();
Optix.geometryGroup->setAcceleration(context->createAcceleration(OPTIX_GEOMETRY_BUILDER, OPTIX_GEOMETRY_TRAVERSER)); // TODO: Look into different traversers/builders
// Add geometries
for (uint i = 0; i < geometries.size(); i++) {
geometries[i]->optixInit(context);
Optix.geometryGroup->addChild(((TriangleMesh*)geometries[i])->Optix.geometryInstance);
}
// Make transform
Optix.transform = context->createTransform();
Optix.transform->setChild(Optix.geometryGroup);
Optix.transform->setMatrix(true, matrix.e, NULL);
} catch (optix::Exception e) {
printException(e);
}
}
void detachThread(Thread *thread) {
Object *group, *excep;
//ExecEnv *ee = thread->ee;
//Object *jThread = ee->thread;
Object *jThread = thread->thread;
Object *vmthread = (Object*)INST_DATA(jThread)[vmthread_offset];
/* Get the thread's group */
group = (Object *)INST_DATA(jThread)[group_offset];
/* If there's an uncaught exception, call uncaughtException on the thread's
exception handler, or the thread's group if this is unset */
if((excep = exceptionOccurred())) {
FieldBlock *fb = findField(thread_class, SYMBOL(exceptionHandler),
SYMBOL(sig_java_lang_Thread_UncaughtExceptionHandler));
Object *thread_handler = fb == NULL ? NULL : (Object *)INST_DATA(jThread)[fb->offset];
Object *handler = thread_handler == NULL ? group : thread_handler;
MethodBlock *uncaught_exp = lookupMethod(handler->classobj, SYMBOL(uncaughtException),
SYMBOL(_java_lang_Thread_java_lang_Throwable__V));
if(uncaught_exp) {
clearException();
DummyFrame dummy;
executeMethod(&dummy, handler, uncaught_exp, jThread, excep);
} else
printException();
}
/* remove thread from thread group */
DummyFrame dummy;
executeMethod(&dummy, group, (CLASS_CB(group->classobj))->method_table[rmveThrd_mtbl_idx], jThread);
/* set VMThread ref in Thread object to null - operations after this
point will result in an IllegalThreadStateException */
INST_DATA(jThread)[vmthread_offset] = 0;
/* Remove thread from the ID map hash table */
deleteThreadFromHash(thread);
/* Disable suspend to protect lock operation */
disableSuspend(thread);
/* Grab global lock, and update thread structures protected by
it (thread list, thread ID and number of daemon threads) */
pthread_mutex_lock(&lock);
/* remove from thread list... */
if((thread->prev->next = thread->next))
thread->next->prev = thread->prev;
/* One less live thread */
threads_count--;
/* Recycle the thread's thread ID */
freeThreadID(thread->id);
/* Handle daemon thread status */
if(!INST_DATA(jThread)[daemon_offset])
non_daemon_thrds--;
pthread_mutex_unlock(&lock);
/* notify any threads waiting on VMThread object -
these are joining this thread */
objectLock(vmthread);
objectNotifyAll(vmthread);
objectUnlock(vmthread);
/* It is safe to free the thread's ExecEnv and stack now as these are
only used within the thread. It is _not_ safe to free the native
thread structure as another thread may be concurrently accessing it.
However, they must have a reference to the VMThread -- therefore, it
is safe to free during GC when the VMThread is determined to be no
longer reachable. */
// sysFree(ee->stack);
//sysFree(ee);
/* If no more daemon threads notify the main thread (which
may be waiting to exit VM). Note, this is not protected
by lock, but main thread checks again */
if(non_daemon_thrds == 0) {
/* No need to bother with disabling suspension
* around lock, as we're no longer on thread list */
pthread_mutex_lock(&exit_lock);
pthread_cond_signal(&exit_cv);
pthread_mutex_unlock(&exit_lock);
}
TRACE("Thread 0x%x id: %d detached from VM\n", thread, thread->id);
}
void initialiseThreadStage2(InitArgs *args) {
Object *java_thread;
Class *thrdGrp_class;
MethodBlock *run, *remove_thread;
FieldBlock *group, *priority, *root, *threadId;
FieldBlock *vmThread = NULL, *thread = NULL;
FieldBlock *vmData, *daemon, *name;
/* Load thread class and register reference for compaction threading */
thread_class = findSystemClass0(SYMBOL(java_lang_Thread));
registerStaticClassRef(&thread_class);
if(thread_class != NULL) {
vmThread = findField(thread_class, SYMBOL(vmThread), SYMBOL(sig_java_lang_VMThread));
daemon = findField(thread_class, SYMBOL(daemon), SYMBOL(Z));
name = findField(thread_class, SYMBOL(name), SYMBOL(sig_java_lang_String));
group = findField(thread_class, SYMBOL(group), SYMBOL(sig_java_lang_ThreadGroup));
priority = findField(thread_class, SYMBOL(priority), SYMBOL(I));
threadId = findField(thread_class, SYMBOL(threadId), SYMBOL(J));
init_mb = findMethod(thread_class, SYMBOL(object_init),
SYMBOL(_java_lang_VMThread_java_lang_String_I_Z__V));
run = findMethod(thread_class, SYMBOL(run), SYMBOL(___V));
vmthread_class = findSystemClass0(SYMBOL(java_lang_VMThread));
CLASS_CB(vmthread_class)->flags |= VMTHREAD;
/* Register class reference for compaction threading */
registerStaticClassRef(&vmthread_class);
if(vmthread_class != NULL) {
thread = findField(vmthread_class, SYMBOL(thread), SYMBOL(sig_java_lang_Thread));
vmData = findField(vmthread_class, SYMBOL(vmData), SYMBOL(I));
}
}
/* findField and findMethod do not throw an exception... */
if((init_mb == NULL) || (vmData == NULL) || (run == NULL) || (daemon == NULL) ||
(name == NULL) || (group == NULL) || (priority == NULL) || (vmThread == NULL) ||
(thread == NULL) || (threadId == NULL))
goto error;
vmthread_offset = vmThread->offset;
thread_offset = thread->offset;
vmData_offset = vmData->offset;
daemon_offset = daemon->offset;
group_offset = group->offset;
priority_offset = priority->offset;
threadId_offset = threadId->offset;
name_offset = name->offset;
run_mtbl_idx = run->method_table_index;
/* Initialise the Java-level thread objects for the main thread */
java_thread = initJavaThread(&main_thread, FALSE, "main");
/* Main thread is now sufficiently setup to be able to run the thread group
initialiser. This is essential to create the root thread group */
thrdGrp_class = findSystemClass(SYMBOL(java_lang_ThreadGroup));
root = findField(thrdGrp_class, SYMBOL(root), SYMBOL(sig_java_lang_ThreadGroup));
addThread_mb = findMethod(thrdGrp_class, SYMBOL(addThread),
SYMBOL(_java_lang_Thread_args__void));
remove_thread = findMethod(thrdGrp_class, SYMBOL(removeThread),
SYMBOL(_java_lang_Thread_args__void));
/* findField and findMethod do not throw an exception... */
if((root == NULL) || (addThread_mb == NULL) || (remove_thread == NULL))
goto error;
rmveThrd_mtbl_idx = remove_thread->method_table_index;
/* Add the main thread to the root thread group */
INST_DATA(java_thread)[group_offset] = root->static_value;
{
DummyFrame dummy;
executeMethod(&dummy, ((Object*)root->static_value), addThread_mb, java_thread);
}
// dyn
INST_DATA(java_thread)[vmthread_offset] = 0;
/* Setup signal handling. This will be inherited by all
threads created within Java */
initialiseSignals();
/* Create the signal handler thread. It is responsible for
catching and handling SIGQUIT (thread dump) and SIGINT
(user-termination of the VM, e.g. via Ctrl-C). Note it
must be a valid Java-level thread as it needs to run the
shutdown hooks in the event of user-termination */
createVMThread("Signal Handler", dumpThreadsLoop);
return;
error:
jam_fprintf(stderr, "Error initialising VM (initialiseMainThread)\nCheck "
"the README for compatible versions of GNU Classpath\n");
printException();
exitVM(1);
}
int main(int argc, char *argv[]) {
Class *array_class, *main_class;
Object *system_loader, *array;
MethodBlock *mb;
InitArgs args;
int class_arg;
char *cpntr;
int status;
int i;
setDefaultInitArgs(&args);
class_arg = parseCommandLine(argc, argv, &args);
args.main_stack_base = &array_class;
initVM(&args);
if((system_loader = getSystemClassLoader()) == NULL) {
printf("Cannot create system class loader\n");
printException();
exitVM(1);
}
mainThreadSetContextClassLoader(system_loader);
for(cpntr = argv[class_arg]; *cpntr; cpntr++)
if(*cpntr == '.')
*cpntr = '/';
if((main_class = findClassFromClassLoader(argv[class_arg], system_loader)) != NULL)
initClass(main_class);
if(exceptionOccurred()) {
printException();
exitVM(1);
}
mb = lookupMethod(main_class, SYMBOL(main), SYMBOL(_array_java_lang_String__V));
if(!mb || !(mb->access_flags & ACC_STATIC)) {
printf("Static method \"main\" not found in %s\n", argv[class_arg]);
exitVM(1);
}
/* Create the String array holding the command line args */
i = class_arg + 1;
if((array_class = findArrayClass(SYMBOL(array_java_lang_String))) &&
(array = allocArray(array_class, argc - i, sizeof(Object*)))) {
Object **args = (Object**)ARRAY_DATA(array) - i;
for(; i < argc; i++)
if(!(args[i] = Cstr2String(argv[i])))
break;
/* Call the main method */
if(i == argc)
executeStaticMethod(main_class, mb, array);
}
/* ExceptionOccurred returns the exception or NULL, which is OK
for normal conditionals, but not here... */
if((status = exceptionOccurred() ? 1 : 0))
printException();
/* Wait for all but daemon threads to die */
mainThreadWaitToExitVM();
exitVM(status);
}
void TriangleMesh::optixInit(optix::Context context) {
try {
static optix::Program intersectProgram = context->createProgramFromPTXFile("ptx/triangle_mesh_program.cu.ptx", "intersect");
static optix::Program boundsProgram = context->createProgramFromPTXFile("ptx/triangle_mesh_program.cu.ptx", "bounds");
#if OPTIX_USE_GEOMETRY_VBO
// Bind vertex VBO
Optix.posBuffer = context->createBufferFromGLBO(RT_BUFFER_INPUT, vboPos);
Optix.posBuffer->setFormat(RT_FORMAT_FLOAT3);
Optix.posBuffer->setSize(posData.size());
// Bind normal VBO
Optix.normalBuffer = context->createBufferFromGLBO(RT_BUFFER_INPUT, vboNormal);
Optix.normalBuffer->setFormat(RT_FORMAT_FLOAT3);
Optix.normalBuffer->setSize(normalData.size());
// Bind texture VBO
Optix.texCoordBuffer = context->createBufferFromGLBO(RT_BUFFER_INPUT, vboTexCoord);
Optix.texCoordBuffer->setFormat(RT_FORMAT_FLOAT2);
Optix.texCoordBuffer->setSize(texCoordData.size());
// Bind index IBO
Optix.indexBuffer = context->createBufferFromGLBO(RT_BUFFER_INPUT, ibo);
Optix.indexBuffer->setFormat(RT_FORMAT_UNSIGNED_INT);
Optix.indexBuffer->setSize(indexData.size());
#else
// Copy position buffer
Optix.posBuffer = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT3, posData.size());
memcpy(Optix.posBuffer->map(), &posData[0], posData.size() * sizeof(Vec3));
Optix.posBuffer->unmap();
// Copy normal buffer
Optix.normalBuffer = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT3, normalData.size());
memcpy(Optix.normalBuffer->map(), &normalData[0], normalData.size() * sizeof(Vec3));
Optix.normalBuffer->unmap();
// Copy texture buffer
Optix.texCoordBuffer = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT2, texCoordData.size());
memcpy(Optix.texCoordBuffer->map(), &texCoordData[0], texCoordData.size() * sizeof(Vec2));
Optix.texCoordBuffer->unmap();
// Copy index buffer
Optix.indexBuffer = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_UNSIGNED_INT3, indexData.size());
memcpy(Optix.indexBuffer->map(), &indexData[0], indexData.size() * sizeof(TrianglePrimitive));
Optix.indexBuffer->unmap();
#endif
// Make geometry
Optix.geometry = context->createGeometry();
Optix.geometry->setIntersectionProgram(intersectProgram);
Optix.geometry->setBoundingBoxProgram(boundsProgram);
Optix.geometry->setPrimitiveCount(indexData.size());
Optix.geometry["posData"]->setBuffer(Optix.posBuffer);
Optix.geometry["normalData"]->setBuffer(Optix.normalBuffer);
Optix.geometry["texCoordData"]->setBuffer(Optix.texCoordBuffer);
Optix.geometry["indexData"]->setBuffer(Optix.indexBuffer);
// Make instance
if (!material->Optix.material) {
#if OPTIX_USE_OPENGL_TEXTURE
material->Optix.sampler = context->createTextureSamplerFromGLImage(material->image->texture, RT_TARGET_GL_TEXTURE_2D);
#else
optix::Buffer buf = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT4, material->image->width, material->image->height);
memcpy(buf->map(), material->image->pixels, material->image->width * material->image->height * sizeof(Color));
buf->unmap();
material->Optix.sampler = context->createTextureSampler();
material->Optix.sampler->setArraySize(1);
material->Optix.sampler->setMipLevelCount(1);
material->Optix.sampler->setBuffer(0, 0, buf);
#endif
material->Optix.sampler->setWrapMode(0, RT_WRAP_REPEAT);
material->Optix.sampler->setWrapMode(1, RT_WRAP_REPEAT);
material->Optix.sampler->setIndexingMode(RT_TEXTURE_INDEX_NORMALIZED_COORDINATES);
material->Optix.sampler->setReadMode(RT_TEXTURE_READ_NORMALIZED_FLOAT);
material->Optix.sampler->setMaxAnisotropy(1.f);
RTfiltermode filter = (material->image->filter == GL_NEAREST) ? RT_FILTER_NEAREST : RT_FILTER_LINEAR;
material->Optix.sampler->setFilteringModes(filter, filter, RT_FILTER_NONE);
material->Optix.material = context->createMaterial();
material->Optix.material->setClosestHitProgram(0, materialClosestHitProgram);
material->Optix.material->setAnyHitProgram(1, materialAnyHitProgram);
material->Optix.material["sampler"]->setTextureSampler(material->Optix.sampler);
material->Optix.material["ambient"]->setFloat(material->ambient.r(), material->ambient.g(), material->ambient.b(), material->ambient.a());
material->Optix.material["specular"]->setFloat(material->specular.r(), material->specular.g(), material->specular.b(), material->specular.a());
material->Optix.material["diffuse"]->setFloat(material->diffuse.r(), material->diffuse.g(), material->diffuse.b(), material->diffuse.a());
material->Optix.material["shineExponent"]->setFloat(material->shineExponent);
material->Optix.material["reflectIntensity"]->setFloat(material->reflectIntensity);
material->Optix.material["refractIndex"]->setFloat(material->refractIndex);
}
Optix.geometryInstance = context->createGeometryInstance();
Optix.geometryInstance->setGeometry(Optix.geometry);
Optix.geometryInstance->addMaterial(material->Optix.material);
} catch (optix::Exception e) {
printException(e);
}
}
void RayEngine::optixInit() {
if (!OPTIX_ENABLE)
return;
cout << "Starting OptiX..." << endl;
try {
// Make context
Optix.context = optix::Context::create();
Optix.context->setRayTypeCount(2);
Optix.context->setEntryPointCount(1);
Optix.context->setStackSize(OPTIX_STACK_SIZE);
// Generate texture
glGenTextures(1, &Optix.texture);
glBindTexture(GL_TEXTURE_2D, Optix.texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
// Make output buffer
#if OPTIX_USE_OUTPUT_VBO
glGenBuffers(1, &Optix.vbo);
Optix.renderBuffer = Optix.context->createBufferFromGLBO(RT_BUFFER_OUTPUT, Optix.vbo);
Optix.renderBuffer->setFormat(RT_FORMAT_FLOAT4);
Optix.renderBuffer->setSize(window.width, window.height);
Optix.streamRenderBuffer = Optix.context->createBufferFromGLBO(RT_BUFFER_OUTPUT, Optix.vbo);
Optix.streamRenderBuffer->setFormat(RT_FORMAT_FLOAT4);
Optix.streamRenderBuffer->setSize(window.width, window.height);
#else
Optix.renderBuffer = Optix.context->createBuffer(RT_BUFFER_OUTPUT, RT_FORMAT_FLOAT4, window.width, window.height);
Optix.streamRenderBuffer = Optix.context->createBuffer(RT_BUFFER_OUTPUT, RT_FORMAT_FLOAT4, window.width, window.height);
#endif
// Make streaming buffer
Optix.streamBuffer = Optix.context->createBuffer(RT_BUFFER_PROGRESSIVE_STREAM, RT_FORMAT_UNSIGNED_BYTE4, window.width, window.height);
Optix.streamBuffer->bindProgressiveStream(Optix.streamRenderBuffer);
// Make light buffer
Optix.lights = Optix.context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_USER, 0);
Optix.lights->setElementSize(sizeof(Light));
Optix.context["lights"]->set(Optix.lights);
// Make ray generation program
Optix.context->setRayGenerationProgram(0, Optix.context->createProgramFromPTXFile("ptx/camera_program.cu.ptx", "camera"));
// Make miss program
Optix.context->setMissProgram(0, Optix.context->createProgramFromPTXFile("ptx/miss_program.cu.ptx", "miss"));
// Make material programs
materialClosestHitProgram = Optix.context->createProgramFromPTXFile("ptx/material_program.cu.ptx", "closestHit");
materialAnyHitProgram = Optix.context->createProgramFromPTXFile("ptx/material_program.cu.ptx", "anyHit");
// Make AO noise sampler
#if OPTIX_USE_OPENGL_TEXTURE
Optix.aoNoise = Optix.context->createTextureSamplerFromGLImage(aoNoiseImage->texture, RT_TARGET_GL_TEXTURE_2D);
#else
optix::Buffer buf = Optix.context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT4, AO_NOISE_WIDTH, AO_NOISE_HEIGHT);
memcpy(buf->map(), aoNoiseImage->pixels, AO_NOISE_WIDTH * AO_NOISE_HEIGHT * sizeof(Color));
buf->unmap();
Optix.aoNoise = Optix.context->createTextureSampler();
Optix.aoNoise->setArraySize(1);
Optix.aoNoise->setMipLevelCount(1);
Optix.aoNoise->setBuffer(0, 0, buf);
#endif
Optix.aoNoise->setWrapMode(0, RT_WRAP_REPEAT);
Optix.aoNoise->setWrapMode(1, RT_WRAP_REPEAT);
Optix.aoNoise->setIndexingMode(RT_TEXTURE_INDEX_NORMALIZED_COORDINATES);
Optix.aoNoise->setReadMode(RT_TEXTURE_READ_NORMALIZED_FLOAT);
Optix.aoNoise->setMaxAnisotropy(1.f);
Optix.aoNoise->setFilteringModes(RT_FILTER_LINEAR, RT_FILTER_LINEAR, RT_FILTER_NONE);
Optix.context["aoNoise"]->setTextureSampler(Optix.aoNoise);
// Init scenes
for (uint i = 0; i < scenes.size(); i++)
scenes[i]->optixInit(Optix.context);
optixSetScene(scenes[0]);
// Compile
Optix.context["renderBuffer"]->set(Optix.renderBuffer);
Optix.context->validate();
Optix.context->compile();
} catch (optix::Exception e) {
printException(e);
}
}
JavaJSImpl::JavaJSImpl(const char *appserverPath) {
_jvm = 0;
_mainEnv = 0;
_dbhook = 0;
stringstream ss;
string edTemp;
const char * ed = 0;
ss << "-Djava.class.path=.";
if ( appserverPath ) {
ed = findEd(appserverPath);
assert( ed );
ss << SYSTEM_COLON << ed << "/build/";
_addClassPath( ed , ss , "include" );
_addClassPath( ed , ss , "include/jython/" );
_addClassPath( ed , ss , "include/jython/javalib" );
}
else {
const string jars = findJars();
_addClassPath( jars.c_str() , ss , "jars" );
edTemp += (string)jars + "/jars/mongojs-js.jar";
ed = edTemp.c_str();
}
#if defined(_WIN32)
ss << SYSTEM_COLON << "C:\\Program Files\\Java\\jdk\\lib\\tools.jar";
#else
ss << SYSTEM_COLON << "/opt/java/lib/tools.jar";
#endif
if ( getenv( "CLASSPATH" ) )
ss << SYSTEM_COLON << getenv( "CLASSPATH" );
string s = ss.str();
char * p = (char *)malloc( s.size() * 4 );
strcpy( p , s.c_str() );
char *q = p;
#if defined(_WIN32)
while ( *p ) {
if ( *p == '/' ) *p = '\\';
p++;
}
#endif
log(1) << "classpath: " << q << endl;
JavaVMOption * options = new JavaVMOption[4];
options[0].optionString = q;
options[1].optionString = (char*)"-Djava.awt.headless=true";
options[2].optionString = (char*)"-Xmx300m";
// Prevent JVM from using async signals internally, since on linux the pre-installed handlers for these
// signals don't seem to be respected by JNI.
options[3].optionString = (char*)"-Xrs";
// -Xcheck:jni
_vmArgs = new JavaVMInitArgs();
_vmArgs->version = JNI_VERSION_1_4;
_vmArgs->options = options;
_vmArgs->nOptions = 4;
_vmArgs->ignoreUnrecognized = JNI_FALSE;
log(1) << "loading JVM" << endl;
jint res = JNI_CreateJavaVM( &_jvm, (void**)&_mainEnv, _vmArgs );
if ( res ) {
log() << "using classpath: " << q << endl;
log()
<< " res : " << (unsigned) res << " "
<< "_jvm : " << _jvm << " "
<< "_env : " << _mainEnv << " "
<< endl;
problem() << "Couldn't create JVM res:" << (int) res << " terminating" << endl;
log() << "(try --nojni if you do not require that functionality)" << endl;
exit(22);
}
jassert( res == 0 );
jassert( _jvm > 0 );
jassert( _mainEnv > 0 );
_envs = new boost::thread_specific_ptr<JNIEnv>( myJNIClean );
assert( ! _envs->get() );
_envs->reset( _mainEnv );
_dbhook = findClass( "ed/db/JSHook" );
if ( _dbhook == 0 ) {
log() << "using classpath: " << q << endl;
printException();
}
jassert( _dbhook );
if ( ed ) {
jmethodID init = _mainEnv->GetStaticMethodID( _dbhook , "init" , "(Ljava/lang/String;)V" );
jassert( init );
_mainEnv->CallStaticVoidMethod( _dbhook , init , _getEnv()->NewStringUTF( ed ) );
}
_dbjni = findClass( "ed/db/DBJni" );
jassert( _dbjni );
_scopeCreate = _mainEnv->GetStaticMethodID( _dbhook , "scopeCreate" , "()J" );
_scopeInit = _mainEnv->GetStaticMethodID( _dbhook , "scopeInit" , "(JLjava/nio/ByteBuffer;)Z" );
_scopeSetThis = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetThis" , "(JLjava/nio/ByteBuffer;)Z" );
_scopeReset = _mainEnv->GetStaticMethodID( _dbhook , "scopeReset" , "(J)Z" );
_scopeFree = _mainEnv->GetStaticMethodID( _dbhook , "scopeFree" , "(J)V" );
_scopeGetNumber = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetNumber" , "(JLjava/lang/String;)D" );
_scopeGetString = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetString" , "(JLjava/lang/String;)Ljava/lang/String;" );
_scopeGetBoolean = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetBoolean" , "(JLjava/lang/String;)Z" );
_scopeGetType = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetType" , "(JLjava/lang/String;)B" );
_scopeGetObject = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetObject" , "(JLjava/lang/String;Ljava/nio/ByteBuffer;)I" );
_scopeGuessObjectSize = _mainEnv->GetStaticMethodID( _dbhook , "scopeGuessObjectSize" , "(JLjava/lang/String;)J" );
_scopeSetNumber = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetNumber" , "(JLjava/lang/String;D)Z" );
_scopeSetBoolean = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetBoolean" , "(JLjava/lang/String;Z)Z" );
_scopeSetString = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetString" , "(JLjava/lang/String;Ljava/lang/String;)Z" );
_scopeSetObject = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetObject" , "(JLjava/lang/String;Ljava/nio/ByteBuffer;)Z" );
_functionCreate = _mainEnv->GetStaticMethodID( _dbhook , "functionCreate" , "(Ljava/lang/String;)J" );
_invoke = _mainEnv->GetStaticMethodID( _dbhook , "invoke" , "(JJ)I" );
jassert( _scopeCreate );
jassert( _scopeInit );
jassert( _scopeSetThis );
jassert( _scopeReset );
jassert( _scopeFree );
jassert( _scopeGetNumber );
jassert( _scopeGetString );
jassert( _scopeGetObject );
jassert( _scopeGetBoolean );
jassert( _scopeGetType );
jassert( _scopeGuessObjectSize );
jassert( _scopeSetNumber );
jassert( _scopeSetBoolean );
jassert( _scopeSetString );
jassert( _scopeSetObject );
jassert( _functionCreate );
jassert( _invoke );
JNINativeMethod * nativeSay = new JNINativeMethod();
nativeSay->name = (char*)"native_say";
nativeSay->signature = (char*)"(Ljava/nio/ByteBuffer;)V";
nativeSay->fnPtr = (void*)java_native_say;
_mainEnv->RegisterNatives( _dbjni , nativeSay , 1 );
JNINativeMethod * nativeCall = new JNINativeMethod();
nativeCall->name = (char*)"native_call";
nativeCall->signature = (char*)"(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)I";
nativeCall->fnPtr = (void*)java_native_call;
_mainEnv->RegisterNatives( _dbjni , nativeCall , 1 );
}
void MySqlImpl::upload(vector<ResultEntity>& rs, string user, string logDir)
{
try
{
sql::PreparedStatement *prep_stmt;
string sql = "INSERT INTO tbl_interactions(user_name, timestamp, window, parent_window, application, point_x, point_y, win_rect_left, win_rect_top, win_rect_right, win_rect_bottom, \
ui_name, ui_type, ui_value, parent_ui_name, parent_ui_type, ui_bound_left, ui_bound_top, ui_bound_right, ui_bound_bottom, has_screen, screen) \
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
prep_stmt = conn->prepareStatement(sql.c_str());
for(int i=0; i<rs.size(); i++)
{
int idx = 1;
prep_stmt->setString(idx++, user.c_str());
prep_stmt->setString(idx++, rs[i].getColumn("timestamp").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("window_name").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("parent_window").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("process_name").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("p_x").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("p_y").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("win_rect_left").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("win_rect_top").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("win_rect_right").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("win_rect_bottom").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("action_name").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("action_type").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("action_value").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("action_parent_name").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("action_parent_type").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("bound_left").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("bound_top").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("bound_right").c_str());
prep_stmt->setString(idx++, rs[i].getColumn("bound_bottom").c_str());
string imgPath = logDir + "/screen/" + dbTime2ImgTime(rs[i].getColumn("timestamp")) + ".png";
ifstream is(imgPath, std::ios_base::binary);
if(is.is_open())
{
prep_stmt->setBoolean(idx++, true);
prep_stmt->setBlob(idx++, &is);
}
else
{
prep_stmt->setBoolean(idx++, false);
prep_stmt->setBlob(idx++, NULL);
}
prep_stmt->execute();
is.close();
//std::remove(imgPath.c_str());
}
delete prep_stmt;
}
catch(sql::SQLException &exception)
{
printException(exception);
}
}
