bool convert_js_to_mrb_array(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result)
{
NPVariant length;
NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier("length"), &length);
int len;
if (NPVARIANT_IS_INT32(length)){
len = NPVARIANT_TO_INT32(length);
}else if (NPVARIANT_IS_DOUBLE(length)){
len = static_cast< int >(NPVARIANT_TO_DOUBLE(length)); // Why double??
}else{
NPN_ReleaseVariantValue(&length);
return false;
}
NPN_ReleaseVariantValue(&length);
mrb_value ret_array = mrb_ary_new_capa(mrb, len);
for (int32_t i=0; i<len; i++){
NPVariant item;
std::ostringstream oss;
oss << i;
NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), NPN_GetStringIdentifier(oss.str().c_str()), &item);
mrb_value mrb_item;
if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){
NPN_ReleaseVariantValue(&item);
return false;
}
NPN_ReleaseVariantValue(&item);
mrb_ary_push(mrb, ret_array, mrb_item);
}
*result = ret_array;
return true;
}
bool ScriptablePluginObject::SetProperty(NPIdentifier name, const NPVariant *value)
{
if (!m_plugin)
return false;
std::string str;
std::stringstream ss;
bool boolean = false;
unsigned short val = -1;
if (NPVARIANT_IS_STRING(*value))
{
str.assign(NPVARIANT_TO_STRING(*value).UTF8Characters,
NPVARIANT_TO_STRING(*value).UTF8Length);
}
else if (NPVARIANT_IS_BOOLEAN(*value))
{
boolean = NPVARIANT_TO_BOOLEAN(*value);
}
else if (NPVARIANT_IS_INT32(*value))
{
val = NPVARIANT_TO_INT32(*value);
ss << val;
ss >> str;
}
double CPlugin::GetZoomLevel()
{
double level = 1;
NPVariant vLevel;
VOID_TO_NPVARIANT(vLevel);
try
{
NPObject* pContainer = GetContainer();
if (!NPN_Invoke(m_pNPInstance, pContainer, GetIdentifier("getZoomLevel"), NULL, 0, &vLevel))
{
throw CString(_T("Cannot invoke window.Container.getZoomLevel()"));
}
if (NPVARIANT_IS_DOUBLE(vLevel))
level = NPVARIANT_TO_DOUBLE(vLevel);
else if ( NPVARIANT_IS_INT32(vLevel) )
level = NPVARIANT_TO_INT32(vLevel);
}
catch (const CString& strMessage)
{
level = 1;
UNUSED(strMessage);
TRACE(_T("[CPlugin::GetZoomLevel Exception] %s\n"), strMessage);
}
if (!NPVARIANT_IS_VOID(vLevel)) NPN_ReleaseVariantValue(&vLevel);
return level;
}
bool NPSafeArray::GetItem(NPObject *npobj, const NPVariant *args, uint32_t argCount,
NPVariant *result) {
NPSafeArray *safe = static_cast<NPSafeArray*>(npobj);
if (safe->arr_.m_psa == NULL)
return false;
LONG dim = safe->arr_.GetDimensions();
if (argCount < safe->arr_.GetDimensions()) {
return false;
}
CAutoVectorPtr<LONG>pos(new LONG[dim]);
for (int i = 0; i < dim; ++i) {
if (NPVARIANT_IS_DOUBLE(args[i])) {
pos[i] = (LONG)NPVARIANT_TO_DOUBLE(args[i]);
} else if (NPVARIANT_IS_INT32(args[i])) {
pos[i] = NPVARIANT_TO_INT32(args[i]);
} else {
return false;
}
}
VARIANT var;
if (!SUCCEEDED(safe->arr_.MultiDimGetAt(pos, var))) {
return false;
}
Variant2NPVar(&var, result, safe->instance);
return true;
}
NPIdentifier
int32VariantToIdentifier(NPVariant variant)
{
assert(NPVARIANT_IS_INT32(variant));
int32_t integer = NPVARIANT_TO_INT32(variant);
return NPN_GetIntIdentifier(integer);
}
NPIdentifier variantToIdentifier(NPVariant variant) {
if (NPVARIANT_IS_STRING(variant))
return stringVariantToIdentifier(variant);
else if (NPVARIANT_IS_INT32(variant))
return int32VariantToIdentifier(variant);
else if (NPVARIANT_IS_DOUBLE(variant))
return doubleVariantToIdentifier(variant);
return 0;
}
bool JsAgent::onLoad(const NPVariant* args, unsigned argCount) {
Debug::println("JsAgent::onLoad");
if(argCount != 4) {
Debug::println("JsAgent::onLoad> argCount != 4");
return false;
}
if( !NPVARIANT_IS_OBJECT(args[0]) ||
!NPVARIANT_IS_STRING(args[1]) ||
!NPVARIANT_IS_INT32(args[2]) ||
!NPVARIANT_IS_STRING(args[3]) ) {
Debug::println("JsAgent::onLoad> arg types wrong");
return false;
}
NPObject* pObject = NPVARIANT_TO_OBJECT(args[0]);
m_helper = NPN_RetainObject(pObject);
NPObject* pDebug = NPN_CreateObject(getNPP(), GetNPClass<JsDebug>());
NPN_RetainObject(pDebug);
Variant var;
var.set(pDebug);
if(!NPN_SetProperty(getNPP(), m_window, methods.debug, var.ptr())) {
Debug::println("JsAgent::onLoad> set property failed");
return false;
}
NPString npstr = NPVARIANT_TO_STRING(args[1]);
std::string host(npstr.UTF8Characters, npstr.UTF8Length);
int port = NPVARIANT_TO_INT32(args[2]);
npstr = NPVARIANT_TO_STRING(args[3]);
std::string typeName(npstr.UTF8Characters, npstr.UTF8Length);
if(!m_channel->connect(host.c_str(), port)) {
Debug::println("JsAgent::onLoad> could not connect");
return false;
}
LoadMessage msg;
msg.typeName = typeName;
ArchiveWriter<Channel> ar(*m_channel);
if(!Message::send(msg, ar)) {
Debug::println("JsAgent::onLoad> send failed");
return false;
}
JsValue ret;
return dispatchAndReturn(ret);
}
void Any::Set(ptr<Script::Any> index, ptr<Script::Any> value)
{
NPVariant indexVariant = fast_cast<Any*>(&*index)->variant;
if(NPVARIANT_IS_STRING(indexVariant))
InternalSet(
Platform::NpapiPlugin::browserFuncs.getstringidentifier(
NPVARIANT_TO_STRING(indexVariant).UTF8Characters),
value);
else if(NPVARIANT_IS_INT32(indexVariant))
Set(NPVARIANT_TO_INT32(indexVariant), value);
}
ptr<Script::Any> Any::Get(ptr<Script::Any> index) const
{
NPVariant indexVariant = fast_cast<Any*>(&*index)->variant;
if(NPVARIANT_IS_STRING(indexVariant))
return InternalGet(
Platform::NpapiPlugin::browserFuncs.getstringidentifier(
NPVARIANT_TO_STRING(indexVariant).UTF8Characters));
if(NPVARIANT_IS_INT32(indexVariant))
return Get(NPVARIANT_TO_INT32(indexVariant));
NPVariant result;
VOID_TO_NPVARIANT(result);
return state->CreateAny(result);
}
vector<string> CppVariant::toStringVector() const
{
WEBKIT_ASSERT(isObject());
vector<string> stringVector;
NPObject* npValue = value.objectValue;
NPIdentifier lengthId = WebBindings::getStringIdentifier("length");
if (!WebBindings::hasProperty(0, npValue, lengthId))
return stringVector;
NPVariant lengthValue;
if (!WebBindings::getProperty(0, npValue, lengthId, &lengthValue))
return stringVector;
int length = 0;
// The length is a double in some cases.
if (NPVARIANT_IS_DOUBLE(lengthValue))
length = static_cast<int>(NPVARIANT_TO_DOUBLE(lengthValue));
else if (NPVARIANT_IS_INT32(lengthValue))
length = NPVARIANT_TO_INT32(lengthValue);
WebBindings::releaseVariantValue(&lengthValue);
// For sanity, only allow 100 items.
length = min(100, length);
for (int i = 0; i < length; ++i) {
// Get each of the items.
char indexInChar[20]; // Enough size to store 32-bit integer
snprintf(indexInChar, 20, "%d", i);
string index(indexInChar);
NPIdentifier indexId = WebBindings::getStringIdentifier(index.c_str());
if (!WebBindings::hasProperty(0, npValue, indexId))
continue;
NPVariant indexValue;
if (!WebBindings::getProperty(0, npValue, indexId, &indexValue))
continue;
if (NPVARIANT_IS_STRING(indexValue)) {
string item(NPVARIANT_TO_STRING(indexValue).UTF8Characters,
NPVARIANT_TO_STRING(indexValue).UTF8Length);
stringVector.push_back(item);
}
WebBindings::releaseVariantValue(&indexValue);
}
return stringVector;
}
bool
xplayerNPObject::GetDoubleFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
double& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Double))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_DOUBLE (arg)) {
_result = NPVARIANT_TO_DOUBLE (arg);
} else if (NPVARIANT_IS_INT32 (arg)) {
_result = double (NPVARIANT_TO_INT32 (arg));
}
return true;
}
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;
}
bool
xplayerNPObject::GetInt32FromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
int32_t& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Int32))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_INT32 (arg)) {
_result = NPVARIANT_TO_INT32 (arg);
} else if (NPVARIANT_IS_DOUBLE (arg)) {
_result = int32_t (NPVARIANT_TO_DOUBLE (arg));
/* FIXMEchpe: overflow? */
}
return true;
}
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;
}
// TotalFrames()
//
// Sends something like this:
// <invoke name="TotalFrames" returntype="xml">
// <arguments></arguments>
// </invoke>
//
// Receives:
// <number>66</number>
bool
TotalFrames (NPObject *npobj, NPIdentifier /* name */, const NPVariant */*args */,
uint32_t argCount, NPVariant *result)
{
log_debug(__PRETTY_FUNCTION__);
GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj;
if (argCount == 0) {
std::vector<std::string> iargs;
std::string str = plugin::ExternalInterface::makeInvoke("TotalFrames", iargs);
// Write the message to the Control FD.
size_t ret = gpso->writePlayer(str);
// Unless we wrote the same amount of data as the message contained,
// something went wrong.
if (ret != str.size()) {
log_error("Couldn't check percent loaded, network problems.");
BOOLEAN_TO_NPVARIANT(false, *result);
return false;
}
std::string data = gpso->readPlayer();
if (data.empty()) {
BOOLEAN_TO_NPVARIANT(false, *result);
return false;
}
GnashNPVariant value = plugin::ExternalInterface::parseXML(data);
if (NPVARIANT_IS_INT32(value.get())) {
value.copy(*result);
} else {
INT32_TO_NPVARIANT(0, *result);
}
return true;
}
BOOLEAN_TO_NPVARIANT(false, *result);
return false;
}
bool NPSafeArray::LBound(NPObject *npobj, const NPVariant *args, uint32_t argCount,
NPVariant *result) {
NPSafeArray *safe = static_cast<NPSafeArray*>(npobj);
if (safe->arr_.m_psa == NULL)
return false;
int dim = 1;
if (argCount >= 1) {
if (NPVARIANT_IS_INT32(*args)) {
dim = NPVARIANT_TO_INT32(*args);
} else if (NPVARIANT_IS_DOUBLE(*args)) {
dim = (LONG)NPVARIANT_TO_DOUBLE(*args);
} else {
return false;
}
}
try{
INT32_TO_NPVARIANT(safe->arr_.GetLowerBound(dim - 1), *result);
} catch (...) {
return false;
}
return true;
}
void
printNPVariant(const NPVariant *value)
{
if (NPVARIANT_IS_DOUBLE(*value)) {
double num = NPVARIANT_TO_DOUBLE(*value);
log_debug("is double, value %g", num);
} else if (NPVARIANT_IS_STRING(*value)) {
std::string str = NPStringToString(NPVARIANT_TO_STRING(*value));
log_debug("is string, value %s", str);
} else if (NPVARIANT_IS_BOOLEAN(*value)) {
bool flag = NPVARIANT_TO_BOOLEAN(*value);
log_debug("is boolean, value %d", flag);
} else if (NPVARIANT_IS_INT32(*value)) {
int num = NPVARIANT_TO_INT32(*value);
log_debug("is int, value %d", num);
} else if (NPVARIANT_IS_NULL(*value)) {
log_debug("value is null");
} else if (NPVARIANT_IS_VOID(*value)) {
log_debug("value is void");
} else if (NPVARIANT_IS_OBJECT(*value)) {
log_debug("value is object");
}
}
bool
xplayerNPObject::GetBoolFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
bool& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Bool))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_BOOLEAN (arg)) {
_result = NPVARIANT_TO_BOOLEAN (arg);
} else if (NPVARIANT_IS_INT32 (arg)) {
_result = NPVARIANT_TO_INT32 (arg) != 0;
} else if (NPVARIANT_IS_DOUBLE (arg)) {
_result = NPVARIANT_TO_DOUBLE (arg) != 0.0;
} else {
/* void/null */
_result = false;
}
return true;
}
NPError
StatementObject::AddParam(const NPVariant *value)
{
nsODBCParam* pRec = NULL;
if (NPVARIANT_IS_VOID(*value) || NPVARIANT_IS_NULL(*value)) {
pRec = new nsODBCParam();
} else if (NPVARIANT_IS_BOOLEAN(*value)) {
pRec = new nsODBCParam(NPVARIANT_TO_BOOLEAN(*value));
} else if (NPVARIANT_IS_INT32(*value)) {
pRec = new nsODBCParam(NPVARIANT_TO_INT32(*value));
} else if (NPVARIANT_IS_DOUBLE(*value)) {
double data = NPVARIANT_TO_DOUBLE(*value);
double delta = ceil(data);
if (data-0.000000001 <delta && data+0.000000001 > delta)
pRec = new nsODBCParam((int)data);
else
pRec = new nsODBCParam(data);
//--pRec = new nsODBCParam(NPVARIANT_TO_DOUBLE(*value));
} else if (NPVARIANT_IS_STRING(*value)) {
pRec = new nsODBCParam((NPString*)&NPVARIANT_TO_STRING(*value));
} else {
NPN_SetException(this, "Unsupported parameter type");
return NPERR_GENERIC_ERROR;
}
if (pRec)
m_params.push_back(pRec);
return NPERR_NO_ERROR;
}
bool toString(void *object, const NPVariant *args, uint32_t argCount, NPVariant *result) {
GenericNPObject *map = (GenericNPObject *)object;
if (!map || map->invalid) return false;
// no args expected or cared for...
std::string out;
std::vector<NPVariant>::iterator it;
for (it = map->numeric_mapper.begin(); it < map->numeric_mapper.end(); ++it) {
if (NPVARIANT_IS_VOID(*it)) {
out += ",";
}
else if (NPVARIANT_IS_NULL(*it)) {
out += ",";
}
else if (NPVARIANT_IS_BOOLEAN(*it)) {
if ((*it).value.boolValue) {
out += "true,";
}
else {
out += "false,";
}
}
else if (NPVARIANT_IS_INT32(*it)) {
char tmp[50];
memset(tmp, 0, sizeof(tmp));
_snprintf(tmp, 49, "%d,", (*it).value.intValue);
out += tmp;
}
else if (NPVARIANT_IS_DOUBLE(*it)) {
char tmp[50];
memset(tmp, 0, sizeof(tmp));
_snprintf(tmp, 49, "%f,", (*it).value.doubleValue);
out += tmp;
}
else if (NPVARIANT_IS_STRING(*it)) {
out += (*it).value.stringValue.UTF8Characters;
out += ",";
}
else if (NPVARIANT_IS_OBJECT(*it)) {
out += "[object],";
}
}
// calculate how much space we need
std::string::size_type size = out.length();
char *s = (char *)NPNFuncs.memalloc(size * sizeof(char));
if (NULL == s) {
return false;
}
memcpy(s, out.c_str(), size);
s[size - 1] = 0; // overwrite the last ","
STRINGZ_TO_NPVARIANT(s, (*result));
return true;
}
/*
bool RFunction_GetProp(RFunction *Robj, NPIdentifier name, NPNetscapeFuncs *funcs, NPVariant *result, bool check, NPP inst)
{
SEXP obj, call, ptr, ans;
//do we need to proect here?
obj = Robj->object;
int waserr = 0;
bool toret = 0;
PROTECT(ptr = call = allocVector(LANGSXP, 3));
//try [[
SETCAR(ptr, Rf_install("[["));
ptr = CDR( ptr );
SETCAR(ptr, obj);
ptr = CDR( ptr );
if(funcs->identifierisstring(name))
SETCAR( ptr , Rf_install( (const char *) funcs->utf8fromidentifier(name)));
else
SETCAR( ptr , ScalarReal( (int) funcs->intfromidentifier(name)));
PROTECT(ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance));
if(!waserr && !IsMissing(ans, true))
{
//non-missing, non-null result. stop looking
toret = 1;
} else {
//try $
ptr = call;
SETCAR(ptr, Rf_install("$"));
ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance);
if(!waserr && !IsMissing(ans, true))
toret = 1;
else
{
//try @
ptr = call;
SETCAR(ptr, Rf_install("@"));
ans = rQueue.requestRCall( call, R_GlobalEnv, &waserr, Robj->instance);
if(!waserr && !IsMissing(ans, false))
toret = 1;
else
{
ans = NEW_NUMERIC(1);
REAL(ans)[0] = NA_REAL;
}
}
}
ConvertRToNP(ans, Robj->instance, funcs, result, CONV_REF);
if(!check)
return true;
else
return toret;
}
*/
bool doNamedCall(NPP inst, SEXP fun, const NPVariant *argsIn, uint32_t count, NPVariant *_res, NPNetscapeFuncs *funcs)
{
fprintf(stderr, "\nAttempting to create R call with named arguments\n");fflush(stderr);
uint32_t idcount = 0;
NPIdentifier *ids;
NPObject *obj = argsIn[0].value.objectValue;
bool success = funcs->enumerate(inst, obj, &ids, &idcount);
SEXP call, ans, ptr, tmp;
NPVariant curprop;
NPVariant *convFun = (NPVariant *) funcs->memalloc(sizeof(NPVariant)) ;
convert_t conv= CONV_DEFAULT;
int len = 1 + idcount;
if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("namedArgsForR")))
len = len -1; //the namedArgsForR property isn't going to be used as an argument in the function call
if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("convertRet")))
len = len -1; //the convertRet property isn't going to be used as an argument in the function call
if(funcs->hasproperty(inst, obj, funcs->getstringidentifier("convertFun")))
len = len -1; //the convertFun property isn't going to be used as an argument in the function call
PROTECT(ptr = call = allocVector(LANGSXP, len));
SETCAR(ptr, fun);
PROTECT(tmp = R_NilValue);
for(int i =0; i < idcount; i++)
{
funcs->getproperty(inst, obj, ids[i], &curprop);
if(ids[i] == funcs->getstringidentifier("convertRet"))
{
//switched between 3 options on Javascript side and converted to number
if(NPVARIANT_IS_INT32(curprop))
conv = (convert_t) curprop.value.intValue;
else
conv = (convert_t) curprop.value.doubleValue;
}
else if (ids[i] == funcs->getstringidentifier("convertFun"))
{
*convFun = curprop;
// conv = CONV_REF;
}
else if(curprop.type == NPVariantType_Object && !funcs->hasproperty(inst, curprop.value.objectValue, funcs->getstringidentifier("emptyRArg")))
{
ptr = CDR(ptr);
//empty argument, ie 2nd "argument" in foo(a, , c)
SETCAR(ptr, R_MissingArg);
}
else if(ids[i] != funcs->getstringidentifier("namedArgsForR"))
{
fprintf(stderr, "\nAccessing property %s\n", funcs->utf8fromidentifier(ids[i]));fflush(stderr);
ptr = CDR(ptr);
//funcs->getproperty(inst, obj, ids[i], &curprop);
ConvertNPToR(&curprop, inst, funcs, CONV_DEFAULT, &tmp);
SETCAR(ptr, tmp);
SET_TAG(ptr, Rf_install((const char *) funcs->utf8fromidentifier(ids[i])));
}
}
fprintf(stderr, "\nFull call:\n");fflush(stderr);
Rf_PrintValue(call);
int err = 0;
PROTECT(ans = rQueue.requestRCall(call, R_GlobalEnv, &err, inst));
//NPVariant *tmpres =
ConvertRToNP(ans, inst, funcs, _res, conv);
//ConvertRToNP(ans, inst, funcs, tmpres, conv);
//call custom conversion method if available
if(conv == 3)
{
funcs->invokeDefault(inst, convFun->value.objectValue, _res, 1, _res);
}
funcs->memfree(ids);
funcs->releasevariantvalue(convFun);
return !err;
}
bool
StatementObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
//sprintf(tmp, "stmt Invoke [%s]\n", NPN_UTF8FromIdentifier(name)); log(tmp);
NPError rc;
VOID_TO_NPVARIANT(*result);
int index = 0;
if (name == mc_Init_id) {
if (argCount < 2) {
NPN_SetException(this, "Too few parameters count");
return true;
}
#if 0
if (!(NPVARIANT_IS_INT32(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)(long)NPVARIANT_TO_INT32(args[0]);
#else
if (!(NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)NPVARIANT_TO_OBJECT(args[0]);
#endif
Init(hdbc, NPVARIANT_TO_OBJECT(args[1]));
return true;
} else if (name == mc_AddParameter_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
AddParam(args);
return true;
} else if (name == mc_Execute_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!NPVARIANT_IS_STRING(args[0])) {
NPN_SetException(this, "Wrong argument type");
return true;
}
Execute((NPString*)&NPVARIANT_TO_STRING(args[0]));
return true;
} else if (name == mc_Close_id) {
Close();
return true;
} else if (name == mc_Fetch_id) {
bool ret;
rc = Fetch(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_MoreResults_id) {
bool ret;
rc = MoreResults(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetColumnName_id) {
const char *ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnName(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
STRING_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetVariant_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetVariant(index, result);
return true;
} else if (name == mc_GetColumnType_id) {
int ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnType(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
INT32_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_IsColumnNullable_id) {
bool ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = IsColumnNullable(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetTables_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetTables(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetTypeInfo_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetTypeInfo(index);
return true;
} else if (name == mc_GetPrimaryKeys_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetPrimaryKeys(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetForeignKeys_id) {
if (argCount < 6) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[4]) || NPVARIANT_IS_STRING(args[4]))) {
NPN_SetException(this, "Wrong 5 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[5]) || NPVARIANT_IS_STRING(args[5]))) {
NPN_SetException(this, "Wrong 6 argument type");
return true;
}
GetForeignKeys(&args[0], &args[1], &args[2], &args[3], &args[4], &args[5]);
return true;
} else if (name == mc_GetProcedures_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetProcedures(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetProcedureColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetProcedureColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
}
return false;
}
static bool
NPChewingInvoke(NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
uint8_t symbol = -1;
for (int i = 0; i < METHOD_LENGTH; ++i) {
if (sSymbolIdentifierMap[i].id == name) {
symbol = sSymbolIdentifierMap[i].symbol;
break;
}
}
bool rv = false;
NPChewingObject* obj = (NPChewingObject*)npobj;
if (!obj->ctx) {
return false;
}
switch (symbol) {
case HANDLE_DEFAULT:
{
if (argCount != 1) {
break;
}
if (!NPVARIANT_IS_INT32(args[0])) {
break;
}
int32_t key = NPVARIANT_TO_INT32(args[0]);
int32_t r = chewing.chewing_handle_Default(obj->ctx, key);
INT32_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case HANDLE_ENTER:
{
if (argCount != 0) {
break;
}
int32_t r = chewing.chewing_handle_Enter(obj->ctx);
INT32_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case BUFFER_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_buffer_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
char* str = chewing.chewing_buffer_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case COMMIT_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_commit_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
char* str = chewing.chewing_commit_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case ZHUYIN_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_zuin_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
int count = 0;
char* str = chewing.chewing_zuin_String(obj->ctx, &count);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case CANDIDATES_LIST:
{
if (argCount != 0) {
break;
}
// open candidates list
chewing.chewing_handle_Down(obj->ctx);
// create a array object
NPObject* window = NULL;
npn_getValue(obj->npp, NPNVWindowNPObject, &window);
NPObject* array = NULL;
NPVariant arrayVar;
npn_invoke(obj->npp,
window,
npn_getStringIdentifier("Array"),
NULL,
0,
&arrayVar);
array = NPVARIANT_TO_OBJECT(arrayVar);
npn_releaseObject(window);
// Push all candidates to array
NPIdentifier push = npn_getStringIdentifier("push");
chewing.chewing_cand_Enumerate(obj->ctx);
bool hasCandidates = false;
while (chewing.chewing_cand_hasNext(obj->ctx)) {
hasCandidates = true;
char* str = chewing.chewing_cand_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
NPVariant item;
NPVariant unused;
STRINGZ_TO_NPVARIANT(r, item);
npn_invoke(obj->npp, array, push, &item, 1, &unused);
npn_releaseVariantValue(&unused);
}
OBJECT_TO_NPVARIANT(array, *result);
rv = true;
if (hasCandidates)
chewing.chewing_handle_Esc(obj->ctx);
break;
}
case SELECT_CANDIDATE:
{
if (argCount != 1) {
break;
}
if (!NPVARIANT_IS_INT32(args[0])) {
break;
}
int32_t n = NPVARIANT_TO_INT32(args[0]);
chewing.chewing_handle_Down(obj->ctx);
chewing.chewing_cand_Select(obj->ctx, n);
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
default:
break;
}
return rv;
}
bool ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
if (m_pMainWindow == NULL)
return false;
// void Navigate({string} URL, {string} post, {string} headers)
if (name == m_NavigateID)
{
TRACE ("Navigate called!\n");
if (argCount < 3)
return false;
NPVariant vURL = args[0];
if (vURL.type != NPVariantType_String)
return false;
CString URL = NPStringToCString(vURL.value.stringValue);
NPVariant vHeaders = args[1];
if (vHeaders.type != NPVariantType_String)
return false;
CString headers = NPStringToCString(vHeaders.value.stringValue);
NPVariant vPost = args[2];
if (vPost.type != NPVariantType_String)
return false;
CString post = NPStringToCString(vPost.value.stringValue);
m_pMainWindow->Navigate(URL, post, headers);
VOID_TO_NPVARIANT(*result);
return true;
}
// void Refresh()
else if (name == m_RefreshID)
{
TRACE ("Refresh called!\n");
m_pMainWindow->Refresh();
return true;
}
// void Stop()
else if (name == m_StopID)
{
TRACE ("Stop called!\n");
m_pMainWindow->Stop();
return true;
}
// void Back()
else if (name == m_BackID)
{
TRACE ("Back called!\n");
m_pMainWindow->Back();
return true;
}
// void Forward()
else if (name == m_ForwardID)
{
TRACE ("Forward called!\n");
m_pMainWindow->Forward();
return true;
}
// void Focus()
else if (name == m_FocusID)
{
TRACE ("Focus called!\n");
m_pMainWindow->Focus();
return true;
}
// void Copy()
else if (name == m_CopyID)
{
TRACE ("Copy called!\n");
m_pMainWindow->Copy();
return true;
}
// void Cut()
else if (name == m_CutID)
{
TRACE ("Cut called!\n");
m_pMainWindow->Cut();
return true;
}
// void Paste()
else if (name == m_PasteID)
{
TRACE ("Paste called!\n");
m_pMainWindow->Paste();
return true;
}
// void SelectAll()
else if (name == m_SelectAllID)
{
TRACE ("SelectAll called!\n");
m_pMainWindow->SelectAll();
return true;
}
// void Find()
else if (name == m_FindID)
{
TRACE ("Find called!\n");
m_pMainWindow->Find();
return true;
}
// void HandOverFocus()
else if (name == m_HandOverFocusID)
{
TRACE ("HandOverFocus called!\n");
m_pMainWindow->HandOverFocus();
return true;
}
// void Zoom({number} level)
else if (name == m_ZoomID)
{
TRACE ("Zoom called!\n");
if (argCount < 1)
return false;
double level = 1;
if (NPVARIANT_IS_DOUBLE(args[0]))
level = NPVARIANT_TO_DOUBLE(args[0]);
else if ( NPVARIANT_IS_INT32(args[0]) )
level = NPVARIANT_TO_INT32(args[0]);
m_pMainWindow->Zoom(level);
return true;
}
// void DisplaySecurityInfo()
else if (name == m_DisplaySecurityInfoID)
{
TRACE ("DisplaySecurityInfo called!\n");
m_pMainWindow->DisplaySecurityInfo();
return true;
}
// void SaveAs()
else if (name == m_SaveAsID)
{
TRACE ("SaveAs called!\n");
m_pMainWindow->SaveAs();
return true;
}
// void Print()
else if (name == m_PrintID)
{
TRACE ("Print called!\n");
m_pMainWindow->Print();
return true;
}
// void PrintPreview()
else if (name == m_PrintPreviewID)
{
TRACE ("PrintPreview called!\n");
m_pMainWindow->PrintPreview();
return true;
}
// void PrintSetup()
else if (name == m_PrintSetupID)
{
TRACE ("PrintSetup called!\n");
m_pMainWindow->PrintSetup();
return true;
}
return false;
}
static bool pluginInvoke(NPObject *header, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
PluginObject *obj = (PluginObject *)header;
if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) {
// call whatever method name we're given
if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult);
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) {
if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPUTF8* targetString = createCStringFromNPVariant(&args[1]);
browser->geturl(obj->npp, urlString, targetString);
free(urlString);
free(targetString);
VOID_TO_NPVARIANT(*result);
return true;
} else if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
browser->geturl(obj->npp, urlString, 0);
free(urlString);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_REMOVE_DEFAULT_METHOD]) {
pluginClass.invokeDefault = 0;
VOID_TO_NPVARIANT(*result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) {
testDOMAccess(obj);
VOID_TO_NPVARIANT(*result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY]) {
if (argCount == 3
&& NPVARIANT_IS_STRING(args[0])
&& (NPVARIANT_IS_STRING(args[1]) || NPVARIANT_IS_NULL(args[1]))
&& NPVARIANT_IS_STRING(args[2])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPUTF8* targetString = (NPVARIANT_IS_STRING(args[1]) ? createCStringFromNPVariant(&args[1]) : NULL);
NPUTF8* callbackString = createCStringFromNPVariant(&args[2]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
browser->geturlnotify(obj->npp, urlString, targetString, callbackIdentifier);
free(urlString);
free(targetString);
free(callbackString);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT] && NPVARIANT_IS_OBJECT(args[0])) {
NPObject *callback = NPVARIANT_TO_OBJECT(args[0]);
NPVariant args[1];
NPVariant browserResult;
STRINGZ_TO_NPVARIANT("test", args[0]);
bool retval = browser->invokeDefault(obj->npp, callback, args, 1, &browserResult);
if (retval)
browser->releasevariantvalue(&browserResult);
BOOLEAN_TO_NPVARIANT(retval, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE]) {
if (argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1])) {
uint32_t count;
NPIdentifier* identifiers;
if (browser->enumerate(obj->npp, NPVARIANT_TO_OBJECT(args[0]), &identifiers, &count)) {
NPObject* outArray = NPVARIANT_TO_OBJECT(args[1]);
NPIdentifier pushIdentifier = browser->getstringidentifier("push");
for (uint32_t i = 0; i < count; i++) {
NPUTF8* string = browser->utf8fromidentifier(identifiers[i]);
if (!string)
continue;
NPVariant args[1];
STRINGZ_TO_NPVARIANT(string, args[0]);
NPVariant browserResult;
browser->invoke(obj->npp, outArray, pushIdentifier, args, 1, &browserResult);
browser->releasevariantvalue(&browserResult);
browser->memfree(string);
}
browser->memfree(identifiers);
}
VOID_TO_NPVARIANT(*result);
return true;
}
return false;
} else if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM]) {
NPError npError = browser->destroystream(obj->npp, obj->stream, NPRES_USER_BREAK);
INT32_TO_NPVARIANT(npError, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER]) {
if (argCount == 1) {
NPIdentifier identifier;
if (NPVARIANT_IS_DOUBLE(args[0])) {
identifier = browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0]));
INT32_TO_NPVARIANT((int32)identifier, *result);
return true;
} else if (NPVARIANT_IS_INT32(args[0])) {
identifier = browser->getintidentifier((int)NPVARIANT_TO_INT32(args[0]));
INT32_TO_NPVARIANT((int32)identifier, *result);
return true;
}
}
} else if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE] &&
argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPString s = NPVARIANT_TO_STRING(args[0]);
bool retval = browser->evaluate(obj->npp, windowScriptObject, &s, result);
browser->releaseobject(windowScriptObject);
return retval;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY] &&
argCount > 0) {
NPObject *object;
browser->getvalue(obj->npp, NPNVWindowNPObject, &object);
for (uint32_t i = 0; i < argCount; i++) {
//assert(NPVARIANT_IS_STRING(args[i]));
NPUTF8* propertyString = createCStringFromNPVariant(&args[i]);
NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
free(propertyString);
NPVariant variant;
bool retval = browser->getproperty(obj->npp, object, propertyIdentifier, &variant);
browser->releaseobject(object);
if (!retval)
break;
if (i + 1 < argCount) {
//assert(NPVARIANT_IS_OBJECT(variant));
object = NPVARIANT_TO_OBJECT(variant);
} else {
*result = variant;
return true;
}
}
VOID_TO_NPVARIANT(*result);
return false;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE] &&
argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_STRING(args[1])) {
NPUTF8* propertyString = createCStringFromNPVariant(&args[1]);
NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
free(propertyString);
NPVariant variant;
bool retval = browser->getproperty(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier, &variant);
if (retval)
browser->releasevariantvalue(&variant);
BOOLEAN_TO_NPVARIANT(retval, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RET]) {
// call whatever method name we're given, and pass it the 'window' obj.
// we expect the function to return its argument.
if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant callbackArgs[1];
OBJECT_TO_NPVARIANT(windowScriptObject, callbackArgs[0]);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier,
callbackArgs, 1, &browserResult);
if (NPVARIANT_IS_OBJECT(browserResult)) {
// Now return the callbacks return value back to our caller.
// BUG 897451: This should be the same as the
// windowScriptObject, but its not (in Chrome) - or at least, it
// has a different refcount. This means Chrome will delete the
// object before returning it and the calling JS gets a garbage
// value. Firefox handles it fine.
OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(browserResult), *result);
} else {
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
}
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) {
NPObject *testObject = browser->createobject(obj->npp, getTestClass());
//assert(testObject->referenceCount == 1);
OBJECT_TO_NPVARIANT(testObject, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT]) {
// call whatever method name we're given, and pass it our second
// argument.
if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &browserResult);
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) {
// Create another instance of the same class
NPObject *new_object = browser->createobject(obj->npp, &pluginClass);
//assert(new_object->referenceCount == 1);
OBJECT_TO_NPVARIANT(new_object, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE]) {
if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) {
// Invoke a script callback to get a script NPObject. Then call
// a method on the script NPObject passing it a freshly created
// NPObject.
// Arguments:
// arg1: Callback that returns a script object.
// arg2: Name of the method to call on the script object returned
// from the callback
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject,
&windowScriptObject);
// Arg1 is the name of the callback
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier =
browser->getstringidentifier(callbackString);
free(callbackString);
// Invoke a callback that returns a script object
NPVariant object_result;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier,
&args[1], 1, &object_result);
// Script object returned
NPObject *script_object = object_result.value.objectValue;
// Arg2 is the name of the method to be called on the script object
NPUTF8* object_mehod_string = createCStringFromNPVariant(&args[1]);
NPIdentifier object_method =
browser->getstringidentifier(object_mehod_string);
free(object_mehod_string);
// Create a fresh NPObject to be passed as an argument
NPObject *object_arg = browser->createobject(obj->npp, &pluginClass);
NPVariant invoke_args[1];
OBJECT_TO_NPVARIANT(object_arg, invoke_args[0]);
// Invoke the script method
NPVariant object_method_result;
browser->invoke(obj->npp, script_object, object_method,
invoke_args, 1, &object_method_result);
browser->releasevariantvalue(&object_result);
VOID_TO_NPVARIANT(*result);
if (NPVARIANT_IS_OBJECT(object_method_result)) {
// Now return the callbacks return value back to our caller.
// BUG 897451: This should be the same as the
// windowScriptObject, but its not (in Chrome) - or at least, it
// has a different refcount. This means Chrome will delete the
// object before returning it and the calling JS gets a garbage
// value. Firefox handles it fine.
OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(object_method_result),
*result);
} else {
browser->releasevariantvalue(&object_method_result);
VOID_TO_NPVARIANT(*result);
}
return true;
}
}
return false;
}
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);
}
bool Any::IsNumber() const
{
return NPVARIANT_IS_INT32(variant) || NPVARIANT_IS_DOUBLE(variant);
}
static NPIdentifier int32VariantToIdentifier(NPVariant variant)
{
assert(NPVARIANT_IS_INT32(variant));
int32_t integer = NPVARIANT_TO_INT32(variant);
return browser->getintidentifier(integer);
}
RuntimeNPObject::InvokeResult
LibvlcInputNPObject::setProperty(int index, const NPVariant &value)
{
/* 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);
RETURN_ON_EXCEPTION(this,ex);
switch( index )
{
case ID_input_position:
{
if( ! NPVARIANT_IS_DOUBLE(value) )
{
return INVOKERESULT_INVALID_VALUE;
}
float val = (float)NPVARIANT_TO_DOUBLE(value);
libvlc_media_player_set_position(p_md, val, &ex);
RETURN_ON_EXCEPTION(this,ex);
return INVOKERESULT_NO_ERROR;
}
case ID_input_time:
{
int64_t val;
if( NPVARIANT_IS_INT32(value) )
val = (int64_t)NPVARIANT_TO_INT32(value);
else if( NPVARIANT_IS_DOUBLE(value) )
val = (int64_t)NPVARIANT_TO_DOUBLE(value);
else
{
return INVOKERESULT_INVALID_VALUE;
}
libvlc_media_player_set_time(p_md, val, &ex);
RETURN_ON_EXCEPTION(this,ex);
return INVOKERESULT_NO_ERROR;
}
case ID_input_rate:
{
float val;
if( NPVARIANT_IS_INT32(value) )
val = (float)NPVARIANT_TO_INT32(value);
else if( NPVARIANT_IS_DOUBLE(value) )
val = (float)NPVARIANT_TO_DOUBLE(value);
else
{
return INVOKERESULT_INVALID_VALUE;
}
libvlc_media_player_set_rate(p_md, val, &ex);
RETURN_ON_EXCEPTION(this,ex);
return INVOKERESULT_NO_ERROR;
}
default:
;
}
}
return INVOKERESULT_GENERIC_ERROR;
}
