Handle<Value> TiObject::setPropHelper(const char* propString, Local<Value> value, SET_VALUE_CALLBACK cb) { TiObject* destObj = onLookupMember(propString); TiObject* srcObj = getTiObjectFromJsObject(value); if (srcObj == NULL) { srcObj = new TiObject(propString); srcObj->initializeTiObject(NULL); srcObj->setValue(value); setTiObjectToJsObject(value, srcObj); } if (destObj == NULL) { if ((!canAddMembers()) || (!userCanAddMember(propString))) { srcObj->release(); return Undefined(); } destObj = srcObj; } (destObj->*cb)(value); addMember(destObj, propString); onSetProperty(propString, value); srcObj->release(); return value; }
Handle<Value> TiFilesystemObject::_getFile(void* userContext, TiObject* , const Arguments& args) { // Get the paths from the arguments QString path = ""; for(int i = 0, len = args.Length(); i < len; i++) { String::Utf8Value v8UtfString(Handle<String>::Cast(args[i])); const char* cStr = *v8UtfString; path.append(cStr).append("/"); } // remove the last "/" path.remove(path.length() - 1, 1); // in case there is double slashesh, remove them // Ti.Filesyste.getFile( Ti.Filestem.resourceDirectory, '/app.js') // or // Ti.Filesyste.getFile( Ti.Filestem.resourceDirectory, 'app.js') path.replace("//", "/"); HandleScope handleScope; // Get the Filesystem object TiFilesystemObject* obj = (TiFilesystemObject*) userContext; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); // Create a File object TiFilesystemFileObject* fileObject = new TiFilesystemFileObject(path); fileObject->setNativeObjectFactory(obj->_objectFactory); fileObject->setValue(result); // Return it setTiObjectToJsObject(result, fileObject); return handleScope.Close(result); }
Handle<Value> TiDatabase::_open(void* userContext, TiObject* /*caller*/, const Arguments& args) { HandleScope handleScope; TiDatabase* obj = (TiDatabase*) userContext; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); TiDBObject* newDB = TiDBObject::createDB(obj->objectFactory_, args); newDB->setValue(result); setTiObjectToJsObject(result, newDB); return handleScope.Close(result); }
/* Call back for V8 named properties. This is the entry point for accessing * properties from js. We handle the properties we know and let V8 handle * all other properties. */ Handle<Value> TiObject::_propGetter(Local<String> prop, const AccessorInfo& info) { HandleScope handleScope; Handle<Object> result; TiObject* obj = getTiObjectFromJsObject(info.Holder()); if (obj == NULL) { // Returns "empty". This will cause V8 to go back to default lookup. return result; } Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(info.Holder()); String::Utf8Value propName(prop); const char* propString = (const char*)(*propName); TiObject* propObject = obj->onLookupMember(propString); if (propObject == NULL) { // TODO: Fix the following block of commented out code. Currently it breaks // Titanium runtime. /* if(obj->canAddMembers()) { // If we're allowed to add members, return an "empty" result // so V8 will handle it. V8 will set the value internally so // we can ignore non-Titanium objects. return result; } */ return Handle<Value>(); } Handle<Value> ret = propObject->getValue(); if (!ret.IsEmpty()) { return handleScope.Close(ret); } if ((propObject->hasMembers()) || (propObject->isFunction())) { result = global->NewInstance(); propObject->setValue(result); setTiObjectToJsObject(result, propObject); } else { propObject->release(); return handleScope.Close(propObject->getValue()); } propObject->release(); return handleScope.Close(result); }
Handle<Value> TiTitaniumObject::_createBuffer(void* userContext, TiObject*, const Arguments& args) { HandleScope handleScope; TiTitaniumObject* obj = (TiTitaniumObject*) userContext; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); TiBufferObject* newBuffer = TiBufferObject::createBuffer(obj->objectFactory_); newBuffer->setValue(result); if ((args.Length() > 0) && (args[0]->IsObject())) { Local<Object> settingsObj = Local<Object>::Cast(args[0]); newBuffer->setParametersFromObject(newBuffer, settingsObj); } setTiObjectToJsObject(result, newBuffer); return handleScope.Close(result); }
Handle<Value> TiNetwork::_createHTTPClient(void* userContext, TiObject* /*caller*/, const Arguments& args) { HandleScope handleScope; TiNetwork* obj = (TiNetwork*) userContext; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); TiHTTPClientObject* newHTTP = TiHTTPClientObject::createHTTPClient(obj->objectFactory_); newHTTP->setValue(result); if ((args.Length() > 0) && (args[0]->IsObject())) { Local<Object> settingsObj = Local<Object>::Cast(args[0]); newHTTP->setParametersFromObject(newHTTP, settingsObj); } setTiObjectToJsObject(result, newHTTP); return handleScope.Close(result); }
Handle<Value> TiProxy::createProxy(TiProxy *proxy, void* userContext, const Arguments& args) { TiProxy *module = static_cast<TiProxy*>(userContext); HandleScope handleScope; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); proxy->setNativeObjectFactory(module->getNativeObjectFactory()); proxy->initializeTiObject(NULL); proxy->setValue(result); proxy->setAttachedObject(module); if ((args.Length() > 0) && (args[0]->IsObject())) { Local<Object> settingsObj = Local<Object>::Cast(args[0]); proxy->setParametersFromObject(proxy, settingsObj); } setTiObjectToJsObject(result, proxy); return handleScope.Close(result); }
int TiRootObject::executeScript(NativeObjectFactory* objectFactory, const char* javaScript, MESSAGELOOPENTRY messageLoopEntry, void* context) { HandleScope handleScope; objectFactory_ = objectFactory; globalTemplate_ = ObjectTemplate::New(); TiV8EventContainerFactory* eventFactory = TiV8EventContainerFactory::createEventContainerFactory(globalTemplate_); objectFactory->setEventContainerFactory(eventFactory); onSetGetPropertyCallback(&globalTemplate_); onSetFunctionCallback(&globalTemplate_); g_rootTemplate = ObjectTemplate::New(); context_ = Context::New(NULL, g_rootTemplate); forceSetValue(context_->Global()); context_->Global()->SetHiddenValue(String::New("globalTemplate_"), External::New(&globalTemplate_)); context_->Global()->SetHiddenValue(String::New("context_"), External::New(&context_)); setTiObjectToJsObject(context_->Global(), this); Context::Scope context_scope(context_); initializeTiObject(NULL); const char* bootstrapFilename = "bootstrap.js"; string bootstrapJavascript; { ifstream ifs((string("app/native/framework/") + bootstrapFilename).c_str()); if (!ifs) { TiLogger::getInstance().log(Ti::Msg::ERROR__Cannot_load_bootstrap_js); return -1; } getline(ifs, bootstrapJavascript, string::traits_type::to_char_type(string::traits_type::eof())); ifs.close(); } TryCatch tryCatch; Handle<Script> compiledBootstrapScript = Script::Compile(String::New(bootstrapJavascript.c_str()), String::New(bootstrapFilename)); if (compiledBootstrapScript.IsEmpty()) { String::Utf8Value error(tryCatch.Exception()); TiLogger::getInstance().log(*error); return -1; } Handle<Value> bootstrapResult = compiledBootstrapScript->Run(); if (bootstrapResult.IsEmpty()) { Local<Value> exception = tryCatch.Exception(); // FIXME: need a way to prevent double "filename + line" output Handle<Message> msg = tryCatch.Message(); stringstream ss; ss << bootstrapFilename << " line "; if (msg.IsEmpty()) { ss << "?"; } else { ss << msg->GetLineNumber(); } ss << ": " << *String::Utf8Value(exception); TiLogger::getInstance().log(ss.str().c_str()); return -1; } const char* filename = "app.js"; Handle<Script> compiledScript = Script::Compile(String::New(javaScript), String::New(filename)); if (compiledScript.IsEmpty()) { ReportException(tryCatch, true); return 1; } compiledScript->Run(); if (tryCatch.HasCaught()) { ReportException(tryCatch, true); return 1; } onStartMessagePump(); return (messageLoopEntry)(context); }