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