示例#1
0
文件: mrb_js.cpp 项目: guofei/JsMruby
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;
}
示例#2
0
文件: npolibvlc.cpp 项目: Kafay/vlc
// 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;
            }
        }
    }
}
示例#3
0
文件: plugin.cpp 项目: jiaofeng/COBA
// 获取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;
}
示例#4
0
 bool
 ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
                                uint32_t argCount, NPVariant *result)
 {
   if (name == sFoo_id) {
     printf ("foo called!\n");
 
     NPVariant docv;
     NPN_GetProperty(mNpp, sWindowObj, sDocument_id, &docv);
 
     NPObject *doc = NPVARIANT_TO_OBJECT(docv);
 
     NPVariant strv;
     STRINGZ_TO_NPVARIANT("div", strv);
 
     NPVariant divv;
     NPN_Invoke(mNpp, doc, sCreateElement_id, &strv, 1, &divv);
 
     STRINGZ_TO_NPVARIANT("I'm created by a plugin!", strv);
 
     NPVariant textv;
     NPN_Invoke(mNpp, doc, sCreateTextNode_id, &strv, 1, &textv);
 
     NPVariant v;
     NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(divv), sAppendChild_id, &textv, 1,
                &v);
     NPN_ReleaseVariantValue(&v);
 
     NPN_ReleaseVariantValue(&textv);
 
     NPVariant bodyv;
     NPN_GetProperty(mNpp, doc, sBody_id, &bodyv);
 
     NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(bodyv), sAppendChild_id, &divv, 1,
                &v);
     NPN_ReleaseVariantValue(&v);
 
     NPN_ReleaseVariantValue(&divv);
     NPN_ReleaseVariantValue(&bodyv);
 
     NPN_ReleaseVariantValue(&docv);
 
     STRINGZ_TO_NPVARIANT(strdup("foo return val"), *result);
 
     return PR_TRUE;
   }
 
   return PR_FALSE;
 }
示例#5
0
文件: mrb_js.cpp 项目: guofei/JsMruby
bool convert_js_to_mrb_hash(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result)
{
    NPIdentifier *id_list = NULL;
    uint32_t count;
    NPN_Enumerate(npp, NPVARIANT_TO_OBJECT(variant), &id_list, &count);

    mrb_value ret_hash = mrb_hash_new_capa(mrb, count);
    for (uint32_t i=0; i<count; i++){
        NPVariant item;
        NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), id_list[i], &item);

        mrb_value mrb_item;
        if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){
            NPN_MemFree(id_list);
            NPN_ReleaseVariantValue(&item);
            return false;
        }
        NPN_ReleaseVariantValue(&item);

        NPUTF8 *key = NPN_UTF8FromIdentifier(id_list[i]);
        mrb_hash_set(mrb, ret_hash, mrb_str_new2(mrb, key), mrb_item);
        NPN_MemFree(key);
    }

    NPN_MemFree(id_list);
    *result = ret_hash;
    return true;
}
示例#6
0
	NPObject* CPlugin::GetWindowPropertyObject(const NPUTF8* szPropertyName) const
	{
		NPObject* pWindow = GetWindow();
		NPVariant vObject;
		VOID_TO_NPVARIANT(vObject);

		if ((!NPN_GetProperty(m_pNPInstance, pWindow, GetIdentifier(szPropertyName), &vObject)) || !NPVARIANT_IS_OBJECT(vObject))
		{
			if (!NPVARIANT_IS_VOID(vObject))
				NPN_ReleaseVariantValue(&vObject);
			throw CString(_T("Cannot get window.")) + NPStringCharactersToCString(szPropertyName);
		}

		NPObject* pObject = NPVARIANT_TO_OBJECT(vObject);
		if (!pObject)
		{
			NPN_ReleaseVariantValue(&vObject);
			throw CString(_T("window.")) + NPStringCharactersToCString(szPropertyName) + _T(" is null");
		}

		NPN_RetainObject(pObject);
		NPN_ReleaseVariantValue(&vObject);

		return pObject;
	}
示例#7
0
文件: plugin.cpp 项目: jiaofeng/COBA
// 清空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);
}
示例#8
0
bool JsAgent::onHandleReturn(const Variant& varRet) {
	if(!varRet.isObject()) {
		Debug::println("JsAgent::onHandleReturn> NPN_Invoke did not return an object");
		return false;
	}

	NPObject* pReturn = varRet.asObject();
	Variant varFlag;
	if(!NPN_GetProperty(getNPP(), pReturn, methods.index0, varFlag.ptr())) {
		Debug::println("JsAgent::onHandleReturn> ret[0] failed");
		return false;
	}

	Variant varResult;
	if(!NPN_GetProperty(getNPP(), pReturn, methods.index1, varResult.ptr())) {
		Debug::println("JsAgent::onHandleReturn> ret[1] failed");
		return false;
	}

	if(!varFlag.isBool()) {
		Debug::println("JsAgent::onHandleReturn> flag was not bool");
		return false;
	}

	ReturnMessage retMsg;
	retMsg.isException = varFlag.asBool();
	std::string strRet = varResult.toString(getNPP());
	if(retMsg.isException) {
		Debug::println("JsAgent::onHandleReturn> Exception: '%s'", strRet.c_str());
		NPN_SetException(this, strRet.c_str());
	}
	else {
		Debug::println("JsAgent::onHandleReturn> returned: %s", strRet.c_str());
	}

	if(!wrapLocalValue(varResult, retMsg.value)) {
		Debug::println("JsAgent::onHandleReturn> wrapLocalValue() failed");
		return false;
	}

	ArchiveWriter<Channel> ar(*m_channel);
	if(!Message::send(retMsg, ar)) {
		Debug::println("JsAgent::onHandleReturn> Message::send() failed");
		return false;
	}
	return true;
}
示例#9
0
文件: mrb_js.cpp 项目: guofei/JsMruby
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;
}
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;
}
示例#11
0
bool JsObjectWrapper::invokeDefault(const NPVariant* args, unsigned argCount, NPVariant* result) {
	if(argCount < 1) {
		Debug::println("JsObjectWrapper::invokeDefault> argCount < 1: %d", argCount);
		return false;
	}

	if(!NPVARIANT_IS_OBJECT(args[0])) {
		Debug::println("JsObjectWrapper::invokeDefault> args[0] not an object");
		return false;
	}

	NPObject* pArray = NPVARIANT_TO_OBJECT(args[0]);
	Variant varRet;
	if(!NPN_GetProperty(getNPP(), pArray, m_agent->methods.length, varRet.ptr())) {
		Debug::println("JsObjectWrapper::invokeDefault> get length failed");
		return false;
	}

	if(!NPVARIANT_IS_INT32(varRet.get())) {
		Debug::println("JsObjectWrapper::invokeDefault> length did not return an int");
		return false;
	}

	int len = NPVARIANT_TO_INT32(varRet.get());
	VariantArray varArgs(len);

	for(int i = 0; i < len; i++) {
		NPIdentifier id = NPN_GetIntIdentifier(i);
		Variant varItem;
		if(!NPN_GetProperty(getNPP(), pArray, id, varArgs[i].ptr())) {
			Debug::println("JsObjectWrapper::invokeDefault> get [%d] failed", i);
			return false;
		}
	}

	Debug::println("JsObjectWrapper::invokeDefault");
	if(!m_agent->invokeRemoteDelegate(m_targetId, varArgs.get(), len, result)) {
		Debug::println("JsObjectWrapper::invokeDefault> invokeRemoteDelegate() failed");
		return false;
	}

	return true;
}
示例#12
0
文件: mrb_js.cpp 项目: guofei/JsMruby
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;
}
示例#13
0
static gboolean
get_element_property_object (NPP npp, NPObject *object, NPIdentifier property, NPVariant *child)
{
	VOID_TO_NPVARIANT (*child);

	if (!NPN_GetProperty (npp, object, property, child) ||
		!NPVARIANT_IS_OBJECT (*child)) {
		NPN_ReleaseVariantValue (child);
		return FALSE;
	}

	return TRUE;
}
示例#14
0
bool ParserWrap::execute(NPVariant buffer,NPVariant start,NPVariant end) 
{
	size_t c_start = static_cast<size_t>(start.value.doubleValue),
		   c_end = static_cast<size_t>(end.value.doubleValue);
	
	NPVariant result;
	NPN_GetProperty(m_Instance,buffer.value.objectValue,NPN_GetStringIdentifier("_handle"),&result);

	BufferWrap* b = (BufferWrap*)result.value.objectValue;

	http_parser_execute(parser,&http_parser_callbacks,b->data + c_start,c_end - c_start);

	return true;
}
示例#15
0
文件: plugin.cpp 项目: jiaofeng/COBA
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;
}
示例#16
0
文件: plugin.cpp 项目: jiaofeng/COBA
CString CPlugin::GetNavigateParam(const NPUTF8* name) const
{
  CString strParam;

  NPObject* pWindow = NULL;
  NPVariant vCOBAContainer;
  VOID_TO_NPVARIANT(vCOBAContainer);
  NPVariant vParam;
  VOID_TO_NPVARIANT(vParam);

  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(name), NULL, 0, &vParam))
    {
      throw(CString(_T("Cannot execute window.COBAContainer.getXXX()")));
    }
    if (!NPVARIANT_IS_STRING(vParam)) 
    {
      throw(CString(_T("Invalid return value.")));
    }
    strParam = NPStringToCString(vParam.value.stringValue);
  }
  catch (CString strMessage)
  {
    TRACE(_T("[CPlugin::GetNavigateHeaders Exception] %s"), strMessage);
  }

  if (!NPVARIANT_IS_VOID(vParam))	NPN_ReleaseVariantValue(&vParam);
  if (!NPVARIANT_IS_VOID(vCOBAContainer))	NPN_ReleaseVariantValue(&vCOBAContainer);
  if (pWindow != NULL) NPN_ReleaseObject(pWindow);

  return strParam;
}
示例#17
0
void DoTest(NPP npp)
{
	NPError err;
	NPObject *obj;
	NPVariant result;

	err = __pluginfunc.getvalue(npp,
		NPPVpluginScriptableNPObject, &obj);

	if (err != NPERR_NO_ERROR)
		return;

	if (!NPN_GetProperty(npp, obj, __TextData_id, &result))
		return;

	if (NPVARIANT_IS_STRING(result)) {
		printf("Hello World 1: sizeof(%d)\n", sizeof(result));
	}

	NPN_ReleaseVariantValue(&result);
	return;
}
unordered_map<wstring, wstring> NPObjectToUnorderedMap(NPP npp, NPObject* npobj)
{
	unordered_map<wstring, wstring> result;

	NPIdentifier* pIdentifiers = NULL;
	uint32_t nIdentifiers = 0;
	if (NPN_Enumerate(npp, npobj, &pIdentifiers, &nIdentifiers)) {
		for (uint32_t i = 0; i < nIdentifiers; i++) {
			NPIdentifier npid = pIdentifiers[i];
			CString idName = NPIdentifierToCString(npid);
			NPVariant npvValue;
			if (NPN_GetProperty(npp, npobj, npid, &npvValue)) {
				if (NPVARIANT_IS_STRING(npvValue)) {
					result[idName.GetString()] = NPStringToCString(NPVARIANT_TO_STRING(npvValue)).GetString();
				}
				NPN_ReleaseVariantValue(&npvValue);
			}
		}
		NPN_MemFree(pIdentifiers);
	}

	return result;
}
示例#19
0
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");
	}
}
示例#20
0
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
                               uint32_t argCount, NPVariant *result)
{
	// 添加自定义方法
	if (name == sGetVersion)
	{
		//NPString str;
		//str.UTF8Characters = "1.0";
		//str.UTF8Length = strlen(str.UTF8Characters);
		MessageBox(NULL, "test1", "test", MB_OK);
		//STRINGZ_TO_NPVARIANT(strdup("1.0"), *result);
		//INT32_TO_NPVARIANT(10, *result);
		//MessageBox(NULL, "test2", "test", MB_OK);

		char * version = "1.0";
		char* npOutString = (char *)NPN_MemAlloc(strlen(version) + 1);
		strcpy(npOutString, version);
		STRINGZ_TO_NPVARIANT(npOutString, *result);

		return true;
	}

  if (name == sFoo_id) {
    printf ("foo called!\n");

    NPVariant docv;
    NPN_GetProperty(mNpp, sWindowObj, sDocument_id, &docv);

    NPObject *doc = NPVARIANT_TO_OBJECT(docv);

    NPVariant strv;
    STRINGZ_TO_NPVARIANT("div", strv);

    NPVariant divv;
    NPN_Invoke(mNpp, doc, sCreateElement_id, &strv, 1, &divv);

    STRINGZ_TO_NPVARIANT("I'm created by a plugin!", strv);

    NPVariant textv;
    NPN_Invoke(mNpp, doc, sCreateTextNode_id, &strv, 1, &textv);

    NPVariant v;
    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(divv), sAppendChild_id, &textv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&textv);

    NPVariant bodyv;
    NPN_GetProperty(mNpp, doc, sBody_id, &bodyv);

    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(bodyv), sAppendChild_id, &divv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&divv);
    NPN_ReleaseVariantValue(&bodyv);

    NPN_ReleaseVariantValue(&docv);

    STRINGZ_TO_NPVARIANT(_strdup("foo return val"), *result);

    return true;
  }

  return false;
}
示例#21
0
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);
}
示例#22
0
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
                               uint32_t argCount, NPVariant *result)
{
  if (name == sFoo_id) {
    printf ("foo called!\n");

	
	NPIdentifier sAlert = NPN_GetStringIdentifier("alert");
	NPVariant alertValue;
	NPVariant returnValue;
	STRINGZ_TO_NPVARIANT("hello world",alertValue);
	NPN_Invoke(mNpp,sWindowObj,sAlert,&alertValue,1,&returnValue);

	//FFHelper* ffhelper = new FFHelper();
	//ffhelper->Invoke(mNpp,sWindowObj,"alert",&alertValue,1,&returnValue);

	//ffhelper->GetVersion();

	//char* p7SignedData = ffhelper->P7Sign("","123");

	//MessageBox(NULL,_T(p7SignedData),_T("Information"),MB_OK);

	//NPVariant npp7SignedData;
	//STRINGZ_TO_NPVARIANT(p7SignedData, npp7SignedData);
	//ffhelper->Invoke(mNpp,sWindowObj,"alert",&npp7SignedData,1,&returnValue);

	NPN_ReleaseVariantValue(&returnValue);

    NPVariant docv;
    NPN_GetProperty(mNpp, sWindowObj, sDocument_id, &docv);

    NPObject *doc = NPVARIANT_TO_OBJECT(docv);

    NPVariant strv;
    STRINGZ_TO_NPVARIANT("div", strv);

    NPVariant divv;
    NPN_Invoke(mNpp, doc, sCreateElement_id, &strv, 1, &divv);

    STRINGZ_TO_NPVARIANT("I'm created by a plugin!", strv);

    NPVariant textv;
    NPN_Invoke(mNpp, doc, sCreateTextNode_id, &strv, 1, &textv);

    NPVariant v;
    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(divv), sAppendChild_id, &textv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&textv);

    NPVariant bodyv;
    NPN_GetProperty(mNpp, doc, sBody_id, &bodyv);

    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(bodyv), sAppendChild_id, &divv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&divv);
    NPN_ReleaseVariantValue(&bodyv);

    NPN_ReleaseVariantValue(&docv);

    const char* outString = "foo return val";
    char* npOutString = (char *)NPN_MemAlloc(strlen(outString) + 1);
    if (!npOutString)
      return false;
    strcpy(npOutString, outString);
    STRINGZ_TO_NPVARIANT(npOutString, *result);

    return true;
  }

  return false;
}
示例#23
0
文件: plugin.cpp 项目: jiaofeng/COBA
// 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;
}
示例#24
0
文件: plugin.cpp 项目: xgc820313/js2n
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);
}
示例#25
0
bool TCPWrap::Invoke(NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
	if(name == onconnection_cb) 
	{
		apply(onconnection_callback,args,argCount,result);
		return true;
	}
	if(name == onread_cb) 
	{
		apply(onread_callback,args,argCount,result);
		return true;
	}
	if(name == onshutdown_cb)
	{
		apply(onshutdown_callback,args,argCount,result);
		return true;
	}

	InvokeParams* params = new InvokeParams;
	params->name = name;
	params->object = this;

	params->args = new NPVariant[argCount];
	params->argCount = argCount;
	
	for(uint32_t q = 0; q < argCount; q++) 
	{
		params->args[q] = *CopyNPVariant(&args[q]);
	}

	// if there is a write request a reference must be returned to javascript so it has
	// to be done before the rest of the work is handed off to the worker thread
	if(name == write_func) 
	{
		argCount++;
		WriteReq* w = (WriteReq*)NPN_CreateObject(m_Instance,&WriteReq::_npclass);


		// when we get a buffer we have to find the SlowBuffer._handle to access its data
		if(params->args[0].type == NPVariantType_Object)
		{
			// we dont want to delete the buffer because it's a SlowBuffer and might be accessed later
			// via a Buffer
			w->retainBuffer = true;
			NPVariant offset,
					  length,
					  parent,
					  handle;

			// buffer.offset
			NPN_GetProperty(m_Instance,params->args[0].value.objectValue,NPN_GetStringIdentifier("offset"),&offset);
			// buffer.length
			NPN_GetProperty(m_Instance,params->args[0].value.objectValue,NPN_GetStringIdentifier("length"),&length);

			// buffer.parent
			NPN_GetProperty(m_Instance,params->args[0].value.objectValue,NPN_GetStringIdentifier("parent"),&parent);
			// buffer.parent._handle
			NPN_GetProperty(m_Instance,parent.value.objectValue,NPN_GetStringIdentifier("_handle"),&handle);

			params->args[0].type = NPVariantType_String;
			params->args[0].value.stringValue.UTF8Length = static_cast<uint32_t>(length.value.doubleValue);
			params->args[0].value.stringValue.UTF8Characters = 
				((BufferWrap*)handle.value.objectValue)->data + (uint16_t)offset.value.doubleValue;
		}
		
		w->init(this,args[1],args[2]);
		NPN_RetainObject((NPObject*)w);

		params->returnObject = (NPObject*)w;
		
		//return the write request
		result->type = NPVariantType_Object;
		result->value.objectValue = params->returnObject;
	}
	if(name == shutdown_func)
	{
		ShutdownReq* w = (ShutdownReq*)NPN_CreateObject(m_Instance,&ShutdownReq::_npclass);

		w->init(this, args[0]);
		NPN_RetainObject((NPObject*)w);

		params->returnObject = (NPObject *)w;

		//return the shutdown request
		result->type = NPVariantType_Object;
		result->value.objectValue = params->returnObject;
		
	}

	invoke_queue.push(params);

	//wake the worker thread
	uv_async_send(&TCPWrap::async_handle);
	return true;
}
示例#26
0
文件: plugin.cpp 项目: zhsl2007/study
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
	//kk	
	char *pFunc = NPN_UTF8FromIdentifier(name);
		
	if( !strcmp( "Add", pFunc ) )
	{
		int sum = 0;

		for( unsigned int i = 0; i < argCount; i++ )
		{
			if( args[i].type == NPVariantType_Int32 )
			{
				sum += args[i].value.intValue;
			}
			else if( args[i].type == NPVariantType_String )
			{
				CNPString s(args[i].value.stringValue);
				sum += atoi( s );
			}
			else return false;//an error happenend

		}
		//value for GUI output
		sprintf( m_szTextGui, "Sum = %ld", sum );
		//triggering
		::InvalidateRect( m_hWnd, 0, true );
		//nice and handy little helpers, there are more of it 
		INT32_TO_NPVARIANT( sum,*result);
		return true;
	}

  if (name == sFoo_id) {
    printf ("foo called!\n");

    NPVariant docv;
    NPN_GetProperty(mNpp, sWindowObj, sDocument_id, &docv);

    NPObject *doc = NPVARIANT_TO_OBJECT(docv);

    NPVariant strv;
    STRINGZ_TO_NPVARIANT("div", strv);

    NPVariant divv;
    NPN_Invoke(mNpp, doc, sCreateElement_id, &strv, 1, &divv);

    STRINGZ_TO_NPVARIANT("I'm created by a plugin!", strv);

    NPVariant textv;
    NPN_Invoke(mNpp, doc, sCreateTextNode_id, &strv, 1, &textv);

    NPVariant v;
    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(divv), sAppendChild_id, &textv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&textv);

    NPVariant bodyv;
    NPN_GetProperty(mNpp, doc, sBody_id, &bodyv);

    NPN_Invoke(mNpp, NPVARIANT_TO_OBJECT(bodyv), sAppendChild_id, &divv, 1,
               &v);
    NPN_ReleaseVariantValue(&v);

    NPN_ReleaseVariantValue(&divv);
    NPN_ReleaseVariantValue(&bodyv);

    NPN_ReleaseVariantValue(&docv);

    STRINGZ_TO_NPVARIANT(strdup("foo return val"), *result);

    return true;
  }

  return false;
}