projects/mozilla/control/nporuntime.h

   1 /*****************************************************************************
   2  * runtime.cpp: support for NPRuntime API for Netscape Script-able plugins
   3  *              FYI: http://www.mozilla.org/projects/plugins/npruntime.html
   4  *****************************************************************************
   5  * Copyright (C) 2002-2005 the VideoLAN team
   6  * $Id$
   7  *
   8  * Authors: Damien Fouilleul <damien.fouilleul@laposte.net>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifndef __NPORUNTIME_H__
  26 #define __NPORUNTIME_H__
  27
  28 /*
  29 ** support framework for runtime script objects
  30 */
  31
  32 #include <npapi.h>
  33 #include <npruntime.h>
  34
  35 static void RuntimeNPClassDeallocate(NPObject *npobj);
  36 static void RuntimeNPClassInvalidate(NPObject *npobj);
  37 static bool RuntimeNPClassInvokeDefault(NPObject *npobj,
  38                                         const NPVariant *args,
  39                                         uint32_t argCount,
  40                                         NPVariant *result);
  41
  42 class RuntimeNPObject : public NPObject
  43 {
  44 public:
  45     // Lazy child object cration helper. Doing this avoids
  46     // ownership problems with firefox.
  47     template<class T> void InstantObj( NPObject *&obj );
  48
  49     /*
  50     ** utility functions
  51     */
  52
  53     static bool isNumberValue(const NPVariant &v)
  54     {
  55         return NPVARIANT_IS_INT32(v)
  56             || NPVARIANT_IS_DOUBLE(v);
  57     };
  58
  59     static int numberValue(const NPVariant &v)
  60     {
  61         switch( v.type ) {
  62             case NPVariantType_Int32:
  63                 return NPVARIANT_TO_INT32(v);
  64             case NPVariantType_Double:
  65                 return(int)NPVARIANT_TO_DOUBLE(v);
  66             default:
  67                 return 0;
  68         }
  69     };
  70
  71     static char* stringValue(const NPString &v);
  72     static char* stringValue(const NPVariant &v);
  73
  74 protected:
  75     void *operator new(size_t n)
  76     {
  77         /*
  78         ** Assume that browser has a smarter memory allocator
  79         ** than plain old malloc() and use it instead.
  80         */
  81         return NPN_MemAlloc(n);
  82     };
  83
  84     void operator delete(void *p)
  85     {
  86         NPN_MemFree(p);
  87     };
  88
  89     bool isValid()
  90     {
  91         return _instance != NULL;
  92     };
  93
  94     RuntimeNPObject(NPP instance, const NPClass *aClass) :
  95         _instance(instance)
  96     {
  97         _class = const_cast<NPClass *>(aClass);
  98         referenceCount = 1;
  99     };
 100     virtual ~RuntimeNPObject() {};
 101
 102     enum InvokeResult
 103     {
 104         INVOKERESULT_NO_ERROR       = 0,    /* returns no error */
 105         INVOKERESULT_GENERIC_ERROR  = 1,    /* returns error */
 106         INVOKERESULT_NO_SUCH_METHOD = 2,    /* throws method does not exist */
 107         INVOKERESULT_INVALID_ARGS   = 3,    /* throws invalid arguments */
 108         INVOKERESULT_INVALID_VALUE  = 4,    /* throws invalid value in assignment */
 109         INVOKERESULT_OUT_OF_MEMORY  = 5,    /* throws out of memory */
 110     };
 111
 112     friend void RuntimeNPClassDeallocate(NPObject *npobj);
 113     friend void RuntimeNPClassInvalidate(NPObject *npobj);
 114     template <class RuntimeNPObject> friend bool RuntimeNPClassGetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result);
 115     template <class RuntimeNPObject> friend bool RuntimeNPClassSetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value);
 116     template <class RuntimeNPObject> friend bool RuntimeNPClassRemoveProperty(NPObject *npobj, NPIdentifier name);
 117     template <class RuntimeNPObject> friend bool RuntimeNPClassInvoke(NPObject *npobj, NPIdentifier name,
 118                                                     const NPVariant *args, uint32_t argCount,
 119                                                     NPVariant *result);
 120     friend bool RuntimeNPClassInvokeDefault(NPObject *npobj,
 121                                             const NPVariant *args,
 122                                             uint32_t argCount,
 123                                             NPVariant *result);
 124
 125     virtual InvokeResult getProperty(int index, NPVariant &result);
 126     virtual InvokeResult setProperty(int index, const NPVariant &value);
 127     virtual InvokeResult removeProperty(int index);
 128     virtual InvokeResult invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result);
 129     virtual InvokeResult invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant &result);
 130
 131     bool returnInvokeResult(InvokeResult result);
 132
 133     static InvokeResult invokeResultString(const char *,NPVariant &);
 134
 135     bool isPluginRunning()
 136     {
 137         return (_instance->pdata != NULL);
 138     }
 139     template<class T> T *getPrivate()
 140     {
 141         return reinterpret_cast<T *>(_instance->pdata);
 142     }
 143
 144     NPP _instance;
 145 };
 146
 147 template<class T> class RuntimeNPClass : public NPClass
 148 {
 149 public:
 150     static NPClass *getClass()
 151     {
 152         static NPClass *singleton = new RuntimeNPClass<T>;
 153         return singleton;
 154     }
 155
 156 protected:
 157     RuntimeNPClass();
 158     virtual ~RuntimeNPClass();
 159
 160     template <class RuntimeNPObject> friend NPObject *RuntimeNPClassAllocate(NPP instance, NPClass *aClass);
 161     template <class RuntimeNPObject> friend bool RuntimeNPClassHasMethod(NPObject *npobj, NPIdentifier name);
 162     template <class RuntimeNPObject> friend bool RuntimeNPClassHasProperty(NPObject *npobj, NPIdentifier name);
 163     template <class RuntimeNPObject> friend bool RuntimeNPClassGetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result);
 164     template <class RuntimeNPObject> friend bool RuntimeNPClassSetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value);
 165     template <class RuntimeNPObject> friend bool RuntimeNPClassRemoveProperty(NPObject *npobj, NPIdentifier name);
 166     template <class RuntimeNPObject> friend bool RuntimeNPClassInvoke(NPObject *npobj, NPIdentifier name,
 167                                                                       const NPVariant *args, uint32_t argCount,
 168                                                                       NPVariant *result);
 169
 170     RuntimeNPObject *create(NPP instance) const;
 171
 172     int indexOfMethod(NPIdentifier name) const;
 173     int indexOfProperty(NPIdentifier name) const;
 174
 175 private:
 176     NPIdentifier *propertyIdentifiers;
 177     NPIdentifier *methodIdentifiers;
 178 };
 179
 180 template<class T>
 181 inline void RuntimeNPObject::InstantObj( NPObject *&obj )
 182 {
 183     if( !obj )
 184         obj = NPN_CreateObject(_instance, RuntimeNPClass<T>::getClass());
 185 }
 186
 187 template<class T>
 188 static NPObject *RuntimeNPClassAllocate(NPP instance, NPClass *aClass)
 189 {
 190     const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(aClass);
 191     return vClass->create(instance);
 192 }
 193
 194 static void RuntimeNPClassDeallocate(NPObject *npobj)
 195 {
 196     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 197     vObj->_class = NULL;
 198     delete vObj;
 199 }
 200
 201 static void RuntimeNPClassInvalidate(NPObject *npobj)
 202 {
 203     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 204     vObj->_instance = NULL;
 205 }
 206
 207 template<class T>
 208 static bool RuntimeNPClassHasMethod(NPObject *npobj, NPIdentifier name)
 209 {
 210     const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 211     return vClass->indexOfMethod(name) != -1;
 212 }
 213
 214 template<class T>
 215 static bool RuntimeNPClassHasProperty(NPObject *npobj, NPIdentifier name)
 216 {
 217     const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 218     return vClass->indexOfProperty(name) != -1;
 219 }
 220
 221 template<class T>
 222 static bool RuntimeNPClassGetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
 223 {
 224     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 225     if( vObj->isValid() )
 226     {
 227         const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 228         int index = vClass->indexOfProperty(name);
 229         if( index != -1 )
 230         {
 231             return vObj->returnInvokeResult(vObj->getProperty(index, *result));
 232         }
 233     }
 234     return false;
 235 }
 236
 237 template<class T>
 238 static bool RuntimeNPClassSetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
 239 {
 240     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 241     if( vObj->isValid() )
 242     {
 243         const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 244         int index = vClass->indexOfProperty(name);
 245         if( index != -1 )
 246         {
 247             return vObj->returnInvokeResult(vObj->setProperty(index, *value));
 248         }
 249     }
 250     return false;
 251 }
 252
 253 template<class T>
 254 static bool RuntimeNPClassRemoveProperty(NPObject *npobj, NPIdentifier name)
 255 {
 256     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 257     if( vObj->isValid() )
 258     {
 259         const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 260         int index = vClass->indexOfProperty(name);
 261         if( index != -1 )
 262         {
 263             return vObj->returnInvokeResult(vObj->removeProperty(index));
 264         }
 265     }
 266     return false;
 267 }
 268
 269 template<class T>
 270 static bool RuntimeNPClassInvoke(NPObject *npobj, NPIdentifier name,
 271                                     const NPVariant *args, uint32_t argCount,
 272                                     NPVariant *result)
 273 {
 274     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 275     if( vObj->isValid() )
 276     {
 277         const RuntimeNPClass<T> *vClass = static_cast<RuntimeNPClass<T> *>(npobj->_class);
 278         int index = vClass->indexOfMethod(name);
 279         if( index != -1 )
 280         {
 281             return vObj->returnInvokeResult(vObj->invoke(index, args, argCount, *result));
 282
 283         }
 284     }
 285     return false;
 286 }
 287
 288 static bool RuntimeNPClassInvokeDefault(NPObject *npobj,
 289                                            const NPVariant *args,
 290                                            uint32_t argCount,
 291                                            NPVariant *result)
 292 {
 293     RuntimeNPObject *vObj = static_cast<RuntimeNPObject *>(npobj);
 294     if( vObj->isValid() )
 295     {
 296         return vObj->returnInvokeResult(vObj->invokeDefault(args, argCount, *result));
 297     }
 298     return false;
 299 }
 300
 301 template<class T>
 302 RuntimeNPClass<T>::RuntimeNPClass()
 303 {
 304     // retreive property identifiers from names
 305     if( T::propertyCount > 0 )
 306     {
 307         propertyIdentifiers = new NPIdentifier[T::propertyCount];
 308         if( propertyIdentifiers )
 309             NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::propertyNames),
 310                 T::propertyCount, propertyIdentifiers);
 311     }
 312
 313     // retreive method identifiers from names
 314     if( T::methodCount > 0 )
 315     {
 316         methodIdentifiers = new NPIdentifier[T::methodCount];
 317         if( methodIdentifiers )
 318             NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::methodNames),
 319                 T::methodCount, methodIdentifiers);
 320     }
 321
 322     // fill in NPClass structure
 323     structVersion  = NP_CLASS_STRUCT_VERSION;
 324     allocate       = &RuntimeNPClassAllocate<T>;
 325     deallocate     = &RuntimeNPClassDeallocate;
 326     invalidate     = &RuntimeNPClassInvalidate;
 327     hasMethod      = &RuntimeNPClassHasMethod<T>;
 328     invoke         = &RuntimeNPClassInvoke<T>;
 329     invokeDefault  = &RuntimeNPClassInvokeDefault;
 330     hasProperty    = &RuntimeNPClassHasProperty<T>;
 331     getProperty    = &RuntimeNPClassGetProperty<T>;
 332     setProperty    = &RuntimeNPClassSetProperty<T>;
 333     removeProperty = &RuntimeNPClassRemoveProperty<T>;
 334 }
 335
 336 template<class T>
 337 RuntimeNPClass<T>::~RuntimeNPClass()
 338 {
 339     delete[] propertyIdentifiers;
 340     delete[] methodIdentifiers;
 341 }
 342
 343 template<class T>
 344 RuntimeNPObject *RuntimeNPClass<T>::create(NPP instance) const
 345 {
 346     return new T(instance, this);
 347 }
 348
 349 template<class T>
 350 int RuntimeNPClass<T>::indexOfMethod(NPIdentifier name) const
 351 {
 352     if( methodIdentifiers )
 353     {
 354         for(int c=0; c< T::methodCount; ++c )
 355         {
 356             if( name == methodIdentifiers[c] )
 357                 return c;
 358         }
 359     }
 360     return -1;
 361 }
 362
 363 template<class T>
 364 int RuntimeNPClass<T>::indexOfProperty(NPIdentifier name) const
 365 {
 366     if( propertyIdentifiers )
 367     {
 368         for(int c=0; c< T::propertyCount; ++c )
 369         {
 370             if( name == propertyIdentifiers[c] )
 371                 return c;
 372         }
 373     }
 374     return -1;
 375 }
 376
 377 #endif