bool ConstructablePluginObject::Construct(const NPVariant *args, uint32_t argCount, NPVariant *result) { printf("Creating new ConstructablePluginObject!\n"); NPObject *myobj = NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject)); if (!myobj) return false; OBJECT_TO_NPVARIANT(myobj, *result); return true; }
bool convert_mrb_to_js(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { switch(mrb_type(value)){ case MRB_TT_FALSE: if (mrb_nil_p(value)){ NULL_TO_NPVARIANT(*result); }else{ BOOLEAN_TO_NPVARIANT(false, *result); } return true; case MRB_TT_TRUE: BOOLEAN_TO_NPVARIANT(true, *result); return true; case MRB_TT_FIXNUM: INT32_TO_NPVARIANT(mrb_fixnum(value), *result); return true; case MRB_TT_FLOAT: DOUBLE_TO_NPVARIANT(mrb_float(value), *result); return true; case MRB_TT_ARRAY: return convert_mrb_to_js_array(mrb, value, npp, result); case MRB_TT_HASH: return convert_mrb_to_js_hash(mrb, value, npp, result); case MRB_TT_STRING: return convert_mrb_to_js_string(mrb, value, npp, result); case MRB_TT_DATA: return convert_mrb_to_js_data(mrb, value, npp, result); case MRB_TT_PROC: OBJECT_TO_NPVARIANT(MrbProcObject::Create(npp, mrb, value), *result); return true; default: OBJECT_TO_NPVARIANT(MrbJsObject::Create(npp, mrb, value), *result); return true; } return false; }
static bool plugin_object_get_property (NPObject *npobj, NPIdentifier name, NPVariant *result) { PluginObject *obj; g_return_val_if_fail (plugin_object_has_property (npobj, name), FALSE); obj = (PluginObject*) npobj; if (obj->listener) OBJECT_TO_NPVARIANT (obj->listener, *result); else NULL_TO_NPVARIANT (*result); return TRUE; }
static bool pluginGetProperty(NPObject* obj, NPIdentifier name, NPVariant* result) { PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) { STRINGZ_TO_NPVARIANT("property", *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { BOOLEAN_TO_NPVARIANT(plugin->eventLogging, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { BOOLEAN_TO_NPVARIANT(plugin->logDestroy, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_HAS_STREAM]) { BOOLEAN_TO_NPVARIANT(plugin->stream != 0, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT]) { NPObject* testObject = plugin->testObject; browser->retainobject(testObject); OBJECT_TO_NPVARIANT(testObject, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) { BOOLEAN_TO_NPVARIANT(plugin->returnErrorFromNewStream, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_PRIVATE_BROWSING_ENABLED]) { NPBool privateBrowsingEnabled = FALSE; browser->getvalue(plugin->npp, NPNVprivateModeBool, &privateBrowsingEnabled); BOOLEAN_TO_NPVARIANT(privateBrowsingEnabled, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_CACHED_PRIVATE_BROWSING_ENABLED]) { BOOLEAN_TO_NPVARIANT(plugin->cachedPrivateBrowsingMode, *result); return true; } else if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) { browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS"); return true; } else if (name == pluginPropertyIdentifiers[ID_LAST_SET_WINDOW_ARGUMENTS]) { char* buf = static_cast<char*>(browser->memalloc(256)); snprintf(buf, 256, "x: %d, y: %d, width: %u, height: %u, clipRect: (%u, %u, %u, %u)", (int)plugin->lastWindow.x, (int)plugin->lastWindow.y, (unsigned)plugin->lastWindow.width, (unsigned)plugin->lastWindow.height, plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.top, plugin->lastWindow.clipRect.right - plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.bottom - plugin->lastWindow.clipRect.top); STRINGZ_TO_NPVARIANT(buf, *result); return true; } 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; }
bool ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result) { VOID_TO_NPVARIANT(*result); 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; }
RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result) { /* is plugin still running */ if( isPluginRunning() ) { VlcPlugin* p_plugin = getPrivate<VlcPlugin>(); libvlc_exception_t ex; libvlc_exception_init(&ex); switch( index ) { case ID_playlist_itemcount: /* deprecated */ { int val = p_plugin->playlist_count(&ex); RETURN_ON_EXCEPTION(this,ex); INT32_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_playlist_isplaying: { int val = p_plugin->playlist_isplaying(&ex); RETURN_ON_EXCEPTION(this,ex); BOOLEAN_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_playlist_items: { // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! playlistItemsObj ) playlistItemsObj = NPN_CreateObject(_instance, RuntimeNPClass< LibvlcPlaylistItemsNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistItemsObj), result); return INVOKERESULT_NO_ERROR; } default: ; } } return INVOKERESULT_GENERIC_ERROR; }
// Provide the appropriate value to JS. bool BaseGetProperty(NPObject *obj, NPIdentifier name, NPVariant *result) { if (IS_IDENTIFIER("penAPI")) { // The main part of the API is defined in the PenAPIObject. // Retain and return this object. NPObject *penObj = g_api.penAPI; g_netscapeFuncs->retainobject(penObj); OBJECT_TO_NPVARIANT(penObj, *result); return true; } if (IS_IDENTIFIER("version")) { // Return the PLUGIN_VERSION. STRINGN_TO_NPVARIANT(strdup(PLUGIN_VERSION), sizeof(PLUGIN_VERSION), *result); return true; } return false; }
void ConvertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject *owner, NPVariant* result) { VOID_TO_NPVARIANT(*result); // It is really the caller's responsibility to deal with the empty handle // case because there could be different actions to take in different // contexts. ASSERT(!object.IsEmpty()); if (object.IsEmpty()) return; if (object->IsNumber()) { DOUBLE_TO_NPVARIANT(object->NumberValue(), *result); } else if (object->IsBoolean()) { BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result); } else if (object->IsNull()) { NULL_TO_NPVARIANT(*result); } else if (object->IsUndefined()) { VOID_TO_NPVARIANT(*result); } else if (object->IsString()) { v8::Handle<v8::String> str = object->ToString(); uint16_t *buf = new uint16_t[str->Length()+1]; str->Write(buf); std::string utf8 = WideToUTF8(reinterpret_cast<wchar_t*>(buf)); char* utf8_chars = strdup(utf8.c_str()); STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result); delete[] buf; } else if (object->IsObject()) { WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(); NPObject* npobject = NPN_CreateScriptObject( 0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) { _NPN_RegisterObject(npobject, owner); } OBJECT_TO_NPVARIANT(npobject, *result); } }
bool doGetCertificate(PluginInstance *obj, NPVariant *result) { LOG_LOCATION; FAIL_IF_NOT_ALLOWED_SITE; char selectedCertID[33]; int dlg_result = 0; #ifdef _WIN32 HWND ownerWindowHandle = (HWND)getNativeWindowHandle(obj); EstEID_log("owner window handle passed to DialogBoxParam() = %08X", ownerWindowHandle); dlg_result = (int)DialogBoxParam(pluginInstance, MAKEINTRESOURCE(IDD_CERTIFICATESELECTIONDLG), ownerWindowHandle, CertSelectionDialogProc, (LPARAM)selectedCertID); #else dlg_result = promptForCertificate(getNativeWindowHandle(obj), selectedCertID); #endif EstEID_log("Certificate selection dialog result = %i", dlg_result); EstEID_log("Selected certificate ID = %s", selectedCertID); if(dlg_result == IDCANCEL) { sprintf(EstEID_error, "User canceled"); EstEID_errorCode = ESTEID_USER_CANCEL; EstEID_log("EstEID_error = %s", EstEID_error); browserFunctions->setexception(&obj->header, EstEID_error); return false; } if(dlg_result == IDABORT) { sprintf(EstEID_error, "No certificates"); EstEID_errorCode = ESTEID_CERT_NOT_FOUND_ERROR; EstEID_log("EstEID_error = %s", EstEID_error); browserFunctions->setexception(&obj->header, EstEID_error); return false; } CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass()); certInstance->npp = obj->npp; certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCertById(selectedCertID)); // certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCert()); EstEID_log("certObject=%p", certInstance); OBJECT_TO_NPVARIANT((NPObject *)certInstance, *result); EstEID_log("result=%p", result); return true; }
bool ObjectManager::Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { ScriptManager *obj = static_cast<ScriptManager*>(npobj); if (name == NPNFuncs.getstringidentifier("CreateControlByProgId")) { if (argCount != 1 || !NPVARIANT_IS_STRING(args[0])) { NPNFuncs.setexception(npobj, "Invalid arguments"); return false; } CAxHost* host = new CAxHost(obj->instance); CStringA str(NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length); host->setClsIDFromProgID(str.GetString()); if (!host->CreateControl(false)) { NPNFuncs.setexception(npobj, "Error creating object"); return false; } ObjectManager *manager = static_cast<ObjectManager*>(obj->host); manager->dynamic_hosts.push_back(host); OBJECT_TO_NPVARIANT(host->CreateScriptableObject(), *result); return true; } return false; }
SEXP R_NP_GetGlobal(SEXP Rplug) { NPP inst = (NPP) R_ExternalPtrAddr(GET_SLOT( Rplug , Rf_install( "ref" ) ) ); NPNetscapeFuncs *funcs = (NPNetscapeFuncs *) R_ExternalPtrAddr(GET_SLOT( GET_SLOT(Rplug, Rf_install("funcs")), Rf_install("ref"))); NPObject *domwin = NULL; NPVariant *toret = (NPVariant *) funcs->memalloc(sizeof(NPVariant)); //NPVariant vartmp2; NPError res; bool success; res = funcs->getvalue(inst, NPNVWindowNPObject , &domwin); funcs->retainobject(domwin); OBJECT_TO_NPVARIANT(domwin, *toret); SEXP ans; PROTECT(ans = R_NilValue); ConvertNPToR(toret, inst, funcs, CONV_REF, &ans); UNPROTECT(1); return ans; }
void NPRuntimeObjectMap::convertJSValueToNPVariant(ExecState* exec, JSValue value, NPVariant& variant) { JSLockHolder lock(exec); VOID_TO_NPVARIANT(variant); if (value.isNull()) { NULL_TO_NPVARIANT(variant); return; } if (value.isUndefined()) { VOID_TO_NPVARIANT(variant); return; } if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), variant); return; } if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), variant); return; } if (value.isString()) { NPString npString = createNPString(value.toString(exec)->value(exec).utf8()); STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, variant); return; } if (value.isObject()) { NPObject* npObject = getOrCreateNPObject(exec->vm(), asObject(value)); OBJECT_TO_NPVARIANT(npObject, variant); return; } ASSERT_NOT_REACHED(); }
static mrb_value mrb_js_func_call(mrb_state *mrb, mrb_value self) { NPP npp = MRB_UD_NPP(mrb); NPObject *func = (NPObject *)DATA_PTR(self); if (!func){ return mrb_nil_value(); } mrb_value *values; int len; mrb_get_args(mrb, "*", &values, &len); NPVariant empty = { NPVariantType_Void, NULL }; std::vector< NPVariant > args(len + 1, empty); bool success = true; for (int i=0; i<len; i++){ if (!convert_mrb_to_js(mrb, values[i], npp, &args[i + 1])){ success = false; break; } } mrb_value ret = mrb_nil_value(); if (success){ NPObject *window; NPN_GetValue(npp, NPNVWindowNPObject, &window); NPVariant result; OBJECT_TO_NPVARIANT(window, args[0]); NPN_Invoke(npp, func, NPN_GetStringIdentifier("call"), &args[0], args.size(), &result); convert_js_to_mrb(npp, result, mrb, &ret); } for (int i=0; i<len+1; i++){ NPN_ReleaseVariantValue(&args[i]); } return ret; }
bool APPLICATION_GetProperty(NPObject* obj, NPIdentifier name, NPVariant* result) { TRACEINFO; bool fctresult = false; NPObj_Application* AppliObj = (NPObj_Application*)obj; if (name == v_APPLICATIONPropertyIdentifiers[kAPPLICATION_ID_PROPERTY_PRIVATEDATA]) { sBrowserFuncs->retainobject(AppliObj->privateData); OBJECT_TO_NPVARIANT(AppliObj->privateData, *result); fctresult = true; } else if (name == v_APPLICATIONPropertyIdentifiers[kAPPLICATION_ID_PROPERTY_VISIBLE]) { BOOLEAN_TO_NPVARIANT(AppliObj->visible, *result); fctresult = true; } else return fctresult; }
bool PluginControllerProxy::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups) { PluginDestructionProtector protector(this); NPVariant npObjectAsNPVariant; OBJECT_TO_NPVARIANT(npObject, npObjectAsNPVariant); // Send the NPObject over as an NPVariantData. NPVariantData npObjectAsNPVariantData = m_connection->npRemoteObjectMap()->npVariantToNPVariantData(npObjectAsNPVariant, m_plugin.get()); bool returnValue = false; NPVariantData resultData; if (!m_connection->connection()->sendSync(Messages::PluginProxy::Evaluate(npObjectAsNPVariantData, scriptString, allowPopups), Messages::PluginProxy::Evaluate::Reply(returnValue, resultData), m_pluginInstanceID)) return false; if (!returnValue) return false; *result = m_connection->npRemoteObjectMap()->npVariantDataToNPVariant(resultData, m_plugin.get()); return true; }
GenericNPObject::GenericNPObject(NPP instance, bool isMethodObj): invalid(false), defInvoker(NULL), defInvokerObject(NULL) { NPVariant val; INT32_TO_NPVARIANT(0, val); immutables["length"] = val; if (!isMethodObj) { NPObject *obj = NULL; obj = NPNFuncs.createobject(instance, &MethodNPObjectClass); if (NULL == obj) { throw NULL; } ((GenericNPObject *)obj)->SetDefaultInvoker(&toString, this); OBJECT_TO_NPVARIANT(obj, val); immutables["toString"] = val; } }
static Eina_Bool ewk_js_variant_to_npvariant(const Ewk_JS_Variant* data, NPVariant* result) { EINA_SAFETY_ON_NULL_RETURN_VAL(data, false); EINA_SAFETY_ON_NULL_RETURN_VAL(result, false); const char* string_value; switch (data->type) { case EWK_JS_VARIANT_VOID: VOID_TO_NPVARIANT(*result); break; case EWK_JS_VARIANT_NULL: NULL_TO_NPVARIANT(*result); break; case EWK_JS_VARIANT_INT32: INT32_TO_NPVARIANT(data->value.i, *result); break; case EWK_JS_VARIANT_DOUBLE: DOUBLE_TO_NPVARIANT(data->value.d, *result); break; case EWK_JS_VARIANT_STRING: string_value = eina_stringshare_add(data->value.s); if (string_value) STRINGZ_TO_NPVARIANT(string_value, *result); else return false; break; case EWK_JS_VARIANT_BOOL: BOOLEAN_TO_NPVARIANT(data->value.b, *result); break; case EWK_JS_VARIANT_OBJECT: OBJECT_TO_NPVARIANT(reinterpret_cast<NPObject*>(data->value.o), *result); break; default: return false; } return true; }
void testNPRuntime(NPP npp) { NPObject* windowScriptObject; browser->getvalue(npp, NPNVWindowNPObject, &windowScriptObject); // Invoke NPIdentifier testNPInvoke = browser->getstringidentifier("testNPInvoke"); NPVariant args[7]; VOID_TO_NPVARIANT(args[0]); NULL_TO_NPVARIANT(args[1]); BOOLEAN_TO_NPVARIANT(true, args[2]); INT32_TO_NPVARIANT(242, args[3]); DOUBLE_TO_NPVARIANT(242.242, args[4]); STRINGZ_TO_NPVARIANT("Hello, World", args[5]); OBJECT_TO_NPVARIANT(windowScriptObject, args[6]); NPVariant result; if (browser->invoke(npp, windowScriptObject, testNPInvoke, args, 7, &result)) browser->releasevariantvalue(&result); browser->releaseobject(windowScriptObject); }
bool NPSafeArray::InvokeDefault(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) { NPSafeArray *safe = static_cast<NPSafeArray*>(npobj); if (safe->arr_.m_psa != NULL) return false; if (argCount < 1) return false; if (!NPVARIANT_IS_OBJECT(*args)) { return false; } NPObject *obj = NPVARIANT_TO_OBJECT(*args); if (obj->_class != &NPSafeArray::npClass) { return false; } NPSafeArray *safe_original = static_cast<NPSafeArray*>(obj); if (safe_original->arr_.m_psa == NULL) { return false; } NPSafeArray *ret = CreateFromArray(safe->instance, safe_original->arr_); OBJECT_TO_NPVARIANT(ret, *result); return true; }
static bool invokeMethod(NPObject *obj, NPIdentifier identifier, const NPVariant *args, uint32_t argc, NPVariant *result) { char *argv[20]; int i; char *ptr; if (identifier == identifiers->start) { DEBUG_STR("plugin->whois->invokeMethod(%s): true", DEBUG_IDENTIFIER(identifier)); /* Just the URL argument can be passed from JavaScript */ if (argc != 1 || args[0].type != NPVariantType_String) return false; /* First argument should be command path/name */ i = 0; argv[i++] = ((shell_module *)whois)->path; /* Set the URL as the last argument */ argv[i++] = (char *)STRING_UTF8CHARACTERS(args[0].value.stringValue); /* Set NULL-terminating argument */ argv[i++] = NULL; OBJECT_TO_NPVARIANT(browser->createobject(((object *)obj)->instance, &processClass), *result); if (shell->run((process *)result->value.objectValue, ((shell_module *)whois)->path, argv)) return true; else return false; } DEBUG_STR("plugin->whois->invokeMethod(%s): false", DEBUG_IDENTIFIER(identifier)); return false; }
CPlugin::CPlugin(NPP pNPInstance) : m_pNPInstance(pNPInstance), m_pNPStream(NULL), m_bInitialized(FALSE), m_pScriptableObject(NULL) { NPVariant v; NPVariant rval; NPObject *browserWndObj = NULL; #ifdef XP_WIN m_hWnd = NULL; #endif // setup the display string const char *ua = NPN_UserAgent(m_pNPInstance); strcpy(m_String, ua); if ( NPERR_NO_ERROR == NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &browserWndObj)) { // this is interesting. // Here we are setting up an instance in JavaScript of the ScriptablePluginObject // by inserting a new instance into the DOM. this will be referenced by document.pluginobj; // NPObject *myobj = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); if ( myobj ) { // create an identifier for the plugin object NPIdentifier n = NPN_GetStringIdentifier("pluginobj"); // now insert into the DOM OBJECT_TO_NPVARIANT(myobj, v); if (NPN_SetProperty(m_pNPInstance, browserWndObj, n, &v)) { // validate the object if ( NPN_GetProperty(m_pNPInstance, browserWndObj, n, &rval) ) { printf ("Object set/get test "); if (NPVARIANT_IS_OBJECT(rval) && NPVARIANT_TO_OBJECT(rval) == myobj) { printf ("succeeded!\n"); } else { printf ("FAILED!\n"); } } else { printf("failed to get pluginobj"); } NPN_ReleaseVariantValue(&rval); } else { printf("failed to set pluginobj"); } NPN_ReleaseObject(myobj); } else { printf("failed to create pluginobj"); } } else { printf("failed to get browser window"); } }
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; }
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); }
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"); sendCmd_id = NPN_GetStringIdentifier("sendCmd"); NPVariant v; INT32_TO_NPVARIANT(46, v); NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v); n = NPN_GetStringIdentifier("document"); NPVariant arg; OBJECT_TO_NPVARIANT(sWindowObj, arg); NPObject *myobj = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); n = NPN_GetStringIdentifier("objJSExt"); OBJECT_TO_NPVARIANT(myobj, v); NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v); NPN_ReleaseObject(myobj); const char *ua = NPN_UserAgent(m_pNPInstance); strcpy(m_String, ua); // Create a "location" identifier. NPIdentifier identifier = NPN_GetStringIdentifier( "location" ); // Declare a local variant value. NPVariant variantValue; // Get the location property from the window object (which is another object). bool b1 = NPN_GetProperty( m_pNPInstance, sWindowObj, identifier, &variantValue ); // Get a pointer to the "location" object. NPObject *locationObj = variantValue.value.objectValue; // Create a "href" identifier. identifier = NPN_GetStringIdentifier( "href" ); // Get the location property from the location object. bool b2 = NPN_GetProperty( m_pNPInstance, locationObj, identifier, &variantValue ); g_strPageURL = ""; NPString npStr = NPVARIANT_TO_STRING( variantValue ); for (unsigned int i=0; i<npStr.utf8length; i++) { g_strPageURL += npStr.utf8characters[ i ]; } NPN_ReleaseObject(locationObj); }
void convertJValueToNPVariant(jvalue value, JNIType jniType, const char* javaTypeName, NPVariant* result) { switch (jniType) { case void_type: { VOID_TO_NPVARIANT(*result); } break; case object_type: { if (value.l) { if (!strcmp(javaTypeName, "java.lang.String")) { const char* v = getCharactersFromJString(static_cast<jstring>(value.l)); // s is freed in NPN_ReleaseVariantValue (see npruntime.cpp) const char* s = strdup(v); releaseCharactersForJString(static_cast<jstring>(value.l), v); STRINGZ_TO_NPVARIANT(s, *result); } else OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(new JavaInstance(value.l)), *result); } else VOID_TO_NPVARIANT(*result); } break; case boolean_type: { BOOLEAN_TO_NPVARIANT(value.z, *result); } break; case byte_type: { INT32_TO_NPVARIANT(value.b, *result); } break; case char_type: { INT32_TO_NPVARIANT(value.c, *result); } break; case short_type: { INT32_TO_NPVARIANT(value.s, *result); } break; case int_type: { INT32_TO_NPVARIANT(value.i, *result); } break; // TODO: Check if cast to double is needed. case long_type: { DOUBLE_TO_NPVARIANT(value.j, *result); } break; case float_type: { DOUBLE_TO_NPVARIANT(value.f, *result); } break; case double_type: { DOUBLE_TO_NPVARIANT(value.d, *result); } break; case invalid_type: default: { VOID_TO_NPVARIANT(*result); } break; } }
static bool pluginInvoke(NPObject* header, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result) { PluginObject* plugin = reinterpret_cast<PluginObject*>(header); if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) return testCallback(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RETURN]) return testCallbackReturn(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) return getURL(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) return testDOMAccess(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY]) return getURLNotify(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT]) return testInvokeDefault(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE]) return testEnumerate(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM]) return destroyStream(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER]) return testGetIntIdentifier(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE]) return testEvaluate(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY]) return testGetProperty(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE]) return testGetPropertyReturnValue(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_HAS_PROPERTY]) return testHasProperty(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_HAS_METHOD]) return testHasMethod(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_STRING]) return testIdentifierToString(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_INT]) return testIdentifierToInt(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT]) return testPassTestObject(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_POSTURL_FILE]) return testPostURLFile(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_CONSTRUCT]) return testConstruct(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE]) return testScriptObjectInvoke(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_THROW_EXCEPTION_METHOD]) { browser->setexception(header, "plugin object testThrowException SUCCESS"); return true; } if (name == pluginMethodIdentifiers[ID_TEST_FAIL_METHOD]) { NPObject* windowScriptObject; browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject); browser->invoke(plugin->npp, windowScriptObject, name, args, argCount, result); return false; } if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) { NPObject* new_object = browser->createobject(plugin->npp, &pluginClass); assert(new_object->referenceCount == 1); OBJECT_TO_NPVARIANT(new_object, *result); return true; } if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) { NPObject* testObject = browser->createobject(plugin->npp, getTestClass()); assert(testObject->referenceCount == 1); OBJECT_TO_NPVARIANT(testObject, *result); return true; } if (name == pluginMethodIdentifiers[ID_DESTROY_NULL_STREAM]) return destroyNullStream(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_NO_PAGES]) { browser->reloadplugins(false); return true; } if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_AND_PAGES]) { browser->reloadplugins(true); return true; } if (name == pluginMethodIdentifiers[ID_TEST_GET_BROWSER_PROPERTY]) { browser->getproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), result); return true; } if (name == pluginMethodIdentifiers[ID_TEST_SET_BROWSER_PROPERTY]) { browser->setproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), &args[2]); return true; } if (name == pluginMethodIdentifiers[ID_REMEMBER]) { if (plugin->rememberedObject) browser->releaseobject(plugin->rememberedObject); plugin->rememberedObject = NPVARIANT_TO_OBJECT(args[0]); browser->retainobject(plugin->rememberedObject); VOID_TO_NPVARIANT(*result); return true; } if (name == pluginMethodIdentifiers[ID_GET_REMEMBERED_OBJECT]) { assert(plugin->rememberedObject); browser->retainobject(plugin->rememberedObject); OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result); return true; } if (name == pluginMethodIdentifiers[ID_GET_AND_FORGET_REMEMBERED_OBJECT]) { assert(plugin->rememberedObject); OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result); plugin->rememberedObject = 0; return true; } if (name == pluginMethodIdentifiers[ID_REF_COUNT]) { uint32_t refCount = NPVARIANT_TO_OBJECT(args[0])->referenceCount; INT32_TO_NPVARIANT(refCount, *result); return true; } if (name == pluginMethodIdentifiers[ID_SET_STATUS]) return testSetStatus(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_RESIZE_TO]) return testResizeTo(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_NORMALIZE]) return normalizeOverride(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_INVALIDATE_RECT]) return invalidateRect(plugin, args, argCount, result); if (name == pluginMethodIdentifiers[ID_OBJECTS_ARE_SAME]) return objectsAreSame(plugin, args, argCount, result); return false; }
/** implementation **/ void OAM_ObjectMain_Invoke_GetOwnerApplication(NPObj_OAM* obj,const NPVariant* args, uint32_t argCount, NPVariant* result) { TRACEINFO; sBrowserFuncs->retainobject(obj->ownerApplication); OBJECT_TO_NPVARIANT((NPObject*)(obj->ownerApplication), *result); }
void convertJavaValueToNPVariant(JavaValue value, NPVariant* result) { switch (value.m_type) { case JavaTypeVoid: { VOID_TO_NPVARIANT(*result); } break; case JavaTypeObject: { // If the JavaValue is a String object, it should have type JavaTypeString. if (value.m_objectValue) OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(value.m_objectValue.get()), *result); else VOID_TO_NPVARIANT(*result); } break; case JavaTypeString: { const char* utf8String = strdup(value.m_stringValue.utf8().data()); // The copied string is freed in NPN_ReleaseVariantValue (see npruntime.cpp) STRINGZ_TO_NPVARIANT(utf8String, *result); } break; case JavaTypeBoolean: { BOOLEAN_TO_NPVARIANT(value.m_booleanValue, *result); } break; case JavaTypeByte: { INT32_TO_NPVARIANT(value.m_byteValue, *result); } break; case JavaTypeChar: { INT32_TO_NPVARIANT(value.m_charValue, *result); } break; case JavaTypeShort: { INT32_TO_NPVARIANT(value.m_shortValue, *result); } break; case JavaTypeInt: { INT32_TO_NPVARIANT(value.m_intValue, *result); } break; // TODO: Check if cast to double is needed. case JavaTypeLong: { DOUBLE_TO_NPVARIANT(value.m_longValue, *result); } break; case JavaTypeFloat: { DOUBLE_TO_NPVARIANT(value.m_floatValue, *result); } break; case JavaTypeDouble: { DOUBLE_TO_NPVARIANT(value.m_doubleValue, *result); } break; case JavaTypeInvalid: default: { VOID_TO_NPVARIANT(*result); } break; } }