mozilla: rework events

The mozilla webplugin supports only the libvlc_MediaPlayer* events just like the ActiveX webplugin.
Ommit the 'libvlc_' prefix from the libvlc_MediaPlayer* events to obtain the events name that must be
used from JavaScript to listen on the event. Example:

- libvlc_MediaPlayerOpening becomes 'MediaPlayerOpening'
- libvlc_MediaPlayerNothingSpecial becoms 'MediaPlayerNothingSpecial'

projects/mozilla/control/npolibvlc.cpp

@@ -199,17 +199,26 @@ RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index,
             return INVOKERESULT_GENERIC_ERROR;
         }
 
-        NPObject *listener = NPVARIANT_TO_OBJECT(args[1]);
         VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
 
         bool b;
-        if(ID_root_removeeventlistener!=index)
-            b = p_plugin->events.insert(NPVARIANT_TO_STRING(args[0]),
-                                     listener, NPVARIANT_TO_BOOLEAN(args[2]));
+        if( ID_root_addeventlistener == index )
+        {
+            NPN_RetainObject( NPVARIANT_TO_OBJECT(args[1]) );
+            b = p_plugin->events.insert( NPVARIANT_TO_STRING(args[0]),
+                                         NPVARIANT_TO_OBJECT(args[1]),
+                                         NPVARIANT_TO_BOOLEAN(args[2]) );
+            if( !b )
+                NPN_ReleaseObject( NPVARIANT_TO_OBJECT(args[1]) );
+        }
         else
-            b = p_plugin->events.remove(NPVARIANT_TO_STRING(args[0]),
-                                     listener, NPVARIANT_TO_BOOLEAN(args[2]));
-
+        {
+            b = p_plugin->events.remove( NPVARIANT_TO_STRING(args[0]),
+                                         NPVARIANT_TO_OBJECT(args[1]),
+                                         NPVARIANT_TO_BOOLEAN(args[2]) );
+            if( b )
+                NPN_ReleaseObject( NPVARIANT_TO_OBJECT(args[1]) );
+        }
         VOID_TO_NPVARIANT(result);
 
         return b ? INVOKERESULT_NO_ERROR : INVOKERESULT_GENERIC_ERROR;
@@ -1932,4 +1941,3 @@ LibvlcDeinterlaceNPObject::invoke(int index, const NPVariant *args,
     }
     return INVOKERESULT_NO_ERROR;
 }
-

projects/mozilla/control/nporuntime.cpp

@@ -130,4 +130,3 @@ RuntimeNPObject::invokeResultString(const char *psz, NPVariant &result)
     }
     return INVOKERESULT_NO_ERROR;
 }
-

projects/mozilla/vlcplugin.h

@@ -71,6 +71,8 @@
 #   define __MIN(a, b)   ( ((a) < (b)) ? (a) : (b) )
 #endif
 
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
 typedef struct {
 #if defined(XP_UNIX)
     pthread_mutex_t mutex;
@@ -81,7 +83,6 @@ typedef struct {
 #endif
 } plugin_lock_t;
 
-
 typedef enum vlc_toolbar_clicked_e {
     clicked_Unknown = 0,
     clicked_Play,
@@ -94,82 +95,80 @@ typedef enum vlc_toolbar_clicked_e {
     clicked_Unmute
 } vlc_toolbar_clicked_t;
 
+typedef struct {
+    const char *name;                      /* event name */
+    const libvlc_event_type_t libvlc_type; /* libvlc event type */
+    libvlc_callback_t libvlc_callback;     /* libvlc callback function */
+} vlcplugin_event_t;
 
-// Note that the accessor functions are unsafe, but this is handled in
-// the next layer up. 64bit uints can be substituted to taste (shift=6).
-template<size_t M> class bitmap
-{
-private:
-    typedef uint32_t bitu_t; enum { shift=5 };
-    enum { bmax=M, bpu=1<<shift, mask=bpu-1, units=(bmax+bpu-1)/bpu };
-    bitu_t bits[units];
-public:
-    bool get(size_t idx) const { return bits[idx>>shift]&(1<<(idx&mask)); }
-    void set(size_t idx)       { bits[idx>>shift]|=  1<<(idx&mask);  }
-    void reset(size_t idx)     { bits[idx>>shift]&=~(1<<(idx&mask)); }
-    void toggle(size_t idx)    { bits[idx>>shift]^=  1<<(idx&mask);  }
-    size_t maxbit() const      { return bmax; }
-    void clear()               { memset(bits,0,sizeof(bits)); }
-    bitmap() { clear(); }
-    ~bitmap() { }
-    bool empty() const { // naive invert() will break this
-        for(size_t i=0;i<units;++i)
-            if(bits[i]) return false;
-        return true;
-    }
-};
-
-typedef bitmap<libvlc_VlmMediaInstanceStatusError+1> eventtypes_bitmap_t;
-
-
-class EventObj: private eventtypes_bitmap_t
+class EventObj
 {
 private:
-    typedef libvlc_event_type_t event_t;
-    bool have_event(event_t e) const { return e<maxbit()?get(e):false; }
 
-    class Listener: public eventtypes_bitmap_t
+    class Listener
     {
     public:
-        Listener(event_t e,NPObject *o,bool b): _l(o), _b(b)
-            { NPN_RetainObject(o); set(e); }
-        Listener(): _l(NULL), _b(false) { }
-        ~Listener() { if(_l) NPN_ReleaseObject(_l); }
-        NPObject *listener() const { return _l; }
-        bool bubble() const { return _b; }
+        Listener(vlcplugin_event_t *event, NPObject *p_object, bool b_bubble):
+            _event(event), _listener(p_object), _bubble(b_bubble)
+            {
+                assert(event);
+                assert(p_object);
+            }
+        Listener(): _event(NULL), _listener(NULL), _bubble(false) { }
+        ~Listener()
+            {
+            }
+        const libvlc_event_type_t event_type() const { return _event->libvlc_type; }
+        NPObject *listener() const { return _listener; }
+        bool bubble() const { return _bubble; }
     private:
-        NPObject *_l;
-        bool _b;
+        vlcplugin_event_t *_event;
+        NPObject *_listener;
+        bool _bubble;
     };
 
-    libvlc_event_manager_t *_em;
-    libvlc_callback_t _cb;
-    void *_ud;
+    class VLCEvent
+    {
+    public:
+        VLCEvent(libvlc_event_type_t libvlc_event_type, NPVariant *npparams, uint32_t npcount):
+            _libvlc_event_type(libvlc_event_type), _npparams(npparams), _npcount(npcount)
+            {
+            }
+        VLCEvent(): _libvlc_event_type(0), _npparams(NULL), _npcount(0) { }
+        ~VLCEvent()
+            {
+            }
+        const libvlc_event_type_t event_type() { return _libvlc_event_type; }
+        NPVariant *params() const { return _npparams; }
+        const uint32_t count() { return _npcount; }
+    private:
+        libvlc_event_type_t _libvlc_event_type;
+        NPVariant *_npparams;
+        uint32_t _npcount;
+    };
+    libvlc_event_manager_t *_em; /* libvlc media_player event manager */
 public:
     EventObj(): _em(NULL)  { /* deferred to init() */ }
     bool init();
     ~EventObj();
 
     void deliver(NPP browser);
-    void callback(const libvlc_event_t*);
-    bool insert(const NPString &, NPObject *, bool);
-    bool remove(const NPString &, NPObject *, bool);
-    void unhook_manager();
-    void hook_manager(libvlc_event_manager_t *,libvlc_callback_t, void *);
+    void callback(const libvlc_event_t *event, NPVariant *npparams, uint32_t count);
+    bool insert(const NPString &name, NPObject *listener, bool bubble);
+    bool remove(const NPString &name, NPObject *listener, bool bubble);
+    void unhook_manager(void *);
+    void hook_manager(libvlc_event_manager_t *, void *);
 private:
-    event_t find_event(const char *s) const;
+    vlcplugin_event_t *find_event(const char *s) const;
+    const char *find_name(const libvlc_event_t *event);
     typedef std::vector<Listener> lr_l;
-    typedef std::vector<libvlc_event_type_t> ev_l;
-    lr_l _llist;
-    ev_l _elist;
+    typedef std::vector<VLCEvent> ev_l;
+    lr_l _llist; /* list of registered listeners with 'addEventListener' method */
+    ev_l _elist; /* scheduled events list for delivery to browser */
 
     plugin_lock_t lock;
-
-    bool ask_for_event(event_t e);
-    void unask_for_event(event_t e);
 };
 
-
 class VlcPlugin
 {
 public:
@@ -301,6 +300,7 @@ public:
     static bool canUseEventListener();
 
     EventObj events;
+    static void event_callback(const libvlc_event_t *, NPVariant *, uint32_t, void *);
 private:
     bool playlist_select(int);
     void set_player_window();
@@ -339,7 +339,6 @@ private:
 #endif
 
     static void eventAsync(void *);
-    static void event_callback(const libvlc_event_t *, void *);
 };
 
 /*******************************************************************************

projects/mozilla/vlcshell.h

 /*****************************************************************************
- * vlcshell.hp:
+ * vlcshell.h:
  *****************************************************************************
- * Copyright (C) 2009 the VideoLAN team
+ * Copyright (C) 2009-2010 the VideoLAN team
  * $Id$
  *
  * Authors: Jean-Paul Saman <jpsaman@videolan.org>