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;
}
