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