Revision: 357
http://zoolib.svn.sourceforge.net/zoolib/?rev=357&view=rev
Author: agreen
Date: 2009-01-06 21:59:30 +0000 (Tue, 06 Jan 2009)
Log Message:
-----------
Reorganize code, mainly NPObjectXX and NPVariantXX-related stuff.
Also, move stuff that had been only overridable at the Host
level up into HostMeister.
Modified Paths:
--------------
trunk/zoolib/source/cxx/zoolib/ZNetscape.cpp
trunk/zoolib/source/cxx/zoolib/ZNetscape.h
trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.cpp
trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.h
trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest_Std.cpp
trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.cpp
trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.h
trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.cpp
trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.h
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape.cpp 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape.cpp 2009-01-06 21:59:30 UTC (rev 357)
@@ -85,148 +85,6 @@
#undef CASE
-// =================================================================================================
-#pragma mark -
-#pragma mark * NPVariantBase
-
-NPVariantBase::NPVariantBase()
- {
- type = NPVariantType_Void;
- }
-
-NPVariantBase::NPVariantBase(bool iValue)
- {
- type = NPVariantType_Bool;
- value.boolValue = iValue;
- }
-
-NPVariantBase::NPVariantBase(int32 iValue)
- {
- type = NPVariantType_Int32;
- value.intValue = iValue;
- }
-
-NPVariantBase::NPVariantBase(double iValue)
- {
- type = NPVariantType_Double;
- value.doubleValue = iValue;
- }
-
-NPVariantBase::NPVariantBase(const string& iValue)
- {
- this->pSetString(iValue);
- type = NPVariantType_String;
- }
-
-bool NPVariantBase::IsVoid() const
- { return type == NPVariantType_Void; }
-
-bool NPVariantBase::IsNull() const
- { return type == NPVariantType_Null; }
-
-bool NPVariantBase::IsBool() const
- { return type == NPVariantType_Bool; }
-
-bool NPVariantBase::IsInt32() const
- { return type == NPVariantType_Int32; }
-
-bool NPVariantBase::IsDouble() const
- { return type == NPVariantType_Double; }
-
-bool NPVariantBase::IsString() const
- { return type == NPVariantType_String; }
-
-bool NPVariantBase::IsObject() const
- { return type == NPVariantType_Object; }
-
-bool NPVariantBase::GetBool() const
- { return this->DGetBool(false); }
-
-bool NPVariantBase::GetBool(bool& oValue) const
- {
- if (type != NPVariantType_Bool)
- return false;
- oValue = value.boolValue;
- return true;
- }
-
-bool NPVariantBase::DGetBool(bool iDefault) const
- {
- if (type == NPVariantType_Bool)
- return value.boolValue;
- return iDefault;
- }
-
-int32 NPVariantBase::GetInt32() const
- { return this->DGetInt32(0); }
-
-bool NPVariantBase::GetInt32(int32& oValue) const
- {
- if (type != NPVariantType_Int32)
- return false;
- oValue = value.intValue;
- return true;
- }
-
-int32 NPVariantBase::DGetInt32(int32 iDefault) const
- {
- if (type == NPVariantType_Int32)
- return value.intValue;
- return iDefault;
- }
-
-double NPVariantBase::GetDouble() const
- { return this->DGetDouble(0); }
-
-bool NPVariantBase::GetDouble(double& oValue) const
- {
- if (type != NPVariantType_Double)
- return false;
- oValue = value.doubleValue;
- return true;
- }
-
-double NPVariantBase::DGetDouble(double iDefault) const
- {
- if (type == NPVariantType_Double)
- return value.doubleValue;
- return iDefault;
- }
-
-string NPVariantBase::GetString() const
- { return this->DGetString(string()); }
-
-bool NPVariantBase::GetString(string& oValue) const
- {
- if (type != NPVariantType_String)
- return false;
- oValue =
- string(sNPStringCharsConst(value.stringValue), sNPStringLengthConst(value.stringValue));
- return true;
- }
-
-string NPVariantBase::DGetString(const string& iDefault) const
- {
- if (type != NPVariantType_String)
- return iDefault;
- return string(sNPStringCharsConst(value.stringValue), sNPStringLengthConst(value.stringValue));
- }
-
-void NPVariantBase::pSetString(const char* iChars, size_t iLength)
- {
- sNPStringLength(value.stringValue) = iLength;
- sNPStringChars(value.stringValue) = static_cast<char*>(malloc(iLength));
- strncpy(sNPStringChars(value.stringValue), iChars, iLength);
- }
-
-void NPVariantBase::pSetString(const std::string& iString)
- {
- if (size_t theLength = iString.length())
- this->pSetString(iString.data(), theLength);
- else
- this->pSetString(nil, 0);
- }
-
} // namespace ZNetscape
NAMESPACE_ZOOLIB_END
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape.h 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape.h 2009-01-06 21:59:30 UTC (rev 357)
@@ -27,6 +27,9 @@
#if ZCONFIG_SPI_Enabled(Netscape)
#include "zoolib/ZCompat_npapi.h"
+#include "zoolib/ZCompat_operator_bool.h"
+#include "zoolib/ZDebug.h" // For ZAssert
+#include "zoolib/ZNetscape_Macros.h"
#include <string>
@@ -43,51 +46,549 @@
// =================================================================================================
#pragma mark -
-#pragma mark * NPVariantBase
+#pragma mark * NPVariant_T
-class NPVariantBase : public NPVariant
+template <class T>
+class NPVariant_T : public NPVariant
{
+private:
+ void pCopyFrom(const NPVariant& iOther)
+ {
+ switch (iOther.type)
+ {
+ case NPVariantType_Void:
+ case NPVariantType_Null:
+ break;
+ case NPVariantType_Bool:
+ {
+ value.boolValue = iOther.value.boolValue;
+ break;
+ }
+ case NPVariantType_Int32:
+ {
+ value.intValue = iOther.value.intValue;
+ break;
+ }
+ case NPVariantType_Double:
+ {
+ value.doubleValue = iOther.value.doubleValue;
+ break;
+ }
+ case NPVariantType_String:
+ {
+ this->pSetString(
+ sNPStringCharsConst(iOther.value.stringValue),
+ sNPStringLengthConst(iOther.value.stringValue));
+ break;
+ }
+ case NPVariantType_Object:
+ {
+ value.objectValue = iOther.value.objectValue;
+ static_cast<T*>(value.objectValue)->Retain();
+ break;
+ }
+ }
+ type = iOther.type;
+ }
+
public:
- NPVariantBase();
+ ZOOLIB_DEFINE_OPERATOR_BOOL_TYPES_T(NPVariant_T<T>,
+ operator_bool_generator_type, operator_bool_type);
- NPVariantBase(bool iValue);
- NPVariantBase(int32 iValue);
- NPVariantBase(double iValue);
- NPVariantBase(const std::string& iValue);
+ operator operator_bool_type() const
+ { return operator_bool_generator_type::translate(type != NPVariantType_Void); }
- bool IsVoid() const;
- bool IsNull() const;
+ typedef T Object_t;
- bool IsBool() const;
- bool IsInt32() const;
- bool IsDouble() const;
- bool IsString() const;
- bool IsObject() const;
+ NPVariant_T()
+ { type = NPVariantType_Void; }
- void SetVoid();
- void SetNull();
+ NPVariant_T(const NPVariant& iOther)
+ {
+ ZAssert(this != &iOther);
+ this->pCopyFrom(iOther);
+ }
- bool GetBool() const;
- bool GetBool(bool& oValue) const;
- bool DGetBool(bool iDefault) const;
+ NPVariant_T(const NPVariant_T& iOther)
+ {
+ ZAssert(this != &iOther);
+ this->pCopyFrom(iOther);
+ }
- int32 GetInt32() const;
- bool GetInt32(int32& oValue) const;
- int32 DGetInt32(int32 iDefault) const;
+ ~NPVariant_T()
+ { sRelease(*this); }
- double GetDouble() const;
- bool GetDouble(double& oValue) const;
- double DGetDouble(double iDefault) const;
+ NPVariant_T& operator=(const NPVariant& iOther)
+ {
+ if (this != &iOther)
+ {
+ sRelease(*this);
+ this->pCopyFrom(iOther);
+ }
+ return *this;
+ }
- std::string GetString() const;
- bool GetString(std::string& oValue) const;
- std::string DGetString(const std::string& iDefault) const;
+ NPVariant_T& operator=(const NPVariant_T& iOther)
+ {
+ if (this != &iOther)
+ {
+ sRelease(*this);
+ this->pCopyFrom(iOther);
+ }
+ return *this;
+ }
+ NPVariant_T(bool iValue)
+ {
+ type = NPVariantType_Bool;
+ value.boolValue = iValue;
+ }
+
+ NPVariant_T(int32 iValue)
+ {
+ type = NPVariantType_Int32;
+ value.intValue = iValue;
+ }
+
+ NPVariant_T(double iValue)
+ {
+ type = NPVariantType_Double;
+ value.doubleValue = iValue;
+ }
+
+ NPVariant_T(const std::string& iValue)
+ {
+ this->pSetString(iValue);
+ type = NPVariantType_String;
+ }
+
+ NPVariant_T(T* iValue)
+ {
+ type = NPVariantType_Void;
+ this->SetObject(iValue);
+ }
+
+ NPVariant_T& operator=(bool iValue)
+ {
+ this->SetBool(iValue);
+ return *this;
+ }
+
+ NPVariant_T& operator=(int32 iValue)
+ {
+ this->SetInt32(iValue);
+ return *this;
+ }
+
+ NPVariant_T& operator=(double iValue)
+ {
+ this->SetDouble(iValue);
+ return *this;
+ }
+
+ NPVariant_T& operator=(const std::string& iValue)
+ {
+ this->SetString(iValue);
+ return *this;
+ }
+
+ NPVariant_T& operator=(T* iValue)
+ {
+ this->SetObject(iValue);
+ return *this;
+ }
+
+ bool IsVoid() const
+ { return type == NPVariantType_Void; }
+
+ bool IsNull() const
+ { return type == NPVariantType_Null; }
+
+ bool IsBool() const
+ { return type == NPVariantType_Bool; }
+
+ bool IsInt32() const
+ { return type == NPVariantType_Int32; }
+
+ bool IsDouble() const
+ { return type == NPVariantType_Double; }
+
+ bool IsString() const
+ { return type == NPVariantType_String; }
+
+ bool IsObject() const
+ { return type == NPVariantType_Object; }
+
+ void SetVoid()
+ {
+ sRelease(*this);
+ type = NPVariantType_Void;
+ }
+
+ void SetNull()
+ {
+ sRelease(*this);
+ type = NPVariantType_Null;
+ }
+
+ void SetBool(bool iValue)
+ {
+ sRelease(*this);
+ value.boolValue = iValue;
+ type = NPVariantType_Bool;
+ }
+
+ void SetInt32(int32 iValue)
+ {
+ sRelease(*this);
+ value.intValue = iValue;
+ type = NPVariantType_Int32;
+ }
+
+ void SetDouble(double iValue)
+ {
+ sRelease(*this);
+ value.doubleValue = iValue;
+ type = NPVariantType_Double;
+ }
+
+ void SetString(const std::string& iValue)
+ {
+ sRelease(*this);
+ this->pSetString(iValue);
+ type = NPVariantType_String;
+ }
+
+ bool GetBool() const
+ { return this->DGetBool(false); }
+
+ bool GetBool(bool& oValue) const
+ {
+ if (type != NPVariantType_Bool)
+ return false;
+ oValue = value.boolValue;
+ return true;
+ }
+
+ bool DGetBool(bool iDefault) const
+ {
+ if (type == NPVariantType_Bool)
+ return value.boolValue;
+ return iDefault;
+ }
+
+ int32 GetInt32() const
+ { return this->DGetInt32(0); }
+
+ bool GetInt32(int32& oValue) const
+ {
+ if (type != NPVariantType_Int32)
+ return false;
+ oValue = value.intValue;
+ return true;
+ }
+
+ int32 DGetInt32(int32 iDefault) const
+ {
+ if (type == NPVariantType_Int32)
+ return value.intValue;
+ return iDefault;
+ }
+
+ double GetDouble() const
+ { return this->DGetDouble(0); }
+
+ bool GetDouble(double& oValue) const
+ {
+ if (type != NPVariantType_Double)
+ return false;
+ oValue = value.doubleValue;
+ return true;
+ }
+
+ double DGetDouble(double iDefault) const
+ {
+ if (type == NPVariantType_Double)
+ return value.doubleValue;
+ return iDefault;
+ }
+
+ std::string GetString() const
+ { return this->DGetString(std::string()); }
+
+ bool GetString(std::string& oValue) const
+ {
+ if (type != NPVariantType_String)
+ return false;
+
+ oValue = std::string(
+ sNPStringCharsConst(value.stringValue),
+ sNPStringLengthConst(value.stringValue));
+ return true;
+ }
+
+ std::string DGetString(const std::string& iDefault) const
+ {
+ if (type != NPVariantType_String)
+ return iDefault;
+
+ return std::string(
+ sNPStringCharsConst(value.stringValue),
+ sNPStringLengthConst(value.stringValue));
+ }
+
+ T* CopyObject() const
+ { return this->DCopyObject(nil); }
+
+ bool CopyObject(T*& oValue) const
+ {
+ if (type != NPVariantType_Object)
+ return false;
+ oValue = static_cast<T*>(value.objectValue);
+
+ oValue->Retain();
+ return true;
+ }
+
+ T* DCopyObject(T* iDefault) const
+ {
+ T* result = iDefault;
+ if (type == NPVariantType_Object)
+ result = static_cast<T*>(value.objectValue);
+
+ result->Retain();
+ return result;
+ }
+
+ T* GetObject() const
+ { return this->DGetObject(nil); }
+
+ bool GetObject(T*& oValue) const
+ {
+ if (type != NPVariantType_Object)
+ return false;
+ oValue = static_cast<T*>(value.objectValue);
+ return true;
+ }
+
+ T* DGetObject(T* iDefault) const
+ {
+ if (type == NPVariantType_Object)
+ return static_cast<T*>(value.objectValue);
+
+ return iDefault;
+ }
+
+ void SetObject(T* iValue)
+ {
+ sRelease(*this);
+ value.objectValue = iValue;
+ iValue->Retain();
+ type = NPVariantType_Object;
+ }
+
+private:
+ void pSetString(const char* iChars, size_t iLength)
+ {
+ sNPStringLength(value.stringValue) = iLength;
+ sNPStringChars(value.stringValue) = static_cast<char*>(malloc(iLength));
+ strncpy(sNPStringChars(value.stringValue), iChars, iLength);
+ }
+
+ void pSetString(const std::string& iString)
+ {
+ if (size_t theLength = iString.length())
+ this->pSetString(iString.data(), theLength);
+ else
+ this->pSetString(nil, 0);
+ }
+ };
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * Object_T
+
+template <class Variant_t>
+class Object_T : public Variant_t::Object_t
+ {
protected:
- void pSetString(const char* iChars, size_t iLength);
- void pSetString(const std::string& iString);
+ typedef typename Variant_t::Object_t Object_t;
+
+ Object_T()
+ {
+ this->_class = &sNPClass;
+ this->referenceCount = 1;
+ }
+
+ virtual ~Object_T()
+ {}
+
+ virtual void Imp_Invalidate()
+ {}
+
+ virtual bool Imp_HasMethod(const std::string& iName)
+ { return false; }
+
+ virtual bool Imp_Invoke(
+ const std::string& iName, const Variant_t* iArgs, size_t iCount, Variant_t& oResult)
+ { return false; }
+
+ virtual bool Imp_InvokeDefault(const Variant_t* iArgs, size_t iCount, Variant_t& oResult)
+ { return false; }
+
+ virtual bool Imp_HasProperty(const std::string& iName)
+ { return false; }
+
+ virtual bool Imp_HasProperty(int32_t iInt)
+ { return false; }
+
+ virtual bool Imp_GetProperty(const std::string& iName, Variant_t& oResult)
+ { return false; }
+
+ virtual bool Imp_GetProperty(int32_t iInt, Variant_t& oResult)
+ { return false; }
+
+ virtual bool Imp_SetProperty(const std::string& iName, const Variant_t& iValue)
+ { return false; }
+
+ virtual bool Imp_SetProperty(int32_t iInt, const Variant_t& iValue)
+ { return false; }
+
+ virtual bool Imp_RemoveProperty(const std::string& iName)
+ { return false; }
+
+ virtual bool Imp_RemoveProperty(int32_t iInt)
+ { return false; }
+
+private:
+ static NPObject* sAllocate(NPP npp, NPClass *aClass)
+ {
+ ZUnimplemented();
+ return nil;
+ }
+
+ static void sDeallocate(NPObject* npobj)
+ {
+ ZNETSCAPE_BEFORE
+ delete static_cast<Object_T*>(npobj);
+ ZNETSCAPE_AFTER_VOID
+ }
+
+ static void sInvalidate(NPObject* npobj)
+ {
+ ZNETSCAPE_BEFORE
+ static_cast<Object_T*>(npobj)->Imp_Invalidate();
+ ZNETSCAPE_AFTER_VOID
+ }
+
+ static bool sHasMethod(NPObject* npobj, NPIdentifier name)
+ {
+ ZNETSCAPE_BEFORE
+ return static_cast<Object_T*>(npobj)->Imp_HasMethod(Object_t::sAsString(name));
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sInvoke(NPObject* npobj,
+ NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
+ {
+ ZNETSCAPE_BEFORE
+ return static_cast<Object_T*>(npobj)->Imp_Invoke(
+ Object_t::sAsString(name),
+ static_cast<const Variant_t*>(args),
+ argCount,
+ *static_cast<Variant_t*>(result));
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sInvokeDefault(NPObject* npobj,
+ const NPVariant* args, uint32_t argCount, NPVariant* result)
+ {
+ ZNETSCAPE_BEFORE
+ return static_cast<Object_T*>(npobj)->Imp_InvokeDefault(
+ static_cast<const Variant_t*>(args),
+ argCount,
+ *static_cast<Variant_t*>(result));
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sHasProperty(NPObject* npobj, NPIdentifier name)
+ {
+ ZNETSCAPE_BEFORE
+ {
+ if (Object_t::sIsString(name))
+ return static_cast<Object_T*>(npobj)->Imp_HasProperty(Object_t::sAsString(name));
+ else
+ return static_cast<Object_T*>(npobj)->Imp_HasProperty(Object_t::sAsInt(name));
+ }
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
+ {
+ ZNETSCAPE_BEFORE
+ if (Object_t::sIsString(name))
+ {
+ return static_cast<Object_T*>(npobj)->Imp_GetProperty(
+ Object_t::sAsString(name),
+ *static_cast<Variant_t*>(result));
+ }
+ else
+ {
+ return static_cast<Object_T*>(npobj)->Imp_GetProperty(
+ Object_t::sAsInt(name),
+ *static_cast<Variant_t*>(result));
+ }
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value)
+ {
+ ZNETSCAPE_BEFORE
+ if (Object_t::sIsString(name))
+ {
+ return static_cast<Object_T*>(npobj)->Imp_SetProperty(
+ Object_t::sAsString(name),
+ *static_cast<const Variant_t*>(value));
+ }
+ else
+ {
+ return static_cast<Object_T*>(npobj)->Imp_SetProperty(
+ Object_t::sAsInt(name),
+ *static_cast<const Variant_t*>(value));
+ }
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static bool sRemoveProperty(NPObject* npobj, NPIdentifier name)
+ {
+ ZNETSCAPE_BEFORE
+ if (Object_t::sIsString(name))
+ return static_cast<Object_T*>(npobj)->RemoveProperty(Object_t::sAsString(name));
+ else
+ return static_cast<Object_T*>(npobj)->RemoveProperty(Object_t::sAsInt(name));
+ ZNETSCAPE_AFTER_RETURN_FALSE
+ }
+
+ static NPClass sNPClass;
};
+#define ZNETSCAPE_OBJECT_SETUP(a) \
+template<> \
+NPClass Object_T<a>::sNPClass = \
+ { \
+ 1, \
+ Object_T<a>::sAllocate, \
+ Object_T<a>::sDeallocate, \
+ Object_T<a>::sInvalidate, \
+ Object_T<a>::sHasMethod, \
+ Object_T<a>::sInvoke, \
+ Object_T<a>::sInvokeDefault, \
+ Object_T<a>::sHasProperty, \
+ Object_T<a>::sGetProperty, \
+ Object_T<a>::sSetProperty, \
+ Object_T<a>::sRemoveProperty \
+ }
+
} // namespace ZNetscape
NAMESPACE_ZOOLIB_END
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.cpp 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.cpp 2009-01-06 21:59:30 UTC (rev 357)
@@ -33,6 +33,8 @@
using std::min;
using std::string;
+// =================================================================================================
+
extern "C" {
#if __MACH__
@@ -58,7 +60,7 @@
// For compatibility with CFM and Mozilla-type browsers
#pragma export on
-int main(NPNetscapeFuncs* iNPNF, NPPluginFuncs* oPluginFuncs, NPP_ShutdownProcPtr* oShutdownFunc);
+int main(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownProcPtr*);
int main(NPNetscapeFuncs* iNPNF, NPPluginFuncs* oPluginFuncs, NPP_ShutdownProcPtr* oShutdownFunc)
{
return ZOOLIB_PREFIX::ZNetscape::GuestMeister::sGet()->
@@ -72,233 +74,61 @@
NAMESPACE_ZOOLIB_BEGIN
-// =================================================================================================
-#pragma mark -
-#pragma mark * ZNetscape
-
namespace ZNetscape {
-void sRetainG(NPObject* iObject)
- { GuestMeister::sGet()->Host_RetainObject(iObject); }
-
-void sReleaseG(NPObject* iObject)
- { GuestMeister::sGet()->Host_ReleaseObject(iObject); }
-
-void sRetain(NPObjectG* iObject)
- { sRetainG(iObject); }
-
-void sRelease(NPObjectG* iObject)
- { sReleaseG(iObject); }
-
// =================================================================================================
#pragma mark -
#pragma mark * NPVariantG
-void NPVariantG::pRelease()
- {
- GuestMeister::sGet()->Host_ReleaseVariantValue(this);
- type = NPVariantType_Void;
- }
+void sRelease(NPVariantG& iNPVariantG)
+ { GuestMeister::sGet()->Host_ReleaseVariantValue(&iNPVariantG); }
-void NPVariantG::pRetain(NPObject* iObject) const
- { GuestMeister::sGet()->Host_RetainObject(iObject); }
+// =================================================================================================
+#pragma mark -
+#pragma mark * ObjectG
-void NPVariantG::pCopyFrom(const NPVariant& iOther)
- {
- switch (iOther.type)
- {
- case NPVariantType_Void:
- case NPVariantType_Null:
- break;
- case NPVariantType_Bool:
- {
- value.boolValue = iOther.value.boolValue;
- break;
- }
- case NPVariantType_Int32:
- {
- value.intValue = iOther.value.intValue;
- break;
- }
- case NPVariantType_Double:
- {
- value.doubleValue = iOther.value.doubleValue;
- break;
- }
- case NPVariantType_String:
- {
- this->pSetString(
- sNPStringCharsConst(iOther.value.stringValue),
- sNPStringLengthConst(iOther.value.stringValue));
- break;
- }
- case NPVariantType_Object:
- {
- value.objectValue = iOther.value.objectValue;
- this->pRetain(value.objectValue);
- break;
- }
- }
- type = iOther.type;
- }
+ZNETSCAPE_OBJECT_SETUP(NPVariantG);
-NPVariantG::NPVariantG()
- {}
+// =================================================================================================
+#pragma mark -
+#pragma mark * NPObjectG
-NPVariantG::NPVariantG(const NPVariant& iOther)
- {
- ZAssert(this != &iOther);
- this->pCopyFrom(iOther);
- }
+static NPP fake = nil;
-NPVariantG::~NPVariantG()
- {
- this->pRelease();
- }
-
-NPVariantG& NPVariantG::operator=(const NPVariant& iOther)
- {
- if (this != &iOther)
- {
- this->pRelease();
- this->pCopyFrom(iOther);
- }
- return *this;
- }
-
-NPVariantG::NPVariantG(bool iValue)
-: NPVariantBase(iValue)
+NPObjectG::NPObjectG()
{}
-NPVariantG::NPVariantG(int32 iValue)
-: NPVariantBase(iValue)
+NPObjectG::~NPObjectG()
{}
-NPVariantG::NPVariantG(double iValue)
-: NPVariantBase(iValue)
- {}
+bool NPObjectG::sIsString(NPIdentifier iNPI)
+ { return GuestMeister::sGet()->Host_IdentifierIsString(iNPI); }
-NPVariantG::NPVariantG(const string& iValue)
-: NPVariantBase(iValue)
- {}
-
-NPVariantG::NPVariantG(NPObjectG* iValue)
+string NPObjectG::sAsString(NPIdentifier iNPI)
{
- type = NPVariantType_Void;
- this->SetObject(iValue);
- }
-
-NPVariantG& NPVariantG::operator=(bool iValue)
- {
- this->SetBool(iValue);
- return *this;
- }
-
-NPVariantG& NPVariantG::operator=(int32 iValue)
- {
- this->SetInt32(iValue);
- return *this;
- }
-
-NPVariantG& NPVariantG::operator=(double iValue)
- {
- this->SetDouble(iValue);
- return *this;
- }
-
-NPVariantG& NPVariantG::operator=(const string& iValue)
- {
- this->SetString(iValue);
- return *this;
- }
-
-NPVariantG& NPVariantG::operator=(NPObjectG* iValue)
- {
- this->SetObject(iValue);
- return *this;
- }
-
-void NPVariantG::SetVoid()
- {
- this->pRelease();
- type = NPVariantType_Void;
- }
-
-void NPVariantG::SetNull()
- {
- this->pRelease();
- type = NPVariantType_Null;
- }
-
-void NPVariantG::SetBool(bool iValue)
- {
- this->pRelease();
- type = NPVariantType_Bool;
- value.boolValue = iValue;
- }
-
-void NPVariantG::SetInt32(int32 iValue)
- {
- this->pRelease();
- type = NPVariantType_Int32;
- value.intValue = iValue;
- }
-
-void NPVariantG::SetDouble(double iValue)
- {
- this->pRelease();
- type = NPVariantType_Double;
- value.doubleValue = iValue;
- }
-
-void NPVariantG::SetString(const string& iValue)
- {
- this->pRelease();
- this->pSetString(iValue);
- type = NPVariantType_String;
- }
-
-NPObjectG* NPVariantG::GetObject() const
- { return this->DGetObject(nil); }
-
-bool NPVariantG::GetObject(NPObjectG*& oValue) const
- {
- if (type != NPVariantType_String)
- return false;
- oValue = static_cast<NPObjectG*>(value.objectValue);
- this->pRetain(oValue);
- return true;
- }
-
-NPObjectG* NPVariantG::DGetObject(NPObjectG* iDefault) const
- {
- NPObjectG* result = iDefault;
- if (type == NPVariantType_Object)
- result = static_cast<NPObjectG*>(value.objectValue);
-
- this->pRetain(result);
+ string result;
+ if (NPUTF8* theString = GuestMeister::sGet()->Host_UTF8FromIdentifier(iNPI))
+ {
+ result = theString;
+ free(theString);
+ }
return result;
}
-void NPVariantG::SetObject(NPObjectG* iValue)
- {
- this->pRelease();
- value.objectValue = iValue;
- this->pRetain(iValue);
- type = NPVariantType_Object;
- }
+int32_t NPObjectG::sAsInt(NPIdentifier iNPI)
+ { return GuestMeister::sGet()->Host_IntFromIdentifier(iNPI); }
-// =================================================================================================
-#pragma mark -
-#pragma mark * NPObjectG
+NPIdentifier NPObjectG::sAsNPI(const string& iName)
+ { return GuestMeister::sGet()->Host_GetStringIdentifier(iName.c_str()); }
-NPObjectG::NPObjectG()
- {}
+NPIdentifier NPObjectG::sAsNPI(int32_t iInt)
+ { return GuestMeister::sGet()->Host_GetIntIdentifier(iInt); }
-NPObjectG::~NPObjectG()
- {}
+void NPObjectG::Retain()
+ { GuestMeister::sGet()->Host_RetainObject(this); }
-static NPP fake = (NPP)1;
+void NPObjectG::Release()
+ { GuestMeister::sGet()->Host_ReleaseObject(this); }
bool NPObjectG::HasMethod(const string& iName)
{ return GuestMeister::sGet()->Host_HasMethod(fake, this, sAsNPI(iName)); }
@@ -315,164 +145,69 @@
bool NPObjectG::HasProperty(const string& iName)
{ return GuestMeister::sGet()->Host_HasProperty(fake, this, sAsNPI(iName)); }
+bool NPObjectG::HasProperty(size_t iIndex)
+ { return GuestMeister::sGet()->Host_HasProperty(fake, this, sAsNPI(iIndex)); }
+
bool NPObjectG::GetProperty(const string& iName, NPVariantG& oResult)
{ return GuestMeister::sGet()->Host_GetProperty(fake, this, sAsNPI(iName), &oResult); }
+bool NPObjectG::GetProperty(size_t iIndex, NPVariantG& oResult)
+ { return GuestMeister::sGet()->Host_GetProperty(fake, this, sAsNPI(iIndex), &oResult); }
+
bool NPObjectG::SetProperty(const string& iName, const NPVariantG& iValue)
{ return GuestMeister::sGet()->Host_SetProperty(fake, this, sAsNPI(iName), &iValue); }
+bool NPObjectG::SetProperty(size_t iIndex, const NPVariantG& iValue)
+ { return GuestMeister::sGet()->Host_SetProperty(fake, this, sAsNPI(iIndex), &iValue); }
+
bool NPObjectG::RemoveProperty(const string& iName)
{ return GuestMeister::sGet()->Host_RemoveProperty(fake, this, sAsNPI(iName)); }
-string NPObjectG::sAsString(NPIdentifier iNPI)
+bool NPObjectG::RemoveProperty(size_t iIndex)
+ { return GuestMeister::sGet()->Host_RemoveProperty(fake, this, sAsNPI(iIndex)); }
+
+NPVariantG NPObjectG::Invoke(const std::string& iName, const NPVariantG* iArgs, size_t iCount)
{
- string result;
- if (NPUTF8* theString = GuestMeister::sGet()->Host_UTF8FromIdentifier(iNPI))
- {
- result = theString;
- free(theString);
- }
+ NPVariantG result;
+ this->Invoke(iName, iArgs, iCount, result);
return result;
}
-NPIdentifier NPObjectG::sAsNPI(const string& iName)
- { return GuestMeister::sGet()->Host_GetStringIdentifier(iName.c_str()); }
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * ObjectG
-
-ObjectG::ObjectG()
+NPVariantG NPObjectG::Invoke(const std::string& iName)
{
- _class = &sNPClass;
- referenceCount = 1;
+ NPVariantG result;
+ this->Invoke(iName, nil, 0, result);
+ return result;
}
-ObjectG::~ObjectG()
- {}
-
-void ObjectG::Imp_Invalidate()
- {}
-
-bool ObjectG::Imp_HasMethod(const string& iName)
- { return false; }
-
-bool ObjectG::Imp_Invoke(
- const string& iName, const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult)
- { return false; }
-
-bool ObjectG::Imp_InvokeDefault(const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult)
- { return false; }
-
-bool ObjectG::Imp_HasProperty(const string& iName)
- { return false; }
-
-bool ObjectG::Imp_GetProperty(const string& iName, NPVariantG& oResult)
- { return false; }
-
-bool ObjectG::Imp_SetProperty(const string& iName, const NPVariantG& iValue)
- { return false; }
-
-bool ObjectG::Imp_RemoveProperty(const string& iName)
- { return false; }
-
-NPObject* ObjectG::sAllocate(NPP npp, NPClass *aClass)
+NPVariantG NPObjectG::InvokeDefault(const NPVariantG* iArgs, size_t iCount)
{
- ZUnimplemented();
- return nil;
+ NPVariantG result;
+ this->InvokeDefault(iArgs, iCount, result);
+ return result;
}
-void ObjectG::sDeallocate(NPObject* npobj)
+NPVariantG NPObjectG::InvokeDefault()
{
- ZNETSCAPE_BEFORE
- delete static_cast<ObjectG*>(npobj);
- ZNETSCAPE_AFTER_VOID
+ NPVariantG result;
+ this->InvokeDefault(nil, 0, result);
+ return result;
}
-void ObjectG::sInvalidate(NPObject* npobj)
+NPVariantG NPObjectG::GetProperty(const std::string& iName)
{
- ZNETSCAPE_BEFORE
- static_cast<ObjectG*>(npobj)->Imp_Invalidate();
- ZNETSCAPE_AFTER_VOID
+ NPVariantG result;
+ this->GetProperty(iName, result);
+ return result;
}
-bool ObjectG::sHasMethod(NPObject* npobj, NPIdentifier name)
+NPVariantG NPObjectG::GetProperty(size_t iIndex)
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_HasMethod(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantG result;
+ this->GetProperty(iIndex, result);
+ return result;
}
-bool ObjectG::sInvoke(NPObject* npobj,
- NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_Invoke(
- sAsString(name),
- static_cast<const NPVariantG*>(args),
- argCount,
- *static_cast<NPVariantG*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-bool ObjectG::sInvokeDefault(NPObject* npobj,
- const NPVariant* args, uint32_t argCount, NPVariant* result)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_InvokeDefault(
- static_cast<const NPVariantG*>(args),
- argCount,
- *static_cast<NPVariantG*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-bool ObjectG::sHasProperty(NPObject* npobj, NPIdentifier name)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_HasProperty(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-bool ObjectG::sGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_GetProperty(
- sAsString(name),
- *static_cast<NPVariantG*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-bool ObjectG::sSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_SetProperty(
- sAsString(name),
- *static_cast<const NPVariantG*>(value));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-bool ObjectG::sRemoveProperty(NPObject* npobj, NPIdentifier name)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectG*>(npobj)->Imp_RemoveProperty(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-NPClass ObjectG::sNPClass =
- {
- 1,
- sAllocate,
- sDeallocate,
- sInvalidate,
- sHasMethod,
- sInvoke,
- sInvokeDefault,
- sHasProperty,
- sGetProperty,
- sSetProperty,
- sRemoveProperty
- };
-
// =================================================================================================
#pragma mark -
#pragma mark * GuestMeister
@@ -740,20 +475,70 @@
bool GuestMeister::Host_GetProperty(NPP iNPP,
NPObject* obj, NPIdentifier propertyName, NPVariant* result)
- { return fNPNF.getproperty(iNPP, obj, propertyName, result); }
+ {
+ if (fNPNF.getproperty)
+ return fNPNF.getproperty(iNPP, obj, propertyName, result);
+ return false;
+ }
bool GuestMeister::Host_SetProperty(NPP iNPP,
NPObject* obj, NPIdentifier propertyName, const NPVariant* value)
- { return fNPNF.setproperty(iNPP, obj, propertyName, value); }
+ {
+ if (fNPNF.setproperty)
+ return fNPNF.setproperty(iNPP, obj, propertyName, value);
+ return false;
+ }
bool GuestMeister::Host_RemoveProperty(NPP iNPP, NPObject* obj, NPIdentifier propertyName)
- { return fNPNF.removeproperty(iNPP, obj, propertyName); }
+ {
+ if (fNPNF.removeproperty)
+ return fNPNF.removeproperty(iNPP, obj, propertyName);
+ return false;
+ }
bool GuestMeister::Host_HasProperty(NPP iNPP, NPObject* npobj, NPIdentifier propertyName)
- { return fNPNF.hasproperty(iNPP, npobj, propertyName); }
+ {
+ if (fNPNF.hasproperty)
+ {
+ return fNPNF.hasproperty(iNPP, npobj, propertyName);
+ }
+ else if (fNPNF.getproperty)
+ {
+ NPVariantG dummy;
+ if (fNPNF.getproperty(iNPP, npobj, propertyName, &dummy))
+ return !dummy.IsVoid();
+ }
+ return false;
+ }
+
bool GuestMeister::Host_HasMethod(NPP iNPP, NPObject* npobj, NPIdentifier methodName)
- { return fNPNF.hasmethod(iNPP, npobj, methodName); }
+ {
+ if (fNPNF.hasmethod)
+ {
+ return fNPNF.hasmethod(iNPP, npobj, methodName);
+ }
+ else if (fNPNF.hasproperty)
+ {
+ return !fNPNF.hasproperty(iNPP, npobj, methodName);
+ }
+ else if (fNPNF.getproperty)
+ {
+ // We don't have hasmethod *or* hasproperty. WebKit, at least that in
+ // Safari 3.1.2, craps out if you attempt a call of a value when it's
+ // not a function. Later versions work.
+ // So, we at least distinguish between primitives and objects, and
+ // if the entity is an object then we claim that it's a method, which I
+ // suppose is better than nothing.
+ NPVariantG dummy;
+ if (fNPNF.getproperty(iNPP, npobj, methodName, &dummy))
+ {
+ if (dummy.IsObject())
+ return true;
+ }
+ }
+ return false;
+ }
void GuestMeister::Host_ReleaseVariantValue(NPVariant* variant)
{ return fNPNF.releasevariantvalue(variant); }
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.h 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest.h 2009-01-06 21:59:30 UTC (rev 357)
@@ -35,54 +35,20 @@
class NPObjectG;
-void sRetainG(NPObject* iObject);
-void sReleaseG(NPObject* iObject);
-
-void sRetain(NPObjectG* iObject);
-void sRelease(NPObjectG* iObject);
-
// =================================================================================================
#pragma mark -
#pragma mark * NPVariantG
-class NPVariantG : public NPVariantBase
- {
-public:
- NPVariantG();
- NPVariantG(const NPVariant& iOther);
- ~NPVariantG();
- NPVariantG& operator=(const NPVariant& iOther);
+typedef NPVariant_T<NPObjectG> NPVariantG;
- NPVariantG(bool iValue);
- NPVariantG(int32 iValue);
- NPVariantG(double iValue);
- NPVariantG(const std::string& iValue);
- NPVariantG(NPObjectG* iValue);
+void sRelease(NPVariantG& iNPVariantG);
- NPVariantG& operator=(bool iValue);
- NPVariantG& operator=(int32 iValue);
- NPVariantG& operator=(double iValue);
- NPVariantG& operator=(const std::string& iValue);
- NPVariantG& operator=(NPObjectG* iValue);
+// =================================================================================================
+#pragma mark -
+#pragma mark * ObjectG
- void SetVoid();
- void SetNull();
- void SetBool(bool iValue);
- void SetInt32(int32 iValue);
- void SetDouble(double iValue);
- void SetString(const std::string& iValue);
+typedef Object_T<NPVariantG> ObjectG;
- NPObjectG* GetObject() const;
- bool GetObject(NPObjectG*& oValue) const;
- NPObjectG* DGetObject(NPObjectG* iDefault) const;
- void SetObject(NPObjectG* iValue);
-
-private:
- void pRelease();
- void pRetain(NPObject* iObject) const;
- void pCopyFrom(const NPVariant& iOther);
- };
-
// =================================================================================================
#pragma mark -
#pragma mark * NPObjectG
@@ -94,61 +60,41 @@
~NPObjectG();
public:
+ static bool sIsString(NPIdentifier iNPI);
+ static std::string sAsString(NPIdentifier iNPI);
+ static int32_t sAsInt(NPIdentifier iNPI);
+
+ static NPIdentifier sAsNPI(const std::string& iName);
+ static NPIdentifier sAsNPI(int32_t iInt);
+
+ void Retain();
+ void Release();
+
bool HasMethod(const std::string& iName);
bool Invoke(
const std::string& iName, const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult);
bool InvokeDefault(const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult);
bool HasProperty(const std::string& iName);
+ bool HasProperty(size_t iIndex);
+
bool GetProperty(const std::string& iName, NPVariantG& oResult);
+ bool GetProperty(size_t iIndex, NPVariantG& oResult);
+
bool SetProperty(const std::string& iName, const NPVariantG& iValue);
+ bool SetProperty(size_t iIndex, const NPVariantG& iValue);
+
bool RemoveProperty(const std::string& iName);
+ bool RemoveProperty(size_t iIndex);
- static std::string sAsString(NPIdentifier iNPI);
- static NPIdentifier sAsNPI(const std::string& iName);
- };
+ NPVariantG Invoke(const std::string& iName, const NPVariantG* iArgs, size_t iCount);
+ NPVariantG Invoke(const std::string& iName);
-// =================================================================================================
-#pragma mark -
-#pragma mark * ObjectG
+ NPVariantG InvokeDefault(const NPVariantG* iArgs, size_t iCount);
+ NPVariantG InvokeDefault();
-class ObjectG : public NPObjectG
- {
-protected:
- ObjectG();
- virtual ~ObjectG();
-
- virtual void Imp_Invalidate();
-
- virtual bool Imp_HasMethod(const std::string& iName);
- virtual bool Imp_Invoke(
- const std::string& iName, const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult);
- virtual bool Imp_InvokeDefault(const NPVariantG* iArgs, size_t iCount, NPVariantG& oResult);
-
- virtual bool Imp_HasProperty(const std::string& iName);
- virtual bool Imp_GetProperty(const std::string& iName, NPVariantG& oResult);
- virtual bool Imp_SetProperty(const std::string& iName, const NPVariantG& iValue);
- virtual bool Imp_RemoveProperty(const std::string& iName);
-
-private:
- static NPObject* sAllocate(NPP npp, NPClass *aClass);
- static void sDeallocate(NPObject* npobj);
- static void sInvalidate(NPObject* npobj);
-
- static bool sHasMethod(NPObject* npobj, NPIdentifier name);
-
- static bool sInvoke(NPObject* npobj,
- NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result);
-
- static bool sInvokeDefault(NPObject* npobj,
- const NPVariant* args, uint32_t argCount, NPVariant* result);
-
- static bool sHasProperty(NPObject* npobj, NPIdentifier name);
- static bool sGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result);
- static bool sSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value);
- static bool sRemoveProperty(NPObject* npobj, NPIdentifier name);
-
- static NPClass sNPClass;
+ NPVariantG GetProperty(const std::string& iName);
+ NPVariantG GetProperty(size_t iIndex);
};
// =================================================================================================
@@ -281,7 +227,8 @@
virtual int32 WriteReady(NPP instance, NPStream* stream) = 0;
- virtual int32 Write(NPP instance, NPStream* stream, int32_t offset, int32_t len, void* buffer) = 0;
+ virtual int32 Write(NPP instance,
+ NPStream* stream, int32_t offset, int32_t len, void* buffer) = 0;
virtual void StreamAsFile(NPP instance, NPStream* stream, const char* fname) = 0;
@@ -338,7 +285,6 @@
#endif
};
-
// =================================================================================================
#pragma mark -
#pragma mark * Guest
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest_Std.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest_Std.cpp 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Guest_Std.cpp 2009-01-06 21:59:30 UTC (rev 357)
@@ -144,8 +144,7 @@
}
void Guest_Std::Guest_URLNotify(const char* url, NPReason reason, void* notifyData)
- {
- }
+ {}
NPError Guest_Std::Guest_GetValue(NPPVariable iNPPVariable, void* oValue)
{ return NPERR_GENERIC_ERROR; }
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.cpp 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.cpp 2009-01-06 21:59:30 UTC (rev 357)
@@ -38,278 +38,32 @@
// =================================================================================================
#pragma mark -
-#pragma mark * ZNetscape
+#pragma mark * NPVariantH
-void sRetainH(NPObject* iObject)
- { HostMeister::sGet()->RetainObject(iObject); }
+void sRelease(NPVariantH& iNPVariantH)
+ { HostMeister::sGet()->ReleaseVariantValue(&iNPVariantH); }
-void sReleaseH(NPObject* iObject)
- { HostMeister::sGet()->ReleaseObject(iObject); }
-
-void sRetain(NPObjectH* iObject)
- { sRetainH(iObject); }
-
-void sRelease(NPObjectH* iObject)
- { sReleaseH(iObject); }
-
// =================================================================================================
#pragma mark -
-#pragma mark * NPVariantH
+#pragma mark * ObjectH
-void NPVariantH::pRelease()
- {
- HostMeister::sGet()->ReleaseVariantValue(this);
- type = NPVariantType_Void;
- }
+ZNETSCAPE_OBJECT_SETUP(NPVariantH);
-void NPVariantH::pRetain(NPObject* iObject) const
- { HostMeister::sGet()->RetainObject(iObject); }
-
-void NPVariantH::pCopyFrom(const NPVariant& iOther)
- {
- switch (iOther.type)
- {
- case NPVariantType_Void:
- case NPVariantType_Null:
- break;
- case NPVariantType_Bool:
- {
- value.boolValue = iOther.value.boolValue;
- break;
- }
- case NPVariantType_Int32:
- {
- value.intValue = iOther.value.intValue;
- break;
- }
- case NPVariantType_Double:
- {
- value.doubleValue = iOther.value.doubleValue;
- break;
- }
- case NPVariantType_String:
- {
- this->pSetString(
- sNPStringCharsConst(iOther.value.stringValue),
- sNPStringLengthConst(iOther.value.stringValue));
- break;
- }
- case NPVariantType_Object:
- {
- value.objectValue = iOther.value.objectValue;
- this->pRetain(value.objectValue);
- break;
- }
- }
- type = iOther.type;
- }
-
-NPVariantH::NPVariantH()
- {}
-
-NPVariantH::NPVariantH(const NPVariant& iOther)
- {
- ZAssert(this != &iOther);
- this->pCopyFrom(iOther);
- }
-
-NPVariantH::~NPVariantH()
- {
- this->pRelease();
- }
-
-NPVariantH& NPVariantH::operator=(const NPVariant& iOther)
- {
- if (this != &iOther)
- {
- this->pRelease();
- this->pCopyFrom(iOther);
- }
- return *this;
- }
-
-NPVariantH::NPVariantH(bool iValue)
-: NPVariantBase(iValue)
- {}
-
-NPVariantH::NPVariantH(int32 iValue)
-: NPVariantBase(iValue)
- {}
-
-NPVariantH::NPVariantH(double iValue)
-: NPVariantBase(iValue)
- {}
-
-NPVariantH::NPVariantH(const string& iValue)
-: NPVariantBase(iValue)
- {}
-
-NPVariantH::NPVariantH(NPObjectH* iValue)
- {
- type = NPVariantType_Void;
- this->SetObject(iValue);
- }
-
-NPVariantH& NPVariantH::operator=(bool iValue)
- {
- this->SetBool(iValue);
- return *this;
- }
-
-NPVariantH& NPVariantH::operator=(int32 iValue)
- {
- this->SetInt32(iValue);
- return *this;
- }
-
-NPVariantH& NPVariantH::operator=(double iValue)
- {
- this->SetDouble(iValue);
- return *this;
- }
-
-NPVariantH& NPVariantH::operator=(const string& iValue)
- {
- this->SetString(iValue);
- return *this;
- }
-
-NPVariantH& NPVariantH::operator=(NPObjectH* iValue)
- {
- this->SetObject(iValue);
- return *this;
- }
-
-void NPVariantH::SetVoid()
- {
- this->pRelease();
- type = NPVariantType_Void;
- }
-
-void NPVariantH::SetNull()
- {
- this->pRelease();
- type = NPVariantType_Null;
- }
-
-void NPVariantH::SetBool(bool iValue)
- {
- this->pRelease();
- type = NPVariantType_Bool;
- value.boolValue = iValue;
- }
-
-void NPVariantH::SetInt32(int32 iValue)
- {
- this->pRelease();
- type = NPVariantType_Int32;
- value.intValue = iValue;
- }
-
-void NPVariantH::SetDouble(double iValue)
- {
- this->pRelease();
- type = NPVariantType_Double;
- value.doubleValue = iValue;
- }
-
-void NPVariantH::SetString(const string& iValue)
- {
- this->pRelease();
- this->pSetString(iValue);
- type = NPVariantType_String;
- }
-
-NPObjectH* NPVariantH::GetObject() const
- { return this->DGetObject(nil); }
-
-bool NPVariantH::GetObject(NPObjectH*& oValue) const
- {
- if (type != NPVariantType_String)
- return false;
- oValue = static_cast<NPObjectH*>(value.objectValue);
- this->pRetain(oValue);
- return true;
- }
-
-NPObjectH* NPVariantH::DGetObject(NPObjectH* iDefault) const
- {
- NPObjectH* result = iDefault;
- if (type == NPVariantType_Object)
- result = static_cast<NPObjectH*>(value.objectValue);
-
- this->pRetain(result);
- return result;
- }
-
-void NPVariantH::SetObject(NPObjectH* iValue)
- {
- this->pRelease();
- value.objectValue = iValue;
- this->pRetain(iValue);
- type = NPVariantType_Object;
- }
-
// =================================================================================================
#pragma mark -
#pragma mark * NPObjectH
+static NPP fake = nil;
+
NPObjectH::NPObjectH()
{}
NPObjectH::~NPObjectH()
{}
-bool NPObjectH::HasMethod(const string& iName)
- {
- if (_class && _class->hasMethod)
- return _class->hasMethod(this, sAsNPI(iName));
- return false;
- }
+bool NPObjectH::sIsString(NPIdentifier iNPI)
+ { return HostMeister::sGet()->IdentifierIsString(iNPI); }
-bool NPObjectH::Invoke(
- const string& iName, const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult)
- {
- if (_class && _class->invoke)
- return _class->invoke(this, sAsNPI(iName), iArgs, iCount, &oResult);
- return false;
- }
-
-bool NPObjectH::InvokeDefault(const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult)
- {
- if (_class && _class->invokeDefault)
- return _class->invokeDefault(this, iArgs, iCount, &oResult);
- return false;
- }
-
-bool NPObjectH::HasProperty(const string& iName)
- {
- if (_class && _class->hasProperty)
- return _class->hasProperty(this, sAsNPI(iName));
- return false;
- }
-
-bool NPObjectH::GetProperty(const string& iName, NPVariantH& oResult)
- {
- if (_class && _class->getProperty)
- return _class->getProperty(this, sAsNPI(iName), &oResult);
- return false;
- }
-
-bool NPObjectH::SetProperty(const string& iName, const NPVariantH& iValue)
- {
- if (_class && _class->setProperty)
- return _class->setProperty(this, sAsNPI(iName), &iValue);
- return false;
- }
-
-bool NPObjectH::RemoveProperty(const string& iName)
- {
- if (_class && _class->removeProperty)
- return _class->removeProperty(this, sAsNPI(iName));
- return false;
- }
-
string NPObjectH::sAsString(NPIdentifier iNPI)
{
string result;
@@ -321,144 +75,97 @@
return result;
}
+int32_t NPObjectH::sAsInt(NPIdentifier iNPI)
+ { return HostMeister::sGet()->IntFromIdentifier(iNPI); }
+
NPIdentifier NPObjectH::sAsNPI(const string& iName)
{ return HostMeister::sGet()->GetStringIdentifier(iName.c_str()); }
-// =================================================================================================
-#pragma mark -
-#pragma mark * ObjectH
+NPIdentifier NPObjectH::sAsNPI(int32_t iInt)
+ { return HostMeister::sGet()->GetIntIdentifier(iInt); }
-ObjectH::ObjectH()
- {
- _class = &sNPClass;
- referenceCount = 1;
- }
+void NPObjectH::Retain()
+ { HostMeister::sGet()->RetainObject(this); }
-ObjectH::~ObjectH()
- {}
+void NPObjectH::Release()
+ { HostMeister::sGet()->ReleaseObject(this); }
-void ObjectH::Imp_Invalidate()
- {}
+bool NPObjectH::HasMethod(const string& iName)
+ { return HostMeister::sGet()->HasMethod(fake, this, sAsNPI(iName)); }
-bool ObjectH::Imp_HasMethod(const string& iName)
- { return false; }
-
-bool ObjectH::Imp_Invoke(
+bool NPObjectH::Invoke(
const string& iName, const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult)
- { return false; }
+ { return HostMeister::sGet()->Invoke(fake, this, sAsNPI(iName), iArgs, iCount, &oResult); }
-bool ObjectH::Imp_InvokeDefault(const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult)
- { return false; }
+bool NPObjectH::InvokeDefault(const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult)
+ { return HostMeister::sGet()->InvokeDefault(fake, this, iArgs, iCount, &oResult); }
-bool ObjectH::Imp_HasProperty(const string& iName)
- { return false; }
+bool NPObjectH::HasProperty(const string& iName)
+ { return HostMeister::sGet()->HasProperty(fake, this, sAsNPI(iName)); }
-bool ObjectH::Imp_GetProperty(const string& iName, NPVariantH& oResult)
- { return false; }
+bool NPObjectH::HasProperty(size_t iIndex)
+ { return HostMeister::sGet()->HasProperty(fake, this, sAsNPI(iIndex)); }
-bool ObjectH::Imp_SetProperty(const string& iName, const NPVariantH& iValue)
- { return false; }
+bool NPObjectH::GetProperty(const string& iName, NPVariantH& oResult)
+ { return HostMeister::sGet()->GetProperty(fake, this, sAsNPI(iName), &oResult); }
-bool ObjectH::Imp_RemoveProperty(const string& iName)
- { return false; }
+bool NPObjectH::GetProperty(size_t iIndex, NPVariantH& oResult)
+ { return HostMeister::sGet()->GetProperty(fake, this, sAsNPI(iIndex), &oResult); }
-NPObject* ObjectH::sAllocate(NPP npp, NPClass *aClass)
- {
- ZUnimplemented();
- return nil;
- }
+bool NPObjectH::SetProperty(const string& iName, const NPVariantH& iValue)
+ { return HostMeister::sGet()->SetProperty(fake, this, sAsNPI(iName), &iValue); }
-void ObjectH::sDeallocate(NPObject* npobj)
- {
- ZNETSCAPE_BEFORE
- delete static_cast<ObjectH*>(npobj);
- ZNETSCAPE_AFTER_VOID
- }
+bool NPObjectH::SetProperty(size_t iIndex, const NPVariantH& iValue)
+ { return HostMeister::sGet()->SetProperty(fake, this, sAsNPI(iIndex), &iValue); }
-void ObjectH::sInvalidate(NPObject* npobj)
- {
- ZNETSCAPE_BEFORE
- static_cast<ObjectH*>(npobj)->Imp_Invalidate();
- ZNETSCAPE_AFTER_VOID
- }
+bool NPObjectH::RemoveProperty(const string& iName)
+ { return HostMeister::sGet()->RemoveProperty(fake, this, sAsNPI(iName)); }
-bool ObjectH::sHasMethod(NPObject* npobj, NPIdentifier name)
- {
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_HasMethod(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
+bool NPObjectH::RemoveProperty(size_t iIndex)
+ { return HostMeister::sGet()->RemoveProperty(fake, this, sAsNPI(iIndex)); }
-bool ObjectH::sInvoke(NPObject* npobj,
- NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
+NPVariantH NPObjectH::Invoke(const std::string& iName, const NPVariantH* iArgs, size_t iCount)
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_Invoke(
- sAsString(name),
- static_cast<const NPVariantH*>(args),
- argCount,
- *static_cast<NPVariantH*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->Invoke(iName, iArgs, iCount, result);
+ return result;
}
-bool ObjectH::sInvokeDefault(NPObject* npobj,
- const NPVariant* args, uint32_t argCount, NPVariant* result)
+NPVariantH NPObjectH::Invoke(const std::string& iName)
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_InvokeDefault(
- static_cast<const NPVariantH*>(args),
- argCount,
- *static_cast<NPVariantH*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->Invoke(iName, nil, 0, result);
+ return result;
}
-bool ObjectH::sHasProperty(NPObject* npobj, NPIdentifier name)
+NPVariantH NPObjectH::InvokeDefault(const NPVariantH* iArgs, size_t iCount)
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_HasProperty(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->InvokeDefault(iArgs, iCount, result);
+ return result;
}
-bool ObjectH::sGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
+NPVariantH NPObjectH::InvokeDefault()
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_GetProperty(
- sAsString(name),
- *static_cast<NPVariantH*>(result));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->InvokeDefault(nil, 0, result);
+ return result;
}
-bool ObjectH::sSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value)
+NPVariantH NPObjectH::GetProperty(const std::string& iName)
{
- ZNETSCAPE_BEFORE
- return static_cast<ObjectH*>(npobj)->Imp_SetProperty(
- sAsString(name),
- *static_cast<const NPVariantH*>(value));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->GetProperty(iName, result);
+ return result;
}
-bool ObjectH::sRemoveProperty(NPObject* npobj, NPIdentifier name)
+NPVariantH NPObjectH::GetProperty(size_t iIndex)
{
- ZNETSCAPE_BEFORE
- return static_cast<NPObjectH*>(npobj)->RemoveProperty(sAsString(name));
- ZNETSCAPE_AFTER_RETURN_FALSE
+ NPVariantH result;
+ this->GetProperty(iIndex, result);
+ return result;
}
-NPClass ObjectH::sNPClass =
- {
- 1,
- sAllocate,
- sDeallocate,
- sInvalidate,
- sHasMethod,
- sInvoke,
- sInvokeDefault,
- sHasProperty,
- sGetProperty,
- sSetProperty,
- sRemoveProperty
- };
-
// =================================================================================================
#pragma mark -
#pragma mark * HostMeister
@@ -589,257 +296,228 @@
return result;
}
-// -----
-// Forwarded to HostMeister
-
-void* HostMeister::sMemAlloc(uint32 size)
+NPError HostMeister::sGetURL(NPP npp, const char* URL, const char* window)
{
ZNETSCAPE_BEFORE
- return sGet()->MemAlloc(size);
- ZNETSCAPE_AFTER_RETURN_NIL
+ return sGet()->GetURL(npp, URL, window);
+ ZNETSCAPE_AFTER_NPERROR
}
-void HostMeister::sMemFree(void* ptr)
+NPError HostMeister::sPostURL(NPP npp,
+ const char* URL, const char* window, uint32 len, const char* buf, NPBool file)
{
ZNETSCAPE_BEFORE
- sGet()->MemFree(ptr);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->PostURL(npp, URL, window, len, buf, file);
+ ZNETSCAPE_AFTER_NPERROR
}
-uint32 HostMeister::sMemFlush(uint32 size)
+NPError HostMeister::sRequestRead(NPStream* stream, NPByteRange* rangeList)
{
ZNETSCAPE_BEFORE
- return sGet()->MemFlush(size);
- ZNETSCAPE_AFTER_RETURN(0)
+ return sGet()->RequestRead(stream, rangeList);
+ ZNETSCAPE_AFTER_NPERROR
}
-void HostMeister::sReloadPlugins(NPBool reloadPages)
+NPError HostMeister::sNewStream(NPP npp,
+ NPMIMEType type, const char* window, NPStream** stream)
{
ZNETSCAPE_BEFORE
- sGet()->ReloadPlugins(reloadPages);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->NewStream(npp, type, window, stream);
+ ZNETSCAPE_AFTER_NPERROR
}
-void* HostMeister::sGetJavaEnv()
+int32 HostMeister::sWrite(NPP npp, NPStream* stream, int32 len, void* buffer)
{
ZNETSCAPE_BEFORE
- return sGet()->GetJavaEnv();
- ZNETSCAPE_AFTER_RETURN_NIL
+ return sGet()->Write(npp, stream, len, buffer);
+ ZNETSCAPE_AFTER_RETURN(-1)
}
-NPIdentifier HostMeister::sGetStringIdentifier(const NPUTF8* name)
+NPError HostMeister::sDestroyStream(NPP npp, NPStream* stream, NPReason reason)
{
ZNETSCAPE_BEFORE
- return sGet()->GetStringIdentifier(name);
- ZNETSCAPE_AFTER_RETURN_NIL
+ return sGet()->DestroyStream(npp, stream, reason);
+ ZNETSCAPE_AFTER_NPERROR
}
-void HostMeister::sGetStringIdentifiers(
- const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
+void HostMeister::sStatus(NPP npp, const char* message)
{
ZNETSCAPE_BEFORE
- sGet()->GetStringIdentifiers(names, nameCount, identifiers);
+ return sGet()->Status(npp, message);
ZNETSCAPE_AFTER_VOID
}
-NPIdentifier HostMeister::sGetIntIdentifier(int32_t intid)
+const char* HostMeister::sUserAgent(NPP npp)
{
- ZNETSCAPE_BEFORE
- return sGet()->GetIntIdentifier(intid);
+ ZNETSCAPE_BEFORE
+ return sGet()->UserAgent(npp);
ZNETSCAPE_AFTER_RETURN_NIL
}
-bool HostMeister::sIdentifierIsString(NPIdentifier identifier)
+void* HostMeister::sMemAlloc(uint32 size)
{
ZNETSCAPE_BEFORE
- return sGet()->IdentifierIsString(identifier);
- ZNETSCAPE_AFTER_RETURN_FALSE
- }
-
-NPUTF8* HostMeister::sUTF8FromIdentifier(NPIdentifier identifier)
- {
- ZNETSCAPE_BEFORE
- return sGet()->UTF8FromIdentifier(identifier);
+ return sGet()->MemAlloc(size);
ZNETSCAPE_AFTER_RETURN_NIL
}
-int32_t HostMeister::sIntFromIdentifier(NPIdentifier identifier)
+void HostMeister::sMemFree(void* ptr)
{
ZNETSCAPE_BEFORE
- return sGet()->IntFromIdentifier(identifier);
- ZNETSCAPE_AFTER_RETURN(0xFFFFFFFF)
+ sGet()->MemFree(ptr);
+ ZNETSCAPE_AFTER_VOID
}
-NPObject* HostMeister::sRetainObject(NPObject* obj)
+uint32 HostMeister::sMemFlush(uint32 size)
{
ZNETSCAPE_BEFORE
- return sGet()->RetainObject(obj);
- ZNETSCAPE_AFTER_RETURN_NIL
+ return sGet()->MemFlush(size);
+ ZNETSCAPE_AFTER_RETURN(0)
}
-void HostMeister::sReleaseObject(NPObject* obj)
+void HostMeister::sReloadPlugins(NPBool reloadPages)
{
ZNETSCAPE_BEFORE
- sGet()->ReleaseObject(obj);
+ sGet()->ReloadPlugins(reloadPages);
ZNETSCAPE_AFTER_VOID
}
-void HostMeister::sReleaseVariantValue(NPVariant* variant)
+void* HostMeister::sGetJavaEnv()
{
ZNETSCAPE_BEFORE
- sGet()->ReleaseVariantValue(variant);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->GetJavaEnv();
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-void HostMeister::sSetException(NPObject* obj, const NPUTF8* message)
+void* HostMeister::sGetJavaPeer(NPP npp)
{
ZNETSCAPE_BEFORE
- sGet()->SetException(obj, message);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->GetJavaPeer(npp);
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-void HostMeister::sSetExceptionNPString(NPObject* obj, NPString* message)
+NPError HostMeister::sGetURLNotify(NPP npp,
+ const char* URL, const char* window, void* notifyData)
{
ZNETSCAPE_BEFORE
- sGet()->SetException(obj, sNPStringChars(*message));
- ZNETSCAPE_AFTER_VOID
- }
-
-// -----
-// Forwarded to Host
-
-NPError HostMeister::sGetURL(NPP npp, const char* URL, const char* window)
- {
- ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_GetURL(npp, URL, window);
+ return sGet()->GetURLNotify(npp, URL, window, notifyData);
ZNETSCAPE_AFTER_NPERROR
}
-NPError HostMeister::sPostURL(NPP npp,
- const char* URL, const char* window, uint32 len, const char* buf, NPBool file)
+NPError HostMeister::sPostURLNotify(NPP npp,
+ const char* URL, const char* window,
+ uint32 len, const char* buf, NPBool file, void* notifyData)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_PostURL(npp, URL, window, len, buf, file);
+ return sGet()->PostURLNotify(npp, URL, window, len, buf, file, notifyData);
ZNETSCAPE_AFTER_NPERROR
}
-NPError HostMeister::sRequestRead(NPStream* stream, NPByteRange* rangeList)
+NPError HostMeister::sGetValue(NPP npp, NPNVariable variable, void* ret_value)
{
ZNETSCAPE_BEFORE
- return sHostFromStream(stream)->Host_RequestRead(stream, rangeList);
+ return sGet()->GetValue(npp, variable, ret_value);
ZNETSCAPE_AFTER_NPERROR
}
-NPError HostMeister::sNewStream(NPP npp,
- NPMIMEType type, const char* window, NPStream** stream)
+NPError HostMeister::sSetValue(NPP npp, NPPVariable variable, void* value)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_NewStream(npp, type, window, stream);
+ return sGet()->SetValue(npp, variable, value);
ZNETSCAPE_AFTER_NPERROR
}
-int32 HostMeister::sWrite(NPP npp, NPStream* stream, int32 len, void* buffer)
+void HostMeister::sInvalidateRect(NPP npp, NPRect* rect)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_Write(npp, stream, len, buffer);
- ZNETSCAPE_AFTER_RETURN(-1)
+ return sGet()->InvalidateRect(npp, rect);
+ ZNETSCAPE_AFTER_VOID
}
-NPError HostMeister::sDestroyStream(NPP npp, NPStream* stream, NPReason reason)
+void HostMeister::sInvalidateRegion(NPP npp, NPRegion region)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_DestroyStream(npp, stream, reason);
- ZNETSCAPE_AFTER_NPERROR
+ return sGet()->InvalidateRegion(npp, region);
+ ZNETSCAPE_AFTER_VOID
}
-void HostMeister::sStatus(NPP npp, const char* message)
+void HostMeister::sForceRedraw(NPP npp)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_Status(npp, message);
+ return sGet()->ForceRedraw(npp);
ZNETSCAPE_AFTER_VOID
}
-const char* HostMeister::sUserAgent(NPP npp)
+NPIdentifier HostMeister::sGetStringIdentifier(const NPUTF8* name)
{
- ZNETSCAPE_BEFORE
- if (Host* theHost = sHostFromNPP(npp))
- return theHost->Host_UserAgent(npp);
- return "Unknown";
+ ZNETSCAPE_BEFORE
+ return sGet()->GetStringIdentifier(name);
ZNETSCAPE_AFTER_RETURN_NIL
}
-void* HostMeister::sGetJavaPeer(NPP npp)
+void HostMeister::sGetStringIdentifiers(
+ const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_GetJavaPeer(npp);
- ZNETSCAPE_AFTER_RETURN_NIL
+ sGet()->GetStringIdentifiers(names, nameCount, identifiers);
+ ZNETSCAPE_AFTER_VOID
}
-NPError HostMeister::sGetURLNotify(NPP npp,
- const char* URL, const char* window, void* notifyData)
+NPIdentifier HostMeister::sGetIntIdentifier(int32_t intid)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_GetURLNotify(npp, URL, window, notifyData);
- ZNETSCAPE_AFTER_NPERROR
+ return sGet()->GetIntIdentifier(intid);
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-NPError HostMeister::sPostURLNotify(NPP npp,
- const char* URL, const char* window,
- uint32 len, const char* buf, NPBool file, void* notifyData)
+bool HostMeister::sIdentifierIsString(NPIdentifier identifier)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_PostURLNotify(npp, URL, window, len, buf, file, notifyData);
- ZNETSCAPE_AFTER_NPERROR
+ return sGet()->IdentifierIsString(identifier);
+ ZNETSCAPE_AFTER_RETURN_FALSE
}
-NPError HostMeister::sGetValue(NPP npp, NPNVariable variable, void* ret_value)
+NPUTF8* HostMeister::sUTF8FromIdentifier(NPIdentifier identifier)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_GetValue(npp, variable, ret_value);
- ZNETSCAPE_AFTER_NPERROR
+ return sGet()->UTF8FromIdentifier(identifier);
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-NPError HostMeister::sSetValue(NPP npp, NPPVariable variable, void* value)
+int32_t HostMeister::sIntFromIdentifier(NPIdentifier identifier)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_SetValue(npp, variable, value);
- ZNETSCAPE_AFTER_NPERROR
+ return sGet()->IntFromIdentifier(identifier);
+ ZNETSCAPE_AFTER_RETURN(0xFFFFFFFF)
}
-void HostMeister::sInvalidateRect(NPP npp, NPRect* rect)
+NPObject* HostMeister::sCreateObject(NPP npp, NPClass* aClass)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_InvalidateRect(npp, rect);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->CreateObject(npp, aClass);
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-void HostMeister::sInvalidateRegion(NPP npp, NPRegion region)
+NPObject* HostMeister::sRetainObject(NPObject* obj)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_InvalidateRegion(npp, region);
- ZNETSCAPE_AFTER_VOID
+ return sGet()->RetainObject(obj);
+ ZNETSCAPE_AFTER_RETURN_NIL
}
-void HostMeister::sForceRedraw(NPP npp)
+void HostMeister::sReleaseObject(NPObject* obj)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_ForceRedraw(npp);
+ sGet()->ReleaseObject(obj);
ZNETSCAPE_AFTER_VOID
}
-NPObject* HostMeister::sCreateObject(NPP npp, NPClass* aClass)
- {
- ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_CreateObject(npp, aClass);
- ZNETSCAPE_AFTER_RETURN_NIL
- }
-
bool HostMeister::sInvoke(NPP npp,
NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
NPVariant* result)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_Invoke(npp, obj, methodName, args, argCount, result);
+ return sGet()->Invoke(npp, obj, methodName, args, argCount, result);
ZNETSCAPE_AFTER_RETURN_FALSE
}
@@ -847,7 +525,7 @@
NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_InvokeDefault(npp, obj, args, argCount, result);
+ return sGet()->InvokeDefault(npp, obj, args, argCount, result);
ZNETSCAPE_AFTER_RETURN_FALSE
}
@@ -855,7 +533,7 @@
NPObject* obj, NPString* script, NPVariant* result)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_Evaluate(npp, obj, script, result);
+ return sGet()->Evaluate(npp, obj, script, result);
ZNETSCAPE_AFTER_RETURN_FALSE
}
@@ -863,7 +541,7 @@
NPObject* obj, NPIdentifier propertyName, NPVariant* result)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_GetProperty(npp, obj, propertyName, result);
+ return sGet()->GetProperty(npp, obj, propertyName, result);
ZNETSCAPE_AFTER_RETURN_FALSE
}
@@ -871,31 +549,52 @@
NPObject* obj, NPIdentifier propertyName, const NPVariant* value)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_SetProperty(npp, obj, propertyName, value);
+ return sGet()->SetProperty(npp, obj, propertyName, value);
ZNETSCAPE_AFTER_RETURN_FALSE
}
bool HostMeister::sRemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_RemoveProperty(npp, obj, propertyName);
+ return sGet()->RemoveProperty(npp, obj, propertyName);
ZNETSCAPE_AFTER_RETURN_FALSE
}
bool HostMeister::sHasProperty(NPP npp, NPObject* npobj, NPIdentifier propertyName)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_HasProperty(npp, npobj, propertyName);
+ return sGet()->HasProperty(npp, npobj, propertyName);
ZNETSCAPE_AFTER_RETURN_FALSE
}
bool HostMeister::sHasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName)
{
ZNETSCAPE_BEFORE
- return sHostFromNPP(npp)->Host_HasMethod(npp, npobj, methodName);
+ return sGet()->HasMethod(npp, npobj, methodName);
ZNETSCAPE_AFTER_RETURN_FALSE
}
+void HostMeister::sReleaseVariantValue(NPVariant* variant)
+ {
+ ZNETSCAPE_BEFORE
+ sGet()->ReleaseVariantValue(variant);
+ ZNETSCAPE_AFTER_VOID
+ }
+
+void HostMeister::sSetException(NPObject* obj, const NPUTF8* message)
+ {
+ ZNETSCAPE_BEFORE
+ sGet()->SetException(obj, message);
+ ZNETSCAPE_AFTER_VOID
+ }
+
+void HostMeister::sSetExceptionNPString(NPObject* obj, NPString* message)
+ {
+ ZNETSCAPE_BEFORE
+ sGet()->SetException(obj, sNPStringChars(*message));
+ ZNETSCAPE_AFTER_VOID
+ }
+
// =================================================================================================
#pragma mark -
#pragma mark * GuestFactory
@@ -907,9 +606,7 @@
{}
void GuestFactory::GetNPNF(NPNetscapeFuncs& oNPNF)
- {
- HostMeister::sGet()->sGetNPNF(oNPNF);
- }
+ { HostMeister::sGet()->sGetNPNF(oNPNF); }
// =================================================================================================
#pragma mark -
@@ -931,26 +628,6 @@
ZRef<GuestFactory> Host::GetGuestFactory()
{ return fGuestFactory; }
-void Host::Release(NPObject* iObj)
- { HostMeister::sGet()->ReleaseObject(iObj); }
-
-bool Host::Invoke(
- NPObject* obj, const std::string& iMethod, const NPVariant* iArgs, size_t iCount,
- NPVariant& oResult)
- {
- NPIdentifier methodID = HostMeister::sGet()->GetStringIdentifier(iMethod.c_str());
-
- if (obj && obj->_class && obj->_class->hasMethod && obj->_class->invoke)
- {
- if (obj->_class->hasMethod(obj, methodID))
- {
- if (obj->_class->invoke(obj, methodID, iArgs, iCount, &oResult))
- return true;
- }
- }
- return false;
- }
-
const NPP_t& Host::GetNPP()
{ return fNPP_t; }
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.h 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Host.h 2009-01-06 21:59:30 UTC (rev 357)
@@ -40,54 +40,20 @@
class NPObjectH;
-void sRetainH(NPObject* iObject);
-void sReleaseH(NPObject* iObject);
-
-void sRetain(NPObjectH* iObject);
-void sRelease(NPObjectH* iObject);
-
// =================================================================================================
#pragma mark -
#pragma mark * NPVariantH
-class NPVariantH : public NPVariantBase
- {
-public:
- NPVariantH();
- NPVariantH(const NPVariant& iOther);
- ~NPVariantH();
- NPVariantH& operator=(const NPVariant& iOther);
+typedef NPVariant_T<NPObjectH> NPVariantH;
- NPVariantH(bool iValue);
- NPVariantH(int32 iValue);
- NPVariantH(double iValue);
- NPVariantH(const std::string& iValue);
- NPVariantH(NPObjectH* iValue);
+void sRelease(NPVariantH& iNPVariantH);
- NPVariantH& operator=(bool iValue);
- NPVariantH& operator=(int32 iValue);
- NPVariantH& operator=(double iValue);
- NPVariantH& operator=(const std::string& iValue);
- NPVariantH& operator=(NPObjectH* iValue);
+// =================================================================================================
+#pragma mark -
+#pragma mark * ObjectH
- void SetVoid();
- void SetNull();
- void SetBool(bool iValue);
- void SetInt32(int32 iValue);
- void SetDouble(double iValue);
- void SetString(const std::string& iValue);
+typedef Object_T<NPVariantH> ObjectH;
- NPObjectH* GetObject() const;
- bool GetObject(NPObjectH*& oValue) const;
- NPObjectH* DGetObject(NPObjectH* iDefault) const;
- void SetObject(NPObjectH* iValue);
-
-private:
- void pRelease();
- void pRetain(NPObject* iObject) const;
- void pCopyFrom(const NPVariant& iOther);
- };
-
// =================================================================================================
#pragma mark -
#pragma mark * NPObjectH
@@ -99,61 +65,41 @@
~NPObjectH();
public:
+ static bool sIsString(NPIdentifier iNPI);
+ static std::string sAsString(NPIdentifier iNPI);
+ static int32_t sAsInt(NPIdentifier iNPI);
+
+ static NPIdentifier sAsNPI(const std::string& iName);
+ static NPIdentifier sAsNPI(int32_t iInt);
+
+ void Retain();
+ void Release();
+
bool HasMethod(const std::string& iName);
bool Invoke(
const std::string& iName, const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult);
bool InvokeDefault(const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult);
bool HasProperty(const std::string& iName);
+ bool HasProperty(size_t iIndex);
+
bool GetProperty(const std::string& iName, NPVariantH& oResult);
+ bool GetProperty(size_t iIndex, NPVariantH& oResult);
+
bool SetProperty(const std::string& iName, const NPVariantH& iValue);
+ bool SetProperty(size_t iIndex, const NPVariantH& iValue);
+
bool RemoveProperty(const std::string& iName);
+ bool RemoveProperty(size_t iIndex);
- static std::string sAsString(NPIdentifier iNPI);
- static NPIdentifier sAsNPI(const std::string& iName);
- };
+ NPVariantH Invoke(const std::string& iName, const NPVariantH* iArgs, size_t iCount);
+ NPVariantH Invoke(const std::string& iName);
-// =================================================================================================
-#pragma mark -
-#pragma mark * ObjectH
+ NPVariantH InvokeDefault(const NPVariantH* iArgs, size_t iCount);
+ NPVariantH InvokeDefault();
-class ObjectH : public NPObjectH
- {
-protected:
- ObjectH();
- virtual ~ObjectH();
-
- virtual void Imp_Invalidate();
-
- virtual bool Imp_HasMethod(const std::string& iName);
- virtual bool Imp_Invoke(
- const std::string& iName, const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult);
- virtual bool Imp_InvokeDefault(const NPVariantH* iArgs, size_t iCount, NPVariantH& oResult);
-
- virtual bool Imp_HasProperty(const std::string& iName);
- virtual bool Imp_GetProperty(const std::string& iName, NPVariantH& oResult);
- virtual bool Imp_SetProperty(const std::string& iName, const NPVariantH& iValue);
- virtual bool Imp_RemoveProperty(const std::string& iName);
-
-private:
- static NPObject* sAllocate(NPP npp, NPClass *aClass);
- static void sDeallocate(NPObject* npobj);
- static void sInvalidate(NPObject* npobj);
-
- static bool sHasMethod(NPObject* npobj, NPIdentifier name);
-
- static bool sInvoke(NPObject* npobj,
- NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result);
-
- static bool sInvokeDefault(NPObject* npobj,
- const NPVariant* args, uint32_t argCount, NPVariant* result);
-
- static bool sHasProperty(NPObject* npobj, NPIdentifier name);
- static bool sGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result);
- static bool sSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value);
- static bool sRemoveProperty(NPObject* npobj, NPIdentifier name);
-
- static NPClass sNPClass;
+ NPVariantH GetProperty(const std::string& iName);
+ NPVariantH GetProperty(size_t iIndex);
};
// =================================================================================================
@@ -176,6 +122,24 @@
std::string StringFromIdentifier(NPIdentifier identifier);
+ virtual NPError GetURL(NPP npp, const char* URL, const char* window) = 0;
+
+ virtual NPError PostURL(NPP npp,
+ const char* URL, const char* window, uint32 len, const char* buf, NPBool file) = 0;
+
+ virtual NPError RequestRead(NPStream* stream, NPByteRange* rangeList) = 0;
+
+ virtual NPError NewStream(NPP npp,
+ NPMIMEType type, const char* window, NPStream** stream) = 0;
+
+ virtual int32 Write(NPP npp, NPStream* stream, int32 len, void* buffer) = 0;
+
+ virtual NPError DestroyStream(NPP npp, NPStream* stream, NPReason reason) = 0;
+
+ virtual void Status(NPP npp, const char* message) = 0;
+
+ virtual const char* UserAgent(NPP npp) = 0;
+
virtual void* MemAlloc(uint32 size) = 0;
virtual void MemFree(void* ptr) = 0;
@@ -186,6 +150,25 @@
virtual void* GetJavaEnv() = 0;
+ virtual void* GetJavaPeer(NPP npp) = 0;
+
+ virtual NPError GetURLNotify(NPP npp,
+ const char* URL, const char* window, void* notifyData) = 0;
+
+ virtual NPError PostURLNotify(NPP npp,
+ const char* URL, const char* window,
+ uint32 len, const char* buf, NPBool file, void* notifyData) = 0;
+
+ virtual NPError GetValue(NPP npp, NPNVariable variable, void* ret_value) = 0;
+
+ virtual NPError SetValue(NPP npp, NPPVariable variable, void* value) = 0;
+
+ virtual void InvalidateRect(NPP npp, NPRect* rect) = 0;
+
+ virtual void InvalidateRegion(NPP npp, NPRegion region) = 0;
+
+ virtual void ForceRedraw(NPP npp) = 0;
+
virtual NPIdentifier GetStringIdentifier(const NPUTF8* name) = 0;
virtual void GetStringIdentifiers(
@@ -199,49 +182,39 @@
virtual int32_t IntFromIdentifier(NPIdentifier identifier) = 0;
+ virtual NPObject* CreateObject(NPP npp, NPClass* aClass) = 0;
+
virtual NPObject* RetainObject(NPObject* obj) = 0;
virtual void ReleaseObject(NPObject* obj) = 0;
- virtual void ReleaseVariantValue(NPVariant* variant) = 0;
+ virtual bool Invoke(NPP npp,
+ NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
+ NPVariant* result) = 0;
- virtual void SetException(NPObject* obj, const NPUTF8* message) = 0;
+ virtual bool InvokeDefault(NPP npp,
+ NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result) = 0;
-private:
-// Forwarded to HostMeister
- static void* sMemAlloc(uint32 size);
+ virtual bool Evaluate(NPP npp,
+ NPObject* obj, NPString* script, NPVariant* result) = 0;
- static void sMemFree(void* ptr);
+ virtual bool GetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, NPVariant* result) = 0;
- static uint32 sMemFlush(uint32 size);
+ virtual bool SetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, const NPVariant* value) = 0;
- static void sReloadPlugins(NPBool reloadPages);
+ virtual bool RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) = 0;
- static void* sGetJavaEnv();
+ virtual bool HasProperty(NPP, NPObject* npobj, NPIdentifier propertyName) = 0;
- static NPIdentifier sGetStringIdentifier(const NPUTF8* name);
+ virtual bool HasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName) = 0;
- static void sGetStringIdentifiers(
- const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers);
+ virtual void ReleaseVariantValue(NPVariant* variant) = 0;
- static NPIdentifier sGetIntIdentifier(int32_t intid);
+ virtual void SetException(NPObject* obj, const NPUTF8* message) = 0;
- static bool sIdentifierIsString(NPIdentifier identifier);
-
- static NPUTF8* sUTF8FromIdentifier(NPIdentifier identifier);
-
- static int32_t sIntFromIdentifier(NPIdentifier identifier);
-
- static NPObject* sRetainObject(NPObject* obj);
-
- static void sReleaseObject(NPObject* obj);
-
- static void sReleaseVariantValue(NPVariant* variant);
-
- static void sSetException(NPObject* obj, const NPUTF8* message);
- static void sSetExceptionNPString(NPObject* obj, NPString* message);
-
-// Forwarded to Host
+private:
static NPError sGetURL(NPP npp, const char* URL, const char* window);
static NPError sPostURL(NPP npp,
@@ -260,6 +233,16 @@
static const char* sUserAgent(NPP npp);
+ static void* sMemAlloc(uint32 size);
+
+ static void sMemFree(void* ptr);
+
+ static uint32 sMemFlush(uint32 size);
+
+ static void sReloadPlugins(NPBool reloadPages);
+
+ static void* sGetJavaEnv();
+
static void* sGetJavaPeer(NPP npp);
static NPError sGetURLNotify(NPP npp,
@@ -279,8 +262,25 @@
static void sForceRedraw(NPP npp);
+ static NPIdentifier sGetStringIdentifier(const NPUTF8* name);
+
+ static void sGetStringIdentifiers(
+ const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers);
+
+ static NPIdentifier sGetIntIdentifier(int32_t intid);
+
+ static bool sIdentifierIsString(NPIdentifier identifier);
+
+ static NPUTF8* sUTF8FromIdentifier(NPIdentifier identifier);
+
+ static int32_t sIntFromIdentifier(NPIdentifier identifier);
+
static NPObject* sCreateObject(NPP npp, NPClass* aClass);
+ static NPObject* sRetainObject(NPObject* obj);
+
+ static void sReleaseObject(NPObject* obj);
+
static bool sInvoke(NPP npp,
NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
NPVariant* result);
@@ -302,6 +302,11 @@
static bool sHasProperty(NPP npp, NPObject* npobj, NPIdentifier propertyName);
static bool sHasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName);
+
+ static void sReleaseVariantValue(NPVariant* variant);
+
+ static void sSetException(NPObject* obj, const NPUTF8* message);
+ static void sSetExceptionNPString(NPObject* obj, NPString* message);
};
// =================================================================================================
@@ -334,12 +339,6 @@
public:
ZRef<GuestFactory> GetGuestFactory();
- void Release(NPObject* iObj);
-
- bool Invoke(
- NPObject* obj, const std::string& iMethod, const NPVariant* iArgs, size_t iCount,
- NPVariant& oResult);
-
const NPP_t& GetNPP();
// Calls into the guest
@@ -371,68 +370,6 @@
NPError Guest_SetValue(NPNVariable iNPNVariable, void* iValue);
-// Our protocol
- virtual NPError Host_GetURL(NPP npp, const char* URL, const char* window) = 0;
-
- virtual NPError Host_PostURL(NPP npp,
- const char* URL, const char* window, uint32 len, const char* buf, NPBool file) = 0;
-
- virtual NPError Host_RequestRead(NPStream* stream, NPByteRange* rangeList) = 0;
-
- virtual NPError Host_NewStream(NPP npp,
- NPMIMEType type, const char* window, NPStream** stream) = 0;
-
- virtual int32 Host_Write(NPP npp, NPStream* stream, int32 len, void* buffer) = 0;
-
- virtual NPError Host_DestroyStream(NPP npp, NPStream* stream, NPReason reason) = 0;
-
- virtual void Host_Status(NPP npp, const char* message) = 0;
-
- virtual const char* Host_UserAgent(NPP npp) = 0;
-
- virtual void* Host_GetJavaPeer(NPP npp) = 0;
-
- virtual NPError Host_GetURLNotify(NPP npp,
- const char* URL, const char* window, void* notifyData) = 0;
-
- virtual NPError Host_PostURLNotify(NPP npp,
- const char* URL, const char* window,
- uint32 len, const char* buf, NPBool file, void* notifyData) = 0;
-
- virtual NPError Host_GetValue(NPP npp, NPNVariable variable, void* ret_value) = 0;
-
- virtual NPError Host_SetValue(NPP npp, NPPVariable variable, void* value) = 0;
-
- virtual void Host_InvalidateRect(NPP npp, NPRect* rect) = 0;
-
- virtual void Host_InvalidateRegion(NPP npp, NPRegion region) = 0;
-
- virtual void Host_ForceRedraw(NPP npp) = 0;
-
- virtual NPObject* Host_CreateObject(NPP npp, NPClass* aClass) = 0;
-
- virtual bool Host_Invoke(NPP npp,
- NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
- NPVariant* result) = 0;
-
- virtual bool Host_InvokeDefault(NPP npp,
- NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result) = 0;
-
- virtual bool Host_Evaluate(NPP npp,
- NPObject* obj, NPString* script, NPVariant* result) = 0;
-
- virtual bool Host_GetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, NPVariant* result) = 0;
-
- virtual bool Host_SetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, const NPVariant* value) = 0;
-
- virtual bool Host_RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) = 0;
-
- virtual bool Host_HasProperty(NPP, NPObject* npobj, NPIdentifier propertyName) = 0;
-
- virtual bool Host_HasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName) = 0;
-
private:
ZRef<GuestFactory> fGuestFactory;
NPPluginFuncs fNPPluginFuncs;
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.cpp 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.cpp 2009-01-06 21:59:30 UTC (rev 357)
@@ -53,8 +53,7 @@
NAMESPACE_ZOOLIB_BEGIN
using std::list;
-using std::map;
-using std::pair;
+using std::set;
using std::string;
using std::vector;
@@ -70,6 +69,100 @@
HostMeister_Std::~HostMeister_Std()
{}
+Host_Std* HostMeister_Std::sHostFromNPP_Std(NPP npp)
+ { return static_cast<Host_Std*>(sHostFromNPP(npp)); }
+
+Host_Std* HostMeister_Std::sHostFromStream_Std(NPStream* iNPStream)
+ { return static_cast<Host_Std*>(sHostFromStream(iNPStream)); }
+
+NPError HostMeister_Std::GetURL(NPP npp, const char* URL, const char* window)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "GetURL";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_GetURL(npp, URL, window);
+
+ return NPERR_GENERIC_ERROR;
+ }
+
+NPError HostMeister_Std::PostURL(NPP npp,
+ const char* URL, const char* window, uint32 len, const char* buf, NPBool file)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "PostURL";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_PostURL(npp, URL, window, len, buf, file);
+
+ return NPERR_GENERIC_ERROR;
+ }
+
+NPError HostMeister_Std::RequestRead(NPStream* stream, NPByteRange* rangeList)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "RequestRead";
+
+ if (Host_Std* theHost = sHostFromStream_Std(stream))
+ return theHost->Host_RequestRead(stream, rangeList);
+
+ return NPERR_GENERIC_ERROR;
+ }
+
+NPError HostMeister_Std::NewStream(NPP npp,
+ NPMIMEType type, const char* window, NPStream** stream)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "NewStream";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_NewStream(npp, type, window, stream);
+
+ return NPERR_GENERIC_ERROR;
+ }
+
+int32 HostMeister_Std::Write(NPP npp, NPStream* stream, int32 len, void* buffer)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "Write";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_Write(npp, stream, len, buffer);
+
+ return -1;
+ }
+
+NPError HostMeister_Std::DestroyStream(NPP npp, NPStream* stream, NPReason reason)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "DestroyStream";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_DestroyStream(npp, stream, reason);
+
+ return NPERR_GENERIC_ERROR;
+ }
+
+void HostMeister_Std::Status(NPP npp, const char* message)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "Status";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ theHost->Host_Status(npp, message);
+ }
+
+const char* HostMeister_Std::UserAgent(NPP npp)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "UserAgent";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_UserAgent(npp);
+
+ return nil;
+ }
+
void* HostMeister_Std::MemAlloc(uint32 size)
{ return ::malloc(size); }
@@ -85,69 +178,146 @@
void* HostMeister_Std::GetJavaEnv()
{ return nil; }
-NPIdentifier HostMeister_Std::GetStringIdentifier(const NPUTF8* name)
+void* HostMeister_Std::GetJavaPeer(NPP npp)
{
- const string theName = name;
- map<string, Identifier*>::iterator i = fMap_Strings.find(theName);
- if (i != fMap_Strings.end())
- return static_cast<NPIdentifier>((*i).second);
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "GetJavaPeer";
- Identifier* theIdentifier = new Identifier;
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_GetJavaPeer(npp);
- theIdentifier->fIsString = true;
- theIdentifier->fAsString = strdup(name);
- fMap_Strings.insert(pair<string, Identifier*>(theName, theIdentifier));
+ return nil;
+ }
- return static_cast<NPIdentifier>(theIdentifier);
+NPError HostMeister_Std::GetURLNotify(NPP npp,
+ const char* URL, const char* window, void* notifyData)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "GetURLNotify";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_GetURLNotify(npp, URL, window, notifyData);
+
+ return NPERR_GENERIC_ERROR;
}
-void HostMeister_Std::GetStringIdentifiers(
- const NPUTF8* *names, int32_t nameCount, NPIdentifier* identifiers)
+NPError HostMeister_Std::PostURLNotify(NPP npp,
+ const char* URL, const char* window,
+ uint32 len, const char* buf, NPBool file, void* notifyData)
{
- while (--nameCount)
- {
- *identifiers++ = this->GetStringIdentifier(*names++);
- }
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "PostURLNotify";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_PostURLNotify(npp, URL, window, len, buf, file, notifyData);
+
+ return NPERR_GENERIC_ERROR;
}
-NPIdentifier HostMeister_Std::GetIntIdentifier(int32_t intid)
+NPError HostMeister_Std::GetValue(NPP npp, NPNVariable variable, void* ret_value)
{
- map<int, Identifier*>::iterator i = fMap_Ints.find(intid);
- if (i != fMap_Ints.end())
- return static_cast<NPIdentifier>((*i).second);
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "GetValue";
- Identifier* theIdentifier = new Identifier;
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_GetValue(npp, variable, ret_value);
- theIdentifier->fIsString = false;
- theIdentifier->fAsInt = intid;
- fMap_Ints.insert(pair<int, Identifier*>(intid, theIdentifier));
+ return NPERR_GENERIC_ERROR;
+ }
- return static_cast<NPIdentifier>(theIdentifier);
+NPError HostMeister_Std::SetValue(NPP npp, NPPVariable variable, void* value)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "SetValue";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_SetValue(npp, variable, value);
+
+ return NPERR_GENERIC_ERROR;
}
-bool HostMeister_Std::IdentifierIsString(NPIdentifier identifier)
+void HostMeister_Std::InvalidateRect(NPP npp, NPRect* rect)
{
- return static_cast<Identifier*>(identifier)->fIsString;
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "InvalidateRect";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ theHost->Host_InvalidateRect(npp, rect);
}
+void HostMeister_Std::InvalidateRegion(NPP npp, NPRegion region)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "InvalidateRegion";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ theHost->Host_InvalidateRegion(npp, region);
+ }
+
+void HostMeister_Std::ForceRedraw(NPP npp)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "ForceRedraw";
+
+ if (Host_Std* theHost = sHostFromNPP_Std(npp))
+ return theHost->Host_ForceRedraw(npp);
+ }
+
+NPIdentifier HostMeister_Std::GetStringIdentifier(const NPUTF8* name)
+ {
+ const string theName = name;
+ set<string>::iterator iter = fStrings.lower_bound(theName);
+ if (iter == fStrings.end() || *iter != theName)
+ iter = fStrings.insert(iter, theName);
+ return static_cast<NPIdentifier>(const_cast<string*>(&*iter));
+ }
+
+void HostMeister_Std::GetStringIdentifiers(
+ const NPUTF8* *names, int32_t nameCount, NPIdentifier* identifiers)
+ {
+ while (--nameCount)
+ *identifiers++ = this->GetStringIdentifier(*names++);
+ }
+
+NPIdentifier HostMeister_Std::GetIntIdentifier(int32_t intid)
+ { return reinterpret_cast<NPIdentifier>((intid << 1) | 0x1); }
+
+bool HostMeister_Std::IdentifierIsString(NPIdentifier identifier)
+ { return 0 == (reinterpret_cast<intptr_t>(identifier) & 0x1); }
+
NPUTF8* HostMeister_Std::UTF8FromIdentifier(NPIdentifier identifier)
{
- Identifier* theID = static_cast<Identifier*>(identifier);
- if (!theID->fIsString || !theID->fAsString)
- return nil;
-
- return (NPUTF8*)strdup(theID->fAsString);
+ if (0 == (reinterpret_cast<intptr_t>(identifier) & 0x1))
+ return (NPUTF8*)strdup(static_cast<string*>(identifier)->c_str());
+ return nil;
}
int32_t HostMeister_Std::IntFromIdentifier(NPIdentifier identifier)
{
- Identifier* theID = static_cast<Identifier*>(identifier);
- if (theID->fIsString)
- return 0;
-
- return theID->fAsInt;
+ const int32_t asInt = reinterpret_cast<intptr_t>(identifier);
+ if (asInt & 0x1)
+ return asInt >> 1;
+ return 0;
}
+NPObject* HostMeister_Std::CreateObject(NPP npp, NPClass* aClass)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("CreateObject");
+
+ ZAssert(aClass);
+ NPObject* result;
+ if (aClass->allocate)
+ result = aClass->allocate(npp, aClass);
+ else
+ result = (NPObject*)malloc(sizeof(NPObject));
+
+ result->_class = aClass;
+ result->referenceCount = 1;
+
+ return result;
+ }
+
NPObject* HostMeister_Std::RetainObject(NPObject* obj)
{
ZAssert(obj);
@@ -167,6 +337,96 @@
}
}
+bool HostMeister_Std::Invoke(NPP npp,
+ NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
+ NPVariant* result)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "Invoke: " << this->StringFromIdentifier(methodName);
+
+ if (obj && obj->_class && obj->_class->invoke)
+ return obj->_class->invoke(obj, methodName, args, argCount, result);
+
+ return false;
+ }
+
+bool HostMeister_Std::InvokeDefault(NPP npp,
+ NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("InvokeDefault");
+
+ if (obj && obj->_class && obj->_class->invokeDefault)
+ return obj->_class->invokeDefault(obj, args, argCount, result);
+
+ return false;
+ }
+
+bool HostMeister_Std::Evaluate(NPP npp,
+ NPObject* obj, NPString* script, NPVariant* result)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("Evaluate");
+ return false;
+ }
+
+bool HostMeister_Std::GetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, NPVariant* result)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s << "GetProperty: " << this->StringFromIdentifier(propertyName);
+
+ if (obj && obj->_class && obj->_class->getProperty)
+ return obj->_class->getProperty(obj, propertyName, result);
+
+ return false;
+ }
+
+bool HostMeister_Std::SetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, const NPVariant* value)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("SetProperty");
+
+ if (obj && obj->_class && obj->_class->getProperty)
+ return obj->_class->setProperty(obj, propertyName, value);
+
+ return false;
+ }
+
+bool HostMeister_Std::RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("RemoveProperty");
+
+ if (obj && obj->_class && obj->_class->removeProperty)
+ return obj->_class->removeProperty(obj, propertyName);
+
+ return false;
+ }
+
+bool HostMeister_Std::HasProperty(NPP, NPObject* obj, NPIdentifier propertyName)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("HasProperty");
+
+ if (obj && obj->_class && obj->_class->hasProperty)
+ return obj->_class->hasProperty(obj, propertyName);
+
+ return false;
+ }
+
+bool HostMeister_Std::HasMethod(NPP npp, NPObject* obj, NPIdentifier methodName)
+ {
+ if (ZLOG(s, eDebug, "HostMeister_Std"))
+ s.Writef("HasMethod");
+
+ if (obj && obj->_class && obj->_class->hasMethod)
+ return obj->_class->hasMethod(obj, methodName);
+
+ return false;
+ }
+
void HostMeister_Std::ReleaseVariantValue(NPVariant* variant)
{
ZAssert(variant);
@@ -588,114 +848,6 @@
s.Writef("ForceRedraw");
}
-NPObject* Host_Std::Host_CreateObject(NPP npp, NPClass* aClass)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("CreateObject");
-
- ZAssert(aClass);
- NPObject* result;
- if (aClass->allocate)
- result = aClass->allocate(npp, aClass);
- else
- result = (NPObject*)malloc(sizeof(NPObject));
-
- result->_class = aClass;
- result->referenceCount = 1;
-
- return result;
- }
-
-bool Host_Std::Host_Invoke(NPP npp,
- NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
- NPVariant* result)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s << "Invoke: " << HostMeister::sGet()->StringFromIdentifier(methodName);
-
- if (obj && obj->_class && obj->_class->invoke)
- return obj->_class->invoke(obj, methodName, args, argCount, result);
-
- return false;
- }
-
-bool Host_Std::Host_InvokeDefault(NPP npp,
- NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("InvokeDefault");
-
- if (obj && obj->_class && obj->_class->invokeDefault)
- return obj->_class->invokeDefault(obj, args, argCount, result);
-
- return false;
- }
-
-bool Host_Std::Host_Evaluate(NPP npp,
- NPObject* obj, NPString* script, NPVariant* result)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("Evaluate");
- return false;
- }
-
-bool Host_Std::Host_GetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, NPVariant* result)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s << "GetProperty: " << HostMeister::sGet()->StringFromIdentifier(propertyName);
-
- if (obj && obj->_class && obj->_class->getProperty)
- return obj->_class->getProperty(obj, propertyName, result);
-
- return false;
- }
-
-bool Host_Std::Host_SetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, const NPVariant* value)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("SetProperty");
-
- if (obj && obj->_class && obj->_class->getProperty)
- return obj->_class->setProperty(obj, propertyName, value);
-
- return false;
- }
-
-bool Host_Std::Host_RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("RemoveProperty");
-
- if (obj && obj->_class && obj->_class->removeProperty)
- return obj->_class->removeProperty(obj, propertyName);
-
- return false;
- }
-
-bool Host_Std::Host_HasProperty(NPP, NPObject* obj, NPIdentifier propertyName)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("HasProperty");
-
- if (obj && obj->_class && obj->_class->hasProperty)
- return obj->_class->hasProperty(obj, propertyName);
-
- return false;
- }
-
-bool Host_Std::Host_HasMethod(NPP npp, NPObject* obj, NPIdentifier methodName)
- {
- if (ZLOG(s, eDebug, "Host_Std"))
- s.Writef("HasMethod");
-
- if (obj && obj->_class && obj->_class->hasMethod)
- return obj->_class->hasMethod(obj, methodName);
-
- return false;
- }
-
void Host_Std::pHTTPerFinished(HTTPer* iHTTPer, void* iNotifyData,
const std::string& iURL, const std::string& iMIME, const ZMemoryBlock& iHeaders,
ZRef<ZStreamerR> iStreamerR)
@@ -705,7 +857,6 @@
this->SendDataAsync(iNotifyData, iURL, iMIME, iHeaders, iStreamerR);
}
-
void Host_Std::Create(const string& iURL, const string& iMIME)
{
char* npp_argv[] =
@@ -818,7 +969,7 @@
}
}
-NPObjectH* Host_Std::GetScriptableNPObject()
+NPObjectH* Host_Std::CopyScriptableNPObject()
{
NPObjectH* theNPObject;
this->Guest_GetValue(NPPVpluginScriptableNPObject, &theNPObject);
Modified: trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.h 2009-01-01 03:42:38 UTC (rev 356)
+++ trunk/zoolib/source/cxx/zoolib/ZNetscape_Host_Std.h 2009-01-06 21:59:30 UTC (rev 357)
@@ -26,13 +26,15 @@
#if ZCONFIG_SPI_Enabled(Netscape)
-#include <map>
+#include <set>
#include <vector>
NAMESPACE_ZOOLIB_BEGIN
namespace ZNetscape {
+class Host_Std;
+
// =================================================================================================
#pragma mark -
#pragma mark * HostMeister_Std
@@ -43,6 +45,27 @@
HostMeister_Std();
virtual ~HostMeister_Std();
+ static Host_Std* sHostFromNPP_Std(NPP npp);
+ static Host_Std* sHostFromStream_Std(NPStream* iNPStream);
+
+ virtual NPError GetURL(NPP npp, const char* URL, const char* window);
+
+ virtual NPError PostURL(NPP npp,
+ const char* URL, const char* window, uint32 len, const char* buf, NPBool file);
+
+ virtual NPError RequestRead(NPStream* stream, NPByteRange* rangeList);
+
+ virtual NPError NewStream(NPP npp,
+ NPMIMEType type, const char* window, NPStream** stream);
+
+ virtual int32 Write(NPP npp, NPStream* stream, int32 len, void* buffer);
+
+ virtual NPError DestroyStream(NPP npp, NPStream* stream, NPReason reason);
+
+ virtual void Status(NPP npp, const char* message);
+
+ virtual const char* UserAgent(NPP npp);
+
virtual void* MemAlloc(uint32 size);
virtual void MemFree(void* ptr);
@@ -53,6 +76,25 @@
virtual void* GetJavaEnv();
+ virtual void* GetJavaPeer(NPP npp);
+
+ virtual NPError GetURLNotify(NPP npp,
+ const char* URL, const char* window, void* notifyData);
+
+ virtual NPError PostURLNotify(NPP npp,
+ const char* URL, const char* window,
+ uint32 len, const char* buf, NPBool file, void* notifyData);
+
+ virtual NPError GetValue(NPP npp, NPNVariable variable, void* ret_value);
+
+ virtual NPError SetValue(NPP npp, NPPVariable variable, void* value);
+
+ virtual void InvalidateRect(NPP npp, NPRect* rect);
+
+ virtual void InvalidateRegion(NPP npp, NPRegion region);
+
+ virtual void ForceRedraw(NPP npp);
+
virtual NPIdentifier GetStringIdentifier(const NPUTF8* name);
virtual void GetStringIdentifiers(
@@ -66,27 +108,40 @@
virtual int32_t IntFromIdentifier(NPIdentifier identifier);
+ virtual NPObject* CreateObject(NPP npp, NPClass* aClass);
+
virtual NPObject* RetainObject(NPObject* obj);
virtual void ReleaseObject(NPObject* obj);
+ virtual bool Invoke(NPP npp,
+ NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
+ NPVariant* result);
+
+ virtual bool InvokeDefault(NPP npp,
+ NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result);
+
+ virtual bool Evaluate(NPP npp,
+ NPObject* obj, NPString* script, NPVariant* result);
+
+ virtual bool GetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, NPVariant* result);
+
+ virtual bool SetProperty(NPP npp,
+ NPObject* obj, NPIdentifier propertyName, const NPVariant* value);
+
+ virtual bool RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName);
+
+ virtual bool HasProperty(NPP, NPObject* npobj, NPIdentifier propertyName);
+
+ virtual bool HasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName);
+
virtual void ReleaseVariantValue(NPVariant* variant);
virtual void SetException(NPObject* obj, const NPUTF8* message);
private:
- struct Identifier
- {
- bool fIsString;
- union
- {
- const char* fAsString;
- int fAsInt;
- };
- };
-
- std::map<std::string, Identifier*> fMap_Strings;
- std::map<int, Identifier*> fMap_Ints;
+ std::set<std::string> fStrings;
};
// =================================================================================================
@@ -137,30 +192,6 @@
virtual void Host_ForceRedraw(NPP npp);
- virtual NPObject* Host_CreateObject(NPP npp, NPClass* aClass);
-
- virtual bool Host_Invoke(NPP npp,
- NPObject* obj, NPIdentifier methodName, const NPVariant* args, uint32_t argCount,
- NPVariant* result);
-
- virtual bool Host_InvokeDefault(NPP npp,
- NPObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result);
-
- virtual bool Host_Evaluate(NPP npp,
- NPObject* obj, NPString* script, NPVariant* result);
-
- virtual bool Host_GetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, NPVariant* result);
-
- virtual bool Host_SetProperty(NPP npp,
- NPObject* obj, NPIdentifier propertyName, const NPVariant* value);
-
- virtual bool Host_RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName);
-
- virtual bool Host_HasProperty(NPP, NPObject* npobj, NPIdentifier propertyName);
-
- virtual bool Host_HasMethod(NPP npp, NPObject* npobj, NPIdentifier methodName);
-
// Our protocol
void Create(const std::string& iURL, const std::string& iMIME);
void Destroy();
@@ -177,7 +208,7 @@
void DeliverData();
- NPObjectH* GetScriptableNPObject();
+ NPObjectH* CopyScriptableNPObject();
void DoActivate(bool iActivate);
void DoFocus(bool iFocused);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|