bool GnashPluginScriptObject::Invoke(NPObject */* npobj */, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { // log_debug(__PRETTY_FUNCTION__); #if 1 if (NPN_IdentifierIsString(name)) { log_debug("Invoking Method \"%s\"...", NPN_UTF8FromIdentifier(name)); } else { log_debug("Invoking Method: \"%d\"...", NPN_IntFromIdentifier(name)); } // log_debug("SCRIPT OBJECT invoke %s: %x", NPN_UTF8FromIdentifier(name), // (void *)npobj); #endif std::map<NPIdentifier, NPInvokeFunctionPtr>::iterator it; it = _methods.find(name); if (it != _methods.end()) { // log_debug("FOUND Method \"%s\"!", NPN_UTF8FromIdentifier(name)); NPInvokeFunctionPtr func = it->second; return func(this, name, args, argCount, result); } else { log_error("Couldn't find Method \"%s\"", NPN_UTF8FromIdentifier(name)); } return false; // return NPN_Invoke(nppinstance, this, name, args, argCount, result); }
bool JsObjectWrapper::getInfo(NPIdentifier name, TypeMemberInfo& info) { if(!getTypeInfo()) return false; if(NPN_IdentifierIsString(name)) { NPUTF8* id = NPN_UTF8FromIdentifier(name); MembersByName_t::const_iterator it = m_byName.find(id); NPN_MemFree(id); if(it == m_byName.end()) return false; info = it->second; return true; } else if(m_indexerLength >= 0) { uint32_t index = NPN_IntFromIdentifier(name); if(index < m_indexerLength) { info.dispatchType = DT_PropertyGet | DT_PropertySet; //info.memberId = index; return true; } } return false; }
static bool HasProperty(NPObject *obj, NPIdentifier propertyName) { printf("*** HasProperty(%p)\n", propertyName); if (NPN_IdentifierIsString(propertyName)) { printf("*** is a string\n"); char *name = NPN_UTF8FromIdentifier(propertyName); printf("*** HasProperty(string %s)\n", name); } else { int i = NPN_IntFromIdentifier(propertyName); printf("*** HasProperty(int %d)\n", i); } return false; }
const char* debugName(NPIdentifier name) { static char buf[1024]; if(NPN_IdentifierIsString(name)) { NPUTF8* strName = NPN_UTF8FromIdentifier(name); sprintf_s(buf, sizeof(buf), "'%s'", strName); NPN_MemFree(strName); } else { int intName = NPN_IntFromIdentifier(name); sprintf_s(buf, sizeof(buf), "%d", intName); } return buf; }
bool GnashPluginScriptObject::HasMethod(NPIdentifier name) { #if 0 log_debug("Checking for Method \""); if (NPN_IdentifierIsString(name)) { log_debug("%s\"...", NPN_UTF8FromIdentifier(name)); } else { log_debug("%d\"...", NPN_IntFromIdentifier(name)); } #endif return _methods.find(name) != _methods.end(); }
bool GnashPluginScriptObject::InvokeDefault(const NPVariant */* args */, uint32_t /* argCount */, NPVariant */* result */) { log_debug(__PRETTY_FUNCTION__); #if 0 log_debug("Invoking Default Method \""); if (NPN_IdentifierIsString(name)) { log_debug("%s\"...", NPN_UTF8FromIdentifier(name)); } else { log_debug("%d\"...", NPN_IntFromIdentifier(name)); } #endif return false; }
DispatchIdentifier CreateDispatchIdentifier(NPIdentifier name) { static char buf[1024]; DispatchIdentifier ret; if(NPN_IdentifierIsString(name)) { NPUTF8* strName = NPN_UTF8FromIdentifier(name); ret.tag = IT_String; ret.name = strName; NPN_MemFree(strName); } else { int id = NPN_IntFromIdentifier(name); ret.tag = IT_Int; ret.id = id; } return ret; }
bool GnashPluginScriptObject::AddMethod(NPIdentifier name, NPInvokeFunctionPtr func) { // log_debug(__PRETTY_FUNCTION__); #if 0 if (NPN_IdentifierIsString(name)) { log_debug("Adding Method \"%s\"...", NPN_UTF8FromIdentifier(name)); } else { log_debug("Adding Method \"%d\"...", NPN_IntFromIdentifier(name)); } #endif _methods[name] = func; return true; }
bool GnashPluginScriptObject::marshalHasMethod (NPObject *npobj, NPIdentifier name) { // log_debug(__PRETTY_FUNCTION__); GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj; #if 0 log_debug("Checking for Method: "); if (NPN_IdentifierIsString(name)) { log_debug("%s", NPN_UTF8FromIdentifier(name)); } else { log_debug("%d", NPN_IntFromIdentifier(name)); } #endif return gpso->HasMethod(name); }
bool GnashPluginScriptObject::GetProperty(NPIdentifier name, NPVariant *result) { if (NPN_IdentifierIsString(name)) { log_debug("Getting Property \"%s\"...", NPN_UTF8FromIdentifier(name)); } else { log_debug("Getting Property \"%d\"...", NPN_IntFromIdentifier(name)); } std::map<NPIdentifier, GnashNPVariant>::const_iterator it; it = _properties.find(name); if (it == _properties.end()) { return false; } const GnashNPVariant& val = it->second; val.copy(*result); return true; };
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); }
// Sends something like this: // <invoke name="TestASMethod" returntype="xml"> // <arguments> // <number>123</number> // </arguments> // </invoke> // // Receives: // An XML response of one of the standard types like Number or String. bool remoteCallback (NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { // log_debug(__PRETTY_FUNCTION__); GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj; std::string method; #if 1 if (NPN_IdentifierIsString(name)) { log_debug("Invoking remote Method \"%s\"...", NPN_UTF8FromIdentifier(name)); method = NPN_UTF8FromIdentifier(name); } else { log_debug("Invoking remote Method: \"%d\"...", NPN_IntFromIdentifier(name)); } #endif // Build the argument array std::vector<std::string> fnargs; for (uint32_t i=0; i<argCount; ++i) { std::string xml = plugin::ExternalInterface::convertNPVariant(&args[i]); fnargs.push_back(xml); } std::string str = plugin::ExternalInterface::makeInvoke(method, fnargs); // 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 invoke %s, network problems.", method); return false; } // Have the read function allocate the memory std::string data = gpso->readPlayer(); if (data.empty()) { log_error("Couldn't read a response for invoke, network problems."); NULL_TO_NPVARIANT(*result); return false; } std::string answer; GnashNPVariant parsed = plugin::ExternalInterface::parseXML(data); if (!NPVARIANT_IS_NULL(parsed.get())) { answer = NPStringToString(NPVARIANT_TO_STRING(parsed.get())); } if (answer == "Error") { NULL_TO_NPVARIANT(*result); } else if (answer == "SecurityError") { NULL_TO_NPVARIANT(*result); } else { parsed.copy(*result); } // printNPVariant(&parsed.get()); // Returning false makes Javascript stop executing the script. return true; }