bool convert_js_to_mrb_array(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result) { NPVariant length; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier("length"), &length); int len; if (NPVARIANT_IS_INT32(length)){ len = NPVARIANT_TO_INT32(length); }else if (NPVARIANT_IS_DOUBLE(length)){ len = static_cast< int >(NPVARIANT_TO_DOUBLE(length)); // Why double?? }else{ NPN_ReleaseVariantValue(&length); return false; } NPN_ReleaseVariantValue(&length); mrb_value ret_array = mrb_ary_new_capa(mrb, len); for (int32_t i=0; i<len; i++){ NPVariant item; std::ostringstream oss; oss << i; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier(oss.str().c_str()), &item); mrb_value mrb_item; if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){ NPN_ReleaseVariantValue(&item); return false; } NPN_ReleaseVariantValue(&item); mrb_ary_push(mrb, ret_array, mrb_item); } *result = ret_array; return true; }
bool ScriptablePluginObject::SetProperty(NPIdentifier name, const NPVariant *value) { if (!m_plugin) return false; std::string str; std::stringstream ss; bool boolean = false; unsigned short val = -1; if (NPVARIANT_IS_STRING(*value)) { str.assign(NPVARIANT_TO_STRING(*value).UTF8Characters, NPVARIANT_TO_STRING(*value).UTF8Length); } else if (NPVARIANT_IS_BOOLEAN(*value)) { boolean = NPVARIANT_TO_BOOLEAN(*value); } else if (NPVARIANT_IS_INT32(*value)) { val = NPVARIANT_TO_INT32(*value); ss << val; ss >> str; }
double CPlugin::GetZoomLevel() { double level = 1; NPVariant vLevel; VOID_TO_NPVARIANT(vLevel); try { NPObject* pContainer = GetContainer(); if (!NPN_Invoke(m_pNPInstance, pContainer, GetIdentifier("getZoomLevel"), NULL, 0, &vLevel)) { throw CString(_T("Cannot invoke window.Container.getZoomLevel()")); } if (NPVARIANT_IS_DOUBLE(vLevel)) level = NPVARIANT_TO_DOUBLE(vLevel); else if ( NPVARIANT_IS_INT32(vLevel) ) level = NPVARIANT_TO_INT32(vLevel); } catch (const CString& strMessage) { level = 1; UNUSED(strMessage); TRACE(_T("[CPlugin::GetZoomLevel Exception] %s\n"), strMessage); } if (!NPVARIANT_IS_VOID(vLevel)) NPN_ReleaseVariantValue(&vLevel); return level; }
bool NPSafeArray::GetItem(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) { NPSafeArray *safe = static_cast<NPSafeArray*>(npobj); if (safe->arr_.m_psa == NULL) return false; LONG dim = safe->arr_.GetDimensions(); if (argCount < safe->arr_.GetDimensions()) { return false; } CAutoVectorPtr<LONG>pos(new LONG[dim]); for (int i = 0; i < dim; ++i) { if (NPVARIANT_IS_DOUBLE(args[i])) { pos[i] = (LONG)NPVARIANT_TO_DOUBLE(args[i]); } else if (NPVARIANT_IS_INT32(args[i])) { pos[i] = NPVARIANT_TO_INT32(args[i]); } else { return false; } } VARIANT var; if (!SUCCEEDED(safe->arr_.MultiDimGetAt(pos, var))) { return false; } Variant2NPVar(&var, result, safe->instance); return true; }
NPIdentifier int32VariantToIdentifier(NPVariant variant) { assert(NPVARIANT_IS_INT32(variant)); int32_t integer = NPVARIANT_TO_INT32(variant); return NPN_GetIntIdentifier(integer); }
NPIdentifier variantToIdentifier(NPVariant variant) { if (NPVARIANT_IS_STRING(variant)) return stringVariantToIdentifier(variant); else if (NPVARIANT_IS_INT32(variant)) return int32VariantToIdentifier(variant); else if (NPVARIANT_IS_DOUBLE(variant)) return doubleVariantToIdentifier(variant); return 0; }
bool JsAgent::onLoad(const NPVariant* args, unsigned argCount) { Debug::println("JsAgent::onLoad"); if(argCount != 4) { Debug::println("JsAgent::onLoad> argCount != 4"); return false; } if( !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_INT32(args[2]) || !NPVARIANT_IS_STRING(args[3]) ) { Debug::println("JsAgent::onLoad> arg types wrong"); return false; } NPObject* pObject = NPVARIANT_TO_OBJECT(args[0]); m_helper = NPN_RetainObject(pObject); NPObject* pDebug = NPN_CreateObject(getNPP(), GetNPClass<JsDebug>()); NPN_RetainObject(pDebug); Variant var; var.set(pDebug); if(!NPN_SetProperty(getNPP(), m_window, methods.debug, var.ptr())) { Debug::println("JsAgent::onLoad> set property failed"); return false; } NPString npstr = NPVARIANT_TO_STRING(args[1]); std::string host(npstr.UTF8Characters, npstr.UTF8Length); int port = NPVARIANT_TO_INT32(args[2]); npstr = NPVARIANT_TO_STRING(args[3]); std::string typeName(npstr.UTF8Characters, npstr.UTF8Length); if(!m_channel->connect(host.c_str(), port)) { Debug::println("JsAgent::onLoad> could not connect"); return false; } LoadMessage msg; msg.typeName = typeName; ArchiveWriter<Channel> ar(*m_channel); if(!Message::send(msg, ar)) { Debug::println("JsAgent::onLoad> send failed"); return false; } JsValue ret; return dispatchAndReturn(ret); }
void Any::Set(ptr<Script::Any> index, ptr<Script::Any> value) { NPVariant indexVariant = fast_cast<Any*>(&*index)->variant; if(NPVARIANT_IS_STRING(indexVariant)) InternalSet( Platform::NpapiPlugin::browserFuncs.getstringidentifier( NPVARIANT_TO_STRING(indexVariant).UTF8Characters), value); else if(NPVARIANT_IS_INT32(indexVariant)) Set(NPVARIANT_TO_INT32(indexVariant), value); }
ptr<Script::Any> Any::Get(ptr<Script::Any> index) const { NPVariant indexVariant = fast_cast<Any*>(&*index)->variant; if(NPVARIANT_IS_STRING(indexVariant)) return InternalGet( Platform::NpapiPlugin::browserFuncs.getstringidentifier( NPVARIANT_TO_STRING(indexVariant).UTF8Characters)); if(NPVARIANT_IS_INT32(indexVariant)) return Get(NPVARIANT_TO_INT32(indexVariant)); NPVariant result; VOID_TO_NPVARIANT(result); return state->CreateAny(result); }
vector<string> CppVariant::toStringVector() const { WEBKIT_ASSERT(isObject()); vector<string> stringVector; NPObject* npValue = value.objectValue; NPIdentifier lengthId = WebBindings::getStringIdentifier("length"); if (!WebBindings::hasProperty(0, npValue, lengthId)) return stringVector; NPVariant lengthValue; if (!WebBindings::getProperty(0, npValue, lengthId, &lengthValue)) return stringVector; int length = 0; // The length is a double in some cases. if (NPVARIANT_IS_DOUBLE(lengthValue)) length = static_cast<int>(NPVARIANT_TO_DOUBLE(lengthValue)); else if (NPVARIANT_IS_INT32(lengthValue)) length = NPVARIANT_TO_INT32(lengthValue); WebBindings::releaseVariantValue(&lengthValue); // For sanity, only allow 100 items. length = min(100, length); for (int i = 0; i < length; ++i) { // Get each of the items. char indexInChar[20]; // Enough size to store 32-bit integer snprintf(indexInChar, 20, "%d", i); string index(indexInChar); NPIdentifier indexId = WebBindings::getStringIdentifier(index.c_str()); if (!WebBindings::hasProperty(0, npValue, indexId)) continue; NPVariant indexValue; if (!WebBindings::getProperty(0, npValue, indexId, &indexValue)) continue; if (NPVARIANT_IS_STRING(indexValue)) { string item(NPVARIANT_TO_STRING(indexValue).UTF8Characters, NPVARIANT_TO_STRING(indexValue).UTF8Length); stringVector.push_back(item); } WebBindings::releaseVariantValue(&indexValue); } return stringVector; }
bool xplayerNPObject::GetDoubleFromArguments (const NPVariant* argv, uint32_t argc, uint32_t argNum, double& _result) { if (!CheckArg (argv, argc, argNum, NPVariantType_Double)) return false; NPVariant arg = argv[argNum]; if (NPVARIANT_IS_DOUBLE (arg)) { _result = NPVARIANT_TO_DOUBLE (arg); } else if (NPVARIANT_IS_INT32 (arg)) { _result = double (NPVARIANT_TO_INT32 (arg)); } return true; }
bool JsObjectWrapper::invokeDefault(const NPVariant* args, unsigned argCount, NPVariant* result) { if(argCount < 1) { Debug::println("JsObjectWrapper::invokeDefault> argCount < 1: %d", argCount); return false; } if(!NPVARIANT_IS_OBJECT(args[0])) { Debug::println("JsObjectWrapper::invokeDefault> args[0] not an object"); return false; } NPObject* pArray = NPVARIANT_TO_OBJECT(args[0]); Variant varRet; if(!NPN_GetProperty(getNPP(), pArray, m_agent->methods.length, varRet.ptr())) { Debug::println("JsObjectWrapper::invokeDefault> get length failed"); return false; } if(!NPVARIANT_IS_INT32(varRet.get())) { Debug::println("JsObjectWrapper::invokeDefault> length did not return an int"); return false; } int len = NPVARIANT_TO_INT32(varRet.get()); VariantArray varArgs(len); for(int i = 0; i < len; i++) { NPIdentifier id = NPN_GetIntIdentifier(i); Variant varItem; if(!NPN_GetProperty(getNPP(), pArray, id, varArgs[i].ptr())) { Debug::println("JsObjectWrapper::invokeDefault> get [%d] failed", i); return false; } } Debug::println("JsObjectWrapper::invokeDefault"); if(!m_agent->invokeRemoteDelegate(m_targetId, varArgs.get(), len, result)) { Debug::println("JsObjectWrapper::invokeDefault> invokeRemoteDelegate() failed"); return false; } return true; }
bool xplayerNPObject::GetInt32FromArguments (const NPVariant* argv, uint32_t argc, uint32_t argNum, int32_t& _result) { if (!CheckArg (argv, argc, argNum, NPVariantType_Int32)) return false; NPVariant arg = argv[argNum]; if (NPVARIANT_IS_INT32 (arg)) { _result = NPVARIANT_TO_INT32 (arg); } else if (NPVARIANT_IS_DOUBLE (arg)) { _result = int32_t (NPVARIANT_TO_DOUBLE (arg)); /* FIXMEchpe: overflow? */ } return true; }
double CPlugin::GetZoomLevel() { double level = 1; NPObject* pWindow = NULL; NPVariant vCOBA; VOID_TO_NPVARIANT(vCOBA); NPVariant vLevel; VOID_TO_NPVARIANT(vLevel); try { if ((NPN_GetValue( m_pNPInstance, NPNVWindowNPObject, &pWindow) != NPERR_NO_ERROR ) || !pWindow ) { throw(CString(_T("Cannot get window"))); } if ((!NPN_GetProperty( m_pNPInstance, pWindow, NPN_GetStringIdentifier ("COBA"), &vCOBA)) || !NPVARIANT_IS_OBJECT (vCOBA)) { throw(CString(_T("Cannot get window.COBA"))); } if (!NPN_Invoke(m_pNPInstance, NPVARIANT_TO_OBJECT(vCOBA), NPN_GetStringIdentifier("getZoomLevel"), NULL, 0, &vLevel)) { throw(CString(_T("Cannot execute window.COBA.getZoomLevel()"))); } if (NPVARIANT_IS_DOUBLE(vLevel)) level = NPVARIANT_TO_DOUBLE(vLevel); else if ( NPVARIANT_IS_INT32(vLevel) ) level = NPVARIANT_TO_INT32(vLevel); } catch (CString strMessage) { level = 1; TRACE(_T("[CPlugin::FireEvent Exception] %s"), strMessage); } if (!NPVARIANT_IS_VOID(vLevel)) NPN_ReleaseVariantValue(&vLevel); if (!NPVARIANT_IS_VOID(vCOBA)) NPN_ReleaseVariantValue(&vCOBA); if (pWindow != NULL) NPN_ReleaseObject(pWindow); return level; }
// TotalFrames() // // Sends something like this: // <invoke name="TotalFrames" returntype="xml"> // <arguments></arguments> // </invoke> // // Receives: // <number>66</number> bool TotalFrames (NPObject *npobj, NPIdentifier /* name */, const NPVariant */*args */, uint32_t argCount, NPVariant *result) { log_debug(__PRETTY_FUNCTION__); GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj; if (argCount == 0) { std::vector<std::string> iargs; std::string str = plugin::ExternalInterface::makeInvoke("TotalFrames", iargs); // Write the message to the Control FD. size_t ret = gpso->writePlayer(str); // Unless we wrote the same amount of data as the message contained, // something went wrong. if (ret != str.size()) { log_error("Couldn't check percent loaded, network problems."); BOOLEAN_TO_NPVARIANT(false, *result); return false; } std::string data = gpso->readPlayer(); if (data.empty()) { BOOLEAN_TO_NPVARIANT(false, *result); return false; } GnashNPVariant value = plugin::ExternalInterface::parseXML(data); if (NPVARIANT_IS_INT32(value.get())) { value.copy(*result); } else { INT32_TO_NPVARIANT(0, *result); } return true; } BOOLEAN_TO_NPVARIANT(false, *result); return false; }
bool NPSafeArray::LBound(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) { NPSafeArray *safe = static_cast<NPSafeArray*>(npobj); if (safe->arr_.m_psa == NULL) return false; int dim = 1; if (argCount >= 1) { if (NPVARIANT_IS_INT32(*args)) { dim = NPVARIANT_TO_INT32(*args); } else if (NPVARIANT_IS_DOUBLE(*args)) { dim = (LONG)NPVARIANT_TO_DOUBLE(*args); } else { return false; } } try{ INT32_TO_NPVARIANT(safe->arr_.GetLowerBound(dim - 1), *result); } catch (...) { return false; } return true; }
void printNPVariant(const NPVariant *value) { if (NPVARIANT_IS_DOUBLE(*value)) { double num = NPVARIANT_TO_DOUBLE(*value); log_debug("is double, value %g", num); } else if (NPVARIANT_IS_STRING(*value)) { std::string str = NPStringToString(NPVARIANT_TO_STRING(*value)); log_debug("is string, value %s", str); } else if (NPVARIANT_IS_BOOLEAN(*value)) { bool flag = NPVARIANT_TO_BOOLEAN(*value); log_debug("is boolean, value %d", flag); } else if (NPVARIANT_IS_INT32(*value)) { int num = NPVARIANT_TO_INT32(*value); log_debug("is int, value %d", num); } else if (NPVARIANT_IS_NULL(*value)) { log_debug("value is null"); } else if (NPVARIANT_IS_VOID(*value)) { log_debug("value is void"); } else if (NPVARIANT_IS_OBJECT(*value)) { log_debug("value is object"); } }
bool xplayerNPObject::GetBoolFromArguments (const NPVariant* argv, uint32_t argc, uint32_t argNum, bool& _result) { if (!CheckArg (argv, argc, argNum, NPVariantType_Bool)) return false; NPVariant arg = argv[argNum]; if (NPVARIANT_IS_BOOLEAN (arg)) { _result = NPVARIANT_TO_BOOLEAN (arg); } else if (NPVARIANT_IS_INT32 (arg)) { _result = NPVARIANT_TO_INT32 (arg) != 0; } else if (NPVARIANT_IS_DOUBLE (arg)) { _result = NPVARIANT_TO_DOUBLE (arg) != 0.0; } else { /* void/null */ _result = false; } return true; }
NPError StatementObject::AddParam(const NPVariant *value) { nsODBCParam* pRec = NULL; if (NPVARIANT_IS_VOID(*value) || NPVARIANT_IS_NULL(*value)) { pRec = new nsODBCParam(); } else if (NPVARIANT_IS_BOOLEAN(*value)) { pRec = new nsODBCParam(NPVARIANT_TO_BOOLEAN(*value)); } else if (NPVARIANT_IS_INT32(*value)) { pRec = new nsODBCParam(NPVARIANT_TO_INT32(*value)); } else if (NPVARIANT_IS_DOUBLE(*value)) { double data = NPVARIANT_TO_DOUBLE(*value); double delta = ceil(data); if (data-0.000000001 <delta && data+0.000000001 > delta) pRec = new nsODBCParam((int)data); else pRec = new nsODBCParam(data); //--pRec = new nsODBCParam(NPVARIANT_TO_DOUBLE(*value)); } else if (NPVARIANT_IS_STRING(*value)) { pRec = new nsODBCParam((NPString*)&NPVARIANT_TO_STRING(*value)); } else { NPN_SetException(this, "Unsupported parameter type"); return NPERR_GENERIC_ERROR; } if (pRec) m_params.push_back(pRec); return NPERR_NO_ERROR; }
bool toString(void *object, const NPVariant *args, uint32_t argCount, NPVariant *result) { GenericNPObject *map = (GenericNPObject *)object; if (!map || map->invalid) return false; // no args expected or cared for... std::string out; std::vector<NPVariant>::iterator it; for (it = map->numeric_mapper.begin(); it < map->numeric_mapper.end(); ++it) { if (NPVARIANT_IS_VOID(*it)) { out += ","; } else if (NPVARIANT_IS_NULL(*it)) { out += ","; } else if (NPVARIANT_IS_BOOLEAN(*it)) { if ((*it).value.boolValue) { out += "true,"; } else { out += "false,"; } } else if (NPVARIANT_IS_INT32(*it)) { char tmp[50]; memset(tmp, 0, sizeof(tmp)); _snprintf(tmp, 49, "%d,", (*it).value.intValue); out += tmp; } else if (NPVARIANT_IS_DOUBLE(*it)) { char tmp[50]; memset(tmp, 0, sizeof(tmp)); _snprintf(tmp, 49, "%f,", (*it).value.doubleValue); out += tmp; } else if (NPVARIANT_IS_STRING(*it)) { out += (*it).value.stringValue.UTF8Characters; out += ","; } else if (NPVARIANT_IS_OBJECT(*it)) { out += "[object],"; } } // calculate how much space we need std::string::size_type size = out.length(); char *s = (char *)NPNFuncs.memalloc(size * sizeof(char)); if (NULL == s) { return false; } memcpy(s, out.c_str(), size); s[size - 1] = 0; // overwrite the last "," STRINGZ_TO_NPVARIANT(s, (*result)); return true; }
/* bool RFunction_GetProp(RFunction *Robj, NPIdentifier name, NPNetscapeFuncs *funcs, NPVariant *result, bool check, NPP inst) { SEXP obj, call, ptr, ans; //do we need to proect here? obj = Robj->object; int waserr = 0; bool toret = 0; PROTECT(ptr = call = allocVector(LANGSXP, 3)); //try [[ SETCAR(ptr, Rf_install("[[")); ptr = CDR( ptr ); SETCAR(ptr, obj); ptr = CDR( ptr ); if(funcs->identifierisstring(name)) SETCAR( ptr , Rf_install( (const char *) funcs->utf8fromidentifier(name))); else SETCAR( ptr , ScalarReal( (int) funcs->intfromidentifier(name))); PROTECT(ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance)); if(!waserr && !IsMissing(ans, true)) { //non-missing, non-null result. stop looking toret = 1; } else { //try $ ptr = call; SETCAR(ptr, Rf_install("$")); ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance); if(!waserr && !IsMissing(ans, true)) toret = 1; else { //try @ ptr = call; SETCAR(ptr, Rf_install("@")); ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance); if(!waserr && !IsMissing(ans, false)) toret = 1; else { ans = NEW_NUMERIC(1); REAL(ans)[0] = NA_REAL; } } } ConvertRToNP(ans, Robj->instance, funcs, result, CONV_REF); if(!check) return true; else return toret; } */ bool doNamedCall(NPP inst, SEXP fun, const NPVariant *argsIn, uint32_t count, NPVariant *_res, NPNetscapeFuncs *funcs) { fprintf(stderr, "\nAttempting to create R call with named arguments\n");fflush(stderr); uint32_t idcount = 0; NPIdentifier *ids; NPObject *obj = argsIn[0].value.objectValue; bool success = funcs->enumerate(inst, obj, &ids, &idcount); SEXP call, ans, ptr, tmp; NPVariant curprop; NPVariant *convFun = (NPVariant *) funcs->memalloc(sizeof(NPVariant)) ; convert_t conv= CONV_DEFAULT; int len = 1 + idcount; if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("namedArgsForR"))) len = len -1; //the namedArgsForR property isn't going to be used as an argument in the function call if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("convertRet"))) len = len -1; //the convertRet property isn't going to be used as an argument in the function call if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("convertFun"))) len = len -1; //the convertFun property isn't going to be used as an argument in the function call PROTECT(ptr = call = allocVector(LANGSXP, len)); SETCAR(ptr, fun); PROTECT(tmp = R_NilValue); for(int i =0; i < idcount; i++) { funcs->getproperty(inst, obj, ids[i], &curprop); if(ids[i] == funcs->getstringidentifier("convertRet")) { //switched between 3 options on Javascript side and converted to number if(NPVARIANT_IS_INT32(curprop)) conv = (convert_t) curprop.value.intValue; else conv = (convert_t) curprop.value.doubleValue; } else if (ids[i] == funcs->getstringidentifier("convertFun")) { *convFun = curprop; // conv = CONV_REF; } else if(curprop.type == NPVariantType_Object && !funcs->hasproperty(inst, curprop.value.objectValue, funcs->getstringidentifier("emptyRArg"))) { ptr = CDR(ptr); //empty argument, ie 2nd "argument" in foo(a, , c) SETCAR(ptr, R_MissingArg); } else if(ids[i] != funcs->getstringidentifier("namedArgsForR")) { fprintf(stderr, "\nAccessing property %s\n", funcs->utf8fromidentifier(ids[i]));fflush(stderr); ptr = CDR(ptr); //funcs->getproperty(inst, obj, ids[i], &curprop); ConvertNPToR(&curprop, inst, funcs, CONV_DEFAULT, &tmp); SETCAR(ptr, tmp); SET_TAG(ptr, Rf_install((const char *) funcs->utf8fromidentifier(ids[i]))); } } fprintf(stderr, "\nFull call:\n");fflush(stderr); Rf_PrintValue(call); int err = 0; PROTECT(ans = rQueue.requestRCall(call, R_GlobalEnv, &err, inst)); //NPVariant *tmpres = ConvertRToNP(ans, inst, funcs, _res, conv); //ConvertRToNP(ans, inst, funcs, tmpres, conv); //call custom conversion method if available if(conv == 3) { funcs->invokeDefault(inst, convFun->value.objectValue, _res, 1, _res); } funcs->memfree(ids); funcs->releasevariantvalue(convFun); return !err; }
bool StatementObject::Invoke(NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { //sprintf(tmp, "stmt Invoke [%s]\n", NPN_UTF8FromIdentifier(name)); log(tmp); NPError rc; VOID_TO_NPVARIANT(*result); int index = 0; if (name == mc_Init_id) { if (argCount < 2) { NPN_SetException(this, "Too few parameters count"); return true; } #if 0 if (!(NPVARIANT_IS_INT32(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) { NPN_SetException(this, "Wrong argument type"); return true; } SQLHANDLE hdbc = (SQLHANDLE)(long)NPVARIANT_TO_INT32(args[0]); #else if (!(NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) { NPN_SetException(this, "Wrong argument type"); return true; } SQLHANDLE hdbc = (SQLHANDLE)NPVARIANT_TO_OBJECT(args[0]); #endif Init(hdbc, NPVARIANT_TO_OBJECT(args[1])); return true; } else if (name == mc_AddParameter_id) { if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } AddParam(args); return true; } else if (name == mc_Execute_id) { if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (!NPVARIANT_IS_STRING(args[0])) { NPN_SetException(this, "Wrong argument type"); return true; } Execute((NPString*)&NPVARIANT_TO_STRING(args[0])); return true; } else if (name == mc_Close_id) { Close(); return true; } else if (name == mc_Fetch_id) { bool ret; rc = Fetch(&ret); if (rc != NPERR_NO_ERROR) return true; BOOLEAN_TO_NPVARIANT(ret, *result); return true; } else if (name == mc_MoreResults_id) { bool ret; rc = MoreResults(&ret); if (rc != NPERR_NO_ERROR) return true; BOOLEAN_TO_NPVARIANT(ret, *result); return true; } else if (name == mc_GetColumnName_id) { const char *ret; if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (NPVARIANT_IS_INT32(args[0])) index = NPVARIANT_TO_INT32(args[0]); else if (NPVARIANT_IS_DOUBLE(args[0])) index = (int)NPVARIANT_TO_DOUBLE(args[0]); else { NPN_SetException(this, "Wrong argument type"); return true; } rc = GetColumnName(index, &ret); if (rc != NPERR_NO_ERROR) return true; STRING_TO_NPVARIANT(ret, *result); return true; } else if (name == mc_GetVariant_id) { if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (NPVARIANT_IS_INT32(args[0])) index = NPVARIANT_TO_INT32(args[0]); else if (NPVARIANT_IS_DOUBLE(args[0])) index = (int)NPVARIANT_TO_DOUBLE(args[0]); else { NPN_SetException(this, "Wrong argument type"); return true; } GetVariant(index, result); return true; } else if (name == mc_GetColumnType_id) { int ret; if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (NPVARIANT_IS_INT32(args[0])) index = NPVARIANT_TO_INT32(args[0]); else if (NPVARIANT_IS_DOUBLE(args[0])) index = (int)NPVARIANT_TO_DOUBLE(args[0]); else { NPN_SetException(this, "Wrong argument type"); return true; } rc = GetColumnType(index, &ret); if (rc != NPERR_NO_ERROR) return true; INT32_TO_NPVARIANT(ret, *result); return true; } else if (name == mc_IsColumnNullable_id) { bool ret; if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (NPVARIANT_IS_INT32(args[0])) index = NPVARIANT_TO_INT32(args[0]); else if (NPVARIANT_IS_DOUBLE(args[0])) index = (int)NPVARIANT_TO_DOUBLE(args[0]); else { NPN_SetException(this, "Wrong argument type"); return true; } rc = IsColumnNullable(index, &ret); if (rc != NPERR_NO_ERROR) return true; BOOLEAN_TO_NPVARIANT(ret, *result); return true; } else if (name == mc_GetTables_id) { if (argCount < 4) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) { NPN_SetException(this, "Wrong 4 argument type"); return true; } GetTables(&args[0], &args[1], &args[2], &args[3]); return true; } else if (name == mc_GetColumns_id) { if (argCount < 4) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) { NPN_SetException(this, "Wrong 4 argument type"); return true; } GetColumns(&args[0], &args[1], &args[2], &args[3]); return true; } else if (name == mc_GetTypeInfo_id) { if (argCount < 1) { NPN_SetException(this, "Too few parameters count"); return true; } if (NPVARIANT_IS_INT32(args[0])) index = NPVARIANT_TO_INT32(args[0]); else if (NPVARIANT_IS_DOUBLE(args[0])) index = (int)NPVARIANT_TO_DOUBLE(args[0]); else { NPN_SetException(this, "Wrong argument type"); return true; } GetTypeInfo(index); return true; } else if (name == mc_GetPrimaryKeys_id) { if (argCount < 3) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } GetPrimaryKeys(&args[0], &args[1], &args[2]); return true; } else if (name == mc_GetForeignKeys_id) { if (argCount < 6) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) { NPN_SetException(this, "Wrong 4 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[4]) || NPVARIANT_IS_STRING(args[4]))) { NPN_SetException(this, "Wrong 5 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[5]) || NPVARIANT_IS_STRING(args[5]))) { NPN_SetException(this, "Wrong 6 argument type"); return true; } GetForeignKeys(&args[0], &args[1], &args[2], &args[3], &args[4], &args[5]); return true; } else if (name == mc_GetProcedures_id) { if (argCount < 3) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } GetProcedures(&args[0], &args[1], &args[2]); return true; } else if (name == mc_GetProcedureColumns_id) { if (argCount < 4) { NPN_SetException(this, "Too few parameters count"); return true; } if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) { NPN_SetException(this, "Wrong 1 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) { NPN_SetException(this, "Wrong 2 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) { NPN_SetException(this, "Wrong 3 argument type"); return true; } if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) { NPN_SetException(this, "Wrong 4 argument type"); return true; } GetProcedureColumns(&args[0], &args[1], &args[2], &args[3]); return true; } return false; }
static bool NPChewingInvoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { uint8_t symbol = -1; for (int i = 0; i < METHOD_LENGTH; ++i) { if (sSymbolIdentifierMap[i].id == name) { symbol = sSymbolIdentifierMap[i].symbol; break; } } bool rv = false; NPChewingObject* obj = (NPChewingObject*)npobj; if (!obj->ctx) { return false; } switch (symbol) { case HANDLE_DEFAULT: { if (argCount != 1) { break; } if (!NPVARIANT_IS_INT32(args[0])) { break; } int32_t key = NPVARIANT_TO_INT32(args[0]); int32_t r = chewing.chewing_handle_Default(obj->ctx, key); INT32_TO_NPVARIANT(r, *result); rv = true; break; } case HANDLE_ENTER: { if (argCount != 0) { break; } int32_t r = chewing.chewing_handle_Enter(obj->ctx); INT32_TO_NPVARIANT(r, *result); rv = true; break; } case BUFFER_STRING: { if (argCount != 0) { break; } if (!chewing.chewing_buffer_Check(obj->ctx)) { NULL_TO_NPVARIANT(*result); rv = true; break; } char* str = chewing.chewing_buffer_String(obj->ctx); char* r = (char*)npn_malloc(strlen(str)+1); strcpy(r, str); chewing.chewing_free(str); STRINGZ_TO_NPVARIANT(r, *result); rv = true; break; } case COMMIT_STRING: { if (argCount != 0) { break; } if (!chewing.chewing_commit_Check(obj->ctx)) { NULL_TO_NPVARIANT(*result); rv = true; break; } char* str = chewing.chewing_commit_String(obj->ctx); char* r = (char*)npn_malloc(strlen(str)+1); strcpy(r, str); chewing.chewing_free(str); STRINGZ_TO_NPVARIANT(r, *result); rv = true; break; } case ZHUYIN_STRING: { if (argCount != 0) { break; } if (!chewing.chewing_zuin_Check(obj->ctx)) { NULL_TO_NPVARIANT(*result); rv = true; break; } int count = 0; char* str = chewing.chewing_zuin_String(obj->ctx, &count); char* r = (char*)npn_malloc(strlen(str)+1); strcpy(r, str); chewing.chewing_free(str); STRINGZ_TO_NPVARIANT(r, *result); rv = true; break; } case CANDIDATES_LIST: { if (argCount != 0) { break; } // open candidates list chewing.chewing_handle_Down(obj->ctx); // create a array object NPObject* window = NULL; npn_getValue(obj->npp, NPNVWindowNPObject, &window); NPObject* array = NULL; NPVariant arrayVar; npn_invoke(obj->npp, window, npn_getStringIdentifier("Array"), NULL, 0, &arrayVar); array = NPVARIANT_TO_OBJECT(arrayVar); npn_releaseObject(window); // Push all candidates to array NPIdentifier push = npn_getStringIdentifier("push"); chewing.chewing_cand_Enumerate(obj->ctx); bool hasCandidates = false; while (chewing.chewing_cand_hasNext(obj->ctx)) { hasCandidates = true; char* str = chewing.chewing_cand_String(obj->ctx); char* r = (char*)npn_malloc(strlen(str)+1); strcpy(r, str); chewing.chewing_free(str); NPVariant item; NPVariant unused; STRINGZ_TO_NPVARIANT(r, item); npn_invoke(obj->npp, array, push, &item, 1, &unused); npn_releaseVariantValue(&unused); } OBJECT_TO_NPVARIANT(array, *result); rv = true; if (hasCandidates) chewing.chewing_handle_Esc(obj->ctx); break; } case SELECT_CANDIDATE: { if (argCount != 1) { break; } if (!NPVARIANT_IS_INT32(args[0])) { break; } int32_t n = NPVARIANT_TO_INT32(args[0]); chewing.chewing_handle_Down(obj->ctx); chewing.chewing_cand_Select(obj->ctx, n); NULL_TO_NPVARIANT(*result); rv = true; break; } default: break; } return rv; }
bool ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { if (m_pMainWindow == NULL) return false; // void Navigate({string} URL, {string} post, {string} headers) if (name == m_NavigateID) { TRACE ("Navigate called!\n"); if (argCount < 3) return false; NPVariant vURL = args[0]; if (vURL.type != NPVariantType_String) return false; CString URL = NPStringToCString(vURL.value.stringValue); NPVariant vHeaders = args[1]; if (vHeaders.type != NPVariantType_String) return false; CString headers = NPStringToCString(vHeaders.value.stringValue); NPVariant vPost = args[2]; if (vPost.type != NPVariantType_String) return false; CString post = NPStringToCString(vPost.value.stringValue); m_pMainWindow->Navigate(URL, post, headers); VOID_TO_NPVARIANT(*result); return true; } // void Refresh() else if (name == m_RefreshID) { TRACE ("Refresh called!\n"); m_pMainWindow->Refresh(); return true; } // void Stop() else if (name == m_StopID) { TRACE ("Stop called!\n"); m_pMainWindow->Stop(); return true; } // void Back() else if (name == m_BackID) { TRACE ("Back called!\n"); m_pMainWindow->Back(); return true; } // void Forward() else if (name == m_ForwardID) { TRACE ("Forward called!\n"); m_pMainWindow->Forward(); return true; } // void Focus() else if (name == m_FocusID) { TRACE ("Focus called!\n"); m_pMainWindow->Focus(); return true; } // void Copy() else if (name == m_CopyID) { TRACE ("Copy called!\n"); m_pMainWindow->Copy(); return true; } // void Cut() else if (name == m_CutID) { TRACE ("Cut called!\n"); m_pMainWindow->Cut(); return true; } // void Paste() else if (name == m_PasteID) { TRACE ("Paste called!\n"); m_pMainWindow->Paste(); return true; } // void SelectAll() else if (name == m_SelectAllID) { TRACE ("SelectAll called!\n"); m_pMainWindow->SelectAll(); return true; } // void Find() else if (name == m_FindID) { TRACE ("Find called!\n"); m_pMainWindow->Find(); return true; } // void HandOverFocus() else if (name == m_HandOverFocusID) { TRACE ("HandOverFocus called!\n"); m_pMainWindow->HandOverFocus(); return true; } // void Zoom({number} level) else if (name == m_ZoomID) { TRACE ("Zoom called!\n"); if (argCount < 1) return false; double level = 1; if (NPVARIANT_IS_DOUBLE(args[0])) level = NPVARIANT_TO_DOUBLE(args[0]); else if ( NPVARIANT_IS_INT32(args[0]) ) level = NPVARIANT_TO_INT32(args[0]); m_pMainWindow->Zoom(level); return true; } // void DisplaySecurityInfo() else if (name == m_DisplaySecurityInfoID) { TRACE ("DisplaySecurityInfo called!\n"); m_pMainWindow->DisplaySecurityInfo(); return true; } // void SaveAs() else if (name == m_SaveAsID) { TRACE ("SaveAs called!\n"); m_pMainWindow->SaveAs(); return true; } // void Print() else if (name == m_PrintID) { TRACE ("Print called!\n"); m_pMainWindow->Print(); return true; } // void PrintPreview() else if (name == m_PrintPreviewID) { TRACE ("PrintPreview called!\n"); m_pMainWindow->PrintPreview(); return true; } // void PrintSetup() else if (name == m_PrintSetupID) { TRACE ("PrintSetup called!\n"); m_pMainWindow->PrintSetup(); return true; } return false; }
static bool pluginInvoke(NPObject *header, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { PluginObject *obj = (PluginObject *)header; if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) { // call whatever method name we're given if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) { NPObject *windowScriptObject; browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString); free(callbackString); NPVariant browserResult; browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult); browser->releasevariantvalue(&browserResult); VOID_TO_NPVARIANT(*result); return true; } } else if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) { if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) { NPUTF8* urlString = createCStringFromNPVariant(&args[0]); NPUTF8* targetString = createCStringFromNPVariant(&args[1]); browser->geturl(obj->npp, urlString, targetString); free(urlString); free(targetString); VOID_TO_NPVARIANT(*result); return true; } else if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) { NPUTF8* urlString = createCStringFromNPVariant(&args[0]); browser->geturl(obj->npp, urlString, 0); free(urlString); VOID_TO_NPVARIANT(*result); return true; } } else if (name == pluginMethodIdentifiers[ID_REMOVE_DEFAULT_METHOD]) { pluginClass.invokeDefault = 0; VOID_TO_NPVARIANT(*result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) { testDOMAccess(obj); VOID_TO_NPVARIANT(*result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY]) { if (argCount == 3 && NPVARIANT_IS_STRING(args[0]) && (NPVARIANT_IS_STRING(args[1]) || NPVARIANT_IS_NULL(args[1])) && NPVARIANT_IS_STRING(args[2])) { NPUTF8* urlString = createCStringFromNPVariant(&args[0]); NPUTF8* targetString = (NPVARIANT_IS_STRING(args[1]) ? createCStringFromNPVariant(&args[1]) : NULL); NPUTF8* callbackString = createCStringFromNPVariant(&args[2]); NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString); browser->geturlnotify(obj->npp, urlString, targetString, callbackIdentifier); free(urlString); free(targetString); free(callbackString); VOID_TO_NPVARIANT(*result); return true; } } else if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT] && NPVARIANT_IS_OBJECT(args[0])) { NPObject *callback = NPVARIANT_TO_OBJECT(args[0]); NPVariant args[1]; NPVariant browserResult; STRINGZ_TO_NPVARIANT("test", args[0]); bool retval = browser->invokeDefault(obj->npp, callback, args, 1, &browserResult); if (retval) browser->releasevariantvalue(&browserResult); BOOLEAN_TO_NPVARIANT(retval, *result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE]) { if (argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1])) { uint32_t count; NPIdentifier* identifiers; if (browser->enumerate(obj->npp, NPVARIANT_TO_OBJECT(args[0]), &identifiers, &count)) { NPObject* outArray = NPVARIANT_TO_OBJECT(args[1]); NPIdentifier pushIdentifier = browser->getstringidentifier("push"); for (uint32_t i = 0; i < count; i++) { NPUTF8* string = browser->utf8fromidentifier(identifiers[i]); if (!string) continue; NPVariant args[1]; STRINGZ_TO_NPVARIANT(string, args[0]); NPVariant browserResult; browser->invoke(obj->npp, outArray, pushIdentifier, args, 1, &browserResult); browser->releasevariantvalue(&browserResult); browser->memfree(string); } browser->memfree(identifiers); } VOID_TO_NPVARIANT(*result); return true; } return false; } else if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM]) { NPError npError = browser->destroystream(obj->npp, obj->stream, NPRES_USER_BREAK); INT32_TO_NPVARIANT(npError, *result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER]) { if (argCount == 1) { NPIdentifier identifier; if (NPVARIANT_IS_DOUBLE(args[0])) { identifier = browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0])); INT32_TO_NPVARIANT((int32)identifier, *result); return true; } else if (NPVARIANT_IS_INT32(args[0])) { identifier = browser->getintidentifier((int)NPVARIANT_TO_INT32(args[0])); INT32_TO_NPVARIANT((int32)identifier, *result); return true; } } } else if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE] && argCount == 1 && NPVARIANT_IS_STRING(args[0])) { NPObject *windowScriptObject; browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); NPString s = NPVARIANT_TO_STRING(args[0]); bool retval = browser->evaluate(obj->npp, windowScriptObject, &s, result); browser->releaseobject(windowScriptObject); return retval; } else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY] && argCount > 0) { NPObject *object; browser->getvalue(obj->npp, NPNVWindowNPObject, &object); for (uint32_t i = 0; i < argCount; i++) { //assert(NPVARIANT_IS_STRING(args[i])); NPUTF8* propertyString = createCStringFromNPVariant(&args[i]); NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString); free(propertyString); NPVariant variant; bool retval = browser->getproperty(obj->npp, object, propertyIdentifier, &variant); browser->releaseobject(object); if (!retval) break; if (i + 1 < argCount) { //assert(NPVARIANT_IS_OBJECT(variant)); object = NPVARIANT_TO_OBJECT(variant); } else { *result = variant; return true; } } VOID_TO_NPVARIANT(*result); return false; } else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE] && argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_STRING(args[1])) { NPUTF8* propertyString = createCStringFromNPVariant(&args[1]); NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString); free(propertyString); NPVariant variant; bool retval = browser->getproperty(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier, &variant); if (retval) browser->releasevariantvalue(&variant); BOOLEAN_TO_NPVARIANT(retval, *result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RET]) { // call whatever method name we're given, and pass it the 'window' obj. // we expect the function to return its argument. if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) { NPObject *windowScriptObject; browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString); free(callbackString); NPVariant callbackArgs[1]; OBJECT_TO_NPVARIANT(windowScriptObject, callbackArgs[0]); NPVariant browserResult; browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, callbackArgs, 1, &browserResult); if (NPVARIANT_IS_OBJECT(browserResult)) { // Now return the callbacks return value back to our caller. // BUG 897451: This should be the same as the // windowScriptObject, but its not (in Chrome) - or at least, it // has a different refcount. This means Chrome will delete the // object before returning it and the calling JS gets a garbage // value. Firefox handles it fine. OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(browserResult), *result); } else { browser->releasevariantvalue(&browserResult); VOID_TO_NPVARIANT(*result); } return true; } } else if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) { NPObject *testObject = browser->createobject(obj->npp, getTestClass()); //assert(testObject->referenceCount == 1); OBJECT_TO_NPVARIANT(testObject, *result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT]) { // call whatever method name we're given, and pass it our second // argument. if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) { NPObject *windowScriptObject; browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString); free(callbackString); NPVariant browserResult; browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &browserResult); browser->releasevariantvalue(&browserResult); VOID_TO_NPVARIANT(*result); return true; } } else if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) { // Create another instance of the same class NPObject *new_object = browser->createobject(obj->npp, &pluginClass); //assert(new_object->referenceCount == 1); OBJECT_TO_NPVARIANT(new_object, *result); return true; } else if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE]) { if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) { // Invoke a script callback to get a script NPObject. Then call // a method on the script NPObject passing it a freshly created // NPObject. // Arguments: // arg1: Callback that returns a script object. // arg2: Name of the method to call on the script object returned // from the callback NPObject *windowScriptObject; browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); // Arg1 is the name of the callback NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString); free(callbackString); // Invoke a callback that returns a script object NPVariant object_result; browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &object_result); // Script object returned NPObject *script_object = object_result.value.objectValue; // Arg2 is the name of the method to be called on the script object NPUTF8* object_mehod_string = createCStringFromNPVariant(&args[1]); NPIdentifier object_method = browser->getstringidentifier(object_mehod_string); free(object_mehod_string); // Create a fresh NPObject to be passed as an argument NPObject *object_arg = browser->createobject(obj->npp, &pluginClass); NPVariant invoke_args[1]; OBJECT_TO_NPVARIANT(object_arg, invoke_args[0]); // Invoke the script method NPVariant object_method_result; browser->invoke(obj->npp, script_object, object_method, invoke_args, 1, &object_method_result); browser->releasevariantvalue(&object_result); VOID_TO_NPVARIANT(*result); if (NPVARIANT_IS_OBJECT(object_method_result)) { // Now return the callbacks return value back to our caller. // BUG 897451: This should be the same as the // windowScriptObject, but its not (in Chrome) - or at least, it // has a different refcount. This means Chrome will delete the // object before returning it and the calling JS gets a garbage // value. Firefox handles it fine. OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(object_method_result), *result); } else { browser->releasevariantvalue(&object_method_result); VOID_TO_NPVARIANT(*result); } return true; } } return false; }
CPlugin::CPlugin(NPP pNPInstance) : m_pNPInstance(pNPInstance), m_pNPStream(NULL), m_bInitialized(false), m_pScriptableObject(NULL) { #ifdef XP_WIN m_hWnd = NULL; #endif NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &sWindowObj); NPIdentifier n = NPN_GetStringIdentifier("foof"); sFoo_id = NPN_GetStringIdentifier("foo"); sBar_id = NPN_GetStringIdentifier("bar"); sDocument_id = NPN_GetStringIdentifier("document"); sBody_id = NPN_GetStringIdentifier("body"); sCreateElement_id = NPN_GetStringIdentifier("createElement"); sCreateTextNode_id = NPN_GetStringIdentifier("createTextNode"); sAppendChild_id = NPN_GetStringIdentifier("appendChild"); sPluginType_id = NPN_GetStringIdentifier("PluginType"); NPVariant v; INT32_TO_NPVARIANT(46, v); NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v); NPVariant rval; NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval); if (NPVARIANT_IS_INT32(rval)) { printf("rval = %d\n", NPVARIANT_TO_INT32(rval)); } n = NPN_GetStringIdentifier("document"); if (!NPN_IdentifierIsString(n)) { NPString str; str.UTF8Characters = "alert('NPN_IdentifierIsString() test failed!');"; str.UTF8Length = strlen(str.UTF8Characters); NPN_Evaluate(m_pNPInstance, sWindowObj, &str, NULL); } NPObject *doc; NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval); if (NPVARIANT_IS_OBJECT(rval) && (doc = NPVARIANT_TO_OBJECT(rval))) { n = NPN_GetStringIdentifier("title"); NPN_GetProperty(m_pNPInstance, doc, n, &rval); if (NPVARIANT_IS_STRING(rval)) { printf ("title = %s\n", NPVARIANT_TO_STRING(rval).UTF8Characters); NPN_ReleaseVariantValue(&rval); } n = NPN_GetStringIdentifier("plugindoc"); OBJECT_TO_NPVARIANT(doc, v); NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v); NPString str; str.UTF8Characters = "document.getElementById('result').innerHTML += '<p>' + 'NPN_Evaluate() test, document = ' + this + '</p>';"; str.UTF8Length = strlen(str.UTF8Characters); //NPN_Evaluate(m_pNPInstance, doc, &str, NULL); NPN_ReleaseObject(doc); } NPVariant barval; NPN_GetProperty(m_pNPInstance, sWindowObj, sBar_id, &barval); NPVariant arg; OBJECT_TO_NPVARIANT(sWindowObj, arg); NPN_InvokeDefault(m_pNPInstance, NPVARIANT_TO_OBJECT(barval), &arg, 1, &rval); if (NPVARIANT_IS_INT32(rval) && NPVARIANT_TO_INT32(rval) == 4) { printf ("Default function call SUCCEEDED!\n"); } else { printf ("Default function call FAILED!\n"); } NPN_ReleaseVariantValue(&barval); NPN_ReleaseVariantValue(&rval); #if 0 n = NPN_GetStringIdentifier("prompt"); NPVariant vars[3]; STRINGZ_TO_NPVARIANT("foo", vars[0]); STRINGZ_TO_NPVARIANT("bar", vars[1]); STRINGZ_TO_NPVARIANT("foof", vars[2]); NPN_Invoke(sWindowObj, n, vars, 3, &rval); if (NPVARIANT_IS_STRING(rval)) { printf ("prompt returned '%s'\n", NPVARIANT_TO_STRING(rval).UTF8Characters); } NPN_ReleaseVariantValue(&rval); #endif NPObject *myobj = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); n = NPN_GetStringIdentifier("pluginobj"); OBJECT_TO_NPVARIANT(myobj, v); NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v); NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval); printf ("Object set/get test "); if (NPVARIANT_IS_OBJECT(rval) && NPVARIANT_TO_OBJECT(rval) == myobj) { printf ("succeeded!\n"); } else { printf ("FAILED!\n"); } NPN_ReleaseVariantValue(&rval); NPN_ReleaseObject(myobj); const char *ua = NPN_UserAgent(m_pNPInstance); strcpy(m_String, ua); }
bool Any::IsNumber() const { return NPVARIANT_IS_INT32(variant) || NPVARIANT_IS_DOUBLE(variant); }
static NPIdentifier int32VariantToIdentifier(NPVariant variant) { assert(NPVARIANT_IS_INT32(variant)); int32_t integer = NPVARIANT_TO_INT32(variant); return browser->getintidentifier(integer); }
RuntimeNPObject::InvokeResult LibvlcInputNPObject::setProperty(int index, const NPVariant &value) { /* is plugin still running */ if( isPluginRunning() ) { VlcPlugin* p_plugin = getPrivate<VlcPlugin>(); libvlc_exception_t ex; libvlc_exception_init(&ex); libvlc_media_player_t *p_md = p_plugin->getMD(&ex); RETURN_ON_EXCEPTION(this,ex); switch( index ) { case ID_input_position: { if( ! NPVARIANT_IS_DOUBLE(value) ) { return INVOKERESULT_INVALID_VALUE; } float val = (float)NPVARIANT_TO_DOUBLE(value); libvlc_media_player_set_position(p_md, val, &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } case ID_input_time: { int64_t val; if( NPVARIANT_IS_INT32(value) ) val = (int64_t)NPVARIANT_TO_INT32(value); else if( NPVARIANT_IS_DOUBLE(value) ) val = (int64_t)NPVARIANT_TO_DOUBLE(value); else { return INVOKERESULT_INVALID_VALUE; } libvlc_media_player_set_time(p_md, val, &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } case ID_input_rate: { float val; if( NPVARIANT_IS_INT32(value) ) val = (float)NPVARIANT_TO_INT32(value); else if( NPVARIANT_IS_DOUBLE(value) ) val = (float)NPVARIANT_TO_DOUBLE(value); else { return INVOKERESULT_INVALID_VALUE; } libvlc_media_player_set_rate(p_md, val, &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } default: ; } } return INVOKERESULT_GENERIC_ERROR; }