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);
}
/**
* Invoke a method
*
* @param npobj - Instance
* @param name - Method name (as a browser-specific identifier)
* @param args - Array of arguments
* @param argCount - Number of arguments
* @param result - Result of the method should be stored here
*
* @return True if method correctly executed. False otherwise
*/
static bool
jsInterface_Invoke (NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
int i;
bool retVal = false;
NPUTF8* methodName;
jsInterfaceObject* obj = (jsInterfaceObject*)npobj;
methodName = NPN_UTF8FromIdentifier(name);
if (!methodName)
return false;
for (i=0; i<JS_INTERFACE_METHOD_COUNT; i++)
{
if (strcmp(methodName, jsInterfaceMethodNames[i]) == 0)
{
retVal = jsInterfaceMethodImpl[i](obj, args, argCount, result);
break;
}
}
return retVal;
}
bool convert_js_to_mrb_hash(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result)
{
NPIdentifier *id_list = NULL;
uint32_t count;
NPN_Enumerate(npp, NPVARIANT_TO_OBJECT(variant), &id_list, &count);
mrb_value ret_hash = mrb_hash_new_capa(mrb, count);
for (uint32_t i=0; i<count; i++){
NPVariant item;
NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), id_list[i], &item);
mrb_value mrb_item;
if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){
NPN_MemFree(id_list);
NPN_ReleaseVariantValue(&item);
return false;
}
NPN_ReleaseVariantValue(&item);
NPUTF8 *key = NPN_UTF8FromIdentifier(id_list[i]);
mrb_hash_set(mrb, ret_hash, mrb_str_new2(mrb, key), mrb_item);
NPN_MemFree(key);
}
NPN_MemFree(id_list);
*result = ret_hash;
return true;
}
bool
xplayerNPObject::Invoke (NPIdentifier aName,
const NPVariant *argv,
uint32_t argc,
NPVariant *_result)
{
if (!IsValid ())
return false;
NOTE (g_print ("xplayerNPObject::Invoke [%p] %s\n", (void*) this, NPN_UTF8FromIdentifier (aName)));
int methodIndex = GetClass()->GetMethodIndex (aName);
if (methodIndex >= 0)
return InvokeByIndex (methodIndex, argv, argc, _result);
if (aName == NPN_GetStringIdentifier ("__noSuchMethod__")) {
/* http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Object:_noSuchMethod */
if (!CheckArgv (argv, argc, 2, NPVariantType_String, NPVariantType_Object))
return false;
const char *id = NPVARIANT_TO_STRING (argv[0]).UTF8Characters;
g_message ("NOTE: site calls unknown function \"%s\" on xplayerNPObject %p\n", id ? id : "(null)", (void*) this);
/* Silently ignore the invocation */
VOID_TO_NPVARIANT (*_result);
return true;
}
return Throw ("No method with this name exists.");
}
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 NPClass_SetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *result)
{
NPClass_Prolog;
const QByteArray qname = NPN_UTF8FromIdentifier(name);
QVariant qvar = *result;
return qobject->setProperty(qname, qvar);
}
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result)
{
NPClass_Prolog;
int slotIndex = publicMethodIndex(npobj, name);
if (slotIndex == -1) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("No such method " + qname).constData());
return false;
}
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
QList<QByteArray> parameterTypes = slot.parameterTypes();
if (parameterTypes.count() != static_cast<int>(argCount)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + qname).constData());
return false;
}
QVariant returnVariant(QVariant::nameToType(slot.typeName()), (void *)0);
QVector<QVariant> variants(parameterTypes.count()); // keep data alive
QVector<const void *> metacallArgs(parameterTypes.count() + 1); // arguments for qt_metacall
metacallArgs[0] = returnVariant.data(); // args[0] == return value
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter in method " + qname).constData());
return false;
}
QVariant qvar = args[p];
if (!qvar.convert(type)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter value in method " + qname).constData());
return false;
}
variants[p] = qvar;
metacallArgs[p + 1] = variants.at(p).constData(); // must not detach!
}
qobject->qt_metacall(QMetaObject::InvokeMetaMethod, slotIndex, const_cast<void * *>(metacallArgs.data()));
if (returnVariant.isValid() && result)
*result = NPVariant::fromQVariant(This, returnVariant);
return true;
}
CString NPIdentifierToCString(NPIdentifier npid)
{
NPUTF8* putf8IdName = NPN_UTF8FromIdentifier(npid);
NPString npstrIdName = { putf8IdName, (uint32_t)strlen(putf8IdName) };
CString idName = NPStringToCString(npstrIdName);
NPN_MemFree(putf8IdName);
return idName;
}
bool nsScriptableObjectRawInput::HasProperty(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the property exist?
return (properties_.find(name) != properties_.end());
}
bool nsScriptableObjectOverwolfSample::HasMethod(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the method exist?
return (methods_.find(name) != methods_.end());
}
bool nsScriptableObjectRawInput::HasMethod(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the method exist?
return ((generic_methods_.find(name) != generic_methods_.end()) || (methods_.find(name) != methods_.end()));
}
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;
}
static bool NPClass_GetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
{
NPClass_Prolog;
const QByteArray qname = NPN_UTF8FromIdentifier(name);
QVariant qvar = qobject->property(qname);
if (!qvar.isValid()) {
NPN_SetException(npobj, QByteArray("Failed to get value for property " + qname).constData());
return false;
}
*result = NPVariant::fromQVariant(This, qvar);
return true;
}
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
xplayerNPObject::RemoveProperty (NPIdentifier aName)
{
if (!IsValid ())
return false;
NOTE (g_print ("xplayerNPObject::RemoveProperty [%p] %s\n", (void*) this, NPN_UTF8FromIdentifier (aName)));
int propertyIndex = GetClass()->GetPropertyIndex (aName);
if (propertyIndex >= 0)
return RemovePropertyByIndex (propertyIndex);
return Throw ("No property with this name exists.");
}
bool
xplayerNPObject::HasProperty (NPIdentifier aName)
{
if (!IsValid ())
return false;
int propertyIndex = GetClass()->GetPropertyIndex (aName);
NOTE (g_print ("xplayerNPObject::HasProperty [%p] %s => %s\n", (void*) this, NPN_UTF8FromIdentifier (aName), propertyIndex >= 0 ? "yes" : "no"));
if (propertyIndex >= 0)
return true;
return false;
}
bool
totemNPObject::SetProperty (NPIdentifier aName,
const NPVariant *aValue)
{
if (!IsValid ())
return false;
NOTE (g_print ("totemNPObject::SetProperty [%p] %s\n", (void*) this, NPN_UTF8FromIdentifier (aName)));
int propertyIndex = GetClass()->GetPropertyIndex (aName);
if (propertyIndex >= 0)
return SetPropertyByIndex (propertyIndex, aValue);
return Throw ("No property with this name exists.");
}
static bool NPClass_HasProperty(NPObject *npobj, NPIdentifier name)
{
NPClass_Prolog;
const QByteArray qname = NPN_UTF8FromIdentifier(name);
const QMetaObject *metaObject = qobject->metaObject();
int propertyIndex = metaObject->indexOfProperty(qname);
if (propertyIndex == -1 || propertyIndex < metaOffset(metaObject, MetaProperty))
return false;
QMetaProperty property = qobject->metaObject()->property(propertyIndex);
if (!property.isScriptable())
return false;
return true;
}
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
ScriptablePluginObject::HasMethod(NPIdentifier name)
{
//kk
//return name == sFoo_id;
char *pFunc = NPN_UTF8FromIdentifier(name);
//is function implemented
if( !strcmp( "Add", pFunc ) )
{
return true;
}
return false;
}
bool
ScriptablePluginObjectBase::SetProperty(NPIdentifier name,
const NPVariant *value)
{
if (name == sBar_id) {
printf ("bar set\n");
return true;
}
char *pProp = NPN_UTF8FromIdentifier(name);
return false;
}
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result)
{
NPClass_Prolog;
const QByteArray slotName = NPN_UTF8FromIdentifier(name);
int slotIndex = publicMethodIndex(npobj, slotName, static_cast<int>(argCount));
if (slotIndex == -1) {
NPN_SetException(npobj, QByteArray("No method '" + slotName + "' with " + QByteArray::number(argCount) + " parameters").constData());
return false;
}
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
QList<QByteArray> parameterTypes = slot.parameterTypes();
if (parameterTypes.count() != static_cast<int>(argCount)) {
NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + slotName).constData());
return false;
}
QVariant returnVariant(QVariant::nameToType(slot.typeName()), (void*)0);
QVector<QVariant> variants(parameterTypes.count()); // keep data alive
QVector<const void*> metacallArgs(parameterTypes.count() + 1); // arguments for qt_metacall
metacallArgs[0] = returnVariant.data(); // args[0] == return value
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid && parameterTypes.at(p) != "QVariant") {
NPN_SetException(npobj, QString("Parameter %1 in method '%2' has invalid type")
.arg(p).arg(QString::fromUtf8(slotName)).toAscii().constData());
return false;
}
QVariant qvar = args[p];
if (type != QVariant::Invalid && !qvar.convert(type)) {
NPN_SetException(npobj, QString("Parameter %1 to method '%2' needs to be convertable to '%3'")
.arg(p).arg(QString::fromUtf8(slotName)).arg(QString::fromAscii(parameterTypes.at(p))).toAscii().constData());
return false;
}
variants[p] = qvar;
if (type == QVariant::Invalid)
metacallArgs[p + 1] = &variants.at(p);
else
metacallArgs[p + 1] = variants.at(p).constData(); // must not detach!
}
qobject->qt_metacall(QMetaObject::InvokeMetaMethod, slotIndex, const_cast<void**>(metacallArgs.data()));
if (returnVariant.isValid() && result)
*result = NPVariant::fromQVariant(This, returnVariant);
return true;
}
static int publicMethodIndex(NPObject *npobj, NPIdentifier name)
{
NPClass_Prolog;
QByteArray qname = NPN_UTF8FromIdentifier(name);
const QMetaObject *metaObject = qobject->metaObject();
for (int slotIndex = metaOffset(metaObject, MetaMethod); slotIndex < metaObject->methodCount(); ++slotIndex) {
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
if (slot.access() != QMetaMethod::Public || slot.methodType() == QMetaMethod::Signal)
continue;
QByteArray signature = slot.signature();
if (signature.left(signature.indexOf('(')) == qname)
return slotIndex;
}
return -1;
}
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::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;
}
bool
xplayerNPObject::HasMethod (NPIdentifier aName)
{
if (!IsValid ())
return false;
int methodIndex = GetClass()->GetMethodIndex (aName);
NOTE (g_print ("xplayerNPObject::HasMethod [%p] %s => %s\n", (void*) this, NPN_UTF8FromIdentifier (aName), methodIndex >= 0 ? "yes" : "no"));
if (methodIndex >= 0)
return true;
if (aName == NPN_GetStringIdentifier ("__noSuchMethod__"))
return true;
return false;
}
static bool
NPClass_HasMethod (NPObject *npobj, NPIdentifier name)
{
DnObjectWrapper *wrapper = (DnObjectWrapper *) npobj;
gchar *method_name;
gboolean has_method;
g_return_val_if_fail (wrapper != NULL, false);
method_name = NPN_UTF8FromIdentifier (name);
has_method = (g_hash_table_lookup (wrapper->methods, method_name) != NULL);
g_debug ("%s(\"%s\")", G_STRFUNC, method_name);
NPN_MemFree (method_name);
return has_method;
}
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 nsScriptableObjectRawInput::Invoke(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
#ifdef _DEBUG
NPUTF8* szName = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)szName);
#endif
// dispatch method to appropriate handler
MethodsMap::iterator iter = methods_.find(name);
if (iter == methods_.end()) {
GenericMethodsMap::iterator generic_iter = generic_methods_.find(name);
if (generic_iter == generic_methods_.end()) {
// should never reach here
NPN_SetException(this, "bad function called??");
return false;
}
return (this->*generic_iter->second)(name, args, argCount, result);
}
PluginMethod* plugin_method = iter->second->Clone(this, npp_, args, argCount, result);
if (nullptr == plugin_method) {
return false;
}
utils::Thread* thread = 0;
if (plugin_method->GetName().compare("RawInputMonitor") == 0) {
thread = thread_key.get();
if (thread->isQueueEmpty()) // this thread only has one task
return thread->PostTask(std::bind(&nsScriptableObjectRawInput::ExecuteMethod, this, plugin_method));
else
return true;
}
else
{
NPN_SetException(this, "could not find thread??");
return false;
}
}
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
//kk
/*if (name == sBar_id) {
static int a = 17;
INT32_TO_NPVARIANT(a, *result);
a += 5;
return true;
}*/
char *pProp = NPN_UTF8FromIdentifier(name);
if( !strcmp( "Version", pProp ) )
{
char *p = (char*) NPN_MemAlloc( "Version 1.0" );//allocating Memory for the string with invocation of Browser-API
STRINGZ_TO_NPVARIANT( p, *result);
return true;
}
if( !strcmp( "Name", pProp ) )
{
char *p = (char*) NPN_MemAlloc( m_pszName );//allocating Memory for the string with invocation of Browser-API
STRINGZ_TO_NPVARIANT( p, *result);
return true;
}
if (name == sPluginType_id) {
NPObject *myobj =
NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
if (!myobj) {
return false;
}
OBJECT_TO_NPVARIANT(myobj, *result);
return true;
}
return true;
}
