void TCPWrap::init(uv_tcp_t* stream) { bind_func = NPN_GetStringIdentifier("bind"); listen_func = NPN_GetStringIdentifier("listen"); readstart_func = NPN_GetStringIdentifier("readStart"); readstop_func = NPN_GetStringIdentifier("readStop"); write_func = NPN_GetStringIdentifier("write"); close_func = NPN_GetStringIdentifier("close"); connect_func = NPN_GetStringIdentifier("connect"); onconnection_cb = NPN_GetStringIdentifier("onconnection"); onread_cb = NPN_GetStringIdentifier("onread"); socket_prop = NPN_GetStringIdentifier("socket"); uv_tcp_init(uv_default_loop(), stream); onconnection_callback = new NPObject(); onread_callback = new NPObject(); socket_pointer = new NPObject(); this->stream = stream; this->stream->data = (void *)this; }
bool convert_mrb_to_js_array(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { NPObject *window; NPN_GetValue(npp, NPNVWindowNPObject, &window); NPVariant array; NPN_Invoke(npp, window, NPN_GetStringIdentifier("Array"), NULL, 0, &array); NPN_ReleaseObject(window); NPIdentifier push = NPN_GetStringIdentifier("push"); mrb_value *ptr = RARRAY_PTR(value); for (int i=0, len=RARRAY_LEN(value); i<len; i++){ NPVariant var; if (!convert_mrb_to_js(mrb, ptr[i], npp, &var)){ NPN_ReleaseVariantValue(&array); return false; } NPVariant ret; NPN_Invoke(npp, NPVARIANT_TO_OBJECT(array), push, &var, 1, &ret); NPN_ReleaseVariantValue(&ret); } *result = array; return true; }
ParserWrap::ParserWrap(NPP instance): ScriptableObject(instance) { execute_func = NPN_GetStringIdentifier("execute"); reinitialise_func = NPN_GetStringIdentifier("reinitialize"); onmessagebegin_func = NPN_GetStringIdentifier("onMessageBegin"); onurl_func = NPN_GetStringIdentifier("onURL"); onheaderfield_func = NPN_GetStringIdentifier("onHeaderField"); onheadervalue_func = NPN_GetStringIdentifier("onHeaderValue"); onheaderscomplete_func = NPN_GetStringIdentifier("onHeadersComplete"); onbody_func = NPN_GetStringIdentifier("onBody"); onmessagecomplete_func = NPN_GetStringIdentifier("onMessageComplete"); createinfo_prop = NPN_GetStringIdentifier("createInfo"); onmessagebegin_callback = new NPObject; onurl_callback = new NPObject; onheaderfield_callback = new NPObject; onheadervalue_callback = new NPObject; onheaderscomplete_callback = new NPObject; onbody_callback = new NPObject; onmessagecomplete_callback = new NPObject; create_info = new NPObject; parser = new http_parser; parser->data = this; }
bool convert_js_to_mrb_array(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result) { NPVariant length; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier("length"), &length); int len; if (NPVARIANT_IS_INT32(length)){ len = NPVARIANT_TO_INT32(length); }else if (NPVARIANT_IS_DOUBLE(length)){ len = static_cast< int >(NPVARIANT_TO_DOUBLE(length)); // Why double?? }else{ NPN_ReleaseVariantValue(&length); return false; } NPN_ReleaseVariantValue(&length); mrb_value ret_array = mrb_ary_new_capa(mrb, len); for (int32_t i=0; i<len; i++){ NPVariant item; std::ostringstream oss; oss << i; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier(oss.str().c_str()), &item); mrb_value mrb_item; if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){ NPN_ReleaseVariantValue(&item); return false; } NPN_ReleaseVariantValue(&item); mrb_ary_push(mrb, ret_array, mrb_item); } *result = ret_array; return true; }
bool convert_mrb_to_js_hash(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { NPObject *window; NPN_GetValue(npp, NPNVWindowNPObject, &window); NPVariant hash; NPN_Invoke(npp, window, NPN_GetStringIdentifier("Object"), NULL, 0, &hash); NPN_ReleaseObject(window); khash_t(ht) *h = RHASH_TBL(value); if (!h){ *result = hash; return true; } NPObject *hash_obj = NPVARIANT_TO_OBJECT(hash); for (khiter_t k=kh_begin(h); k!=kh_end(h); k++){ if (kh_exist(h, k)) { mrb_value key = mrb_funcall(mrb, kh_key(h, k), "to_s", 0); mrb_value val = kh_value(h, k); NPVariant var; if (!convert_mrb_to_js(mrb, val, npp, &var)){ NPN_ReleaseVariantValue(&hash); return false; } std::string name(RSTRING_PTR(key), RSTRING_LEN(key)); NPN_SetProperty(npp, hash_obj, NPN_GetStringIdentifier(name.c_str()), &var); } } *result = hash; return true; }
// 清空IECtrl::Navigate的参数 void CPlugin::RemoveNavigateParams() { NPObject* pWindow = NULL; NPVariant vCOBAContainer; VOID_TO_NPVARIANT(vCOBAContainer); NPVariant vResult; VOID_TO_NPVARIANT(vResult); try { if ((NPN_GetValue( m_pNPInstance, NPNVWindowNPObject, &pWindow) != NPERR_NO_ERROR ) || !pWindow ) { throw(CString(_T("Cannot get window"))); } if ((!NPN_GetProperty( m_pNPInstance, pWindow, NPN_GetStringIdentifier ("COBAContainer"), &vCOBAContainer)) || !NPVARIANT_IS_OBJECT (vCOBAContainer)) { throw(CString(_T("Cannot get window.COBAContainer"))); } if (!NPN_Invoke(m_pNPInstance, NPVARIANT_TO_OBJECT(vCOBAContainer), NPN_GetStringIdentifier("removeNavigateParams"), NULL, 0, &vResult)) { throw(CString(_T("Cannot execute window.COBAContainer.removeNavigateParams()"))); } } catch (CString strMessage) { TRACE(_T("[CPlugin::RemoveNavigateParams Exception] %s"), strMessage); } if (!NPVARIANT_IS_VOID(vResult)) NPN_ReleaseVariantValue(&vResult); if (!NPVARIANT_IS_VOID(vCOBAContainer)) NPN_ReleaseVariantValue(&vCOBAContainer); if (pWindow != NULL) NPN_ReleaseObject(pWindow); }
std::string getInterfaceName(NPP npp, NPObject* object) { std::string className; NPVariant result; bool asConstructor = true; // true if object can be a constructor VOID_TO_NPVARIANT(result); NPN_Invoke(npp, object, NPN_GetStringIdentifier("toString"), 0, 0, &result); for (;;) { if (NPVARIANT_IS_STRING(result)) { className = std::string(NPVARIANT_TO_STRING(result).utf8characters, NPVARIANT_TO_STRING(result).utf8length); } NPN_ReleaseVariantValue(&result); if (className.compare(0, 9, "function ") == 0) { // In Chrome, a [Constructor] object is represented as a 'Function'. className = className.substr(9); size_t pos = className.find('('); if (pos != std::string::npos) { className = className.substr(0, pos); break; } return "Function"; } if (className.compare(0, 8, "[object ", 8) == 0 && className[className.length() - 1] == ']') { className = className.substr(8, className.length() - 9); break; } // This object is likely to have a stringifier. Check the constructor name directly. NPVariant constructor; VOID_TO_NPVARIANT(constructor); if (asConstructor && NPN_GetProperty(npp, object, NPN_GetStringIdentifier("constructor"), &constructor)) { if (NPVARIANT_IS_OBJECT(constructor) && NPN_Invoke(npp, NPVARIANT_TO_OBJECT(constructor), NPN_GetStringIdentifier("toString"), 0, 0, &result)) { NPN_ReleaseVariantValue(&constructor); asConstructor = false; continue; } NPN_ReleaseVariantValue(&constructor); } return "Object"; } // In Firefox, the constructor and an instance object cannot be distinguished by toString(). // Check if object has a 'prototype' to see if it is a constructor. if (asConstructor && NPN_HasProperty(npp, object, NPN_GetStringIdentifier("prototype"))) { className += "_Constructor"; } return className; }
bool ScriptablePluginObject::HasProperty(NPIdentifier name) { // method for Keyword value NPIdentifier keyword_id = NPN_GetStringIdentifier("keyword"); NPIdentifier code_id = NPN_GetStringIdentifier("code"); return ((name == keyword_id) || (name == code_id)); }
// 获取Plugin所在页面的URL CString CPlugin::GetHostURL() const { CString url; BOOL bOK = FALSE; NPObject* pWindow = NULL; NPVariant vLocation; VOID_TO_NPVARIANT(vLocation); NPVariant vHref; VOID_TO_NPVARIANT(vHref); try { if (( NPN_GetValue( m_pNPInstance, NPNVWindowNPObject, &pWindow) != NPERR_NO_ERROR ) || !pWindow ) { throw(CString(_T("Cannot get window"))); } if ((!NPN_GetProperty( m_pNPInstance, pWindow, NPN_GetStringIdentifier ("location"), &vLocation)) || !NPVARIANT_IS_OBJECT (vLocation)) { throw(CString(_T("Cannot get window.location"))); } if ((!NPN_GetProperty( m_pNPInstance, NPVARIANT_TO_OBJECT(vLocation), NPN_GetStringIdentifier ("href"), &vHref)) || !NPVARIANT_IS_STRING(vHref)) { throw(CString(_T("Cannot get window.location.href"))); } // 转换window.location.href的编码 int buffer_size = vHref.value.stringValue.UTF8Length + 1; char* szUnescaped = new char[buffer_size]; DWORD dwSize = buffer_size; if (SUCCEEDED(UrlUnescapeA(const_cast<LPSTR>(vHref.value.stringValue.UTF8Characters), szUnescaped, &dwSize, 0))) { WCHAR* szURL = new WCHAR[dwSize + 1]; if (MultiByteToWideChar(CP_UTF8, 0, szUnescaped, -1, szURL, dwSize + 1) > 0) { url = CW2T(szURL); } delete[] szURL; } delete[] szUnescaped; } catch (CString strMessage) { TRACE(_T("[CPlugin::GetHostURL Exception] %s"), strMessage); } if (!NPVARIANT_IS_VOID(vHref)) NPN_ReleaseVariantValue(&vHref); if (!NPVARIANT_IS_VOID(vLocation)) NPN_ReleaseVariantValue(&vLocation); if (pWindow != NULL) NPN_ReleaseObject(pWindow); return url; }
bool ScriptablePluginObject::HasMethod(NPIdentifier name) { // method for login.jsp test NPIdentifier doSignature_id = NPN_GetStringIdentifier("doSignature"); NPIdentifier getPublicKeyContent_id = NPN_GetStringIdentifier("getPublicKeyContent"); NPIdentifier test_id = NPN_GetStringIdentifier("test"); return ((name == doSignature_id) || (name == getPublicKeyContent_id) || (name==test_id)); }
// listenOnFile( filename, skipToEnd, callback(status, data) ) PluginMethodListenOnFile::PluginMethodListenOnFile(NPObject* object, NPP npp) : PluginMethod(object, npp) { id_listen_on_file_ = NPN_GetStringIdentifier(kListenOnFileMethodName); id_stop_file_listen_ = NPN_GetStringIdentifier(kStopFileListenMethodName); }
static void load_identifiers () { id_document = NPN_GetStringIdentifier ("document"); id_get_element_by_id = NPN_GetStringIdentifier ("getElementById"); id_create_element = NPN_GetStringIdentifier ("createElement"); id_create_text_node = NPN_GetStringIdentifier ("createTextNode"); id_append_child = NPN_GetStringIdentifier ("appendChild"); identifiers_loaded = TRUE; }
WriteReq::WriteReq(NPP npp) : ScriptableObject(npp) { write_req.data = this; oncomplete_func = NPN_GetStringIdentifier("oncomplete"); cb_func = NPN_GetStringIdentifier("cb"); oncomplete_callback = new NPObject(); cb_callback = new NPObject(); retainBuffer = false; }
int OnHeadersComplete(http_parser* parser) { ParserWrap* wrap = (ParserWrap*)parser->data; NPP npp = wrap->m_Instance; // this is a bit hacky // we have to create an empty javascript object // so we use a function we created and passed to // the plugin NPVariant info; wrap->apply(wrap->create_info,NULL,0,&info); NPVariant major; major.type = NPVariantType_Double; major.value.doubleValue = parser->http_major; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("versionMajor"),&major); NPVariant minor; minor.type = NPVariantType_Double; minor.value.doubleValue = parser->http_major; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("versionMinor"),&minor); /*NPVariant method; method.type = NPVariantType_String; NPString method_str = {(NPUTF8 *)parser->method,strlen((char*)parser->method)}; method.value.stringValue = method; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("method"),&method);*/ NPVariant status; status.type = NPVariantType_Double; status.value.doubleValue = parser->status_code; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("statusCode"),&status); NPVariant upgrade; upgrade.type = NPVariantType_Bool; upgrade.value.boolValue = parser->upgrade; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("upgrade"),&upgrade); NPVariant keepAlive; keepAlive.type = NPVariantType_Bool; keepAlive.value.boolValue = http_should_keep_alive(parser); NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("shouldKeepAlive"),&keepAlive); NPVariant* args = new NPVariant; args->type = NPVariantType_Object; args->value.objectValue = info.value.objectValue; NPN_RetainObject(info.value.objectValue); NPVariant result; wrap->apply(wrap->onheaderscomplete_callback,args,1,&result); return 0; }
static mrb_value mrb_js_obj_method_missing(mrb_state *mrb, mrb_value self) { NPP npp = MRB_UD_NPP(mrb); mrb_value name_sym, *args; int len; mrb_get_args(mrb, "o*", &name_sym, &args, &len); if (mrb_type(name_sym) != MRB_TT_SYMBOL){ return mrb_nil_value(); } bool success = true; NPVariant empty; NULL_TO_NPVARIANT(empty); std::vector< NPVariant > var_args(len, empty); for (int i=0; i<len; i++){ if (!convert_mrb_to_js(mrb, args[i], npp, &var_args[i])){ success = false; break; } } mrb_value ret = mrb_nil_value(); if (success){ int name_len; const char *name_char = mrb_sym2name_len(mrb, SYM2ID(name_sym), &name_len); std::string name(name_char, name_len); NPIdentifier name_id = NPN_GetStringIdentifier(name.c_str()); NPObject *obj = (NPObject *)DATA_PTR(self); if (NPN_HasMethod(npp, obj, name_id)){ NPVariant result; NPN_Invoke(npp, obj, name_id, &var_args[0], len, &result); convert_js_to_mrb(npp, result, mrb, &ret); }else if (NPN_HasProperty(npp, obj, name_id)){ NPVariant result; NPN_GetProperty(npp, obj, name_id, &result); convert_js_to_mrb(npp, result, mrb, &ret); }else if (name.size() > 1 && name[name.size() - 1] == '=' && var_args.size() == 1){ name.resize(name.size() - 1); name_id = NPN_GetStringIdentifier(name.c_str()); if (NPN_HasProperty(npp, obj, name_id)){ NPN_SetProperty(npp, obj, name_id, &var_args[0]); } } } for (int i=0; i<len; i++){ NPN_ReleaseVariantValue(&var_args[i]); } return ret; }
JsAgent::MethodIds::MethodIds() : onLoad(NPN_GetStringIdentifier("onLoad")) , onUnload(NPN_GetStringIdentifier("onUnload")) , toString(NPN_GetStringIdentifier("toString")) , defineFunction(NPN_GetStringIdentifier("defineFunction")) , invokeFunction(NPN_GetStringIdentifier("invokeFunction")) , invokeDelegate(NPN_GetStringIdentifier("invokeDelegate")) , wrapDelegate(NPN_GetStringIdentifier("wrapDelegate")) , length(NPN_GetStringIdentifier("length")) , debug(NPN_GetStringIdentifier("debug")) , createArgs(NPN_GetStringIdentifier("createArgs")) , index0(NPN_GetIntIdentifier(0)) , index1(NPN_GetIntIdentifier(1)) {}
CPlugin::CPlugin(NPP pNPInstance, int16_t argc, char* argn[], char* argv[]): m_pNPInstance(pNPInstance), m_pNPStream(NULL), m_bInitialized(false), m_pScriptableObject(NULL) { #ifdef XP_WIN m_hWnd = NULL; #endif // code from npruntime, get browser version const char *ua = NPN_UserAgent(m_pNPInstance); strcpy(m_String, ua); // Here is an example of passing parameters from plugin to ScriptablePlugin // initialize id NPIdentifier code_id = NPN_GetStringIdentifier("code"); NPVariant v1; VOID_TO_NPVARIANT(v1); for (int16_t i = 0;i < argc;i++) { printf("%s = %s\n", argn[i], argv[i]); if (!strcmp(argn[i],"code")) { STRINGZ_TO_NPVARIANT(m_strdup(argv[i]),v1); } } NPObject *myobj = this->GetScriptableObject(); NPN_SetProperty(m_pNPInstance, myobj, code_id, &v1); NPN_ReleaseObject(myobj); }
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."); }
NPIdentifier stringVariantToIdentifier(NPVariant variant) { assert(NPVARIANT_IS_STRING(variant)); NPUTF8* utf8String = createCStringFromNPVariant(&variant); NPIdentifier identifier = NPN_GetStringIdentifier(utf8String); free(utf8String); return identifier; }
gboolean mmp_script_element_get_property_object (NPP npp, NPVariant *element, const gchar *property_name, NPVariant *property_object) { return get_element_property_object (npp, NPVARIANT_TO_OBJECT (*element), NPN_GetStringIdentifier (property_name), property_object); }
ScriptablePluginObject::ScriptablePluginObject(NPP npp) : ScriptablePluginObjectBase(npp) { // Get the instance of the browser window object NPN_GetValue(npp, NPNVWindowNPObject, &sWindowObj); // define some npids for HTML elements that we commonly use. sDocument_id = NPN_GetStringIdentifier("document"); sBody_id = NPN_GetStringIdentifier("body"); // these are the element npid used to create new elements to be appended to the dom sCreateElement_id = NPN_GetStringIdentifier("createElement"); sCreateTextNode_id = NPN_GetStringIdentifier("createTextNode"); // used to append to the loaded dom sAppendChild_id = NPN_GetStringIdentifier("appendChild"); }
static bool ProtoHasProperty(NPObject* obj, NPIdentifier name) { if (NPN_GetStringIdentifier("bsmedbergprop") == name) return true; return false; }
// XXX FIXME See comment at the other parseOptions variant. void LibvlcPlaylistNPObject::parseOptions(NPObject *obj, int *i_options, char*** ppsz_options) { /* WARNING: Safari does not implement NPN_HasProperty/NPN_HasMethod */ NPVariant value; /* we are expecting to have a Javascript Array object */ NPIdentifier propId = NPN_GetStringIdentifier("length"); if( NPN_GetProperty(_instance, obj, propId, &value) ) { int count = numberValue(value); NPN_ReleaseVariantValue(&value); if( count ) { long capacity = 16; char **options = (char **)malloc(capacity*sizeof(char *)); if( options ) { int nOptions = 0; while( nOptions < count ) { propId = NPN_GetIntIdentifier(nOptions); if( ! NPN_GetProperty(_instance, obj, propId, &value) ) /* return what we got so far */ break; if( ! NPVARIANT_IS_STRING(value) ) { /* return what we got so far */ NPN_ReleaseVariantValue(&value); break; } if( nOptions == capacity ) { capacity += 16; char **moreOptions = (char **)realloc(options, capacity*sizeof(char*)); if( ! moreOptions ) { /* failed to allocate more memory */ NPN_ReleaseVariantValue(&value); /* return what we got so far */ *i_options = nOptions; *ppsz_options = options; break; } options = moreOptions; } options[nOptions++] = stringValue(value); } *i_options = nOptions; *ppsz_options = options; } } } }
bool convert_js_to_mrb_object(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result) { if (NPVARIANT_IS_MRB_JS_OBJECT(variant)){ MrbJsObject *obj = static_cast< MrbJsObject* >(NPVARIANT_TO_OBJECT(variant)); *result = obj->Value(); return true; } NPObject *window; NPN_GetValue(npp, NPNVWindowNPObject, &window); NPVariant object; NPN_GetProperty(npp, window, NPN_GetStringIdentifier("Object"), &object); NPN_ReleaseObject(window); NPVariant prototype; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(object), NPN_GetStringIdentifier("prototype"), &prototype); NPN_ReleaseVariantValue(&object); NPVariant to_string; NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(prototype), NPN_GetStringIdentifier("toString"), &to_string); NPN_ReleaseVariantValue(&prototype); NPVariant type_string; NPN_Invoke(npp, NPVARIANT_TO_OBJECT(to_string), NPN_GetStringIdentifier("call"), &variant, 1, &type_string); NPN_ReleaseVariantValue(&to_string); if (!NPVARIANT_IS_STRING(type_string)){ NPN_ReleaseVariantValue(&type_string); return false; } std::string type(NPVARIANT_TO_STRING(type_string).UTF8Characters, NPVARIANT_TO_STRING(type_string).UTF8Length); NPN_ReleaseVariantValue(&type_string); if (type == "[object Array]"){ return convert_js_to_mrb_array(npp, variant, mrb, result); }else if (type == "[object Object]"){ return convert_js_to_mrb_hash(npp, variant, mrb, result); }else if (type == "[object Function]"){ return convert_js_to_mrb_function(npp, variant, mrb, result); }else{ *result = mrb_js_obj_class_new(mrb, NPVARIANT_TO_OBJECT(variant)); return true; } return true; }
void GnashPluginScriptObject::AddProperty(const std::string &name, int num) { NPIdentifier id = NPN_GetStringIdentifier(name.c_str()); NPVariant value; INT32_TO_NPVARIANT(num, value); SetProperty(id, value); }
static bool ProtoHasMethod(NPObject* obj, NPIdentifier name) { if (NPN_GetStringIdentifier("bsmedbergcall") == name) return true; return false; }
// Helper function to create an NPN String Identifier from a v8 string. NPIdentifier GetStringIdentifier(v8::Handle<v8::String> str) { const int kStackBufSize = 100; int buf_len = str->Length() + 1; if (buf_len <= kStackBufSize) { // Use local stack buffer to avoid heap allocations for small strings. // Here we should only use the stack space for stack_buf when it's used, // not when we use the heap. char stack_buf[kStackBufSize]; str->WriteAscii(stack_buf); return NPN_GetStringIdentifier(stack_buf); } scoped_array<char> heap_buf(new char[buf_len]); str->WriteAscii(heap_buf.get()); return NPN_GetStringIdentifier(heap_buf.get()); }
gboolean mmp_script_element_set_property_string (NPP npp, NPVariant *element, const gchar *property_name, const gchar *property_value) { NPVariant string; STRINGZ_TO_NPVARIANT (property_value, string); return NPN_SetProperty (npp, NPVARIANT_TO_OBJECT (*element), NPN_GetStringIdentifier (property_name), &string); }
static bool ProtoGetProperty(NPObject* obj, NPIdentifier name, NPVariant* result) { if (NPN_GetStringIdentifier("bsmedbergprop") == name) { INT32_TO_NPVARIANT(42, *result); return true; } return false; }
double CPlugin::GetZoomLevel() { double level = 1; NPObject* pWindow = NULL; NPVariant vCOBA; VOID_TO_NPVARIANT(vCOBA); NPVariant vLevel; VOID_TO_NPVARIANT(vLevel); try { if ((NPN_GetValue( m_pNPInstance, NPNVWindowNPObject, &pWindow) != NPERR_NO_ERROR ) || !pWindow ) { throw(CString(_T("Cannot get window"))); } if ((!NPN_GetProperty( m_pNPInstance, pWindow, NPN_GetStringIdentifier ("COBA"), &vCOBA)) || !NPVARIANT_IS_OBJECT (vCOBA)) { throw(CString(_T("Cannot get window.COBA"))); } if (!NPN_Invoke(m_pNPInstance, NPVARIANT_TO_OBJECT(vCOBA), NPN_GetStringIdentifier("getZoomLevel"), NULL, 0, &vLevel)) { throw(CString(_T("Cannot execute window.COBA.getZoomLevel()"))); } if (NPVARIANT_IS_DOUBLE(vLevel)) level = NPVARIANT_TO_DOUBLE(vLevel); else if ( NPVARIANT_IS_INT32(vLevel) ) level = NPVARIANT_TO_INT32(vLevel); } catch (CString strMessage) { level = 1; TRACE(_T("[CPlugin::FireEvent Exception] %s"), strMessage); } if (!NPVARIANT_IS_VOID(vLevel)) NPN_ReleaseVariantValue(&vLevel); if (!NPVARIANT_IS_VOID(vCOBA)) NPN_ReleaseVariantValue(&vCOBA); if (pWindow != NULL) NPN_ReleaseObject(pWindow); return level; }