- modules/control/showintf.c: new control module, able to show the

   interface when moving the mouse to the top of the screen (in
   fullscreen mode).
 - modules/control/hotkeys.c: added a hotkey to raise the interface
 - modules/gui/wxwindows/*, modules/gui/skins2/*: added callbacks for
   the "intf-show" variable; it should be easy to do the same for BeOS
   and MacOSX interfaces

configure.ac

@@ -943,7 +943,7 @@ test "${enable_cprof}" != "yes" && enable_cprof="no"
 dnl
 dnl  default modules
 dnl
-VLC_ADD_PLUGINS([dummy rc telnet logger gestures memcpy hotkeys netsync])
+VLC_ADD_PLUGINS([dummy rc telnet logger gestures memcpy hotkeys netsync showintf])
 VLC_ADD_PLUGINS([mpgv mpga m4v m4a h264 ps pva avi asf aac mp4 rawdv nsv real aiff mjpeg demuxdump])
 VLC_ADD_PLUGINS([cvdsub svcdsub spudec subsdec dvbsub mpeg_audio lpcm a52 dts cinepak])
 VLC_ADD_PLUGINS([deinterlace invert adjust wall transform distort clone crop motionblur])

include/vlc_keys.h

@@ -230,7 +230,7 @@ static inline int StringToKey( char *psz_key )
 #define ACTIONID_SUBDELAY_DOWN         47
 #define ACTIONID_HISTORY_BACK          48
 #define ACTIONID_HISTORY_FORWARD       49
-
 #define ACTIONID_AUDIO_TRACK           50
 #define ACTIONID_SUBTITLE_TRACK        51
+#define ACTIONID_INTF_SHOW             52
 

modules/control/Modules.am

 SOURCES_gestures = gestures.c
+SOURCES_showintf = showintf.c
 SOURCES_http = http.c
 SOURCES_telnet = telnet.c
 SOURCES_netsync = netsync.c

modules/control/hotkeys.c

@@ -288,7 +288,17 @@ static void Run( intf_thread_t *p_intf )
                 }
             }
         }
-
+        else if( i_action == ACTIONID_INTF_SHOW )
+        {
+            val.b_bool = VLC_TRUE;
+            p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                          FIND_ANYWHERE );
+            if( p_playlist )
+            {
+                var_Set( p_playlist, "intf-show", val );
+                vlc_object_release( p_playlist );
+            }
+        }
         else if( i_action == ACTIONID_SUBDELAY_DOWN )
         {
             int64_t i_delay = var_GetTime( p_input, "spu-delay" );

modules/control/showintf.c

+/*****************************************************************************
+ * showintf.c: control the display of the interface in fullscreen mode
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id:$
+ *
+ * Authors: Olivier Teuliere <ipkiss@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <stdlib.h>                                      /* malloc(), free() */
+#include <string.h>
+
+#include <vlc/vlc.h>
+#include <vlc/intf.h>
+#include <vlc/vout.h>
+
+#ifdef HAVE_UNISTD_H
+#    include <unistd.h>
+#endif
+
+/*****************************************************************************
+ * intf_sys_t: description and status of interface
+ *****************************************************************************/
+struct intf_sys_t
+{
+    vlc_object_t * p_vout;
+    vlc_bool_t     b_button_pressed;
+    vlc_bool_t     b_triggered;
+    int            i_threshold;
+};
+
+/*****************************************************************************
+ * Local prototypes.
+ *****************************************************************************/
+int  E_(Open) ( vlc_object_t * );
+void E_(Close)( vlc_object_t * );
+static void RunIntf( intf_thread_t *p_intf );
+static int  InitThread( intf_thread_t *p_intf );
+static int  MouseEvent( vlc_object_t *, char const *,
+                        vlc_value_t, vlc_value_t, void * );
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+#define THRESHOLD_TEXT N_( "Threshold" )
+#define THRESHOLD_LONGTEXT N_( "Height of the zone triggering the interface" )
+
+vlc_module_begin();
+    add_integer( "showintf-threshold", 10, NULL, THRESHOLD_TEXT, THRESHOLD_LONGTEXT, VLC_TRUE );
+    set_description( _("Interface showing control interface") );
+
+    set_capability( "interface", 0 );
+    set_callbacks( E_(Open), E_(Close) );
+vlc_module_end();
+
+/*****************************************************************************
+ * Open: initialize interface
+ *****************************************************************************/
+int E_(Open)( vlc_object_t *p_this )
+{
+    intf_thread_t *p_intf = (intf_thread_t *)p_this;
+
+    /* Allocate instance and initialize some members */
+    p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
+    if( p_intf->p_sys == NULL )
+    {
+        return( 1 );
+    };
+
+    p_intf->pf_run = RunIntf;
+
+    return( 0 );
+}
+
+/*****************************************************************************
+ * Close: destroy interface
+ *****************************************************************************/
+void E_(Close)( vlc_object_t *p_this )
+{
+    intf_thread_t *p_intf = (intf_thread_t *)p_this;
+
+    /* Destroy structure */
+    free( p_intf->p_sys );
+}
+
+
+/*****************************************************************************
+ * RunIntf: main loop
+ *****************************************************************************/
+static void RunIntf( intf_thread_t *p_intf )
+{
+    p_intf->p_sys->p_vout = NULL;
+
+    if( InitThread( p_intf ) < 0 )
+    {
+        msg_Err( p_intf, "cannot initialize intf" );
+        return;
+    }
+
+    /* Main loop */
+    while( !p_intf->b_die )
+    {
+        vlc_mutex_lock( &p_intf->change_lock );
+
+        /* Notify the interfaces */
+        if( p_intf->p_sys->b_triggered )
+        {
+            playlist_t *p_playlist =
+                (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
+                                               FIND_ANYWHERE );
+
+            if( p_playlist != NULL )
+            {
+                vlc_value_t val;
+                val.b_bool = VLC_TRUE;
+                var_Set( p_playlist, "intf-show", val );
+                vlc_object_release( p_playlist );
+            }
+            p_intf->p_sys->b_triggered = VLC_FALSE;
+        }
+
+        vlc_mutex_unlock( &p_intf->change_lock );
+
+
+        /* Take care of the video output */
+        if( p_intf->p_sys->p_vout && p_intf->p_sys->p_vout->b_die )
+        {
+            var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
+                             MouseEvent, p_intf );
+            var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
+                             MouseEvent, p_intf );
+            vlc_object_release( p_intf->p_sys->p_vout );
+            p_intf->p_sys->p_vout = NULL;
+        }
+
+        if( p_intf->p_sys->p_vout == NULL )
+        {
+            p_intf->p_sys->p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
+                                                     FIND_ANYWHERE );
+            if( p_intf->p_sys->p_vout )
+            {
+                var_AddCallback( p_intf->p_sys->p_vout, "mouse-moved",
+                                 MouseEvent, p_intf );
+                var_AddCallback( p_intf->p_sys->p_vout, "mouse-button-down",
+                                 MouseEvent, p_intf );
+            }
+        }
+
+        /* Wait a bit */
+        msleep( INTF_IDLE_SLEEP );
+    }
+
+    if( p_intf->p_sys->p_vout )
+    {
+        var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
+                         MouseEvent, p_intf );
+        var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
+                         MouseEvent, p_intf );
+        vlc_object_release( p_intf->p_sys->p_vout );
+    }
+}
+
+/*****************************************************************************
+ * InitThread:
+ *****************************************************************************/
+static int InitThread( intf_thread_t * p_intf )
+{
+    if( !p_intf->b_die )
+    {
+        vlc_mutex_lock( &p_intf->change_lock );
+
+        p_intf->p_sys->b_triggered = VLC_FALSE;
+        p_intf->p_sys->b_button_pressed = VLC_FALSE;
+        p_intf->p_sys->i_threshold =
+            config_GetInt( p_intf, "showintf-threshold" );
+
+        vlc_mutex_unlock( &p_intf->change_lock );
+
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+/*****************************************************************************
+ * MouseEvent: callback for mouse events
+ *****************************************************************************/
+static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
+                       vlc_value_t oldval, vlc_value_t newval, void *p_data )
+{
+    vlc_value_t val;
+
+    int i_mouse_x, i_mouse_y;
+    intf_thread_t *p_intf = (intf_thread_t *)p_data;
+
+    /* Do nothing when the interface is already requested */
+    if( p_intf->p_sys->b_triggered )
+        return VLC_SUCCESS;
+
+    /* Nothing to do when not in fullscreen mode */
+    var_Get( p_intf->p_sys->p_vout, "fullscreen", &val );
+    if( !val.i_int )
+        return VLC_SUCCESS;
+
+    vlc_mutex_lock( &p_intf->change_lock );
+    if( !strcmp( psz_var, "mouse-moved" ) && !p_intf->p_sys->b_button_pressed )
+    {
+        var_Get( p_intf->p_sys->p_vout, "mouse-x", &val );
+        i_mouse_x = val.i_int;
+        var_Get( p_intf->p_sys->p_vout, "mouse-y", &val );
+        i_mouse_y = val.i_int;
+
+        /* Very basic test, we even ignore the x value :) */
+        if ( i_mouse_y < p_intf->p_sys->i_threshold )
+        {
+            msg_Dbg( p_intf, "interface showing requested" );
+            p_intf->p_sys->b_triggered = VLC_TRUE;
+        }
+    }
+
+    /* We keep track of the button state to avoid interferences with the
+     * gestures plugin */
+    if( !p_intf->p_sys->b_button_pressed &&
+        !strcmp( psz_var, "mouse-button-down" ) )
+    {
+        p_intf->p_sys->b_button_pressed = VLC_TRUE;
+    }
+    if( p_intf->p_sys->b_button_pressed &&
+        !strcmp( psz_var, "mouse-button-down" ) )
+    {
+        p_intf->p_sys->b_button_pressed = VLC_FALSE;
+    }
+
+    vlc_mutex_unlock( &p_intf->change_lock );
+
+    return VLC_SUCCESS;
+}

modules/gui/skins2/commands/cmd_show_window.hpp

@@ -76,4 +76,23 @@ class CmdHideWindow: public CmdGeneric
 };
 
 
+/// Command to raise all windows
+class CmdRaiseAll: public CmdGeneric
+{
+    public:
+        CmdRaiseAll( intf_thread_t *pIntf, WindowManager &rWinManager ):
+            CmdGeneric( pIntf ), m_rWinManager( rWinManager ) {}
+        virtual ~CmdRaiseAll() {}
+
+        /// This method does the real job of the command
+        virtual void execute() { m_rWinManager.raiseAll(); }
+
+        /// Return the type of the command
+        virtual string getType() const { return "raise all windows"; }
+
+    private:
+        /// Reference to the window manager
+        WindowManager &m_rWinManager;
+};
+
 #endif

modules/gui/skins2/src/vlcproc.cpp

@@ -29,8 +29,11 @@
 #include "os_factory.hpp"
 #include "os_timer.hpp"
 #include "var_manager.hpp"
+#include "theme.hpp"
+#include "window_manager.hpp"
 #include "../commands/async_queue.hpp"
 #include "../commands/cmd_change_skin.hpp"
+#include "../commands/cmd_show_window.hpp"
 #include "../commands/cmd_quit.hpp"
 #include "../commands/cmd_vars.hpp"
 #include "../utils/var_bool.hpp"
@@ -95,6 +98,9 @@ VlcProc::VlcProc( intf_thread_t *pIntf ): SkinObject( pIntf ),
     // Called when the playlist changes
     var_AddCallback( pIntf->p_sys->p_playlist, "intf-change",
                      onIntfChange, this );
+    // Called when the "interface shower" wants us to show the skin
+    var_AddCallback( pIntf->p_sys->p_playlist, "intf-show",
+                     onIntfShow, this );
     // Called when the current played item changes
     var_AddCallback( pIntf->p_sys->p_playlist, "playlist-current",
                      onPlaylistChange, this );
@@ -129,10 +135,13 @@ VlcProc::~VlcProc()
 
     var_DelCallback( getIntf()->p_sys->p_playlist, "intf-change",
                      onIntfChange, this );
+    var_DelCallback( getIntf()->p_sys->p_playlist, "intf-show",
+                     onIntfShow, this );
     var_DelCallback( getIntf()->p_sys->p_playlist, "playlist-current",
                      onPlaylistChange, this );
     var_DelCallback( getIntf()->p_sys->p_playlist, "item-change",
                      onItemChange, this );
+    var_DelCallback( getIntf(), "skin-to-load", onSkinToLoad, this );
 }
 
 
@@ -242,7 +251,7 @@ int VlcProc::onIntfChange( vlc_object_t *pObj, const char *pVariable,
                            vlc_value_t oldVal, vlc_value_t newVal,
                            void *pParam )
 {
-    VlcProc *pThis = ( VlcProc* )pParam;
+    VlcProc *pThis = (VlcProc*)pParam;
 
     // Create a playlist notify command
     CmdNotifyPlaylist *pCmd = new CmdNotifyPlaylist( pThis->getIntf() );
@@ -256,11 +265,34 @@ int VlcProc::onIntfChange( vlc_object_t *pObj, const char *pVariable,
 }
 
 
+int VlcProc::onIntfShow( vlc_object_t *pObj, const char *pVariable,
+                         vlc_value_t oldVal, vlc_value_t newVal,
+                         void *pParam )
+{
+    if (newVal.i_int)
+    {
+        VlcProc *pThis = (VlcProc*)pParam;
+
+        // Create a raise all command
+        CmdRaiseAll *pCmd =
+            new CmdRaiseAll( pThis->getIntf(),
+                             pThis->getIntf()->p_sys->p_theme->getWindowManager() );
+
+        // Push the command in the asynchronous command queue
+        AsyncQueue *pQueue = AsyncQueue::instance( pThis->getIntf() );
+        pQueue->remove( "raise all windows" );
+        pQueue->push( CmdGenericPtr( pCmd ) );
+    }
+
+    return VLC_SUCCESS;
+}
+
+
 int VlcProc::onItemChange( vlc_object_t *pObj, const char *pVariable,
                            vlc_value_t oldVal, vlc_value_t newVal,
                            void *pParam )
 {
-    VlcProc *pThis = ( VlcProc* )pParam;
+    VlcProc *pThis = (VlcProc*)pParam;
 
     // Create a playlist notify command
     // TODO: selective update
@@ -279,7 +311,7 @@ int VlcProc::onPlaylistChange( vlc_object_t *pObj, const char *pVariable,
                                vlc_value_t oldVal, vlc_value_t newVal,
                                void *pParam )
 {
-    VlcProc *pThis = ( VlcProc* )pParam;
+    VlcProc *pThis = (VlcProc*)pParam;
 
     AsyncQueue *pQueue = AsyncQueue::instance( pThis->getIntf() );
 
@@ -316,7 +348,7 @@ int VlcProc::onSkinToLoad( vlc_object_t *pObj, const char *pVariable,
                            vlc_value_t oldVal, vlc_value_t newVal,
                            void *pParam )
 {
-    VlcProc *pThis = ( VlcProc* )pParam;
+    VlcProc *pThis = (VlcProc*)pParam;
 
     // Create a playlist notify command
     CmdChangeSkin *pCmd =

modules/gui/skins2/src/vlcproc.hpp

@@ -107,6 +107,11 @@ class VlcProc: public SkinObject
                                  vlc_value_t oldVal, vlc_value_t newVal,
                                  void *pParam );
 
+        /// Callback for intf-show variable
+        static int onIntfShow( vlc_object_t *pObj, const char *pVariable,
+                               vlc_value_t oldVal, vlc_value_t newVal,
+                               void *pParam );
+
         /// Callback for item-change variable
         static int onItemChange( vlc_object_t *pObj, const char *pVariable,
                                  vlc_value_t oldVal, vlc_value_t newVal,

modules/gui/skins2/src/window_manager.cpp

@@ -184,6 +184,17 @@ void WindowManager::synchVisibility() const
 }
 
 
+void WindowManager::raiseAll() const
+{
+    // Raise all the windows
+    WinSet_t::const_iterator it;
+    for( it = m_allWindows.begin(); it != m_allWindows.end(); it++ )
+    {
+        (*it)->raise();
+    }
+}
+
+
 void WindowManager::showAll() const
 {
     // Show all the windows

modules/gui/skins2/src/window_manager.hpp

@@ -67,6 +67,9 @@ class WindowManager: public SkinObject
         /// If a new anchoring is detected, the windows will move accordingly.
         void move( TopWindow &rWindow, int left, int top ) const;
 
+        /// Raise all the registered windows
+        void raiseAll() const;
+
         /// Show all the registered windows
         void showAll() const;
 

modules/gui/skins2/win32/win32_window.cpp

@@ -127,7 +127,8 @@ void Win32Window::moveResize( int left, int top, int width, int height ) const
 
 void Win32Window::raise() const
 {
-    SetWindowPos( m_hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
+//     SetWindowPos( m_hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
+    SetForegroundWindow( m_hWnd );
 }
 
 

modules/gui/wxwindows/timer.cpp

@@ -38,9 +38,11 @@
 
 //void DisplayStreamDate( wxControl *, intf_thread_t *, int );
 
-/* Callback prototype */
+/* Callback prototypes */
 static int PopupMenuCB( vlc_object_t *p_this, const char *psz_variable,
                         vlc_value_t old_val, vlc_value_t new_val, void *param );
+static int IntfShowCB( vlc_object_t *p_this, const char *psz_variable,
+                       vlc_value_t old_val, vlc_value_t new_val, void *param );
 
 /*****************************************************************************
  * Constructor.
@@ -60,6 +62,7 @@ Timer::Timer( intf_thread_t *_p_intf, Interface *_p_main_interface )
     if( p_playlist != NULL )
     {
         var_AddCallback( p_playlist, "intf-popupmenu", PopupMenuCB, p_intf );
+        var_AddCallback( p_playlist, "intf-show", IntfShowCB, p_intf );
         vlc_object_release( p_playlist );
     }
 
@@ -75,6 +78,7 @@ Timer::~Timer()
     if( p_playlist != NULL )
     {
         var_DelCallback( p_playlist, "intf-popupmenu", PopupMenuCB, p_intf );
+        var_DelCallback( p_playlist, "intf-show", IntfShowCB, p_intf );
         vlc_object_release( p_playlist );
     }
 }
@@ -294,6 +298,13 @@ void Timer::Notify()
         i_old_playing_status = PAUSE_S;
     }
 
+    /* Show the interface, if requested */
+    if( p_intf->p_sys->b_intf_show )
+    {
+        p_main_interface->Raise();
+        p_intf->p_sys->b_intf_show = VLC_FALSE;
+    }
+
     if( p_intf->b_die )
     {
         vlc_mutex_unlock( &p_intf->change_lock );
@@ -324,3 +335,15 @@ static int PopupMenuCB( vlc_object_t *p_this, const char *psz_variable,
 
     return VLC_SUCCESS;
 }
+
+/*****************************************************************************
+ * IntfShowCB: callback triggered by the intf-show playlist variable.
+ *****************************************************************************/
+static int IntfShowCB( vlc_object_t *p_this, const char *psz_variable,
+                       vlc_value_t old_val, vlc_value_t new_val, void *param )
+{
+    intf_thread_t *p_intf = (intf_thread_t *)param;
+    p_intf->p_sys->b_intf_show = VLC_TRUE;
+
+    return VLC_SUCCESS;
+}

modules/gui/wxwindows/wxwindows.h

@@ -108,6 +108,7 @@ struct intf_sys_t
 
     /* special actions */
     vlc_bool_t          b_playing;
+    vlc_bool_t          b_intf_show;                /* interface to be shown */
 
     /* The input thread */
     input_thread_t *    p_input;

src/libvlc.h

@@ -738,6 +738,8 @@ static char *ppsz_align_descriptions[] =
 #define AUDIO_TRACK_KEY_LONGTEXT N_("Cycle through the available audio tracks(languages)")
 #define SUBTITLE_TRACK_KEY_TEXT N_("Cycle subtitle track")
 #define SUBTITLE_TRACK_KEY_LONGTEXT N_("Cycle through the available subtitle tracks")
+#define INTF_SHOW_KEY_TEXT N_("Show interface")
+#define INTF_SHOW_KEY_LONGTEXT N_("Raise the interface above all other windows")
 
 #define PLAYLIST_USAGE N_( \
     "\nPlaylist MRL syntax:" \
@@ -1067,6 +1069,7 @@ vlc_module_begin();
 #   define KEY_SUBDELAY_DOWN      KEY_MODIFIER_COMMAND|'j'
 #   define KEY_AUDIO_TRACK        'l'
 #   define KEY_SUBTITLE_TRACK     's'
+#   define KEY_INTF_SHOW          'i'
 
 #   define KEY_SET_BOOKMARK1      KEY_MODIFIER_COMMAND|KEY_F1
 #   define KEY_SET_BOOKMARK2      KEY_MODIFIER_COMMAND|KEY_F2
@@ -1117,10 +1120,11 @@ vlc_module_begin();
 #   define KEY_VOL_UP             KEY_MODIFIER_CTRL|KEY_UP
 #   define KEY_VOL_DOWN           KEY_MODIFIER_CTRL|KEY_DOWN
 #   define KEY_VOL_MUTE           'm'
-#   define KEY_SUBDELAY_UP        KEY_MODIFIER_COMMAND|'h'
-#   define KEY_SUBDELAY_DOWN      KEY_MODIFIER_COMMAND|'j'
+#   define KEY_SUBDELAY_UP        KEY_MODIFIER_CTRL|'h'
+#   define KEY_SUBDELAY_DOWN      KEY_MODIFIER_CTRL|'j'
 #   define KEY_AUDIO_TRACK        'l'
 #   define KEY_SUBTITLE_TRACK     'k'
+#   define KEY_INTF_SHOW          'i'
 
 #   define KEY_SET_BOOKMARK1      KEY_MODIFIER_CTRL|KEY_F1
 #   define KEY_SET_BOOKMARK2      KEY_MODIFIER_CTRL|KEY_F2
@@ -1206,6 +1210,8 @@ vlc_module_begin();
              AUDIO_TRACK_KEY_LONGTEXT, VLC_FALSE );
     add_key( "key-subtitle-track", KEY_SUBTITLE_TRACK, NULL,
              SUBTITLE_TRACK_KEY_TEXT, SUBTITLE_TRACK_KEY_LONGTEXT, VLC_FALSE );
+    add_key( "key-intf-show", KEY_INTF_SHOW, NULL,
+             INTF_SHOW_KEY_TEXT, INTF_SHOW_KEY_LONGTEXT, VLC_TRUE );
 
     add_key( "key-set-bookmark1", KEY_SET_BOOKMARK1, NULL,
              SET_BOOKMARK1_KEY_TEXT, SET_BOOKMARK_KEY_LONGTEXT, VLC_TRUE );
@@ -1315,6 +1321,7 @@ static struct hotkey p_hotkeys[] =
     { "key-subdelay-up", ACTIONID_SUBDELAY_UP, 0 },
     { "key-audio-track", ACTIONID_AUDIO_TRACK, 0},
     { "key-subtitle-track", ACTIONID_SUBTITLE_TRACK, 0},
+    { "key-intf-show", ACTIONID_INTF_SHOW, 0},
     { "key-nav-activate", ACTIONID_NAV_ACTIVATE, 0 },
     { "key-nav-up", ACTIONID_NAV_UP, 0 },
     { "key-nav-down", ACTIONID_NAV_DOWN, 0 },