control/event.c: Change the event API to be per-object driven. It is not yet in use.

include/vlc/libvlc.h

@@ -884,50 +884,51 @@ VLC_PUBLIC_API libvlc_log_message_t *libvlc_log_iterator_next( libvlc_log_iterat
 /** @} */
 
 /*****************************************************************************
- * Callbacks handling
+ * Event handling
  *****************************************************************************/
 
 /** defgroup libvlc_callbacks Callbacks
  * \ingroup libvlc
- * LibVLC Event Callbacks
+ * LibVLC Events
  * @{
  */
 
 /**
- * Register for a callback notification
- * \param p_instance the libvlc instance
- * \param i_event_type the desired event mask to which we want to listen
+ * Register for an event notification
+ * \param p_event_manager the event manager to which you want to attach to
+ * Generally it is obtained by vlc_my_object_event_manager() where my_object
+ * Is the object you want to listen to.
+ * \param i_event_type the desired event to which we want to listen
  * \param f_callback the function to call when i_event_type occurs
  * \param user_data user provided data to carry with the event
  * \param p_e an initialized exception pointer
  */
-VLC_PUBLIC_API void libvlc_event_add_callback( libvlc_instance_t *p_instance,
+VLC_PUBLIC_API void libvlc_event_attach( libvlc_event_manager_t *p_event_manager,
                                          libvlc_event_type_t i_event_type,
                                          libvlc_callback_t f_callback,
                                          void *user_data,
                                          libvlc_exception_t *p_e );
 
 /**
- * Unregister all callbacks notification from an instance
- * \param p_instance the libvlc instance
- * \param p_e an initialized exception pointer
- */
-VLC_PUBLIC_API void libvlc_event_remove_all_callbacks( libvlc_instance_t *p_instance,
-                                                       libvlc_exception_t *p_e );
-
-/**
- * Unregister a callback notification
- * \param p_instance the libvlc instance
- * \param i_event_type the desired event mask to which we want to unregister
+ * Unregister an event notification
+ * \param p_event_manager the event manager
+ * \param i_event_type the desired event to which we want to unregister
  * \param f_callback the function to call when i_event_type occurs
  * \param p_e an initialized exception pointer
  */
-VLC_PUBLIC_API void libvlc_event_remove_callback( libvlc_instance_t *p_instance,
+VLC_PUBLIC_API void libvlc_event_detach( libvlc_event_manager_t *p_event_manager,
                                          libvlc_event_type_t i_event_type,
                                          libvlc_callback_t f_callback,
                                          void *p_user_data,
                                          libvlc_exception_t *p_e );
 
+
+/**
+ * Get an event type name 
+ * \param i_event_type the desired event
+ */
+#define libvlc_event_type_name(a) #a
+
 /** @} */
 
 

include/vlc/libvlc_structures.h

@@ -182,7 +182,7 @@ typedef struct libvlc_log_message_t
  */
     
 /**
- * Available events:
+ * Available events: (XXX: being reworked)
  * - libvlc_VolumeChanged
  * - libvlc_InputPositionChanged
  */
@@ -192,9 +192,17 @@ typedef enum libvlc_event_type_t {
     libvlc_InputPositionChanged,
 } libvlc_event_type_t;
 
+/**
+ * An Event
+ * \param type the even type
+ * \param p_obj the sender object
+ * \param u Event dependent content
+ */
+
 typedef struct libvlc_event_t
 {
     libvlc_event_type_t type;
+	void * p_obj;
     union
     {
         struct
@@ -208,14 +216,19 @@ typedef struct libvlc_event_t
     } u;
 } libvlc_event_t;
 
+/**
+ * Event manager that belongs to a libvlc object, and from whom events can
+ * be received.
+ */
+
+typedef struct libvlc_event_manager_t libvlc_event_manager_t;
+
 /**
  * Callback function notification
- * \param p_instance the libvlc instance
  * \param p_event the event triggering the callback
- * \param p_user_data user provided data
  */
 
-typedef void ( *libvlc_callback_t )( struct libvlc_instance_t *, libvlc_event_t *, void * );
+typedef void ( *libvlc_callback_t )( const libvlc_event_t * );
 
 /**@} */
 

src/control/event.c

@@ -31,217 +31,121 @@
  * Private functions
  */
 
+
+/*
+ * Internal libvlc functions
+ */
+
 /**************************************************************************
- *       handle_event (private)
+ *       libvlc_event_init (internal) :
  *
- * Callback from the vlc variables
+ * initialization function.
  **************************************************************************/
-static int handle_event( vlc_object_t *p_this, char const *psz_cmd,
-                         vlc_value_t oldval, vlc_value_t newval,
-                         void *p_data )
+void libvlc_event_init( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
 {
-    /* This is thread safe, as the var_*Callback already provide the locking
-     * facility for p_data */
-    struct libvlc_callback_entry_t *entry = p_data;
-    libvlc_event_t event;
-
-    event.type = entry->i_event_type;    
-
-    if (event.type == libvlc_VolumeChanged)
-    {
-        if(!strcmp(psz_cmd, "intf-change"))
-        {
-            input_thread_t * p_input = (input_thread_t *)p_this;
-            vlc_value_t val;
-            var_Get( p_input, "time", &val );
-
-            /* Only send event at a reasonable time precision (500ms) */
-            /* (FIXME: this should be configurable) */
-            if ((val.i_time % I64C(500000)) != 0)
-            {
-                /* Don't send this event */
-                return VLC_SUCCESS;
-            }
-
-            event.u.input_position_changed.new_position = val.i_time;
-        }
-        else
-            event.u.input_position_changed.new_position = newval.i_time;
-
-        event.u.input_position_changed.new_position *= 1000LL;
-    }
-    else if (event.type == libvlc_InputPositionChanged)
-    {
-        event.u.volume_changed.new_volume = newval.i_int;
-    }
-
-    /* Call the client entry */
-    entry->f_callback( entry->p_instance, &event, entry->p_user_data );
-
-    return VLC_SUCCESS;
+	/* Will certainly be used to install libvlc_instance event */
 }
 
 /**************************************************************************
- *       get_input (private) :
+ *       libvlc_event_fini (internal) :
  *
- * Utility function, Object should be released by vlc_object_release
- * afterwards
+ * finalization function.
  **************************************************************************/
-static input_thread_t * get_input(libvlc_instance_t * p_instance)
+void libvlc_event_fini( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
 {
-    libvlc_media_instance_t * p_mi;
-    input_thread_t * p_input;
-
-    p_mi = libvlc_playlist_get_media_instance( p_instance, NULL );
-
-    if( !p_mi )
-        return NULL;
-
-    p_input = libvlc_get_input_thread( p_mi, NULL );
-
-    libvlc_media_instance_release( p_mi );
-
-    return p_input;
 }
 
 /**************************************************************************
- *       install_input_event (private) :
+ *       libvlc_event_manager_init (internal) :
  *
- * vlc variables callback, used to install input event.
- * Can be called manually though.
+ * Init an object's event manager.
  **************************************************************************/
-static int install_input_event( vlc_object_t *p_this, char const *psz_cmd,
-                                vlc_value_t oldval, vlc_value_t newval,
-                                void *p_data )
+libvlc_event_manager_t *
+libvlc_event_manager_init( void * p_obj, libvlc_instance_t * p_libvlc_inst,
+                           libvlc_exception_t *p_e )
 {
-    libvlc_instance_t * p_instance = p_data;
-    struct libvlc_callback_entry_list_t *p_listitem;
-    input_thread_t * p_input = get_input( p_instance );
-
-    if( !p_input )
-        return VLC_SUCCESS;
-
-    vlc_mutex_lock( &p_instance->instance_lock );
+    libvlc_event_manager_t * p_em;
 
-    p_listitem = p_instance->p_callback_list;
-
-    for( ; p_listitem ; p_listitem = p_listitem->next )
-    {
-        if (p_listitem->elmt->i_event_type == libvlc_InputPositionChanged)
+	p_em = malloc(sizeof( libvlc_event_manager_t ));
+	if( !p_em )
 	{
-            /* FIXME: here we shouldn't listen on intf-change, we have to provide
-             * in vlc core a more accurate callback */
-            var_AddCallback( p_input, "intf-change", handle_event, p_listitem->elmt );
-            var_AddCallback( p_input, "time", handle_event, p_listitem->elmt );
-        }
+		libvlc_exception_raise( p_e, "No Memory left" );
+		return NULL;
 	}
 
-    vlc_mutex_unlock( &p_instance->instance_lock );
-    vlc_object_release( p_input );
-    return VLC_SUCCESS;
+	p_em->p_obj = p_obj;
+	p_em->p_libvlc_instance = p_libvlc_inst;
+	ARRAY_INIT( p_em->listeners_groups );
+
+	return p_em;
 }
 
 /**************************************************************************
- *       add_callback_to_list (private) :
+ *       libvlc_event_manager_release (internal) :
  *
- * callback list utility function.
+ * Init an object's event manager.
  **************************************************************************/
-static inline void add_callback_to_list( struct libvlc_callback_entry_t *entry,
-                                         struct libvlc_callback_entry_list_t **list )
+void libvlc_event_manager_release( libvlc_event_manager_t * p_em )
 {
-    struct libvlc_callback_entry_list_t *new_listitem;
-
-    /* malloc/free strategy:
-     *  - alloc-ded in add_callback_entry
-     *  - free-ed by libvlc_event_remove_callback
-     *  - free-ed in libvlc_destroy threw libvlc_event_remove_callback
-     *    when entry is destroyed
-     */
-    new_listitem = malloc( sizeof( struct libvlc_callback_entry_list_t ) );
-    new_listitem->elmt = entry;
-    new_listitem->next = *list;
-    new_listitem->prev = NULL;
-
-    if(*list)
-        (*list)->prev = new_listitem;
-
-    *list = new_listitem;
+	libvlc_event_listeners_group_t * listeners_group;
+	libvlc_event_listener_t * listener;
+
+	FOREACH_ARRAY( listeners_group, p_em->listeners_groups )
+		FOREACH_ARRAY( listener, listeners_group->listeners )
+			free( listener );
+		FOREACH_END()
+		free( listeners_group );
+	FOREACH_END()
+	free( p_em );
 }
 
 /**************************************************************************
- *       remove_variable_callback (private) :
+ *       libvlc_event_manager_register_event_type (internal) :
  *
- * Delete the appropriate vlc variables callback for an event.
+ * Init an object's event manager.
  **************************************************************************/
-static int remove_variable_callback( libvlc_instance_t *p_instance, 
-                                     struct libvlc_callback_entry_t * p_entry )
+void libvlc_event_manager_register_event_type(
+		libvlc_event_manager_t * p_em,
+		libvlc_event_type_t event_type,
+		libvlc_exception_t * p_e )
 {
-    input_thread_t * p_input = get_input( p_instance );
-    int res = VLC_SUCCESS;
-
-    /* Note: Appropriate lock should be held by the caller */
-
-    switch ( p_entry->i_event_type )
+	libvlc_event_listeners_group_t * listeners_group;
+	listeners_group = malloc(sizeof(libvlc_event_listeners_group_t));
+	if( !listeners_group )
 	{
-        case libvlc_VolumeChanged:
-            res = var_DelCallback( p_instance->p_libvlc_int, "volume-change",
-                             handle_event, p_entry );
-            break;
-        case libvlc_InputPositionChanged:
-            /* We may not be deleting the right p_input callback, in this case this
-             * will be a no-op */
-            var_DelCallback( p_input, "intf-change", handle_event, p_entry );
-            var_DelCallback( p_input, "position", handle_event, p_entry );
-            break;
+		libvlc_exception_raise( p_e, "No Memory left" );
+		return;
 	}
 
-    if (p_input)
-        vlc_object_release( p_input );
+	listeners_group->event_type = event_type;
+	ARRAY_INIT( listeners_group->listeners );
 
-    return res;
+	ARRAY_APPEND( p_em->listeners_groups, listeners_group );
 }
 
-/*
- * Internal libvlc functions
- */
-
 /**************************************************************************
- *       libvlc_event_init (internal) :
+ *       libvlc_event_send (internal) :
  *
- * initialization function.
+ * Send a callback.
  **************************************************************************/
-void libvlc_event_init( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
+void libvlc_event_send( libvlc_event_manager_t * p_em,
+                        libvlc_event_t * p_event )
 {
-    playlist_t *p_playlist = p_instance->p_libvlc_int->p_playlist;
+	libvlc_event_listeners_group_t * listeners_group;
+	libvlc_event_listener_t * listener;
+	/* Fill event with the sending object now */
+	p_event->p_obj = p_em->p_obj;
 
-    p_instance->p_callback_list = NULL;
-
-    if( !p_playlist )
-        RAISEVOID ("Can't listen to input event");
-
-    /* Install a Callback for input changes, so
-     * so we can track input event */
-     var_AddCallback( p_playlist, "playlist-current",
-                      install_input_event, p_instance );
-}
-
-/**************************************************************************
- *       libvlc_event_fini (internal) :
- *
- * finalization function.
- **************************************************************************/
-void libvlc_event_fini( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
-{
-    playlist_t *p_playlist = p_instance->p_libvlc_int->p_playlist;
-    libvlc_exception_t p_e_unused;
-
-    libvlc_event_remove_all_callbacks( p_instance, &p_e_unused );
-
-    if( !p_playlist )
-        RAISEVOID ("Can't unregister input events");
-
-    var_DelCallback( p_playlist, "playlist-current",
-                     install_input_event, p_instance );
+	FOREACH_ARRAY( listeners_group, p_em->listeners_groups )
+		if( listeners_group->event_type == p_event->type )
+		{
+			/* We found the group, now send every one the event */
+			FOREACH_ARRAY( listener, listeners_group->listeners )
+				listener->pf_callback( p_event );
+			FOREACH_END()
+			break;
+		}
+	FOREACH_END()
 }
 
 /*
@@ -249,129 +153,77 @@ void libvlc_event_fini( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
  */
 
 /**************************************************************************
- *       libvlc_event_add_callback (public) :
+ *       libvlc_event_attach (public) :
  *
  * Add a callback for an event.
  **************************************************************************/
-void libvlc_event_add_callback( libvlc_instance_t *p_instance,
-                                libvlc_event_type_t i_event_type,
-                                libvlc_callback_t f_callback,
-                                void *user_data,
+void libvlc_event_attach( libvlc_event_manager_t * p_event_manager,
+                          libvlc_event_type_t event_type,
+                          libvlc_callback_t pf_callback,
+                          void *p_user_data,
                           libvlc_exception_t *p_e )
 {
-    struct libvlc_callback_entry_t *entry;
-    vlc_value_t unused1, unused2;
-    int res = VLC_SUCCESS;
-
-    if ( !f_callback )
-        RAISEVOID (" Callback function is null ");
-
-    /* malloc/free strategy:
-     *  - alloc-ded in libvlc_event_add_callback
-     *  - free-ed by libvlc_event_add_callback on error
-     *  - free-ed by libvlc_event_remove_callback
-     *  - free-ed in libvlc_destroy threw libvlc_event_remove_callback
-     *    when entry is destroyed
-     */
-    entry = malloc( sizeof( struct libvlc_callback_entry_t ) );
-    entry->f_callback = f_callback;
-    entry->i_event_type = i_event_type;
-    entry->p_user_data = user_data;
-    
-    switch ( i_event_type )
+	libvlc_event_listeners_group_t * listeners_group;
+	libvlc_event_listener_t * listener;
+	listener = malloc(sizeof(libvlc_event_listener_t));
+	if( !listener )
 	{
-        case libvlc_VolumeChanged:
-            res = var_AddCallback( p_instance->p_libvlc_int, "volume-change",
-                           handle_event, entry );
-            break;
-        case libvlc_InputPositionChanged:
-            install_input_event( NULL, NULL, unused1, unused2, p_instance);
-            break;
-        default:
-            free( entry );
-            RAISEVOID( "Unsupported event." );
+		libvlc_exception_raise( p_e, "No Memory left" );
+		return;
 	}
 	
-    if (res != VLC_SUCCESS)
+	listener->event_type = event_type;
+	listener->p_user_data = p_user_data;
+	listener->pf_callback = pf_callback;
+	
+	FOREACH_ARRAY( listeners_group, p_event_manager->listeners_groups )
+		if( listeners_group->event_type == listener->event_type )
 		{
-        free ( entry );
-        RAISEVOID("Internal callback registration was not successful. Callback not registered.");
+			ARRAY_APPEND( listeners_group->listeners, listener );
+			return;
 		}
+	FOREACH_END()
 	
-    vlc_mutex_lock( &p_instance->instance_lock );
-    add_callback_to_list( entry, &p_instance->p_callback_list );
-    vlc_mutex_unlock( &p_instance->instance_lock );
-
-    return;
+	free(listener);
+	libvlc_exception_raise( p_e,
+			"This object event manager doesn't know about '%s' events",
+			libvlc_event_type_name(a));
 }
 
 /**************************************************************************
- *       libvlc_event_remove_callback (public) :
+ *       libvlc_event_detach (public) :
  *
  * Remove a callback for an event.
  **************************************************************************/
-void libvlc_event_remove_callback( libvlc_instance_t *p_instance,
-                                   libvlc_event_type_t i_event_type,
-                                   libvlc_callback_t f_callback,
+void libvlc_event_detach( libvlc_event_manager_t *p_event_manager,
+                          libvlc_event_type_t event_type,
+                          libvlc_callback_t pf_callback,
 						  void *p_user_data,
                           libvlc_exception_t *p_e )
 {
-    struct libvlc_callback_entry_list_t *p_listitem;
-
-    vlc_mutex_lock( &p_instance->instance_lock );
-
-    p_listitem = p_instance->p_callback_list;
-
-    while( p_listitem )
+	libvlc_event_listeners_group_t * listeners_group;
+	libvlc_event_listener_t * listener;
+	FOREACH_ARRAY( listeners_group, p_event_manager->listeners_groups )
+		if( listeners_group->event_type == event_type )
 		{
-        if( p_listitem->elmt->f_callback == f_callback
-            && ( p_listitem->elmt->i_event_type == i_event_type )
-            && ( p_listitem->elmt->p_user_data == p_user_data )
-        
-        )
+			FOREACH_ARRAY( listener, listeners_group->listeners )
+				if( listener->event_type == event_type &&
+					listener->pf_callback == pf_callback &&
+					listener->p_user_data == p_user_data )
 				{
-            remove_variable_callback( p_instance, p_listitem->elmt ); /* FIXME: We should warn on error */
-
-            if( p_listitem->prev )
-                p_listitem->prev->next = p_listitem->next;
-            else
-                p_instance->p_callback_list = p_listitem->next;
-
-
-            p_listitem->next->prev = p_listitem->prev;
-
-            free( p_listitem->elmt );
-
-            free( p_listitem );
-            break;
+					/* that's our listener */
+					free( listener );
+					ARRAY_REMOVE( listeners_group->listeners,
+						fe_idx /* This comes from the macro (and that's why
+								  I hate macro) */ );
+					return;
 				}
-        
-        p_listitem = p_listitem->next;
+			FOREACH_END()
 		}
-    vlc_mutex_unlock( &p_instance->instance_lock );
-}
+	FOREACH_END()
 	
-/**************************************************************************
- *       libvlc_event_remove_all_callbacks (public) :
- *
- * Remove all callbacks for all events.
- **************************************************************************/
-void libvlc_event_remove_all_callbacks( libvlc_instance_t *p_instance,
-                                       libvlc_exception_t *p_e )
-{
-    struct libvlc_callback_entry_list_t *p_listitem;
-
-    vlc_mutex_lock( &p_instance->instance_lock );
-
-    p_listitem = p_instance->p_callback_list;
-
-    while( p_listitem )
-    {
-        remove_variable_callback( p_instance, p_listitem->elmt ); /* FIXME: We could warn on error */
-        p_listitem = p_listitem->next;
-
-    }
-    p_instance->p_callback_list = NULL;
-
-    vlc_mutex_unlock( &p_instance->instance_lock );
+	libvlc_exception_raise( p_e,
+			"This object event manager doesn't know about '%i,%p,%p' event observer",
+			event_type, pf_callback, p_user_data );
 }
+

src/control/libvlc_internal.h

@@ -32,6 +32,7 @@ extern "C" {
 #include <vlc/vlc.h>
 #include <vlc/libvlc_structures.h>
 
+#include <vlc_arrays.h>
 #include <vlc_input.h>
     
 /***************************************************************************
@@ -52,21 +53,6 @@ VLC_EXPORT (void, libvlc_event_fini, ( libvlc_instance_t *, libvlc_exception_t *
  * Opaque structures for libvlc API
  ***************************************************************************/
 
-struct libvlc_callback_entry_t
-{
-    libvlc_instance_t *p_instance;
-    libvlc_callback_t f_callback;
-    libvlc_event_type_t i_event_type;
-    void *p_user_data;
-};
-
-struct libvlc_callback_entry_list_t
-{
-    struct libvlc_callback_entry_t *elmt;
-    struct libvlc_callback_entry_list_t *next;
-    struct libvlc_callback_entry_list_t *prev;
-};
-    
 struct libvlc_instance_t
 {
     libvlc_int_t *p_libvlc_int;
@@ -94,24 +80,103 @@ struct libvlc_media_instance_t
     libvlc_media_descriptor_t *p_md; /* current media descriptor */
 };
 
+
+/* 
+ * Event Handling
+ */
+/* Example usage
+ *
+ * struct libvlc_cool_object_t
+ * {
+ *		...
+ *		libvlc_event_manager_t * p_event_manager;
+ *		...
+ * }
+ *
+ * libvlc_my_cool_object_new()
+ * {
+ *		...
+ *		p_self->p_event_manager = libvlc_event_manager_init( p_self,
+ *		                                           p_self->p_libvlc_instance, p_e);
+ *		libvlc_event_manager_register_event_type(p_self->p_event_manager,
+ *				libvlc_MyCoolObjectDidSomething, p_e)
+ *		...
+ * }
+ *
+ * libvlc_my_cool_object_release()
+ * {
+ * 		...
+ * 		libvlc_event_manager_release( p_self->p_event_manager );
+ * 		...
+ * }
+ *
+ * libvlc_my_cool_object_do_something()
+ * {
+ *	    ...
+ *	    libvlc_event_t event;
+ *	    event.type = libvlc_MyCoolObjectDidSomething;
+ *	    event.my_cool_object_did_something.what_it_did = kSomething;
+ *	    libvlc_event_send( p_self->p_event_manager, &event );
+ * }
+ * */
+
+typedef struct libvlc_event_listener_t
+{
+	libvlc_event_type_t event_type;
+	void *              p_user_data;
+	libvlc_callback_t   pf_callback;
+} libvlc_event_listener_t;
+
+typedef struct libvlc_event_listeners_group_t
+{
+	libvlc_event_type_t event_type;
+	DECL_ARRAY(libvlc_event_listener_t *) listeners;
+} libvlc_event_listeners_group_t;
+
+typedef struct libvlc_event_manager_t
+{
+	void * p_obj;
+	struct libvlc_instance_t * p_libvlc_instance;
+	DECL_ARRAY(libvlc_event_listeners_group_t *) listeners_groups;
+} libvlc_event_sender_t;
+
+
 /***************************************************************************
  * Other internal functions
  ***************************************************************************/
 VLC_EXPORT (input_thread_t *, libvlc_get_input_thread,
                         ( struct libvlc_media_instance_t *, libvlc_exception_t * ) );
 
+/* Media instance */
 VLC_EXPORT (libvlc_media_instance_t *, libvlc_media_instance_new_from_input_thread,
                         ( struct libvlc_instance_t *, input_thread_t *, libvlc_exception_t * ) );
 
 VLC_EXPORT (void, libvlc_media_instance_destroy,
                         ( libvlc_media_instance_t * ) );
 
+/* Media Descriptor */
 VLC_EXPORT (libvlc_media_descriptor_t *, libvlc_media_descriptor_new_from_input_item,
                         ( struct libvlc_instance_t *, input_item_t *, libvlc_exception_t * ) );
 
 VLC_EXPORT (libvlc_media_descriptor_t *, libvlc_media_descriptor_duplicate,
                         ( libvlc_media_descriptor_t * ) );
 
+/* Events */
+VLC_EXPORT (void, libvlc_event_init, ( libvlc_instance_t *p_instance, libvlc_exception_t *p_e ) );
+
+VLC_EXPORT (void, libvlc_event_fini, ( libvlc_instance_t *p_instance, libvlc_exception_t *p_e ) );
+
+VLC_EXPORT (libvlc_event_manager_t *, libvlc_event_manager_init, ( void * p_obj, libvlc_instance_t * p_libvlc_inst, libvlc_exception_t *p_e ) );
+
+VLC_EXPORT (void, libvlc_event_manager_release, ( libvlc_event_manager_t * p_em ) );
+
+VLC_EXPORT (void, libvlc_event_manager_register_event_type, ( libvlc_event_manager_t * p_em, libvlc_event_type_t event_type, libvlc_exception_t * p_e ) );
+
+VLC_EXPORT (void, libvlc_event_send, ( libvlc_event_manager_t * p_em, libvlc_event_t * p_event ) );
+
+
+/* Exception shorcuts */
+
 #define RAISENULL( psz,a... ) { libvlc_exception_raise( p_e, psz,##a ); \
                                 return NULL; }
 #define RAISEVOID( psz,a... ) { libvlc_exception_raise( p_e, psz,##a ); \