static bool pluginSetProperty(NPObject* obj, NPIdentifier name, const NPVariant* variant) { PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { plugin->eventLogging = NPVARIANT_TO_BOOLEAN(*variant); return true; } if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { plugin->logDestroy = NPVARIANT_TO_BOOLEAN(*variant); return true; } if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) { plugin->returnErrorFromNewStream = NPVARIANT_TO_BOOLEAN(*variant); return true; } if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE]) { plugin->returnNegativeOneFromWrite = NPVARIANT_TO_BOOLEAN(*variant); return true; } if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) { browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS"); return true; } if (name == pluginPropertyIdentifiers[ID_PROPERTY_WINDOWED_PLUGIN]) { browser->setvalue(plugin->npp, NPPVpluginWindowBool, (void *)NPVARIANT_TO_BOOLEAN(*variant)); return true; } return false; }
static bool pluginSetProperty(NPObject *obj, NPIdentifier name, const NPVariant *variant) { if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { ((PluginObject *)obj)->eventLogging = NPVARIANT_TO_BOOLEAN(*variant); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { ((PluginObject *)obj)->logDestroy = NPVARIANT_TO_BOOLEAN(*variant); return true; } return false; }
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; }
void ShockerScriptableControlObject::GetTestDefinition (const NPVariant *args, uint32_t arg_count, NPVariant *result) { char *test_definition; bool free_test_definition = false; char *retval; bool isJson = false; g_assert (arg_count <= 1); LOG_PLUGIN ("[%i shocker] ShockerScriptableControlObject::GetTestDefinition ()\n", getpid ()); test_definition = getenv ("MOONLIGHT_HARNESS_TESTDEFINITION"); if (test_definition == NULL) { if (arg_count > 0) { g_assert (NPVARIANT_IS_BOOLEAN (args [0])); isJson = NPVARIANT_TO_BOOLEAN (args [0]); } test_definition = LogProvider::GetInstance ()->GetTestDefinition (isJson); free_test_definition = true; } retval = NPN_strdup (test_definition == NULL ? "" : test_definition); STRINGZ_TO_NPVARIANT (retval, *result); if (free_test_definition) g_free (test_definition); }
bool convert_js_to_mrb(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result) { switch(variant.type){ case NPVariantType_Void: case NPVariantType_Null: *result = mrb_nil_value(); return true; case NPVariantType_Bool: if (NPVARIANT_TO_BOOLEAN(variant)){ *result = mrb_true_value(); }else{ *result = mrb_false_value(); } return true; case NPVariantType_Int32: *result = mrb_fixnum_value(NPVARIANT_TO_INT32(variant)); return true; case NPVariantType_Double: *result = mrb_float_value(NPVARIANT_TO_DOUBLE(variant)); return true; case NPVariantType_String: *result = mrb_str_new(mrb, NPVARIANT_TO_STRING(variant).UTF8Characters, NPVARIANT_TO_STRING(variant).UTF8Length); return true; case NPVariantType_Object: return convert_js_to_mrb_object(npp, variant, mrb, result); default: break; } return false; }
v8::Handle<v8::Value> ConvertNPVariantToV8Object(const NPVariant* variant, NPObject* npobject) { NPVariantType type = variant->type; if (type == NPVariantType_Int32) { return v8::Integer::New(NPVARIANT_TO_INT32(*variant)); } if (type == NPVariantType_Double) { return v8::Number::New(NPVARIANT_TO_DOUBLE(*variant)); } if (type == NPVariantType_Bool) { return NPVARIANT_TO_BOOLEAN(*variant) ? v8::True() : v8::False(); } if (type == NPVariantType_Null) { return v8::Null(); } if (type == NPVariantType_Void) { return v8::Undefined(); } if (type == NPVariantType_String) { NPString src = NPVARIANT_TO_STRING(*variant); return v8::String::New(src.UTF8Characters, src.UTF8Length); } if (type == NPVariantType_Object) { NPObject* obj = NPVARIANT_TO_OBJECT(*variant); if (obj->_class == NPScriptObjectClass) { return reinterpret_cast<V8NPObject*>(obj)->v8_object; } return CreateV8ObjectForNPObject(obj, npobject); } return v8::Undefined(); }
v8::Handle<v8::Value> convertNPVariantToV8Object(const NPVariant* variant, NPObject* npobject) { NPVariantType type = variant->type; switch (type) { case NPVariantType_Int32: return v8Integer(NPVARIANT_TO_INT32(*variant)); case NPVariantType_Double: return v8::Number::New(NPVARIANT_TO_DOUBLE(*variant)); case NPVariantType_Bool: return v8Boolean(NPVARIANT_TO_BOOLEAN(*variant)); case NPVariantType_Null: return v8::Null(); case NPVariantType_Void: return v8::Undefined(); case NPVariantType_String: { NPString src = NPVARIANT_TO_STRING(*variant); return v8::String::New(src.UTF8Characters, src.UTF8Length); } case NPVariantType_Object: { NPObject* obj = NPVARIANT_TO_OBJECT(*variant); if (obj->_class == npScriptObjectClass) return reinterpret_cast<V8NPObject*>(obj)->v8Object; return createV8ObjectForNPObject(obj, npobject); } default: return v8::Undefined(); } }
v8::Handle<v8::Value> convertNPVariantToV8Object(const NPVariant* variant, NPObject* owner, v8::Isolate* isolate) { NPVariantType type = variant->type; switch (type) { case NPVariantType_Int32: return v8::Integer::New(NPVARIANT_TO_INT32(*variant), isolate); case NPVariantType_Double: return v8::Number::New(isolate, NPVARIANT_TO_DOUBLE(*variant)); case NPVariantType_Bool: return v8Boolean(NPVARIANT_TO_BOOLEAN(*variant), isolate); case NPVariantType_Null: return v8::Null(isolate); case NPVariantType_Void: return v8::Undefined(isolate); case NPVariantType_String: { NPString src = NPVARIANT_TO_STRING(*variant); return v8::String::NewFromUtf8(isolate, src.UTF8Characters, v8::String::kNormalString, src.UTF8Length); } case NPVariantType_Object: { NPObject* object = NPVARIANT_TO_OBJECT(*variant); if (V8NPObject* v8Object = npObjectToV8NPObject(object)) return v8::Local<v8::Object>::New(isolate, v8Object->v8Object); return createV8ObjectForNPObject(object, owner, isolate); } default: return v8::Undefined(isolate); } }
JSValue convertNPVariantToValue(ExecState* exec, const NPVariant* variant, RootObject* rootObject) { JSLockHolder lock(exec); NPVariantType type = variant->type; if (type == NPVariantType_Bool) return jsBoolean(NPVARIANT_TO_BOOLEAN(*variant)); if (type == NPVariantType_Null) return jsNull(); if (type == NPVariantType_Void) return jsUndefined(); if (type == NPVariantType_Int32) return jsNumber(NPVARIANT_TO_INT32(*variant)); if (type == NPVariantType_Double) return jsNumber(NPVARIANT_TO_DOUBLE(*variant)); if (type == NPVariantType_String) return WebCore::jsString(exec, convertNPStringToUTF16(&variant->value.stringValue)); if (type == NPVariantType_Object) { NPObject* obj = variant->value.objectValue; if (obj->_class == NPScriptObjectClass) // Get JSObject from NP_JavaScriptObject. return ((JavaScriptObject*)obj)->imp; // Wrap NPObject in a CInstance. return CInstance::create(obj, rootObject)->createRuntimeObject(exec); } return jsUndefined(); }
void ShockerScriptableControlObject::SendKeyInput (const NPVariant *args, uint32_t arg_count, NPVariant *result) { g_assert (arg_count >= 4); g_assert (NPVARIANT_IS_NUMBER (args [0])); g_assert (NPVARIANT_IS_BOOLEAN (args [1])); g_assert (NPVARIANT_IS_BOOLEAN (args [2])); g_assert (NPVARIANT_IS_BOOLEAN (args [3])); LOG_PLUGIN ("[%i shocker] ShockerScriptableControlObject::SendKeyInput (key_code: %i, key_down: %i extended: %i, unicode: %i)\n", getpid (), NUMBER_TO_INT32 (args [0]), NPVARIANT_TO_BOOLEAN (args [1]), NPVARIANT_TO_BOOLEAN (args [2]), NPVARIANT_TO_BOOLEAN (args [3])); GetInputProvider ()->SendKeyInput (NUMBER_TO_INT32 (args [0]), NPVARIANT_TO_BOOLEAN (args [1]), NPVARIANT_TO_BOOLEAN (args [2]), NPVARIANT_TO_BOOLEAN (args [3])); BOOLEAN_TO_NPVARIANT (true, *result); }
bool PluginMethodListenOnFile::ExecuteListenOnFile( const NPVariant *args, uint32_t argCount, NPVariant *result) { std::string filename; bool skip_to_end = false; try { if (argCount < 3 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_BOOLEAN(args[1]) || !NPVARIANT_IS_OBJECT(args[2])) { NPN_SetException( object_, "invalid or missing params passed to function - expecting 3 params: " "filename, skipToEnd, callback(status, data)"); return false; } callback_ = NPVARIANT_TO_OBJECT(args[2]); skip_to_end = NPVARIANT_TO_BOOLEAN(args[1]); // add ref count to callback object so it won't delete NPN_RetainObject(callback_); filename.append( NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length); } catch(...) { } if (nullptr == thread_.get()) { thread_.reset(new utils::Thread); if (!thread_->Start()) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't start file listening thread"); return false; } } std::wstring wide_filename = utils::Encoders::utf8_decode(filename); if (!file_stream_.Initialize(wide_filename.c_str(), this, skip_to_end)) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't open the file for read access"); return false; } return thread_->PostTask( std::bind( &PluginMethodListenOnFile::StartListening, this)); }
static bool pluginSetProperty(NPObject* obj, NPIdentifier name, const NPVariant* variant) { PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { plugin->eventLogging = NPVARIANT_TO_BOOLEAN(*variant); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { plugin->logDestroy = NPVARIANT_TO_BOOLEAN(*variant); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) { plugin->returnErrorFromNewStream = NPVARIANT_TO_BOOLEAN(*variant); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) { browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS"); return true; } return false; }
RuntimeNPObject::InvokeResult LibvlcAudioNPObject::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); switch( index ) { case ID_audio_mute: if( NPVARIANT_IS_BOOLEAN(value) ) { libvlc_audio_set_mute(p_plugin->getVLC(), NPVARIANT_TO_BOOLEAN(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; case ID_audio_volume: if( isNumberValue(value) ) { libvlc_audio_set_volume(p_plugin->getVLC(), numberValue(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; case ID_audio_track: if( isNumberValue(value) ) { libvlc_media_player_t *p_md = p_plugin->getMD(&ex); RETURN_ON_EXCEPTION(this,ex); libvlc_audio_set_track(p_md, numberValue(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; case ID_audio_channel: if( isNumberValue(value) ) { libvlc_audio_set_channel(p_plugin->getVLC(), numberValue(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; default: ; } } return INVOKERESULT_GENERIC_ERROR; }
void ShockerScriptableControlObject::CompareImages (const NPVariant *args, uint32_t arg_count, NPVariant *result) { guint8 res = false; g_assert (arg_count >= 5); g_assert (NPVARIANT_IS_STRING (args [0])); g_assert (NPVARIANT_IS_STRING (args [1])); g_assert (NPVARIANT_IS_NUMBER (args [2])); g_assert (NPVARIANT_IS_STRING (args [3])); g_assert (NPVARIANT_IS_BOOLEAN (args [4])); LOG_PLUGIN ("[%i shocker] ShockerScriptableControlObject::CompareImages (imageFile1: '%s', imageFile2: '%s', tolerance: %i, diffFileName: '%s', copySourceFiles: %i)\n", getpid (), STR_FROM_VARIANT (args [0]), STR_FROM_VARIANT (args [1]), NUMBER_TO_INT32 (args [2]), STR_FROM_VARIANT (args [3]), NPVARIANT_TO_BOOLEAN (args [4])); ::CompareImages (STR_FROM_VARIANT (args [0]), STR_FROM_VARIANT (args [1]), NUMBER_TO_INT32 (args [2]), STR_FROM_VARIANT (args [3]), NPVARIANT_TO_BOOLEAN (args [4]), &res); BOOLEAN_TO_NPVARIANT ((bool) res, *result); }
static void topmost_rect_ptac(void *param) { struct topmost_rect_param_s *p = param; struct pp_instance_s *pp_i = tables_get_pp_instance(p->instance); if (!pp_i) { trace_error("%s, no instance\n", __func__); goto err_1; } p->result = PP_FALSE; NPString topmost_func_src = NPString_literal( "(function(elem, x, y) {" "var r = elem.getBoundingClientRect();" "return document.elementFromPoint(x + r.left, y + r.top) == elem;" "})"); NPVariant topmost_func; if (!npn.evaluate(pp_i->npp, pp_i->np_window_obj, &topmost_func_src, &topmost_func)) goto err_1; if (!NPVARIANT_IS_OBJECT(topmost_func)) goto err_1; NPObject *topmost_func_obj = NPVARIANT_TO_OBJECT(topmost_func); NPVariant is_topmost; NPVariant args[3]; OBJECT_TO_NPVARIANT(pp_i->np_plugin_element_obj, args[0]); INT32_TO_NPVARIANT(p->rect.point.x + p->rect.size.width / 2, args[1]); INT32_TO_NPVARIANT(p->rect.point.y + p->rect.size.height / 2, args[2]); if (!npn.invokeDefault(pp_i->npp, topmost_func_obj, args, 3, &is_topmost)) goto err_2; if (!NPVARIANT_IS_BOOLEAN(is_topmost)) goto err_3; p->result = NPVARIANT_TO_BOOLEAN(is_topmost); err_3: npn.releasevariantvalue(&is_topmost); err_2: npn.releasevariantvalue(&topmost_func); err_1: ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth); }
Any convertToAny(NPP npp, const NPVariant* variant) { switch (variant->type) { case NPVariantType_Void: case NPVariantType_Null: return Any(); break; case NPVariantType_Bool: return NPVARIANT_TO_BOOLEAN(*variant); break; case NPVariantType_Int32: return NPVARIANT_TO_INT32(*variant); break; case NPVariantType_Double: return NPVARIANT_TO_DOUBLE(*variant); break; case NPVariantType_String: return std::string(NPVARIANT_TO_STRING(*variant).utf8characters, NPVARIANT_TO_STRING(*variant).utf8length); break; case NPVariantType_Object: { NPObject* object = NPVARIANT_TO_OBJECT(*variant); if (!object) { break; } if (StubObject::isStub(object)) { StubObject* stub = static_cast<StubObject*>(object); return stub->getObject(); } PluginInstance* instance = static_cast<PluginInstance*>(npp->pdata); if (instance) { ProxyControl* proxyControl = instance->getProxyControl(); if (proxyControl) { return proxyControl->createProxy(object); } } break; } default: break; } return Any(); }
static bool plugin_object_invoke (NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argc, NPVariant *result) { PluginObject *obj; g_return_val_if_fail (plugin_object_has_method (npobj, name), FALSE); g_debug ("invoking plugin object method"); obj = (PluginObject*) npobj; VOID_TO_NPVARIANT (*result); if (name == list_extensions_id) return plugin_list_extensions (obj, result); else if (name == get_metadata_id) { g_return_val_if_fail (argc >= 1, FALSE); g_return_val_if_fail (NPVARIANT_IS_STRING(args[0]), FALSE); return plugin_get_metadata (obj, NPVARIANT_TO_STRING(args[0]), result); } else if (name == enable_extension_id) { g_return_val_if_fail (argc >= 2, FALSE); g_return_val_if_fail (NPVARIANT_IS_STRING(args[0]), FALSE); g_return_val_if_fail (NPVARIANT_IS_BOOLEAN(args[1]), FALSE); return plugin_enable_extension (obj, NPVARIANT_TO_STRING(args[0]), NPVARIANT_TO_BOOLEAN(args[1])); } else if (name == install_extension_id) { g_return_val_if_fail (argc >= 1, FALSE); g_return_val_if_fail (NPVARIANT_IS_STRING(args[0]), FALSE); return plugin_install_extension (obj, NPVARIANT_TO_STRING(args[0])); } return TRUE; }
// IsPlaying() // // Sends this: // <invoke name="IsPlaying" returntype="xml"> // <arguments></arguments> // </invoke> // // Receives something like this: // </true/> bool IsPlaying (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("IsPlaying", 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 if the movie is playing, 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_TO_BOOLEAN(value.get()) == true) { BOOLEAN_TO_NPVARIANT(true, *result); } else { BOOLEAN_TO_NPVARIANT(false, *result); } return true; } BOOLEAN_TO_NPVARIANT(false, *result); return false; }
static Eina_Bool ewk_js_npvariant_to_variant(Ewk_JS_Variant* data, const NPVariant* result) { EINA_SAFETY_ON_NULL_RETURN_VAL(data, false); EINA_SAFETY_ON_NULL_RETURN_VAL(result, false); switch (result->type) { case NPVariantType_Void: data->type = EWK_JS_VARIANT_VOID; data->value.o = 0; break; case NPVariantType_Null: data->type = EWK_JS_VARIANT_NULL; data->value.o = 0; break; case NPVariantType_Int32: data->type = EWK_JS_VARIANT_INT32; data->value.i = NPVARIANT_TO_INT32(*result); break; case NPVariantType_Double: data->type = EWK_JS_VARIANT_DOUBLE; data->value.d = NPVARIANT_TO_DOUBLE(*result); break; case NPVariantType_String: data->value.s = eina_stringshare_add_length(NPVARIANT_TO_STRING(*result).UTF8Characters, NPVARIANT_TO_STRING(*result).UTF8Length); data->type = EWK_JS_VARIANT_STRING; break; case NPVariantType_Bool: data->type = EWK_JS_VARIANT_BOOL; data->value.b = NPVARIANT_TO_BOOLEAN(*result); break; case NPVariantType_Object: data->type = EWK_JS_VARIANT_OBJECT; data->value.o = ewk_js_npobject_to_object(NPVARIANT_TO_OBJECT(*result)); break; default: 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; }
JSValue *convertNPVariantToValue(ExecState*, const NPVariant* variant, RootObject* rootObject) { JSLock lock; NPVariantType type = variant->type; if (type == NPVariantType_Bool) return jsBoolean(NPVARIANT_TO_BOOLEAN(*variant)); if (type == NPVariantType_Null) return jsNull(); if (type == NPVariantType_Void) return jsUndefined(); if (type == NPVariantType_Int32) return jsNumber(NPVARIANT_TO_INT32(*variant)); if (type == NPVariantType_Double) return jsNumber(NPVARIANT_TO_DOUBLE(*variant)); if (type == NPVariantType_String) { NPUTF16 *stringValue; unsigned int UTF16Length; convertNPStringToUTF16(&variant->value.stringValue, &stringValue, &UTF16Length); // requires free() of returned memory UString resultString((const UChar *)stringValue,UTF16Length); free(stringValue); return jsString(resultString); } if (type == NPVariantType_Object) { NPObject *obj = variant->value.objectValue; if (obj->_class == NPScriptObjectClass) // Get JSObject from NP_JavaScriptObject. return ((JavaScriptObject *)obj)->imp; // Wrap NPObject in a CInstance. return Instance::createRuntimeObject(Instance::CLanguage, obj, rootObject); } return jsUndefined(); }
// This function is equivalent to the following JavaScript function: // function FireEvent(strEventType, strDetail) { // FireIEContainer.dispatchEvent(strEventType, strDetail) // } // // Uses following JavaScript code to listen to the event fired: // pluginObject.addEventListener(strEventType, function(event) { // alert(event.detail); // } BOOL CPlugin::FireEvent(const CString &strEventType, const CString &strDetail) { // Fast event dispatching, requires helper function in container object try { // FireIEContainer.dispatchEvent(strEventType, strDetail); NPObject* pContainer = GetContainer(); NPVariant args[2]; STRINGZ_TO_NPVARIANT(CStringToNPStringCharacters(strEventType), args[0]); STRINGZ_TO_NPVARIANT(CStringToNPStringCharacters(strDetail), args[1]); NPVariant vSucceeded; VOID_TO_NPVARIANT(vSucceeded); BOOL bOK = NPN_Invoke(m_pNPInstance, pContainer, GetIdentifier("dispatchEvent"), args, 2, &vSucceeded); for (int i = 0; i < 2; i++) NPN_ReleaseVariantValue(&args[i]); if (!bOK || !NPVARIANT_IS_BOOLEAN(vSucceeded)) { NPN_ReleaseVariantValue(&vSucceeded); throw CString(_T("Cannot invoke dispatchEvent")); } bool bSucceeded = NPVARIANT_TO_BOOLEAN(vSucceeded); NPN_ReleaseVariantValue(&vSucceeded); if (!bSucceeded) throw CString(_T("Event dispatch failed")); return TRUE; } catch (const CString& strMessage) { UNUSED(strMessage); TRACE(_T("[CPlugin::FireEvent Exception] Fast event dispatching failed: %s\n"), strMessage); return FALSE; } }
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; }
jvalue convertNPVariantToJValue(NPVariant value, JNIType jniType, const char* javaClassName) { jvalue result; NPVariantType type = value.type; switch (jniType) { case array_type: case object_type: { result.l = static_cast<jobject>(0); // First see if we have a Java instance. if (type == NPVariantType_Object) { NPObject* objectImp = NPVARIANT_TO_OBJECT(value); if (JavaInstance* instance = ExtractJavaInstance(objectImp)) result.l = instance->javaInstance(); } // Now convert value to a string if the target type is a java.lang.string, and we're not // converting from a Null. if (!result.l && !strcmp(javaClassName, "java.lang.String")) { #ifdef CONVERT_NULL_TO_EMPTY_STRING if (type == NPVariantType_Null) { JNIEnv* env = getJNIEnv(); jchar buf[2]; jobject javaString = env->functions->NewString(env, buf, 0); result.l = javaString; } else #else if (type == NPVariantType_String) #endif { NPString src = NPVARIANT_TO_STRING(value); JNIEnv* env = getJNIEnv(); jobject javaString = env->NewStringUTF(src.UTF8Characters); result.l = javaString; } } else if (!result.l) memset(&result, 0, sizeof(jvalue)); // Handle it the same as a void case } break; case boolean_type: { if (type == NPVariantType_Bool) result.z = NPVARIANT_TO_BOOLEAN(value); else memset(&result, 0, sizeof(jvalue)); // as void case } break; case byte_type: { if (type == NPVariantType_Int32) result.b = static_cast<char>(NPVARIANT_TO_INT32(value)); else memset(&result, 0, sizeof(jvalue)); } break; case char_type: { if (type == NPVariantType_Int32) result.c = static_cast<char>(NPVARIANT_TO_INT32(value)); else memset(&result, 0, sizeof(jvalue)); } break; case short_type: { if (type == NPVariantType_Int32) result.s = static_cast<jshort>(NPVARIANT_TO_INT32(value)); else memset(&result, 0, sizeof(jvalue)); } break; case int_type: { if (type == NPVariantType_Int32) result.i = static_cast<jint>(NPVARIANT_TO_INT32(value)); else memset(&result, 0, sizeof(jvalue)); } break; case long_type: { if (type == NPVariantType_Int32) result.j = static_cast<jlong>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.j = static_cast<jlong>(NPVARIANT_TO_DOUBLE(value)); else memset(&result, 0, sizeof(jvalue)); } break; case float_type: { if (type == NPVariantType_Int32) result.f = static_cast<jfloat>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.f = static_cast<jfloat>(NPVARIANT_TO_DOUBLE(value)); else memset(&result, 0, sizeof(jvalue)); } break; case double_type: { if (type == NPVariantType_Int32) result.d = static_cast<jdouble>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.d = static_cast<jdouble>(NPVARIANT_TO_DOUBLE(value)); else memset(&result, 0, sizeof(jvalue)); } break; break; case invalid_type: default: case void_type: { memset(&result, 0, sizeof(jvalue)); } break; } return result; }
RuntimeNPObject::InvokeResult LibvlcVideoNPObject::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_video_fullscreen: { if( ! NPVARIANT_IS_BOOLEAN(value) ) { return INVOKERESULT_INVALID_VALUE; } int val = NPVARIANT_TO_BOOLEAN(value); p_plugin->set_fullscreen(val, &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } case ID_video_aspectratio: { char *psz_aspect = NULL; if( ! NPVARIANT_IS_STRING(value) ) { return INVOKERESULT_INVALID_VALUE; } psz_aspect = stringValue(NPVARIANT_TO_STRING(value)); if( !psz_aspect ) { return INVOKERESULT_GENERIC_ERROR; } libvlc_video_set_aspect_ratio(p_md, psz_aspect, &ex); free(psz_aspect); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } case ID_video_subtitle: { if( isNumberValue(value) ) { libvlc_video_set_spu(p_md, numberValue(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; } case ID_video_crop: { char *psz_geometry = NULL; if( ! NPVARIANT_IS_STRING(value) ) { return INVOKERESULT_INVALID_VALUE; } psz_geometry = stringValue(NPVARIANT_TO_STRING(value)); if( !psz_geometry ) { return INVOKERESULT_GENERIC_ERROR; } libvlc_video_set_crop_geometry(p_md, psz_geometry, &ex); free(psz_geometry); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } case ID_video_teletext: { if( isNumberValue(value) ) { libvlc_video_set_teletext(p_md, numberValue(value), &ex); RETURN_ON_EXCEPTION(this,ex); return INVOKERESULT_NO_ERROR; } return INVOKERESULT_INVALID_VALUE; } } } return INVOKERESULT_GENERIC_ERROR; }
// This function is equivalent to the following JavaScript function: // function FireEvent(strEventType, strDetail) { // var event = document.createEvent("CustomEvent"); // event.initCustomEvent(strEventType, true, true, strDetail); // pluginObject.dispatchEvent(event); // } // // Uses following JavaScript code to listen to the event fired: // pluginObject.addEventListener(strEventType, function(event) { // alert(event.detail); // } BOOL CPlugin::FireEvent(const CString &strEventType, const CString &strDetail) { BOOL bOK = FALSE; NPObject* pWindow = NULL; NPVariant vDocument; VOID_TO_NPVARIANT(vDocument); NPVariant vEvent; NPObject* pDocument = NULL; VOID_TO_NPVARIANT(vEvent); NPObject *pEvent = NULL; NPObject* pPlugin = NULL; try { // get window object if (NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &pWindow) != NPERR_NO_ERROR || pWindow == NULL) { throw CString(_T("Cannot get window")); } // get window.document bOK = NPN_GetProperty(m_pNPInstance, pWindow, NPN_GetStringIdentifier("document"), &vDocument); if (!NPVARIANT_IS_OBJECT(vDocument) || !bOK) { throw CString(_T("Cannot get window.document")); } pDocument = NPVARIANT_TO_OBJECT(vDocument); // var event = document.createEvent("CustomEvent"); if (pDocument) { NPVariant arg; STRINGZ_TO_NPVARIANT(CStringToNPStringCharacters(_T("CustomEvent")), arg); bOK = NPN_Invoke(m_pNPInstance, pDocument, NPN_GetStringIdentifier("createEvent"), &arg, 1, &vEvent); NPN_ReleaseVariantValue(&arg); if (!NPVARIANT_IS_OBJECT(vEvent) || !bOK) { throw CString(_T("Cannot document.createEvent")); } } else { throw CString(_T("window.document is null")); } pEvent = NPVARIANT_TO_OBJECT(vEvent);; // event.initCustomEvent(strEventType, true, true, strDetail); if (pEvent) { NPVariant args[4]; STRINGZ_TO_NPVARIANT(CStringToNPStringCharacters(strEventType), args[0]); BOOLEAN_TO_NPVARIANT(true, args[1]); BOOLEAN_TO_NPVARIANT(true, args[2]); STRINGZ_TO_NPVARIANT(CStringToNPStringCharacters(strDetail), args[3]); NPVariant vResult; bOK = NPN_Invoke(m_pNPInstance, pEvent, NPN_GetStringIdentifier("initCustomEvent"), args, 4, &vResult); for (int i=0; i<4; i++) { NPN_ReleaseVariantValue(&args[i]); } NPN_ReleaseVariantValue(&vResult); if (!bOK) { throw CString(_T("Cannot event.initCustomEvent")); } } else { throw CString(_T("event is null")); } // get plugin object if (NPN_GetValue(m_pNPInstance, NPNVPluginElementNPObject, &pPlugin) != NPERR_NO_ERROR || pPlugin == NULL) { throw CString(_T("Cannot get window")); } // pluginObject.dispatchEvent(event); NPVariant vNotCanceled; bOK = NPN_Invoke(m_pNPInstance, pPlugin, NPN_GetStringIdentifier("dispatchEvent"), &vEvent, 1, &vNotCanceled); NPN_ReleaseVariantValue(&vEvent); if (!bOK || !NPVARIANT_IS_BOOLEAN(vNotCanceled)) { throw CString(_T("Cannot dispatchEvent")); } if (NPVARIANT_TO_BOOLEAN(vNotCanceled) != true) { throw CString(_T("Event is canceled")); } } catch (CString strMessage) { TRACE(_T("[CPlugin::FireEvent Exception] %s"), strMessage); bOK = FALSE; } if (pPlugin != NULL) NPN_ReleaseObject(pPlugin); if (!NPVARIANT_IS_VOID(vEvent)) NPN_ReleaseVariantValue(&vEvent); if (!NPVARIANT_IS_VOID(vDocument)) NPN_ReleaseVariantValue(&vDocument); if (pWindow != NULL) NPN_ReleaseObject(pWindow); return bOK; }
// listenOnFile(id, filename, skipToEnd, callback(status, data) ) bool PluginMethodListenOnFile::ExecuteListenOnFile( const NPVariant *args, uint32_t argCount, NPVariant *result) { std::string id; std::string filename; bool skip_to_end = false; NPObject* callback = nullptr; try { if (argCount < 4 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_BOOLEAN(args[2]) || !NPVARIANT_IS_OBJECT(args[3])) { NPN_SetException( object_, "invalid or missing params passed to function - expecting 4 params: " "id, filename, skipToEnd, callback(id, status, data)"); return false; } callback = NPVARIANT_TO_OBJECT(args[3]); skip_to_end = NPVARIANT_TO_BOOLEAN(args[2]); // add ref count to callback object so it won't delete NPN_RetainObject(callback); id.append( NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length); filename.append( NPVARIANT_TO_STRING(args[1]).UTF8Characters, NPVARIANT_TO_STRING(args[1]).UTF8Length); } catch(...) { } TextFileThreadMap::iterator iter = threads_.find(id); if (iter != threads_.end()) { if (!iter->second.first->StopListening()) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't stop existing listener"); return false; } if (!iter->second.second->Stop()) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't stop existing listener thread"); return false; } } std::wstring wide_filename = utils::Encoders::utf8_decode(filename); threads_.insert( std::pair<std::string, TextFileThread>( id, TextFileThread(new utils::TxtFileStream, new utils::Thread))); if (!threads_[id].first->Initialize( id.c_str(), wide_filename.c_str(), this, skip_to_end)) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't open the file for read access"); return false; } if (!threads_[id].second->Start()) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't start file listening thread"); return false; } // set a callback TextFileIdToCallbackMap::iterator iter_callback = ids_to_callbacks_.find(id); if (iter_callback != ids_to_callbacks_.end()) { if (nullptr != ids_to_callbacks_[id]) { NPN_ReleaseObject(ids_to_callbacks_[id]); } } ids_to_callbacks_[id] = callback; char* id_to_pass = new char[id.size()+1]; strcpy(id_to_pass, id.c_str()); return threads_[id].second->PostTask( std::bind( &PluginMethodListenOnFile::StartListening, this, id_to_pass)); }
JavaValue convertNPVariantToJavaValue(NPVariant value, const String& javaClass) { CString javaClassName = javaClass.utf8(); JavaType javaType = javaTypeFromClassName(javaClassName.data()); JavaValue result; result.m_type = javaType; NPVariantType type = value.type; switch (javaType) { case JavaTypeArray: case JavaTypeObject: { // See if we have a Java instance. if (type == NPVariantType_Object) { NPObject* objectImp = NPVARIANT_TO_OBJECT(value); result.m_objectValue = ExtractJavaInstance(objectImp); } } break; case JavaTypeString: { #ifdef CONVERT_NULL_TO_EMPTY_STRING if (type == NPVariantType_Null) { result.m_type = JavaTypeString; result.m_stringValue = String::fromUTF8(""); } else #else if (type == NPVariantType_String) #endif { NPString src = NPVARIANT_TO_STRING(value); result.m_type = JavaTypeString; result.m_stringValue = String::fromUTF8(src.UTF8Characters); } } break; case JavaTypeBoolean: { if (type == NPVariantType_Bool) result.m_booleanValue = NPVARIANT_TO_BOOLEAN(value); } break; case JavaTypeByte: { if (type == NPVariantType_Int32) result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_DOUBLE(value)); } break; case JavaTypeChar: { if (type == NPVariantType_Int32) result.m_charValue = static_cast<unsigned short>(NPVARIANT_TO_INT32(value)); } break; case JavaTypeShort: { if (type == NPVariantType_Int32) result.m_shortValue = static_cast<short>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_shortValue = static_cast<short>(NPVARIANT_TO_DOUBLE(value)); } break; case JavaTypeInt: { if (type == NPVariantType_Int32) result.m_intValue = static_cast<int>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_intValue = static_cast<int>(NPVARIANT_TO_DOUBLE(value)); } break; case JavaTypeLong: { if (type == NPVariantType_Int32) result.m_longValue = static_cast<long long>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_longValue = static_cast<long long>(NPVARIANT_TO_DOUBLE(value)); } break; case JavaTypeFloat: { if (type == NPVariantType_Int32) result.m_floatValue = static_cast<float>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_floatValue = static_cast<float>(NPVARIANT_TO_DOUBLE(value)); } break; case JavaTypeDouble: { if (type == NPVariantType_Int32) result.m_doubleValue = static_cast<double>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) result.m_doubleValue = static_cast<double>(NPVARIANT_TO_DOUBLE(value)); } break; default: break; } return result; }
static bool plugin_object_invoke (NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argc, NPVariant *result) { PluginObject *obj; g_debug ("invoking plugin object method"); obj = (PluginObject*) npobj; VOID_TO_NPVARIANT (*result); if (!plugin_object_has_method (npobj, name)) return FALSE; if (name == list_extensions_id) return plugin_list_extensions (obj, result); else if (name == get_info_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; return plugin_get_info (obj, NPVARIANT_TO_STRING(args[0]), result); } else if (name == enable_extension_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; if (!NPVARIANT_IS_BOOLEAN(args[1])) return FALSE; return plugin_enable_extension (obj, NPVARIANT_TO_STRING(args[0]), NPVARIANT_TO_BOOLEAN(args[1])); } else if (name == install_extension_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; if (!NPVARIANT_IS_STRING(args[1])) return FALSE; return plugin_install_extension (obj, NPVARIANT_TO_STRING(args[0]), NPVARIANT_TO_STRING(args[1])); } else if (name == uninstall_extension_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; return plugin_uninstall_extension (obj, NPVARIANT_TO_STRING(args[0]), result); } else if (name == get_errors_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; return plugin_get_errors (obj, NPVARIANT_TO_STRING(args[0]), result); } else if (name == launch_extension_prefs_id) { if (!NPVARIANT_IS_STRING(args[0])) return FALSE; return plugin_launch_extension_prefs (obj, NPVARIANT_TO_STRING(args[0]), result); } return TRUE; }