static bool
cloud_spy_variant_get_property (NPObject * npobj, NPIdentifier name, NPVariant * result)
{
CloudSpyByteArray * self = reinterpret_cast<CloudSpyByteArray *> (npobj);
if (cloud_spy_nsfuncs->identifierisstring (name))
{
const gchar * property_name;
property_name = static_cast<NPString *> (name)->UTF8Characters;
if (strcmp (property_name, "length") == 0)
{
INT32_TO_NPVARIANT (self->data_length, *result);
return true;
}
}
else
{
int32_t index;
index = cloud_spy_nsfuncs->intfromidentifier (name);
if (index >= 0 && index < self->data_length)
{
INT32_TO_NPVARIANT (self->data[index], *result);
return true;
}
}
cloud_spy_nsfuncs->setexception (npobj, "invalid property");
return true;
}
bool
StatementObject::GetProperty(NPIdentifier name, NPVariant *result)
{
//sprintf(tmp, "stmt GetProperty [%s]\n", NPN_UTF8FromIdentifier(name)); log(tmp);
VOID_TO_NPVARIANT(*result);
if (name == mc_rowCount_id)
{
INT32_TO_NPVARIANT(m_rowCount, *result);
return true;
}
else if (name == mc_columnCount_id)
{
INT32_TO_NPVARIANT(m_columnCount, *result);
return true;
}
else if (name == mc_errorMessage_id)
{
STRING_TO_NPVARIANT(GetErrorString(), *result);
return true;
}
else if (name == mc_errorCode_id)
{
INT32_TO_NPVARIANT(GetErrorCode(), *result);
return true;
}
else if (name == mc_errorState_id)
{
STRING_TO_NPVARIANT(GetErrorState(), *result);
return true;
}
return false;
}
static bool testGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
{
if (name == testIdentifiers[ID_PROPERTY_FOO]) {
char* mem = static_cast<char*>(browser->memalloc(4));
strcpy(mem, "foo");
STRINGZ_TO_NPVARIANT(mem, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_OBJECT_POINTER]) {
int32_t objectPointer = static_cast<int32_t>(reinterpret_cast<long long>(npobj));
INT32_TO_NPVARIANT(objectPointer, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
TestObject* testObject = reinterpret_cast<TestObject*>(npobj);
if (!testObject->testObject)
testObject->testObject = browser->createobject(0, &testClass);
browser->retainobject(testObject->testObject);
OBJECT_TO_NPVARIANT(testObject->testObject, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_REF_COUNT]) {
INT32_TO_NPVARIANT(npobj->referenceCount, *result);
return true;
}
return false;
}
RuntimeNPObject::InvokeResult
LibvlcAudioNPObject::getProperty(int index, NPVariant &result)
{
/* is plugin still running */
if( isPluginRunning() )
{
VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
libvlc_exception_t ex;
libvlc_exception_init(&ex);
switch( index )
{
case ID_audio_mute:
{
bool muted = libvlc_audio_get_mute(p_plugin->getVLC(), &ex);
RETURN_ON_EXCEPTION(this,ex);
BOOLEAN_TO_NPVARIANT(muted, result);
return INVOKERESULT_NO_ERROR;
}
case ID_audio_volume:
{
int volume = libvlc_audio_get_volume(p_plugin->getVLC(), &ex);
RETURN_ON_EXCEPTION(this,ex);
INT32_TO_NPVARIANT(volume, result);
return INVOKERESULT_NO_ERROR;
}
case ID_audio_track:
{
libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
RETURN_ON_EXCEPTION(this,ex);
int track = libvlc_audio_get_track(p_md, &ex);
RETURN_ON_EXCEPTION(this,ex);
INT32_TO_NPVARIANT(track, result);
return INVOKERESULT_NO_ERROR;
}
case ID_audio_count:
{
libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
RETURN_ON_EXCEPTION(this,ex);
// get the number of audio track available
int i_track = libvlc_audio_get_track_count(p_md, &ex);
RETURN_ON_EXCEPTION(this,ex);
// return it
INT32_TO_NPVARIANT(i_track, result);
return INVOKERESULT_NO_ERROR;
}
case ID_audio_channel:
{
int channel = libvlc_audio_get_channel(p_plugin->getVLC(), &ex);
RETURN_ON_EXCEPTION(this,ex);
INT32_TO_NPVARIANT(channel, result);
return INVOKERESULT_NO_ERROR;
}
default:
;
}
}
return INVOKERESULT_GENERIC_ERROR;
}
void scrollTo(NPP instance, NPObject *scroller, int y, bool animate)
{
NPVariant var, args[3];
INT32_TO_NPVARIANT(/*x*/0, args[0]);
INT32_TO_NPVARIANT(y, args[1]);
BOOLEAN_TO_NPVARIANT(animate, args[2]); //
//BOOLEAN_TO_NPVARIANT(true, args[3]); // supress notifications
scrollCommon(instance, scroller, "scrollTo", args, 3, &var);
}
static
void
topmost_rect_ptac(void *param)
{
struct topmost_rect_param_s *p = param;
struct pp_instance_s *pp_i = tables_get_pp_instance(p->instance);
if (!pp_i) {
trace_error("%s, no instance\n", __func__);
goto err_1;
}
p->result = PP_FALSE;
NPString topmost_func_src = NPString_literal(
"(function(elem, x, y) {"
"var r = elem.getBoundingClientRect();"
"return document.elementFromPoint(x + r.left, y + r.top) == elem;"
"})");
NPVariant topmost_func;
if (!npn.evaluate(pp_i->npp, pp_i->np_window_obj, &topmost_func_src, &topmost_func))
goto err_1;
if (!NPVARIANT_IS_OBJECT(topmost_func))
goto err_1;
NPObject *topmost_func_obj = NPVARIANT_TO_OBJECT(topmost_func);
NPVariant is_topmost;
NPVariant args[3];
OBJECT_TO_NPVARIANT(pp_i->np_plugin_element_obj, args[0]);
INT32_TO_NPVARIANT(p->rect.point.x + p->rect.size.width / 2, args[1]);
INT32_TO_NPVARIANT(p->rect.point.y + p->rect.size.height / 2, args[2]);
if (!npn.invokeDefault(pp_i->npp, topmost_func_obj, args, 3, &is_topmost))
goto err_2;
if (!NPVARIANT_IS_BOOLEAN(is_topmost))
goto err_3;
p->result = NPVARIANT_TO_BOOLEAN(is_topmost);
err_3:
npn.releasevariantvalue(&is_topmost);
err_2:
npn.releasevariantvalue(&topmost_func);
err_1:
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
RuntimeNPObject::InvokeResult
LibvlcPlaylistItemsNPObject::getProperty(int index, NPVariant &result)
{
/* is plugin still running */
if( isPluginRunning() )
{
VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
libvlc_exception_t ex;
libvlc_exception_init(&ex);
switch( index )
{
case ID_playlistitems_count:
{
int val = p_plugin->playlist_count(&ex);
RETURN_ON_EXCEPTION(this,ex);
INT32_TO_NPVARIANT(val, result);
return INVOKERESULT_NO_ERROR;
}
default:
;
}
}
return INVOKERESULT_GENERIC_ERROR;
}
bool CJSMethods::SelectWindowTab(int nTabId)
{
if(m_pScriptableObject == NULL)
{
return false;
}
NPP pluginInstance = m_pScriptableObject->GetPluginInstance();
NPNetscapeFuncs *pBrowserFuncs = m_pScriptableObject->GetBrowserFuncs();
if(pluginInstance == NULL || pBrowserFuncs == NULL)
{
return false;
}
NPVariant varResults;
NPVariant varArgs;
INT32_TO_NPVARIANT(nTabId, varArgs);
bool bResult = CallJSMethod(pBrowserFuncs, pluginInstance, "selectWindowTab", &varArgs, 1, varResults);
pBrowserFuncs->releasevariantvalue(&varArgs);
pBrowserFuncs->releasevariantvalue(&varResults);
return bResult;
}
static bool pluginGetProperty(NPObject *obj, NPIdentifier name, NPVariant *variant)
{
if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) {
char* mem = static_cast<char*>(browser->memalloc(9));
strcpy(mem, "property");
STRINGZ_TO_NPVARIANT(mem, *variant);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) {
BOOLEAN_TO_NPVARIANT(((PluginObject *)obj)->eventLogging, *variant);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) {
BOOLEAN_TO_NPVARIANT(((PluginObject *)obj)->logDestroy, *variant);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_HAS_STREAM]) {
BOOLEAN_TO_NPVARIANT(((PluginObject *)obj)->stream != 0, *variant);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
NPObject *testObject = ((PluginObject *)obj)->testObject;
browser->retainobject(testObject);
OBJECT_TO_NPVARIANT(testObject, *variant);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT_COUNT]) {
INT32_TO_NPVARIANT(getTestObjectCount(), *variant);
return true;
}
return false;
}
static void
on_shell_signal (GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
PluginObject *obj = user_data;
if (strcmp (signal_name, "ExtensionStatusChanged") == 0)
{
gchar *uuid;
gint32 status;
gchar *error;
NPVariant args[3];
NPVariant result;
g_variant_get (parameters, "(sis)", &uuid, &status, &error);
STRINGZ_TO_NPVARIANT (uuid, args[0]);
INT32_TO_NPVARIANT (status, args[1]);
STRINGZ_TO_NPVARIANT (error, args[2]);
funcs.invokeDefault (obj->instance, obj->listener,
args, 3, &result);
funcs.releasevariantvalue (&result);
g_free (uuid);
g_free (error);
}
}
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
if (name == sBar_id) {
static int a = 17;
INT32_TO_NPVARIANT(a, *result);
a += 5;
return true;
}
if (name == sPluginType_id) {
NPObject *myobj =
NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
if (!myobj) {
return false;
}
OBJECT_TO_NPVARIANT(myobj, *result);
return true;
}
return true;
}
bool
xplayerNPObject::Int32Variant (NPVariant* _result,
int32_t value)
{
INT32_TO_NPVARIANT (value, *_result);
return true;
}
static int
plugin_get_api_version (PluginObject *obj,
NPVariant *result)
{
INT32_TO_NPVARIANT (PLUGIN_API_VERSION, *result);
return TRUE;
}
bool nsScriptableObjectRawInput::DeleteInstance(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
if (argCount != 2 ||
!NPVARIANT_IS_DOUBLE(args[0]) ||
!NPVARIANT_IS_OBJECT(args[1])) {
NPN_SetException(this, "(DeleteInstance) invalid params passed to function");
return true;
}
int32_t id = (int32_t)(int)floor(NPVARIANT_TO_DOUBLE(args[0]) + 0.5); // all numbers come in as double in chrome...
bool foundAndDeleted = PluginMethodKeyCapture::DeleteInstance(id);
NPVariant out_args[2];
NPVariant ret_val;
BOOLEAN_TO_NPVARIANT(foundAndDeleted, out_args[0]);
INT32_TO_NPVARIANT(id, out_args[1]);
// fire callback
NPN_InvokeDefault(
__super::npp_,
NPVARIANT_TO_OBJECT(args[1]),
out_args,
2,
&ret_val);
NPN_ReleaseVariantValue(&ret_val);
return true;
}
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);
}
}
void handleCallback(PluginObject* object, const char *url, NPReason reason, void *notifyData)
{
//assert(object);
NPVariant args[2];
NPObject *windowScriptObject;
browser->getvalue(object->npp, NPNVWindowNPObject, &windowScriptObject);
NPIdentifier callbackIdentifier = notifyData;
INT32_TO_NPVARIANT(reason, args[0]);
char *strHdr = NULL;
if (object->firstUrl && object->firstHeaders && object->lastUrl && object->lastHeaders) {
// Format expected by JavaScript validator: four fields separated by \n\n:
// First URL; first header block; last URL; last header block.
// Note that header blocks already end with \n due to how NPStream::headers works.
int len = strlen(object->firstUrl) + 2
+ strlen(object->firstHeaders) + 1
+ strlen(object->lastUrl) + 2
+ strlen(object->lastHeaders) + 1;
strHdr = (char*)malloc(len + 1);
snprintf(strHdr, len + 1, "%s\n\n%s\n%s\n\n%s\n",
object->firstUrl, object->firstHeaders, object->lastUrl, object->lastHeaders);
STRINGN_TO_NPVARIANT(strHdr, len, args[1]);
} else
NULL_TO_NPVARIANT(args[1]);
NPVariant browserResult;
browser->invoke(object->npp, windowScriptObject, callbackIdentifier, args, 2, &browserResult);
browser->releasevariantvalue(&browserResult);
free(strHdr);
}
void
GnashPluginScriptObject::AddProperty(const std::string &name, int num)
{
NPIdentifier id = NPN_GetStringIdentifier(name.c_str());
NPVariant value;
INT32_TO_NPVARIANT(num, value);
SetProperty(id, value);
}
static bool InvokeDefault(NPObject *obj, const NPVariant *args,
uint32_t argCount, NPVariant *result) {
printf("*** InvokeDefault\n");
if (result) {
INT32_TO_NPVARIANT(42, *result);
}
return true;
}
bool NPSafeArray::Dimensions(NPObject *npobj, const NPVariant *args, uint32_t argCount,
NPVariant *result) {
NPSafeArray *safe = static_cast<NPSafeArray*>(npobj);
if (safe->arr_.m_psa == NULL)
return false;
INT32_TO_NPVARIANT(safe->arr_.GetDimensions(), *result);
return true;
}
bool ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
if (!m_plugin)
return false;
if (name == m_id_host_ip)
STRINGZ_TO_NPVARIANT(m_plugin->GetHostIP(), *result);
else if (name == m_id_port)
STRINGZ_TO_NPVARIANT(m_plugin->GetPort(), *result);
else if (name == m_id_secure_port)
STRINGZ_TO_NPVARIANT(m_plugin->GetSecurePort(), *result);
else if (name == m_id_password)
STRINGZ_TO_NPVARIANT(m_plugin->GetPassword(), *result);
else if (name == m_id_cipher_suite)
STRINGZ_TO_NPVARIANT(m_plugin->GetCipherSuite(), *result);
else if (name == m_id_ssl_channels)
STRINGZ_TO_NPVARIANT(m_plugin->GetSSLChannels(), *result);
else if (name == m_id_trust_store)
STRINGZ_TO_NPVARIANT(m_plugin->GetTrustStore(), *result);
else if (name == m_id_host_subject)
STRINGZ_TO_NPVARIANT(m_plugin->GetHostSubject(), *result);
else if (name == m_id_fullscreen)
BOOLEAN_TO_NPVARIANT(m_plugin->GetFullScreen(), *result);
else if (name == m_id_smartcard)
BOOLEAN_TO_NPVARIANT(m_plugin->GetSmartcard(), *result);
else if (name == m_id_admin_console)
BOOLEAN_TO_NPVARIANT(m_plugin->GetAdminConsole(), *result);
else if (name == m_id_title)
STRINGZ_TO_NPVARIANT(m_plugin->GetTitle(), *result);
else if (name == m_id_dynamic_menu)
STRINGZ_TO_NPVARIANT(m_plugin->GetDynamicMenu(), *result);
else if (name == m_id_num_of_monitors)
STRINGZ_TO_NPVARIANT(m_plugin->GetNumberOfMonitors(), *result);
else if (name == m_id_guest_hostname)
STRINGZ_TO_NPVARIANT(m_plugin->GetGuestHostName(), *result);
else if (name == m_id_hotkey)
STRINGZ_TO_NPVARIANT(m_plugin->GetHotKeys(), *result);
else if (name == m_id_no_taskmgr_execution)
BOOLEAN_TO_NPVARIANT(m_plugin->GetNoTaskMgrExecution(), *result);
else if (name == m_id_send_ctrlaltdel)
BOOLEAN_TO_NPVARIANT(m_plugin->GetSendCtrlAltDelete(), *result);
else if (name == m_id_usb_listen_port)
INT32_TO_NPVARIANT(m_plugin->GetUsbListenPort(), *result);
else if (name == m_id_usb_auto_share)
BOOLEAN_TO_NPVARIANT(m_plugin->GetUsbAutoShare(), *result);
else if (name == m_id_color_depth)
STRINGZ_TO_NPVARIANT(m_plugin->GetColorDepth(), *result);
else if (name == m_id_disable_effects)
STRINGZ_TO_NPVARIANT(m_plugin->GetDisableEffects(), *result);
else if (name == m_id_proxy)
STRINGZ_TO_NPVARIANT(m_plugin->GetProxy(), *result);
else
return false;
return true;
}
static bool
ProtoGetProperty(NPObject* obj, NPIdentifier name, NPVariant* result)
{
if (NPN_GetStringIdentifier("bsmedbergprop") == name) {
INT32_TO_NPVARIANT(42, *result);
return true;
}
return false;
}
static bool testGetIntIdentifier(PluginObject*, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
if (argCount != 1 || !NPVARIANT_IS_DOUBLE(args[0]))
return false;
NPIdentifier identifier = browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0]));
INT32_TO_NPVARIANT((int32_t)(long long)identifier, *result);
return true;
}
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
ShockerScriptableControlObject::GetProperty (NPIdentifier id, NPVariant *result)
{
char *name = Browser::Instance ()->UTF8FromIdentifier (id);
bool res = false;
PluginObject *plugin = GetPluginObject ();
if (!strcmp (name, "X")) {
INT32_TO_NPVARIANT (plugin->GetX (), *result);
res = true;
} else if (!strcmp (name, "Y")) {
INT32_TO_NPVARIANT (plugin->GetY (), *result);
res = true;
}
LOG_PLUGIN ("[%i shocker] ShockerScriptableControlObject::GetProperty (%s) x: %i, y: %i => %i\n", getpid (), name, plugin->GetX (), plugin->GetY (), res);
return res;
}
static bool testIdentifierToInt(PluginObject*, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
if (argCount != 1)
return false;
NPIdentifier identifier = variantToIdentifier(args[0]);
if (!identifier)
return false;
int32_t integer = browser->intfromidentifier(identifier);
INT32_TO_NPVARIANT(integer, *result);
return true;
}
static bool getURL(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPUTF8* targetString = createCStringFromNPVariant(&args[1]);
NPError npErr = browser->geturl(obj->npp, urlString, targetString);
free(urlString);
free(targetString);
INT32_TO_NPVARIANT(npErr, *result);
return true;
} else if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPError npErr = browser->geturl(obj->npp, urlString, 0);
free(urlString);
INT32_TO_NPVARIANT(npErr, *result);
return true;
}
return false;
}
// PercentLoaded()
//
// Sends this:
// <invoke name="PercentLoaded" returntype="xml">
// <arguments></arguments>
// </invoke>
//
// Receives something like this:
// <number>33</number>
bool
PercentLoaded (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("PercentLoaded", 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())) {
INT32_TO_NPVARIANT(NPVARIANT_TO_INT32(value.get()), *result);
} else {
INT32_TO_NPVARIANT(0, *result);
}
return true;
}
BOOLEAN_TO_NPVARIANT(false, *result);
return false;
}
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;
}
RuntimeNPObject::InvokeResult
LibvlcSubtitleNPObject::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);
RETURN_ON_EXCEPTION(this,ex);
switch( index )
{
case ID_subtitle_track:
{
/* get the current subtitle ID */
int i_spu = libvlc_video_get_spu(p_md, &ex);
RETURN_ON_EXCEPTION(this,ex);
/* return it */
INT32_TO_NPVARIANT(i_spu, result);
return INVOKERESULT_NO_ERROR;
}
case ID_subtitle_count:
{
/* get the number of subtitles available */
int i_spu = libvlc_video_get_spu_count(p_md, &ex);
RETURN_ON_EXCEPTION(this,ex);
/* return it */
INT32_TO_NPVARIANT(i_spu, result);
return INVOKERESULT_NO_ERROR;
}
}
}
return INVOKERESULT_GENERIC_ERROR;
}
RuntimeNPObject::InvokeResult
LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result)
{
/* is plugin still running */
if( isPluginRunning() )
{
VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
libvlc_exception_t ex;
libvlc_exception_init(&ex);
switch( index )
{
case ID_playlist_itemcount: /* deprecated */
{
int val = p_plugin->playlist_count(&ex);
RETURN_ON_EXCEPTION(this,ex);
INT32_TO_NPVARIANT(val, result);
return INVOKERESULT_NO_ERROR;
}
case ID_playlist_isplaying:
{
int val = p_plugin->playlist_isplaying(&ex);
RETURN_ON_EXCEPTION(this,ex);
BOOLEAN_TO_NPVARIANT(val, result);
return INVOKERESULT_NO_ERROR;
}
case ID_playlist_items:
{
// create child object in lazyman fashion to avoid
// ownership problem with firefox
if( ! playlistItemsObj )
playlistItemsObj =
NPN_CreateObject(_instance, RuntimeNPClass<
LibvlcPlaylistItemsNPObject>::getClass());
OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistItemsObj), result);
return INVOKERESULT_NO_ERROR;
}
default:
;
}
}
return INVOKERESULT_GENERIC_ERROR;
}
