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(); int length = str->Utf8Length() + 1; char* utf8Chars = reinterpret_cast<char*>(malloc(length)); str->WriteUtf8(utf8Chars, length, 0, v8::String::HINT_MANY_WRITES_EXPECTED); STRINGN_TO_NPVARIANT(utf8Chars, length-1, *result); } else if (object->IsObject()) { DOMWindow* window = V8Proxy::retrieveWindow(V8Proxy::currentContext()); NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) _NPN_RegisterObject(npobject, owner); OBJECT_TO_NPVARIANT(npobject, *result); } }
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->IsInt32()) INT32_TO_NPVARIANT(object->NumberValue(), *result); else 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::String::Utf8Value utf8(object); char* utf8_chars = strdup(*utf8); STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result); } else if (object->IsObject()) { WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(WebCore::V8Proxy::currentContext()); NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) _NPN_RegisterObject(npobject, owner); OBJECT_TO_NPVARIANT(npobject, *result); } }
bool xplayerNPObject::DoubleVariant (NPVariant* _result, double value) { DOUBLE_TO_NPVARIANT (value, *_result); return true; }
void GnashPluginScriptObject::AddProperty(const std::string &name, double num) { NPIdentifier id = NPN_GetStringIdentifier(name.c_str()); NPVariant value; DOUBLE_TO_NPVARIANT(num, value); SetProperty(id, value); }
void convertToVariant(NPP npp, const Any& any, NPVariant* variant, bool result) { switch (any.getType()) { case Any::Empty: NULL_TO_NPVARIANT(*variant); break; case Any::Bool: BOOLEAN_TO_NPVARIANT(any.toBoolean(), *variant); break; case Any::Int32: case Any::Uint32: INT32_TO_NPVARIANT(static_cast<int32_t>(any), *variant); break; case Any::Int64: case Any::Uint64: case Any::Float32: case Any::Float64: DOUBLE_TO_NPVARIANT(static_cast<double>(any), *variant); break; case Any::Dynamic: if (any.isString()) { std::string value = any.toString(); if (value.length() == 0) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else if (!result) { STRINGN_TO_NPVARIANT(value.c_str(), static_cast<uint32_t>(value.length()), *variant); } else { void* buffer = NPN_MemAlloc(value.length()); if (!buffer) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else { memmove(buffer, value.c_str(), value.length()); STRINGN_TO_NPVARIANT(static_cast<NPUTF8*>(buffer), static_cast<uint32_t>(value.length()), *variant); } } } else { assert(any.isObject()); convertToVariant(npp, any.toObject(), variant, result); } break; default: VOID_TO_NPVARIANT(*variant); break; } }
bool testfunc (NPObject */* npobj */, NPIdentifier /* name */, const NPVariant */*args */, uint32_t /* argCount */, NPVariant *result) { log_debug(__PRETTY_FUNCTION__); DOUBLE_TO_NPVARIANT(122333.4444, *result); return true; }
NPVariant NPRemoteObjectMap::npVariantDataToNPVariant(const NPVariantData& npVariantData, Plugin* plugin) { NPVariant npVariant; switch (npVariantData.type()) { case NPVariantData::Void: VOID_TO_NPVARIANT(npVariant); break; case NPVariantData::Null: NULL_TO_NPVARIANT(npVariant); break; case NPVariantData::Bool: BOOLEAN_TO_NPVARIANT(npVariantData.boolValue(), npVariant); break; case NPVariantData::Int32: INT32_TO_NPVARIANT(npVariantData.int32Value(), npVariant); break; case NPVariantData::Double: DOUBLE_TO_NPVARIANT(npVariantData.doubleValue(), npVariant); break; case NPVariantData::String: { NPString npString = createNPString(npVariantData.stringValue()); STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, npVariant); break; } case NPVariantData::LocalNPObjectID: { uint64_t npObjectID = npVariantData.localNPObjectIDValue(); ASSERT(npObjectID); NPObjectMessageReceiver* npObjectMessageReceiver = m_registeredNPObjects.get(npObjectID); if (!npObjectMessageReceiver) { ASSERT_NOT_REACHED(); VOID_TO_NPVARIANT(npVariant); break; } NPObject* npObject = npObjectMessageReceiver->npObject(); ASSERT(npObject); retainNPObject(npObject); OBJECT_TO_NPVARIANT(npObject, npVariant); break; } case NPVariantData::RemoteNPObjectID: { NPObject* npObjectProxy = createNPObjectProxy(npVariantData.remoteNPObjectIDValue(), plugin); OBJECT_TO_NPVARIANT(npObjectProxy, npVariant); break; } } return npVariant; }
// Variant value must be released with NPReleaseVariantValue() void convertValueToNPVariant(ExecState *exec, JSValue *value, NPVariant *result) { JSLock lock; JSType type = value->type(); VOID_TO_NPVARIANT(*result); if (type == StringType) { UString ustring = value->toString(exec); CString cstring = ustring.UTF8String(); NPString string = { (const NPUTF8 *)cstring.c_str(), static_cast<uint32_t>(cstring.size()) }; NPN_InitializeVariantWithStringCopy(result, &string); } else if (type == NumberType) { DOUBLE_TO_NPVARIANT(value->toNumber(exec), *result); } else if (type == BooleanType) { BOOLEAN_TO_NPVARIANT(value->toBoolean(exec), *result); } else if (type == UnspecifiedType) { VOID_TO_NPVARIANT(*result); } else if (type == NullType) { NULL_TO_NPVARIANT(*result); } else if (type == ObjectType) { JSObject* object = static_cast<JSObject*>(value); if (object->classInfo() == &RuntimeObjectImp::info) { RuntimeObjectImp* imp = static_cast<RuntimeObjectImp *>(value); CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance()); if (instance) { NPObject* obj = instance->getObject(); _NPN_RetainObject(obj); OBJECT_TO_NPVARIANT(obj, *result); } } else { Interpreter* originInterpreter = exec->dynamicInterpreter(); RootObject* originRootObject = findRootObject(originInterpreter); Interpreter* interpreter = 0; if (originInterpreter->isGlobalObject(value)) { interpreter = originInterpreter->interpreterForGlobalObject(value); } if (!interpreter) interpreter = originInterpreter; RootObject* rootObject = findRootObject(interpreter); if (rootObject) { NPObject* npObject = _NPN_CreateScriptObject(0, object, originRootObject, rootObject); OBJECT_TO_NPVARIANT(npObject, *result); } } } }
// Variant value must be released with NPReleaseVariantValue() void convertValueToNPVariant(ExecState* exec, JSValue value, NPVariant* result) { JSLock lock(SilenceAssertionsOnly); VOID_TO_NPVARIANT(*result); if (value.isString()) { UString ustring = value.toString(exec); CString cstring = ustring.utf8(); NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) }; NPN_InitializeVariantWithStringCopy(result, &string); } else if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result); } else if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result); } else if (value.isNull()) { NULL_TO_NPVARIANT(*result); } else if (value.isObject()) { JSObject* object = asObject(value); if (object->classInfo() == &CRuntimeObject::s_info) { CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object); CInstance* instance = runtimeObject->getInternalCInstance(); if (instance) { NPObject* obj = instance->getObject(); _NPN_RetainObject(obj); OBJECT_TO_NPVARIANT(obj, *result); } } else { #ifdef ANDROID RootObject* rootObject = findRootObject(exec->dynamicGlobalObject()); if (!rootObject) rootObject = findRootObject(exec->lexicalGlobalObject()); #else JSGlobalObject* globalObject = exec->dynamicGlobalObject(); RootObject* rootObject = findRootObject(globalObject); #endif if (rootObject) { NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject); OBJECT_TO_NPVARIANT(npObject, *result); } } } }
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); } }
void nsScriptableObjectOverwolfSample::AddTask( double first, double second, NPObject* callback) { if (shutting_down_) { return; } NPVariant arg; NPVariant ret_val; DOUBLE_TO_NPVARIANT(first+second, arg); // fire callback NPN_InvokeDefault( __super::npp_, callback, &arg, 1, &ret_val); NPN_ReleaseVariantValue(&ret_val); }
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(); }
void getResultAsVariant(NPVariant *result) { NPUTF8 *res = (NPUTF8 *)malloc(strlen(gBuff)+1); memcpy(res, gBuff, strlen(gBuff)+1); // Get rid of leading white spaces while(isspace(res[0])) { if(strlen(res) > 1) { memmove(res,res+1,strlen(res)-1); } else { res[0] = '\0'; break; } } // Get rid of trailing white spaces while(strlen(res) > 0 && isspace(res[strlen(res)-1])) { res[strlen(res)-1] = '\0'; } if(strlen(res) > 0) { // Try to convert to integer char *endPtr; int32_t intResult = strtol(res, &endPtr, 10); if(res != NULL && *endPtr == '\0') { INT32_TO_NPVARIANT(intResult, *result); return; } // Try to convert to double double doubleResult = strtod(res, &endPtr); if(res != NULL && *endPtr == '\0') { DOUBLE_TO_NPVARIANT(doubleResult, *result); return; } } // Return string STRINGN_TO_NPVARIANT(res, (uint32_t)strlen(res), *result); return; }
// Variant value must be released with NPReleaseVariantValue() void convertValueToNPVariant(ExecState* exec, JSValuePtr value, NPVariant* result) { JSLock lock(false); VOID_TO_NPVARIANT(*result); if (value.isString()) { UString ustring = value.toString(exec); CString cstring = ustring.UTF8String(); NPString string = { (const NPUTF8*)cstring.c_str(), static_cast<uint32_t>(cstring.size()) }; NPN_InitializeVariantWithStringCopy(result, &string); } else if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result); } else if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result); } else if (value.isNull()) { NULL_TO_NPVARIANT(*result); } else if (value.isObject()) { JSObject* object = asObject(value); if (object->classInfo() == &RuntimeObjectImp::s_info) { RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(object); CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance()); if (instance) { NPObject* obj = instance->getObject(); _NPN_RetainObject(obj); OBJECT_TO_NPVARIANT(obj, *result); } } else { JSGlobalObject* globalObject = exec->dynamicGlobalObject(); RootObject* rootObject = findRootObject(globalObject); if (rootObject) { NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject); OBJECT_TO_NPVARIANT(npObject, *result); } } } }
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 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; }
NPError StatementObject::GetVariant(int index, NPVariant *value) { if (!m_hstmt) { NPN_SetException(this, "Statement isn't initialized"); return NPERR_GENERIC_ERROR; } if (index < 0 || index >= m_columnCount) { NPN_SetException(this, "Column index is out of range"); return NPERR_GENERIC_ERROR; } SQLLEN cbInd; int type; NPError rc; GetColumnType(index, &type); index++; NULL_TO_NPVARIANT(*value); switch (type) { case VALUE_TYPE_BIT: { bool v_bool; rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BIT, &v_bool, 0, &cbInd)); if (rc != NPERR_NO_ERROR) return rc; if (cbInd != SQL_NULL_DATA) BOOLEAN_TO_NPVARIANT(v_bool, *value); break; } case VALUE_TYPE_TINYINT: case VALUE_TYPE_SMALLINT: case VALUE_TYPE_BIGINT: case VALUE_TYPE_INTEGER: { SQLINTEGER v_int32; rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_LONG, &v_int32, 0, &cbInd)); if (rc != NPERR_NO_ERROR) return rc; if (cbInd != SQL_NULL_DATA) INT32_TO_NPVARIANT(v_int32, *value); break; } case VALUE_TYPE_FLOAT: case VALUE_TYPE_REAL: case VALUE_TYPE_DOUBLE: { double v_double; rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_DOUBLE, &v_double, 0, &cbInd)); if (rc != NPERR_NO_ERROR) return rc; if (cbInd != SQL_NULL_DATA) DOUBLE_TO_NPVARIANT(v_double, *value); break; } /** case VALUE_TYPE_BINARY: case VALUE_TYPE_VARBINARY: case VALUE_TYPE_LONGVARBINARY: { const char hexString[] = "0123456789ABCDEF"; SQLLEN len; SQLWCHAR buf[32]; unsigned char *pin; char *pout; rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, buf, 0, &len)); if (rc != NPERR_NO_ERROR) return rc; if (len == SQL_NO_TOTAL) { const SQLLEN dwUnit = 8192; unsigned char *pBuff; unsigned char *pData = NULL; SQLLEN dwAvialable; SQLLEN bufSize = dwUnit; char *data = NULL; pData = (unsigned char *)NPN_MemAlloc(bufSize); if (!pData) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } len = 0; pBuff = pData; while(1) { SQLRETURN ret; pBuff = pData + len; ret = SQLGetData(m_hstmt, index, SQL_C_BINARY, pBuff, dwUnit, &dwAvialable); if (ret == SQL_NO_DATA_FOUND) break; if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR) return rc; if (dwAvialable < dwUnit) { len += dwAvialable; break; } len += dwUnit; bufSize += dwUnit; unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize); if (!pBuff) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } memcpy(pBuff, pData, len); NPN_MemFree(pData); pData = pBuff; pBuff = pData + len; } data = (char*)NPN_MemAlloc(len*2+1); if (!data) { NPN_MemFree(pData); NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } pout = data; pin = pData; while(len--) { unsigned char binVal = *pin++; *pout++ = hexString[(binVal >> 4) & 0xf]; *pout++ = hexString[binVal & 0xf]; } *pout = 0; NPN_MemFree(pData); STRING_TO_NPVARIANT(data, *value); } else if (len != SQL_NULL_DATA) { unsigned char *pData; SQLLEN bufSize = len + 1; char *data = NULL; pData = (unsigned char *)NPN_MemAlloc(bufSize); if (!pData) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, pData, bufSize, &len)); if (rc != NPERR_NO_ERROR) return rc; data = (char*)NPN_MemAlloc(len*2+1); if (!data) { NPN_MemFree(pData); NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } pout = data; pin = pData; while(len--) { unsigned char binVal = *pin++; *pout++ = hexString[(binVal >> 4) & 0xf]; *pout++ = hexString[binVal & 0xf]; } *pout = 0; NPN_MemFree(pData); STRING_TO_NPVARIANT(data, *value); } break; } **/ case VALUE_TYPE_BINARY: case VALUE_TYPE_VARBINARY: case VALUE_TYPE_LONGVARBINARY: case VALUE_TYPE_GUID: case VALUE_TYPE_CHAR: case VALUE_TYPE_VARCHAR: case VALUE_TYPE_LONGVARCHAR: case VALUE_TYPE_WCHAR: case VALUE_TYPE_WVARCHAR: case VALUE_TYPE_WLONGVARCHAR: case VALUE_TYPE_UNKNOWN: case VALUE_TYPE_NUMERIC: case VALUE_TYPE_DECIMAL: case VALUE_TYPE_DATE: case VALUE_TYPE_TIME: case VALUE_TYPE_TIMESTAMP: default: { SQLLEN len; SQLLEN dtype; SQLWCHAR buf[32]; rc = CheckStmtRC(SQLColAttributesW (m_hstmt, index, SQL_COLUMN_TYPE, NULL, 0, NULL, &dtype)); if (rc != NPERR_NO_ERROR) return rc; if (dtype == SQL_LONGVARBINARY || dtype == SQL_VARBINARY || dtype == SQL_BINARY || dtype == SQL_LONGVARCHAR || dtype == SQL_VARCHAR || dtype == SQL_CHAR || dtype == SQL_WLONGVARCHAR || dtype == SQL_WVARCHAR || dtype == SQL_WCHAR) { rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, 0, &len)); if (rc != NPERR_NO_ERROR) return rc; if (len == SQL_NO_TOTAL) { const SQLLEN dwUnit = 4096*sizeof(SQLWCHAR)+sizeof(SQLWCHAR); unsigned char *pBuff = NULL; unsigned char *pData = NULL; SQLLEN dwAvialable; SQLLEN bufSize = dwUnit; char *data = NULL; SQLRETURN ret; pData = (unsigned char *)NPN_MemAlloc(bufSize); if (!pData) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } len = 0; while(1) { pBuff = pData + len; ret = SQLGetData(m_hstmt, index, SQL_C_WCHAR, pBuff, dwUnit, &dwAvialable); if (ret == SQL_NO_DATA_FOUND) break; if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR) return rc; if (dwAvialable < dwUnit) { len += dwAvialable; break; } len += dwUnit - sizeof(SQLWCHAR); bufSize += dwUnit - sizeof(SQLWCHAR); unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize); if (!tmp) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } memcpy(tmp, pData, len); NPN_MemFree(pData); pData = tmp; } data = strdup_WtoU8((SQLWCHAR *)pData); if (!data) { NPN_MemFree(pData); NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } NPN_MemFree(pData); STRING_TO_NPVARIANT(data, *value); } else if (len != SQL_NULL_DATA) { unsigned char *pData; SQLLEN bufSize = len + sizeof(SQLWCHAR); char *data = NULL; pData = (unsigned char *)NPN_MemAlloc(bufSize); if (!pData) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, pData, bufSize, &len)); if (rc != NPERR_NO_ERROR) return rc; data = strdup_WtoU8((SQLWCHAR *)pData); if (!data) { NPN_MemFree(pData); NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } NPN_MemFree(pData); STRING_TO_NPVARIANT(data, *value); } } else { rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, sizeof(buf), &len)); if (rc != NPERR_NO_ERROR) return rc; if (len != SQL_NULL_DATA) { const char *data = strdup_WtoU8(buf); if (!data) { NPN_SetException(this, "Memory allocation error"); return NPERR_GENERIC_ERROR; } STRING_TO_NPVARIANT(data, *value); } } break; } } return NPERR_NO_ERROR; }
// NOTE: you could also implement SetProperty which receives a callback // function (as an NPObject) and then you can trigger this callback // with nsScriptableObjectOverwolfSample::TriggerCallbackOnMainThread. // This allows you to implement a "global" event for the plugin bool nsScriptableObjectOverwolfSample::GetProperty( NPIdentifier name, NPVariant *result) { DOUBLE_TO_NPVARIANT(sample_property_, *result); return true; }
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; } }
RuntimeNPObject::InvokeResult LibvlcInputNPObject::getProperty(int index, NPVariant &result) { /* is plugin still running */ if( isPluginRunning() ) { VlcPlugin* p_plugin = getPrivate<VlcPlugin>(); libvlc_exception_t ex; libvlc_exception_init(&ex); libvlc_media_player_t *p_md = p_plugin->getMD(&ex); if( libvlc_exception_raised(&ex) ) { if( index != ID_input_state ) { NPN_SetException(this, libvlc_exception_get_message(&ex)); libvlc_exception_clear(&ex); return INVOKERESULT_GENERIC_ERROR; } else { /* for input state, return CLOSED rather than an exception */ INT32_TO_NPVARIANT(0, result); libvlc_exception_clear(&ex); return INVOKERESULT_NO_ERROR; } } switch( index ) { case ID_input_length: { double val = (double)libvlc_media_player_get_length(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); DOUBLE_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_position: { double val = libvlc_media_player_get_position(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); DOUBLE_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_time: { double val = (double)libvlc_media_player_get_time(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); DOUBLE_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_state: { int val = libvlc_media_player_get_state(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); INT32_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_rate: { float val = libvlc_media_player_get_rate(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); DOUBLE_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_fps: { double val = libvlc_media_player_get_fps(p_md, &ex); RETURN_ON_EXCEPTION(this,ex); DOUBLE_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_input_hasvout: { bool val = p_plugin->player_has_vout(&ex); RETURN_ON_EXCEPTION(this,ex); BOOLEAN_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } default: ; } } return INVOKERESULT_GENERIC_ERROR; }
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; } }