1 /*****************************************************************************
2 * extension.c: Lua Extensions (meta data, web information, ...)
3 *****************************************************************************
4 * Copyright (C) 2009-2010 VideoLAN and authors
7 * Authors: Jean-Philippe André < jpeg # videolan.org >
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
26 #include "extension.h"
29 #include <vlc_input.h>
30 #include <vlc_events.h>
32 /* Functions to register */
33 static const luaL_Reg p_reg[] =
39 * Extensions capabilities
40 * Note: #define and ppsz_capabilities must be in sync
42 #define EXT_HAS_MENU (1 << 0) ///< Hook: menu
43 #define EXT_TRIGGER_ONLY (1 << 1) ///< Hook: trigger. Not activable
44 #define EXT_INPUT_LISTENER (1 << 2) ///< Hook: input_changed
45 #define EXT_META_LISTENER (1 << 3) ///< Hook: meta_changed
46 #define EXT_PLAYING_LISTENER (1 << 4) ///< Hook: status_changed
48 const char* const ppsz_capabilities[] = {
57 static int ScanExtensions( extensions_manager_t *p_this );
58 static int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
60 static int Control( extensions_manager_t *, int, va_list );
61 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
62 char ***pppsz_titles, uint16_t **ppi_ids );
63 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
65 static int TriggerMenu( extension_t *p_ext, int id );
66 static int TriggerExtension( extensions_manager_t *p_mgr,
69 int vlclua_extension_deactivate( lua_State *L );
72 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
78 /* Input item callback: vlc_InputItemMetaChanged */
79 static void inputItemMetaChanged( const vlc_event_t *p_event,
86 int Open_Extension( vlc_object_t *p_this )
88 msg_Dbg( p_this, "Opening EXPERIMENTAL Lua Extension module" );
90 extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
92 p_mgr->pf_control = Control;
94 extensions_manager_sys_t *p_sys = ( extensions_manager_sys_t* )
95 calloc( 1, sizeof( extensions_manager_sys_t ) );
96 if( !p_sys ) return VLC_ENOMEM;
99 ARRAY_INIT( p_sys->activated_extensions );
100 ARRAY_INIT( p_mgr->extensions );
101 vlc_mutex_init( &p_mgr->lock );
102 vlc_mutex_init( &p_mgr->p_sys->lock );
104 /* Scan available Lua Extensions */
105 if( ScanExtensions( p_mgr ) != VLC_SUCCESS )
107 msg_Err( p_mgr, "Can't load extensions modules" );
111 // Create the dialog-event variable
112 var_Create( p_this, "dialog-event", VLC_VAR_ADDRESS );
113 var_AddCallback( p_this, "dialog-event",
114 vlclua_extension_dialog_callback, NULL );
120 * Module unload function
122 void Close_Extension( vlc_object_t *p_this )
124 extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
125 msg_Dbg( p_mgr, "Deactivating all loaded extensions" );
127 vlc_mutex_lock( &p_mgr->lock );
128 p_mgr->p_sys->b_killed = true;
129 vlc_mutex_unlock( &p_mgr->lock );
131 var_Destroy( p_mgr, "dialog-event" );
133 extension_t *p_ext = NULL;
134 FOREACH_ARRAY( p_ext, p_mgr->p_sys->activated_extensions )
137 msg_Dbg( p_mgr, "Deactivating '%s'", p_ext->psz_title );
138 Deactivate( p_mgr, p_ext );
139 WaitForDeactivation( p_ext );
143 msg_Dbg( p_mgr, "All extensions are now deactivated" );
144 ARRAY_RESET( p_mgr->p_sys->activated_extensions );
146 vlc_mutex_destroy( &p_mgr->lock );
147 vlc_mutex_destroy( &p_mgr->p_sys->lock );
148 free( p_mgr->p_sys );
151 /* Free extensions' memory */
152 FOREACH_ARRAY( p_ext, p_mgr->extensions )
156 if( p_ext->p_sys->L )
157 lua_close( p_ext->p_sys->L );
158 free( p_ext->psz_name );
159 free( p_ext->psz_title );
160 free( p_ext->psz_author );
161 free( p_ext->psz_description );
162 free( p_ext->psz_shortdescription );
163 free( p_ext->psz_url );
164 free( p_ext->psz_version );
166 vlc_mutex_destroy( &p_ext->p_sys->running_lock );
167 vlc_mutex_destroy( &p_ext->p_sys->command_lock );
168 vlc_cond_destroy( &p_ext->p_sys->wait );
170 free( p_ext->p_sys );
175 ARRAY_RESET( p_mgr->extensions );
179 * Batch scan all Lua files in folder "extensions"
180 * @param p_mgr This extensions_manager_t object
182 static int ScanExtensions( extensions_manager_t *p_mgr )
185 vlclua_scripts_batch_execute( VLC_OBJECT( p_mgr ),
197 * Dummy Lua function: does nothing
198 * @note This function can be used to replace "require" while scanning for
200 * Even the built-in libraries are not loaded when calling descriptor()
202 static int vlclua_dummy_require( lua_State *L )
209 * Batch scan all Lua files in folder "extensions": callback
210 * @param p_this This extensions_manager_t object
211 * @param psz_script Name of the script to run
212 * @param L Lua State, common to all scripts here
213 * @param dummy: unused
215 int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
219 extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
222 msg_Dbg( p_mgr, "Scanning Lua script %s", psz_script );
224 vlc_mutex_lock( &p_mgr->lock );
226 /* Create new script descriptor */
227 extension_t *p_ext = ( extension_t* ) calloc( 1, sizeof( extension_t ) );
230 vlc_mutex_unlock( &p_mgr->lock );
234 p_ext->psz_name = strdup( psz_script );
235 p_ext->p_sys = (extension_sys_t*) calloc( 1, sizeof( extension_sys_t ) );
236 if( !p_ext->p_sys || !p_ext->psz_name )
238 free( p_ext->psz_name );
239 free( p_ext->p_sys );
241 vlc_mutex_unlock( &p_mgr->lock );
244 p_ext->p_sys->p_mgr = p_mgr;
246 /* Mutexes and conditions */
247 vlc_mutex_init( &p_ext->p_sys->command_lock );
248 vlc_mutex_init( &p_ext->p_sys->running_lock );
249 vlc_cond_init( &p_ext->p_sys->wait );
251 /* Prepare Lua state */
252 lua_State *L = luaL_newstate();
253 lua_register( L, "require", &vlclua_dummy_require );
256 if( luaL_dofile( L, psz_script ) )
258 msg_Warn( p_mgr, "Error loading script %s: %s", psz_script,
259 lua_tostring( L, lua_gettop( L ) ) );
264 /* Scan script for capabilities */
265 lua_getglobal( L, "descriptor" );
267 if( !lua_isfunction( L, -1 ) )
269 msg_Warn( p_mgr, "Error while running script %s, "
270 "function descriptor() not found", psz_script );
274 if( lua_pcall( L, 0, 1, 0 ) )
276 msg_Warn( p_mgr, "Error while running script %s, "
277 "function descriptor(): %s", psz_script,
278 lua_tostring( L, lua_gettop( L ) ) );
282 if( lua_gettop( L ) )
284 if( lua_istable( L, -1 ) )
287 lua_getfield( L, -1, "capabilities" );
288 if( lua_istable( L, -1 ) )
291 while( lua_next( L, -2 ) != 0 )
293 /* Key is at index -2 and value at index -1. Discard key */
294 const char *psz_cap = luaL_checkstring( L, -1 );
297 /* Find this capability's flag */
298 for( const char *iter = *ppsz_capabilities;
300 iter = ppsz_capabilities[ ++i_cap ])
302 if( !strcmp( iter, psz_cap ) )
305 p_ext->p_sys->i_capabilities |= 1 << i_cap;
312 msg_Warn( p_mgr, "Extension capability '%s' unknown in"
313 " script %s", psz_cap, psz_script );
315 /* Removes 'value'; keeps 'key' for next iteration */
321 msg_Warn( p_mgr, "In script %s, function descriptor() "
322 "did not return a table of capabilities.",
328 lua_getfield( L, -1, "title" );
329 if( lua_isstring( L, -1 ) )
331 p_ext->psz_title = strdup( luaL_checkstring( L, -1 ) );
335 msg_Dbg( p_mgr, "In script %s, function descriptor() "
336 "did not return a string as title.",
338 p_ext->psz_title = strdup( psz_script );
343 lua_getfield( L, -1, "author" );
344 if( lua_isstring( L, -1 ) )
345 p_ext->psz_author = strdup( luaL_optstring( L, -1, NULL ) );
348 /* Get description */
349 lua_getfield( L, -1, "description" );
350 if( lua_isstring( L, -1 ) )
351 p_ext->psz_description = strdup( luaL_optstring( L, -1, NULL ) );
354 /* Get short description */
355 lua_getfield( L, -1, "shortdesc" );
356 if( lua_isstring( L, -1 ) )
357 p_ext->psz_shortdescription = strdup( luaL_optstring( L, -1, NULL ) );
361 lua_getfield( L, -1, "url" );
362 if( lua_isstring( L, -1 ) )
363 p_ext->psz_url = strdup( luaL_optstring( L, -1, NULL ) );
367 lua_getfield( L, -1, "version" );
368 if( lua_isstring( L, -1 ) )
369 p_ext->psz_version = strdup( luaL_optstring( L, -1, NULL ) );
374 msg_Warn( p_mgr, "In script %s, function descriptor() "
375 "did not return a table!", psz_script );
381 msg_Err( p_mgr, "Script %s went completely foobar", psz_script );
385 msg_Dbg( p_mgr, "Script %s has the following capability flags: 0x%x",
386 psz_script, p_ext->p_sys->i_capabilities );
393 free( p_ext->psz_name );
394 free( p_ext->psz_title );
395 free( p_ext->psz_url );
396 free( p_ext->psz_author );
397 free( p_ext->psz_description );
398 free( p_ext->psz_shortdescription );
399 free( p_ext->psz_version );
400 vlc_mutex_destroy( &p_ext->p_sys->command_lock );
401 vlc_mutex_destroy( &p_ext->p_sys->running_lock );
402 vlc_cond_destroy( &p_ext->p_sys->wait );
403 free( p_ext->p_sys );
408 /* Add the extension to the list of known extensions */
409 ARRAY_APPEND( p_mgr->extensions, p_ext );
412 vlc_mutex_unlock( &p_mgr->lock );
413 /* Continue batch execution */
417 static int Control( extensions_manager_t *p_mgr, int i_control, va_list args )
419 extension_t *p_ext = NULL;
421 uint16_t **ppus = NULL;
422 char ***pppsz = NULL;
427 case EXTENSION_ACTIVATE:
428 p_ext = ( extension_t* ) va_arg( args, extension_t* );
429 return Activate( p_mgr, p_ext );
431 case EXTENSION_DEACTIVATE:
432 p_ext = ( extension_t* ) va_arg( args, extension_t* );
433 return Deactivate( p_mgr, p_ext );
435 case EXTENSION_IS_ACTIVATED:
436 p_ext = ( extension_t* ) va_arg( args, extension_t* );
437 pb = ( bool* ) va_arg( args, bool* );
438 *pb = IsActivated( p_mgr, p_ext );
441 case EXTENSION_HAS_MENU:
442 p_ext = ( extension_t* ) va_arg( args, extension_t* );
443 pb = ( bool* ) va_arg( args, bool* );
444 *pb = ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) ? 1 : 0;
447 case EXTENSION_GET_MENU:
448 p_ext = ( extension_t* ) va_arg( args, extension_t* );
449 pppsz = ( char*** ) va_arg( args, char*** );
450 ppus = ( uint16_t** ) va_arg( args, uint16_t** );
451 return GetMenuEntries( p_mgr, p_ext, pppsz, ppus );
453 case EXTENSION_TRIGGER_ONLY:
454 p_ext = ( extension_t* ) va_arg( args, extension_t* );
455 pb = ( bool* ) va_arg( args, bool* );
456 *pb = ( p_ext->p_sys->i_capabilities & EXT_TRIGGER_ONLY ) ? 1 : 0;
459 case EXTENSION_TRIGGER:
460 p_ext = ( extension_t* ) va_arg( args, extension_t* );
461 return TriggerExtension( p_mgr, p_ext );
463 case EXTENSION_TRIGGER_MENU:
464 p_ext = ( extension_t* ) va_arg( args, extension_t* );
465 // GCC: 'uint16_t' is promoted to 'int' when passed through '...'
466 i = ( int ) va_arg( args, int );
467 return TriggerMenu( p_ext, i );
469 case EXTENSION_SET_INPUT:
471 p_ext = ( extension_t* ) va_arg( args, extension_t* );
472 input_thread_t *p_input = va_arg( args, struct input_thread_t * );
474 if( !LockExtension( p_ext ) )
478 input_thread_t *old = p_ext->p_sys->p_input;
479 input_item_t *p_item;
482 // Untrack meta fetched events
483 if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
485 p_item = input_GetItem( old );
486 vlc_event_detach( &p_item->event_manager,
487 vlc_InputItemMetaChanged,
488 inputItemMetaChanged,
490 vlc_gc_decref( p_item );
492 vlc_object_release( old );
495 p_ext->p_sys->p_input = p_input ? vlc_object_hold( p_input )
498 // Tell the script the input changed
499 if( p_ext->p_sys->i_capabilities & EXT_INPUT_LISTENER )
501 PushCommandUnique( p_ext, CMD_SET_INPUT );
504 // Track meta fetched events
505 if( p_ext->p_sys->p_input &&
506 p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
508 p_item = input_GetItem( p_ext->p_sys->p_input );
509 vlc_gc_incref( p_item );
510 vlc_event_attach( &p_item->event_manager,
511 vlc_InputItemMetaChanged,
512 inputItemMetaChanged,
516 UnlockExtension( p_ext );
519 case EXTENSION_PLAYING_CHANGED:
522 p_ext = ( extension_t* ) va_arg( args, extension_t* );
523 assert( p_ext->psz_name != NULL );
524 i = ( int ) va_arg( args, int );
525 if( p_ext->p_sys->i_capabilities & EXT_PLAYING_LISTENER )
527 PushCommand( p_ext, CMD_PLAYING_CHANGED, i );
532 msg_Warn( p_mgr, "Control '%d' not yet implemented in Extension",
540 int lua_ExtensionActivate( extensions_manager_t *p_mgr, extension_t *p_ext )
542 assert( p_mgr != NULL && p_ext != NULL );
543 return lua_ExecuteFunction( p_mgr, p_ext, "activate", LUA_END );
546 int lua_ExtensionDeactivate( extensions_manager_t *p_mgr, extension_t *p_ext )
548 assert( p_mgr != NULL && p_ext != NULL );
550 if( !p_ext->p_sys->L )
553 // Unset and release input objects
554 if( p_ext->p_sys->p_input )
556 if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
559 input_item_t *p_item = input_GetItem( p_ext->p_sys->p_input );
560 vlc_gc_decref( p_item );
562 vlc_object_release( p_ext->p_sys->p_input );
565 int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "deactivate", LUA_END );
567 /* Clear Lua State */
568 lua_close( p_ext->p_sys->L );
569 p_ext->p_sys->L = NULL;
574 int lua_ExtensionWidgetClick( extensions_manager_t *p_mgr,
576 extension_widget_t *p_widget )
578 if( !p_ext->p_sys->L )
581 lua_State *L = GetLuaState( p_mgr, p_ext );
582 lua_pushlightuserdata( L, p_widget );
583 lua_gettable( L, LUA_REGISTRYINDEX );
584 return lua_ExecuteFunction( p_mgr, p_ext, NULL, LUA_END );
589 * Get the list of menu entries from an extension script
592 * @param pppsz_titles Pointer to NULL. All strings must be freed by the caller
593 * @param ppi_ids Pointer to NULL. Must be freed by the caller.
594 * @note This function is allowed to run in the UI thread. This means
595 * that it MUST respond very fast.
596 * @todo Remove the menu() hook and provide a new function vlc.set_menu()
598 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
599 char ***pppsz_titles, uint16_t **ppi_ids )
601 assert( *pppsz_titles == NULL );
602 assert( *ppi_ids == NULL );
604 if( !IsActivated( p_mgr, p_ext ) )
606 msg_Dbg( p_mgr, "Can't get menu before activating the extension!" );
610 if( !LockExtension( p_ext ) )
612 /* Dying extension, fail. */
616 int i_ret = VLC_EGENERIC;
617 lua_State *L = GetLuaState( p_mgr, p_ext );
619 if( ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) == 0 )
621 msg_Dbg( p_mgr, "can't get a menu from an extension without menu!" );
625 lua_getglobal( L, "menu" );
627 if( !lua_isfunction( L, -1 ) )
629 msg_Warn( p_mgr, "Error while running script %s, "
630 "function menu() not found", p_ext->psz_name );
634 if( lua_pcall( L, 0, 1, 0 ) )
636 msg_Warn( p_mgr, "Error while running script %s, "
637 "function menu(): %s", p_ext->psz_name,
638 lua_tostring( L, lua_gettop( L ) ) );
642 if( lua_gettop( L ) )
644 if( lua_istable( L, -1 ) )
647 size_t i_size = lua_objlen( L, -1 );
648 *pppsz_titles = ( char** ) calloc( i_size+1, sizeof( char* ) );
649 *ppi_ids = ( uint16_t* ) calloc( i_size+1, sizeof( uint16_t ) );
654 while( lua_next( L, -2 ) != 0 )
656 assert( i_idx < i_size );
657 if( (!lua_isstring( L, -1 )) || (!lua_isnumber( L, -2 )) )
659 msg_Warn( p_mgr, "In script %s, an entry in "
660 "the menu table is invalid!", p_ext->psz_name );
663 (*pppsz_titles)[ i_idx ] = strdup( luaL_checkstring( L, -1 ) );
664 (*ppi_ids)[ i_idx ] = (uint16_t) ( luaL_checkinteger( L, -2 ) & 0xFFFF );
671 msg_Warn( p_mgr, "Function menu() in script %s "
672 "did not return a table", p_ext->psz_name );
678 msg_Warn( p_mgr, "Script %s went completely foobar", p_ext->psz_name );
685 UnlockExtension( p_ext );
686 if( i_ret != VLC_SUCCESS )
688 msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
689 __func__, __FILE__, __LINE__ );
694 /* Must be entered with the Lock on Extension */
695 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
707 msg_Err( p_mgr, "Could not create new Lua State" );
710 vlclua_set_this( L, p_mgr );
711 vlclua_extension_set( L, p_ext );
714 luaL_register( L, "vlc", p_reg );
719 /* Load more libraries */
722 luaopen_dialog( L, p_ext );
730 luaopen_playlist( L );
733 luaopen_strings( L );
734 luaopen_variables( L );
740 /* Register extension specific functions */
741 lua_getglobal( L, "vlc" );
742 lua_pushcfunction( L, vlclua_extension_deactivate );
743 lua_setfield( L, -2, "deactivate" );
745 /* Setup the module search path */
746 if( vlclua_add_modules_path( p_mgr, L, p_ext->psz_name ) )
748 msg_Warn( p_mgr, "Error while setting the module search path for %s", p_ext->psz_name );
752 /* Load and run the script(s) */
753 if( luaL_dofile( L, p_ext->psz_name ) != 0 )
755 msg_Warn( p_mgr, "Error loading script %s: %s", p_ext->psz_name,
756 lua_tostring( L, lua_gettop( L ) ) );
768 int lua_ExecuteFunction( extensions_manager_t *p_mgr, extension_t *p_ext,
769 const char *psz_function, ... )
772 va_start( args, psz_function );
773 int i_ret = lua_ExecuteFunctionVa( p_mgr, p_ext, psz_function, args );
779 * Execute a function in a Lua script
780 * @param psz_function Name of global function to execute. If NULL, assume
781 * that the function object is already on top of the
783 * @return < 0 in case of failure, >= 0 in case of success
784 * @note It's better to call this function from a dedicated thread
785 * (see extension_thread.c)
787 int lua_ExecuteFunctionVa( extensions_manager_t *p_mgr, extension_t *p_ext,
788 const char *psz_function, va_list args )
790 int i_ret = VLC_EGENERIC;
792 assert( p_mgr != NULL );
793 assert( p_ext != NULL );
795 lua_State *L = GetLuaState( p_mgr, p_ext );
797 lua_getglobal( L, psz_function );
799 if( !lua_isfunction( L, -1 ) )
801 msg_Warn( p_mgr, "Error while running script %s, "
802 "function %s() not found", p_ext->psz_name, psz_function );
806 lua_datatype_e type = LUA_END;
807 while( ( type = va_arg( args, int ) ) != LUA_END )
809 if( type == LUA_NUM )
811 lua_pushnumber( L , ( int ) va_arg( args, int ) );
813 else if( type == LUA_TEXT )
815 lua_pushstring( L , ( char * ) va_arg( args, char* ) );
819 msg_Warn( p_mgr, "Undefined argument type %d to lua function %s"
820 "from script %s", type, psz_function, p_ext->psz_name );
825 if( lua_pcall( L, i_args, 1, 0 ) )
827 msg_Warn( p_mgr, "Error while running script %s, "
828 "function %s(): %s", p_ext->psz_name, psz_function,
829 lua_tostring( L, lua_gettop( L ) ) );
833 i_ret = lua_DialogFlush( L );
839 static inline int TriggerMenu( extension_t *p_ext, int i_id )
841 return PushCommand( p_ext, CMD_TRIGGERMENU, i_id );
844 int lua_ExtensionTriggerMenu( extensions_manager_t *p_mgr,
845 extension_t *p_ext, int id )
847 int i_ret = VLC_EGENERIC;
848 lua_State *L = GetLuaState( p_mgr, p_ext );
853 luaopen_dialog( L, p_ext );
855 lua_getglobal( L, "trigger_menu" );
856 if( !lua_isfunction( L, -1 ) )
858 msg_Warn( p_mgr, "Error while running script %s, "
859 "function trigger_menu() not found", p_ext->psz_name );
863 /* Pass id as unique argument to the function */
864 lua_pushinteger( L, id );
866 if( lua_pcall( L, 1, 1, 0 ) != 0 )
868 msg_Warn( p_mgr, "Error while running script %s, "
869 "function trigger_menu(): %s", p_ext->psz_name,
870 lua_tostring( L, lua_gettop( L ) ) );
874 i_ret = lua_DialogFlush( L );
875 if( i_ret < VLC_SUCCESS )
877 msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
878 __func__, __FILE__, __LINE__ );
883 /** Directly trigger an extension, without activating it
884 * This is NOT multithreaded, and this code runs in the UI thread
886 * @param p_ext Extension to trigger
887 * @return Value returned by the lua function "trigger"
889 static int TriggerExtension( extensions_manager_t *p_mgr,
892 int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "trigger", LUA_END );
894 /* Close lua state for trigger-only extensions */
895 if( p_ext->p_sys->L )
896 lua_close( p_ext->p_sys->L );
897 p_ext->p_sys->L = NULL;
902 /** Set extension associated to the current script
903 * @param L current lua_State
904 * @param p_ext the extension
906 void vlclua_extension_set( lua_State *L, extension_t *p_ext )
908 lua_pushlightuserdata( L, vlclua_extension_set );
909 lua_pushlightuserdata( L, p_ext );
910 lua_rawset( L, LUA_REGISTRYINDEX );
913 /** Retrieve extension associated to the current script
914 * @param L current lua_State
915 * @return Extension pointer
917 extension_t *vlclua_extension_get( lua_State *L )
919 lua_pushlightuserdata( L, vlclua_extension_set );
920 lua_rawget( L, LUA_REGISTRYINDEX );
921 extension_t *p_ext = (extension_t*) lua_topointer( L, -1 );
926 /** Deactivate an extension by order from the extension itself
928 * @note This is an asynchronous call. A script calling vlc.deactivate() will
929 * be executed to the end before the last call to deactivate() is done.
931 int vlclua_extension_deactivate( lua_State *L )
933 extension_t *p_ext = vlclua_extension_get( L );
934 int i_ret = Deactivate( p_ext->p_sys->p_mgr, p_ext );
935 return ( i_ret == VLC_SUCCESS ) ? 1 : 0;
938 /** Callback for the variable "dialog-event"
939 * @param p_this Current object owner of the extension and the dialog
940 * @param psz_var "dialog-event"
941 * @param oldval Unused
942 * @param newval Address of the dialog
943 * @param p_data Unused
945 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
951 /* psz_var == "dialog-event" */
956 extension_dialog_command_t *command = newval.p_address;
957 assert( command != NULL );
958 assert( command->p_dlg != NULL);
960 extension_t *p_ext = command->p_dlg->p_sys;
961 assert( p_ext != NULL );
963 extension_widget_t *p_widget = command->p_data;
965 switch( command->event )
967 case EXTENSION_EVENT_CLICK:
968 assert( p_widget != NULL );
969 PushCommandUnique( p_ext, CMD_CLICK, p_widget );
971 case EXTENSION_EVENT_CLOSE:
972 PushCommandUnique( p_ext, CMD_CLOSE );
975 msg_Dbg( p_this, "Received unknown UI event %d, discarded",
983 /** Callback on vlc_InputItemMetaChanged event
985 static void inputItemMetaChanged( const vlc_event_t *p_event,
988 assert( p_event && p_event->type == vlc_InputItemMetaChanged );
990 extension_t *p_ext = ( extension_t* ) data;
991 assert( p_ext != NULL );
993 PushCommandUnique( p_ext, CMD_UPDATE_META );
996 /* Lock this extension. Can fail. */
997 bool LockExtension( extension_t *p_ext )
999 if( p_ext->p_sys->b_exiting )
1002 vlc_mutex_lock( &p_ext->p_sys->running_lock );
1003 if( p_ext->p_sys->b_exiting )
1005 vlc_mutex_unlock( &p_ext->p_sys->running_lock );
1012 void UnlockExtension( extension_t *p_ext )
1014 vlc_mutex_unlock( &p_ext->p_sys->running_lock );