Skip to content

V
vlc-2-2
Commit bb12c0f1 authored by Jean-Paul Saman's avatar Jean-Paul Saman
Browse files
Options

mozilla: rework events 

The mozilla webplugin events do not support arguments and expose all events available in libvlc. Most
of these events are not usefull for the webplugins and not being able to pass arguments is another limiting
issue. This patch addresses both problems at the same time.

The mozilla webplugin limits supports to the libvlc_MediaPlayer* events just like the ActiveX webplugin does.
These events are usefull in the context of a 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'
Signed-off-by: Jean-Paul Saman's avatarJean-Paul Saman <jean-paul.saman@m2x.nl>

Conflicts:

	projects/mozilla/vlcplugin.cpp
	projects/mozilla/vlcplugin.h
parent 5e07b00c
Show whitespace changes
Inline Side-by-side
Showing with 311 additions and 218 deletions
projects/mozilla/control/npolibvlc.cpp
View file @ bb12c0f1
...@@ -194,17 +194,26 @@ RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index, ...@@ -194,17 +194,26 @@ RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index,
return INVOKERESULT_GENERIC_ERROR; return INVOKERESULT_GENERIC_ERROR;
} }
NPObject *listener = NPVARIANT_TO_OBJECT(args[1]);
VlcPlugin* p_plugin = getPrivate<VlcPlugin>(); VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
bool b; bool b;
if(ID_root_removeeventlistener!=index) if( ID_root_addeventlistener == index )
b = p_plugin->events.insert(NPVARIANT_TO_STRING(args[0]), {
listener, NPVARIANT_TO_BOOLEAN(args[2])); 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 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); VOID_TO_NPVARIANT(result);
return b ? INVOKERESULT_NO_ERROR : INVOKERESULT_GENERIC_ERROR; return b ? INVOKERESULT_NO_ERROR : INVOKERESULT_GENERIC_ERROR;
...@@ -1927,4 +1936,3 @@ LibvlcDeinterlaceNPObject::invoke(int index, const NPVariant *args, ...@@ -1927,4 +1936,3 @@ LibvlcDeinterlaceNPObject::invoke(int index, const NPVariant *args,
} }
return INVOKERESULT_NO_ERROR; return INVOKERESULT_NO_ERROR;
} }
projects/mozilla/control/nporuntime.cpp
View file @ bb12c0f1
...@@ -125,4 +125,3 @@ RuntimeNPObject::invokeResultString(const char *psz, NPVariant &result) ...@@ -125,4 +125,3 @@ RuntimeNPObject::invokeResultString(const char *psz, NPVariant &result)
} }
return INVOKERESULT_NO_ERROR; return INVOKERESULT_NO_ERROR;
} }
projects/mozilla/vlcplugin.cpp
View file @ bb12c0f1
...@@ -29,6 +29,7 @@ ...@@ -29,6 +29,7 @@
#include "config.h" #include "config.h"
#include "vlcplugin.h" #include "vlcplugin.h"
#include "control/npolibvlc.h" #include "control/npolibvlc.h"
#include <ctype.h> #include <ctype.h>
...@@ -102,56 +103,84 @@ static void plugin_unlock(plugin_lock_t *lock) ...@@ -102,56 +103,84 @@ static void plugin_unlock(plugin_lock_t *lock)
} }
/***************************************************************************** /*****************************************************************************
* VlcPlugin constructor and destructor * Event Object
*****************************************************************************/ *****************************************************************************/
#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) static void handle_input_event(const libvlc_event_t* event, void *param);
VlcPlugin::VlcPlugin( NPP instance, uint16 mode ) : static void handle_changed_event(const libvlc_event_t* event, void *param);
#else
VlcPlugin::VlcPlugin( NPP instance, uint16_t mode ) : static vlcplugin_event_t vlcevents[] = {
#endif { "MediaPlayerMediaChanged", libvlc_MediaPlayerMediaChanged, handle_input_event },
i_npmode(mode), { "MediaPlayerNothingSpecial", libvlc_MediaPlayerNothingSpecial, handle_input_event },
b_stream(0), { "MediaPlayerOpening", libvlc_MediaPlayerOpening, handle_input_event },
b_autoplay(1), { "MediaPlayerBuffering", libvlc_MediaPlayerBuffering, handle_input_event },
b_toolbar(0), { "MediaPlayerPlaying", libvlc_MediaPlayerPlaying, handle_input_event },
psz_text(NULL), { "MediaPlayerPaused", libvlc_MediaPlayerPaused, handle_input_event },
psz_target(NULL), { "MediaPlayerStopped", libvlc_MediaPlayerStopped, handle_input_event },
playlist_index(-1), { "MediaPlayerForward", libvlc_MediaPlayerForward, handle_input_event },
libvlc_instance(NULL), { "MediaPlayerBackward", libvlc_MediaPlayerBackward, handle_input_event },
libvlc_media_list(NULL), { "MediaPlayerEndReached", libvlc_MediaPlayerEndReached, handle_input_event },
libvlc_media_player(NULL), { "MediaPlayerEncounteredError", libvlc_MediaPlayerEncounteredError, handle_input_event },
p_scriptClass(NULL), { "MediaPlayerTimeChanged", libvlc_MediaPlayerTimeChanged, handle_changed_event },
p_browser(instance), { "MediaPlayerPositionChanged", libvlc_MediaPlayerPositionChanged, handle_changed_event },
psz_baseURL(NULL) { "MediaPlayerSeekableChanged", libvlc_MediaPlayerSeekableChanged, handle_changed_event },
#if defined(XP_WIN) { "MediaPlayerPausableChanged", libvlc_MediaPlayerPausableChanged, handle_changed_event },
,pf_wndproc(NULL) { "MediaPlayerTitleChanged", libvlc_MediaPlayerTitleChanged, handle_changed_event },
#endif { "MediaPlayerLengthChanged", libvlc_MediaPlayerLengthChanged, handle_changed_event },
#if defined(XP_UNIX) };
,i_width((unsigned)-1)
,i_height((unsigned)-1) static void handle_input_event(const libvlc_event_t* event, void *param)
,i_tb_width(0)
,i_tb_height(0)
,i_last_position(0)
,p_btnPlay(NULL)
,p_btnPause(NULL)
,p_btnStop(NULL)
,p_btnMute(NULL)
,p_btnUnmute(NULL)
,p_btnFullscreen(NULL)
,p_btnTime(NULL)
,p_timeline(NULL)
#endif
{ {
memset(&npwindow, 0, sizeof(NPWindow)); VlcPlugin *plugin = (VlcPlugin*)param;
#if defined(XP_UNIX) switch( event->type )
memset(&npvideo, 0, sizeof(Window)); {
memset(&npcontrol, 0, sizeof(Window)); case libvlc_MediaPlayerNothingSpecial:
#endif case libvlc_MediaPlayerOpening:
case libvlc_MediaPlayerBuffering:
case libvlc_MediaPlayerPlaying:
case libvlc_MediaPlayerPaused:
case libvlc_MediaPlayerStopped:
case libvlc_MediaPlayerForward:
case libvlc_MediaPlayerBackward:
case libvlc_MediaPlayerEndReached:
case libvlc_MediaPlayerEncounteredError:
plugin->event_callback(event, NULL, 0, param);
break;
default: /* ignore all other libvlc_event_type_t */
break;
}
} }
static bool boolValue(const char *value) { static void handle_changed_event(const libvlc_event_t* event, void *param)
return ( !strcmp(value, "1") || {
!strcasecmp(value, "true") || uint32_t npcount = 1;
!strcasecmp(value, "yes") ); NPVariant *npparam = (NPVariant *) NPN_MemAlloc( sizeof(NPVariant) * npcount );
VlcPlugin *plugin = (VlcPlugin*)param;
switch( event->type )
{
case libvlc_MediaPlayerTimeChanged:
DOUBLE_TO_NPVARIANT(event->u.media_player_time_changed.new_time, npparam[0]);
break;
case libvlc_MediaPlayerPositionChanged:
DOUBLE_TO_NPVARIANT(event->u.media_player_position_changed.new_position, npparam[0]);
break;
case libvlc_MediaPlayerSeekableChanged:
BOOLEAN_TO_NPVARIANT(event->u.media_player_seekable_changed.new_seekable, npparam[0]);
break;
case libvlc_MediaPlayerPausableChanged:
BOOLEAN_TO_NPVARIANT(event->u.media_player_pausable_changed.new_pausable, npparam[0]);
break;
case libvlc_MediaPlayerTitleChanged:
BOOLEAN_TO_NPVARIANT(event->u.media_player_title_changed.new_title, npparam[0]);
break;
case libvlc_MediaPlayerLengthChanged:
DOUBLE_TO_NPVARIANT(event->u.media_player_length_changed.new_length, npparam[0]);
break;
default: /* ignore all other libvlc_event_type_t */
NPN_MemFree( npparam );
return;
}
plugin->event_callback(event, npparam, npcount, param);
} }
bool EventObj::init() bool EventObj::init()
...@@ -167,25 +196,36 @@ EventObj::~EventObj() ...@@ -167,25 +196,36 @@ EventObj::~EventObj()
void EventObj::deliver(NPP browser) void EventObj::deliver(NPP browser)
{ {
NPVariant result;
NPVariant params[1];
plugin_lock(&lock); plugin_lock(&lock);
for( ev_l::iterator i=_elist.begin();i!=_elist.end();++i ) for( ev_l::iterator iter = _elist.begin(); iter != _elist.end(); ++iter )
{
for( lr_l::iterator j = _llist.begin(); j != _llist.end(); ++j )
{ {
libvlc_event_type_t event = *i; if( j->event_type() == iter->event_type() )
STRINGZ_TO_NPVARIANT(libvlc_event_type_name(event), params[0]); {
NPVariant result;
NPVariant *params = iter->params();
uint32_t count = iter->count();
assert( params );
// Invalid events aren't supposed to be queued up. NPObject *listener = j->listener();
// if( !have_event(event) ) continue; assert( listener );
for( lr_l::iterator j=_llist.begin();j!=_llist.end();++j ) NPN_InvokeDefault( browser, listener, params, count, &result );
NPN_ReleaseVariantValue( &result );
for( uint32_t n = 0; n < count; n++ )
{ {
if (j->get(event)) if( NPVARIANT_IS_STRING(params[n]) )
NPN_MemFree( (void*) NPVARIANT_TO_STRING(params[n]).UTF8Characters );
else if( NPVARIANT_IS_OBJECT(params[n]) )
{ {
NPN_InvokeDefault(browser, j->listener(), params, 1, &result); NPN_ReleaseObject( NPVARIANT_TO_OBJECT(params[n]) );
NPN_ReleaseVariantValue(&result); NPN_MemFree( (void*)NPVARIANT_TO_OBJECT(params[n]) );
}
}
NPN_MemFree( params );
} }
} }
} }
...@@ -194,129 +234,175 @@ void EventObj::deliver(NPP browser) ...@@ -194,129 +234,175 @@ void EventObj::deliver(NPP browser)
plugin_unlock(&lock); plugin_unlock(&lock);
} }
void VlcPlugin::eventAsync(void *param) void EventObj::callback(const libvlc_event_t* event,
{ NPVariant *npparams, uint32_t count)
VlcPlugin *plugin = (VlcPlugin*)param;
plugin->events.deliver(plugin->getBrowser());
}
void EventObj::callback(const libvlc_event_t* event)
{ {
plugin_lock(&lock); plugin_lock(&lock);
_elist.push_back(VLCEvent(event->type, npparams, count));
if( have_event(event->type) )
_elist.push_back(event->type);
plugin_unlock(&lock); plugin_unlock(&lock);
} }
void VlcPlugin::event_callback(const libvlc_event_t* event, void *param) vlcplugin_event_t *EventObj::find_event(const char *s) const
{ {
VlcPlugin *plugin = (VlcPlugin*)param; for( int i = 0; i < ARRAY_SIZE(vlcevents); i++ )
#if defined(XP_UNIX) {
plugin->events.callback(event); if( strncmp(vlcevents[i].name, s, strlen(vlcevents[i].name)) == 0 )
NPN_PluginThreadAsyncCall(plugin->getBrowser(), eventAsync, plugin); return &vlcevents[i];
#else }
#warning NPN_PluginThreadAsyncCall not implemented yet. return NULL;
printf("No NPN_PluginThreadAsyncCall(), doing nothing.");
#endif
} }
inline EventObj::event_t EventObj::find_event(const char *s) const const char *EventObj::find_name(const libvlc_event_t *event)
{ {
event_t i; for( int i = 0; i < ARRAY_SIZE(vlcevents); i++ )
for(i=0;i<maxbit();++i) {
if(!strcmp(s,libvlc_event_type_name(i))) if( vlcevents[i].libvlc_type == event->type )
break; return vlcevents[i].name;
return i; }
return NULL;
} }
bool EventObj::insert(const NPString &s, NPObject *l, bool b) bool EventObj::insert(const NPString &name, NPObject *listener, bool bubble)
{ {
event_t e = find_event(s.UTF8Characters); vlcplugin_event_t *event = find_event(name.UTF8Characters);
if( e>=maxbit() ) if( !event )
return false;
if( !have_event(e) && !ask_for_event(e) )
return false; return false;
lr_l::iterator i; lr_l::iterator iter;
for(i=_llist.begin();i!=_llist.end();++i) for( iter = _llist.begin(); iter != _llist.end(); ++iter )
if(i->listener()==l && i->bubble()==b) if( iter->listener() == listener && iter->bubble() == bubble )
break; break;
if( i == _llist.end() ) { if( iter == _llist.end() )
_llist.push_back(Listener(e,l,b)); {
} else { _llist.push_back(Listener(event, listener, bubble));
if( i->get(e) )
return false;
i->get(e);
}
return true; return true;
} }
return false;
}
bool EventObj::remove(const NPString &s, NPObject *l, bool b) bool EventObj::remove(const NPString &name, NPObject *listener, bool bubble)
{ {
event_t e = find_event(s.UTF8Characters); vlcplugin_event_t *event = find_event(name.UTF8Characters);
if( e>=maxbit() || !get(e) ) if( !event )
return false; return false;
bool any=false; for( lr_l::iterator iter = _llist.begin(); iter !=_llist.end(); iter++ )
for(lr_l::iterator i=_llist.begin();i!=_llist.end();)
{ {
if(i->listener()!=l || i->bubble()!=b) if( iter->event_type() == event->libvlc_type &&
any|=i->get(e); iter->listener() == listener &&
else iter->bubble() == bubble )
{ {
i->reset(e); iter = _llist.erase(iter);
if(i->empty()) return true;
{
i=_llist.erase(i);
continue;
}
} }
++i;
} }
if(!any)
unask_for_event(e);
return true; return false;
} }
void EventObj::hook_manager( libvlc_event_manager_t *em, void *userdata )
void EventObj::hook_manager(libvlc_event_manager_t *em,
libvlc_callback_t cb, void *udata)
{ {
_em = em; _cb = cb; _ud = udata; _em = em;
if( !_em )
return; if( _em )
for(size_t i=0;i<maxbit();++i) {
if(get(i)) /* attach all libvlc events we care about */
libvlc_event_attach(_em, i, _cb, _ud); for( int i = 0; i < ARRAY_SIZE(vlcevents); i++ )
{
libvlc_event_attach( _em, vlcevents[i].libvlc_type,
vlcevents[i].libvlc_callback,
userdata );
}
}
} }
void EventObj::unhook_manager() void EventObj::unhook_manager( void *userdata )
{ {
if( !_em ) if( _em )
return; {
for(size_t i=0;i<maxbit();++i) /* detach all libvlc events we cared about */
if(get(i)) for( int i = 0; i < ARRAY_SIZE(vlcevents); i++ )
libvlc_event_detach(_em, i, _cb, _ud); {
libvlc_event_detach( _em, vlcevents[i].libvlc_type,
vlcevents[i].libvlc_callback,
userdata );
}
}
} }
/*****************************************************************************
bool EventObj::ask_for_event(event_t e) * VlcPlugin constructor and destructor
*****************************************************************************/
#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20)
VlcPlugin::VlcPlugin( NPP instance, uint16 mode ) :
#else
VlcPlugin::VlcPlugin( NPP instance, uint16_t mode ) :
#endif
i_npmode(mode),
b_stream(0),
b_autoplay(1),
b_toolbar(0),
psz_text(NULL),
psz_target(NULL),
playlist_index(-1),
libvlc_instance(NULL),
libvlc_media_list(NULL),
libvlc_media_player(NULL),
p_scriptClass(NULL),
p_browser(instance),
psz_baseURL(NULL)
#if defined(XP_WIN)
,pf_wndproc(NULL)
#endif
#if defined(XP_UNIX)
,i_width((unsigned)-1)
,i_height((unsigned)-1)
,i_tb_width(0)
,i_tb_height(0)
,i_last_position(0)
,p_btnPlay(NULL)
,p_btnPause(NULL)
,p_btnStop(NULL)
,p_btnMute(NULL)
,p_btnUnmute(NULL)
,p_btnFullscreen(NULL)
,p_btnTime(NULL)
,p_timeline(NULL)
#endif
{ {
return _em?0==libvlc_event_attach(_em, e, _cb, _ud):false; memset(&npwindow, 0, sizeof(NPWindow));
#if defined(XP_UNIX)
memset(&npvideo, 0, sizeof(Window));
memset(&npcontrol, 0, sizeof(Window));
#endif
} }
static bool boolValue(const char *value) {
return ( !strcmp(value, "1") ||
!strcasecmp(value, "true") ||
!strcasecmp(value, "yes") );
}
void EventObj::unask_for_event(event_t e) void VlcPlugin::eventAsync(void *param)
{ {
if(_em) libvlc_event_detach(_em, e, _cb, _ud); VlcPlugin *plugin = (VlcPlugin*)param;
plugin->events.deliver(plugin->getBrowser());
} }
void VlcPlugin::event_callback(const libvlc_event_t* event,
NPVariant *npparams, uint32_t npcount, void *userdata)
{
VlcPlugin *plugin = (VlcPlugin*)userdata;
#if defined(XP_UNIX)
plugin->events.callback(event, npparams, npcount);
NPN_PluginThreadAsyncCall(plugin->getBrowser(), eventAsync, plugin);
#else
#warning NPN_PluginThreadAsyncCall not implemented yet.
printf("No NPN_PluginThreadAsyncCall(), doing nothing.\n");
#endif
}
NPError VlcPlugin::init(int argc, char* const argn[], char* const argv[]) NPError VlcPlugin::init(int argc, char* const argn[], char* const argv[])
{ {
...@@ -501,13 +587,13 @@ VlcPlugin::~VlcPlugin() ...@@ -501,13 +587,13 @@ VlcPlugin::~VlcPlugin()
{ {
if( playlist_isplaying() ) if( playlist_isplaying() )
playlist_stop(); playlist_stop();
events.unhook_manager(); events.unhook_manager( this );
libvlc_media_player_release( libvlc_media_player ); libvlc_media_player_release( libvlc_media_player );
} }
if( libvlc_media_list ) if( libvlc_media_list )
libvlc_media_list_release( libvlc_media_list ); libvlc_media_list_release( libvlc_media_list );
if( libvlc_instance ) if( libvlc_instance )
libvlc_release(libvlc_instance); libvlc_release( libvlc_instance );
} }
/***************************************************************************** /*****************************************************************************
...@@ -593,25 +679,26 @@ bool VlcPlugin::playlist_select( int idx ) ...@@ -593,25 +679,26 @@ bool VlcPlugin::playlist_select( int idx )
{ {
if( playlist_isplaying() ) if( playlist_isplaying() )
playlist_stop(); playlist_stop();
events.unhook_manager(); events.unhook_manager( this );
libvlc_media_player_release( libvlc_media_player ); libvlc_media_player_release( libvlc_media_player );
libvlc_media_player = NULL; libvlc_media_player = NULL;
} }
libvlc_media_player = libvlc_media_player_new_from_media(p_m); libvlc_media_player = libvlc_media_player_new_from_media( p_m );
if( libvlc_media_player ) if( libvlc_media_player )
{ {
set_player_window(); set_player_window();
events.hook_manager(
libvlc_media_player_event_manager(libvlc_media_player), libvlc_event_manager_t *p_em;
event_callback, this); p_em = libvlc_media_player_event_manager( libvlc_media_player );
events.hook_manager( p_em, this );
} }
libvlc_media_release( p_m ); libvlc_media_release( p_m );
return true; return true;
bad_unlock: bad_unlock:
libvlc_media_list_unlock(libvlc_media_list); libvlc_media_list_unlock( libvlc_media_list );
return false; return false;
} }
......
projects/mozilla/vlcplugin.h
View file @ bb12c0f1
...@@ -78,12 +78,14 @@ ...@@ -78,12 +78,14 @@
# define __MIN(a, b) ( ((a) < (b)) ? (a) : (b) ) # define __MIN(a, b) ( ((a) < (b)) ? (a) : (b) )
#endif #endif
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#include <npapi.h> #include <npapi.h>
#include <vector> #include <vector>
#include <assert.h>
#include "control/nporuntime.h" #include "control/nporuntime.h"
typedef struct { typedef struct {
#if defined(XP_UNIX) #if defined(XP_UNIX)
pthread_mutex_t mutex; pthread_mutex_t mutex;
...@@ -94,7 +96,6 @@ typedef struct { ...@@ -94,7 +96,6 @@ typedef struct {
#endif #endif
} plugin_lock_t; } plugin_lock_t;
typedef enum vlc_toolbar_clicked_e { typedef enum vlc_toolbar_clicked_e {
clicked_Unknown = 0, clicked_Unknown = 0,
clicked_Play, clicked_Play,
...@@ -107,82 +108,80 @@ typedef enum vlc_toolbar_clicked_e { ...@@ -107,82 +108,80 @@ typedef enum vlc_toolbar_clicked_e {
clicked_Unmute clicked_Unmute
} vlc_toolbar_clicked_t; } 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 class EventObj
// 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
{ {
private: 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: public:
Listener(event_t e,NPObject *o,bool b): _l(o), _b(b) Listener(vlcplugin_event_t *event, NPObject *p_object, bool b_bubble):
{ NPN_RetainObject(o); set(e); } _event(event), _listener(p_object), _bubble(b_bubble)
Listener(): _l(NULL), _b(false) { } {
~Listener() { if(_l) NPN_ReleaseObject(_l); } assert(event);
NPObject *listener() const { return _l; } assert(p_object);
bool bubble() const { return _b; } }
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: private:
NPObject *_l; vlcplugin_event_t *_event;
bool _b; NPObject *_listener;
bool _bubble;
}; };
libvlc_event_manager_t *_em; class VLCEvent
libvlc_callback_t _cb; {
void *_ud; 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: public:
EventObj(): _em(NULL) { /* deferred to init() */ } EventObj(): _em(NULL) { /* deferred to init() */ }
bool init(); bool init();
~EventObj(); ~EventObj();
void deliver(NPP browser); void deliver(NPP browser);
void callback(const libvlc_event_t*); void callback(const libvlc_event_t *event, NPVariant *npparams, uint32_t count);
bool insert(const NPString &, NPObject *, bool); bool insert(const NPString &name, NPObject *listener, bool bubble);
bool remove(const NPString &, NPObject *, bool); bool remove(const NPString &name, NPObject *listener, bool bubble);
void unhook_manager(); void unhook_manager(void *);
void hook_manager(libvlc_event_manager_t *,libvlc_callback_t, void *); void hook_manager(libvlc_event_manager_t *, void *);
private: 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<Listener> lr_l;
typedef std::vector<libvlc_event_type_t> ev_l; typedef std::vector<VLCEvent> ev_l;
lr_l _llist; lr_l _llist; /* list of registered listeners with 'addEventListener' method */
ev_l _elist; ev_l _elist; /* scheduled events list for delivery to browser */
plugin_lock_t lock; plugin_lock_t lock;
bool ask_for_event(event_t e);
void unask_for_event(event_t e);
}; };
class VlcPlugin class VlcPlugin
{ {
public: public:
...@@ -314,6 +313,7 @@ public: ...@@ -314,6 +313,7 @@ public:
static bool canUseEventListener(); static bool canUseEventListener();
EventObj events; EventObj events;
static void event_callback(const libvlc_event_t *, NPVariant *, uint32_t, void *);
private: private:
bool playlist_select(int); bool playlist_select(int);
void set_player_window(); void set_player_window();
...@@ -352,7 +352,6 @@ private: ...@@ -352,7 +352,6 @@ private:
#endif #endif
static void eventAsync(void *); static void eventAsync(void *);
static void event_callback(const libvlc_event_t *, void *);
}; };
/******************************************************************************* /*******************************************************************************
......
projects/mozilla/vlcshell.h
View file @ bb12c0f1
/***************************************************************************** /*****************************************************************************
* vlcshell.hp: * vlcshell.h:
***************************************************************************** *****************************************************************************
* Copyright (C) 2009 the VideoLAN team * Copyright (C) 2009-2010 the VideoLAN team
* $Id$ * $Id$
* *
* Authors: Jean-Paul Saman <jpsaman@videolan.org> * Authors: Jean-Paul Saman <jpsaman@videolan.org>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment