diff --git a/include/keystrokes.h b/include/keystrokes.h
index c1c97ad186..0c41fb845b 100644
--- a/include/keystrokes.h
+++ b/include/keystrokes.h
@@ -1,18 +1,17 @@
 #ifndef VLC_KEYS
 #define VLC_KEYS
 
-#define VLC_QUIT	0x01
-#define VLC_CHANNEL	0x02
-#define VLC_LOUDER	0x03
-#define VLC_QUIETER	0x04
-#define	VLC_MUTE	0x05
-#define VLC_LESS_GAMMA  0x06
-#define VLC_MORE_GAMMA	0x07
-#define VLC_GRAYSCALE	0x08
-#define VLC_INTERFACE	0x09
-#define VLC_INFO	0x0A
-#define VLC_SCALING	0x0B
-#define VLC_UNKNOWN	0x0C
-//#define VLC_CHANNEL 0x0D
+#define INTF_KEY_QUIT	0x01
+#define INTF_KEY_SET_CHANNEL	0x02
+#define INTF_KEY_DEC_VOLUME 0x03
+#define INTF_KEY_INC_VOLUME	0x04
+#define	INTF_KEY_TOGGLE_VOLUME	0x05
+#define INTF_KEY_DEC_GAMMA  0x06
+#define INTF_KEY_INC_GAMMA	0x07
+#define INTF_KEY_TOGGLE_GRAYSCALE	0x08
+#define INTF_KEY_TOGGLE_INTERFACE	0x09
+#define INTF_KEY_TOGGLE_INFO	0x0A
+#define INTF_KEY_TOGGLE_SCALING	0x0B
+#define INTF_KEY_UNKNOWN	0x0C
 
 #endif
diff --git a/plugins/sdl/intf_sdl.c b/plugins/sdl/intf_sdl.c
index cd1e660441..fb077c9a39 100644
--- a/plugins/sdl/intf_sdl.c
+++ b/plugins/sdl/intf_sdl.c
@@ -148,7 +148,7 @@ void intf_SDLManage( intf_thread_t *p_intf )
                 }
                 break;
             case SDL_QUIT:
-                intf_ProcessKey( p_intf, VLC_QUIT ); 
+                intf_ProcessKey( p_intf, INTF_KEY_QUIT ); 
                 break;
             default:
                 break;
@@ -161,29 +161,29 @@ void intf_SDLManage( intf_thread_t *p_intf )
 void intf_SDL_Keymap(intf_thread_t * p_intf )
 {
     p_intf->p_intf_getKey = intf_getKey; 
-    intf_AssignSKey(p_intf, SDLK_q,      VLC_QUIT);
-    intf_AssignSKey(p_intf, SDLK_ESCAPE, VLC_QUIT);
+    intf_AssignKey(p_intf, SDLK_q,      INTF_KEY_QUIT, NULL);
+    intf_AssignKey(p_intf, SDLK_ESCAPE, INTF_KEY_QUIT, NULL);
     /* intf_AssignKey(p_intf,3,'Q'); */
-    intf_AssignKey(p_intf, SDLK_0,      VLC_CHANNEL,0);
-    intf_AssignKey(p_intf, SDLK_1,      VLC_CHANNEL,1);
-    intf_AssignKey(p_intf, SDLK_2,      VLC_CHANNEL,2);
-    intf_AssignKey(p_intf, SDLK_3,      VLC_CHANNEL,3);
-    intf_AssignKey(p_intf, SDLK_4,      VLC_CHANNEL,4);
-    intf_AssignKey(p_intf, SDLK_5,      VLC_CHANNEL,5);
-    intf_AssignKey(p_intf, SDLK_6,      VLC_CHANNEL,6);
-    intf_AssignKey(p_intf, SDLK_7,      VLC_CHANNEL,7);
-    intf_AssignKey(p_intf, SDLK_8,      VLC_CHANNEL,8);
-    intf_AssignKey(p_intf, SDLK_9,      VLC_CHANNEL,9);
-    intf_AssignSKey(p_intf, SDLK_PLUS,   VLC_LOUDER);
-    intf_AssignSKey(p_intf, SDLK_MINUS,  VLC_QUIETER);
-    intf_AssignSKey(p_intf, SDLK_m,      VLC_MUTE);
+    intf_AssignKey(p_intf, SDLK_0,      INTF_KEY_SET_CHANNEL,0);
+    intf_AssignKey(p_intf, SDLK_1,      INTF_KEY_SET_CHANNEL,1);
+    intf_AssignKey(p_intf, SDLK_2,      INTF_KEY_SET_CHANNEL,2);
+    intf_AssignKey(p_intf, SDLK_3,      INTF_KEY_SET_CHANNEL,3);
+    intf_AssignKey(p_intf, SDLK_4,      INTF_KEY_SET_CHANNEL,4);
+    intf_AssignKey(p_intf, SDLK_5,      INTF_KEY_SET_CHANNEL,5);
+    intf_AssignKey(p_intf, SDLK_6,      INTF_KEY_SET_CHANNEL,6);
+    intf_AssignKey(p_intf, SDLK_7,      INTF_KEY_SET_CHANNEL,7);
+    intf_AssignKey(p_intf, SDLK_8,      INTF_KEY_SET_CHANNEL,8);
+    intf_AssignKey(p_intf, SDLK_9,      INTF_KEY_SET_CHANNEL,9);
+    intf_AssignKey(p_intf, SDLK_PLUS,   INTF_KEY_INC_VOLUME, NULL);
+    intf_AssignKey(p_intf, SDLK_MINUS,  INTF_KEY_DEC_VOLUME, NULL);
+    intf_AssignKey(p_intf, SDLK_m,      INTF_KEY_TOGGLE_VOLUME, NULL);
     /* intf_AssignKey(p_intf,'M','M'); */
-    intf_AssignSKey(p_intf, SDLK_g,      VLC_LESS_GAMMA);
+    intf_AssignSKey(p_intf, SDLK_g,      INTF_KEY_DEC_GAMMA, NULL);
     /* intf_AssignKey(p_intf,'G','G'); */
-    intf_AssignSKey(p_intf, SDLK_c,      VLC_GRAYSCALE);
-    intf_AssignSKey(p_intf, SDLK_SPACE,  VLC_INTERFACE);
-    intf_AssignSKey(p_intf, 'i',         VLC_INFO);
-    intf_AssignSKey(p_intf, SDLK_s,      VLC_SCALING);
+    intf_AssignSKey(p_intf, SDLK_c,      INTF_KEY_TOGGLE_GRAYSCALE, NULL);
+    intf_AssignSKey(p_intf, SDLK_SPACE,  INTF_KEY_TOGGLE_INTERFACE, NULL);
+    intf_AssignSKey(p_intf, 'i',         INTF_KEY_TOGGLE_INFO, NULL);
+    intf_AssignSKey(p_intf, SDLK_s,      INTF_KEY_TOGGLE_SCALING, NULL);
 
 }
 
diff --git a/src/interface/interface.c b/src/interface/interface.c
index 218cfe3a8a..0bddda700e 100644
--- a/src/interface/interface.c
+++ b/src/interface/interface.c
@@ -124,273 +124,262 @@ intf_thread_t* intf_Create( void )
         }
     }
 
-	    if( i_best_score == 0 )
-	    {
-		free( p_intf );
-		return( NULL );
-	    }
-
-	    /* Get the plugin functions */
-	    ( (intf_getplugin_t *)
-	      p_main->p_bank->p_info[ i_best_index ]->intf_GetPlugin )( p_intf );
-
-	    /* Initialize structure */
-	    p_intf->b_die =     0;
-	    p_intf->p_vout =    NULL;
-	    p_intf->p_input =   NULL;
-	    p_intf->p_keys =    NULL;
-
-	    /* Load channels - the pointer will be set to NULL on failure. The
-	     * return value is ignored since the program can work without
-	     * channels */
-	    LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR, INTF_CHANNELS_DEFAULT ));
-
-	    /* Start interfaces */
-	    p_intf->p_console = intf_ConsoleCreate();
-	    if( p_intf->p_console == NULL )
-	    {
-		intf_ErrMsg("error: can't create control console\n");
-		free( p_intf );
-		return( NULL );
-	    }
-	    if( p_intf->p_sys_create( p_intf ) )
-	    {
-		intf_ErrMsg("error: can't create interface\n");
-		intf_ConsoleDestroy( p_intf->p_console );
-		free( p_intf );
-		return( NULL );
-	    }
-
-	    intf_Msg("Interface initialized\n");
-	    return( p_intf );
-	}
-
-	/*****************************************************************************
-	 * intf_Run
-	 *****************************************************************************
-	 * Initialization script and main interface loop.
-	 *****************************************************************************/
-	void intf_Run( intf_thread_t *p_intf )
-	{
-	    if( p_main->p_playlist->p_list )
-	    {
-		p_intf->p_input = input_CreateThread( INPUT_METHOD_TS_FILE, NULL, 0, 0, p_main->p_intf->p_vout, p_main->p_aout, NULL );
-	    }
-	    /* Execute the initialization script - if a positive number is returned,
-	     * the script could be executed but failed */
-	    else if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 )
-	    {
-		intf_ErrMsg("warning: error(s) during startup script\n");
-	    }
-
-	    /* Main loop */
-	    while(!p_intf->b_die)
-	    {
-		/* Flush waiting messages */
-		intf_FlushMsg();
-
-		/* Manage specific interface */
-		p_intf->p_sys_manage( p_intf );
-
-		/* Check attached threads status */
-		if( (p_intf->p_vout != NULL) && p_intf->p_vout->b_error )
-		{
-		    /* FIXME: add aout error detection ?? */
-		    p_intf->b_die = 1;
-		}
-		if( (p_intf->p_input != NULL) && p_intf->p_input->b_error )
-		{
-		    input_DestroyThread( p_intf->p_input, NULL );
-		    p_intf->p_input = NULL;
-		    intf_DbgMsg("Input thread destroyed\n");
-		}
-
-		/* Sleep to avoid using all CPU - since some interfaces needs to access
-		 * keyboard events, a 100ms delay is a good compromise */
-		msleep( INTF_IDLE_SLEEP );
-	    }
-	}
-
-	/*****************************************************************************
-	 * intf_Destroy: clean interface after main loop
-	 *****************************************************************************
-	 * This function destroys specific interfaces and close output devices.
-	 *****************************************************************************/
-	void intf_Destroy( intf_thread_t *p_intf )
-	{
-	    p_intf_key  p_cur;
-	    p_intf_key  p_next;
-	    /* Destroy interfaces */
-	    p_intf->p_sys_destroy( p_intf );
-	    intf_ConsoleDestroy( p_intf->p_console );
-
-	    /* Unload channels */
-	    UnloadChannels( p_intf );
-
-	    /* Destroy keymap */
-	    
-	    p_cur = p_intf->p_keys;
-	    while( p_cur != NULL)
-	    {
-		p_next = p_cur->next;
-		free(p_cur);
-		p_cur = p_next;
-	     }
-	     
-	    
-	    /* Free structure */
-	    free( p_intf );
-	}
-
-	/*****************************************************************************
-	 * intf_SelectChannel: change channel
-	 *****************************************************************************
-	 * Kill existing input, if any, and try to open a new one, using an input
-	 * configuration table.
-	 *****************************************************************************/
-	int intf_SelectChannel( intf_thread_t * p_intf, int i_channel )
-	{
-	    intf_channel_t *    p_channel;                                /* channel */
-
-	    /* Look for channel in array */
-	    if( p_intf->p_channel != NULL )
-	    {
-		for( p_channel = p_intf->p_channel; p_channel->i_channel != -1; p_channel++ )
-		{
-		    if( p_channel->i_channel == i_channel )
-		    {
-			/*
-			 * Change channel
-			 */
-
-			/* Kill existing input, if any */
-			if( p_intf->p_input != NULL )
-			{
-			    input_DestroyThread( p_intf->p_input, NULL );
-			}
-
-			intf_Msg("Channel %d: %s\n", i_channel, p_channel->psz_description );
-
-			/* Open a new input */
-			p_intf->p_input = input_CreateThread( p_channel->i_input_method, p_channel->psz_input_source,
-							      p_channel->i_input_port, p_channel->i_input_vlan,
-							      p_intf->p_vout, p_main->p_aout, NULL );
-			return( p_intf->p_input == NULL );
-		    }
-		}
-	    }
-
-	    /* Channel does not exist */
-	    intf_Msg("Channel %d does not exist\n", i_channel );
-	    return( 1 );
-	}
-
-	/*****************************************************************************
-	 * intf_AssignKey: assign standartkeys                                       *
-	 *****************************************************************************
-	 * This function fills in the associative array that links the key pressed   *
-	 * and the key we use internally. Support one extra parameter.               *
-	 ****************************************************************************/
-
-	void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
-	{
-	    p_intf_key  p_cur =  p_intf->p_keys;
-	  
-	    if( p_cur == NULL )
-	    {
-		p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
-		p_cur->received_key = r_key;
-		p_cur->forwarded.key = f_key;
-		p_cur->forwarded.param = param; 
-		p_cur->next = NULL;
-		p_intf->p_keys = p_cur;
-	    } else {
-		while( p_cur->next != NULL && p_cur ->received_key != r_key)
-		{
-		    p_cur = p_cur->next;
-		}
-		if( p_cur->next == NULL )
-		{   
-		    p_cur->next  = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
-		    p_cur = p_cur->next;
-		    p_cur->next = NULL;
-		    p_cur->forwarded.param = param; 
-		    p_cur->received_key = r_key;
-		}
-		p_cur->forwarded.key = f_key;
-	    }        
-	}
-
-	/*****************************************************************************
-	 * intf_AssignSKey: assign standartkeys                                      *
-	 *****************************************************************************
-	 * This function fills in the associative array that links the key pressed   *
-	 * and the key we use internally.                                            *
-	 ****************************************************************************/
-	void intf_AssignSKey(intf_thread_t *p_intf, int r_key, int f_key)
-	{
-	    intf_AssignKey( p_intf, r_key, f_key, 0);
-	}
-
-
-	/* Basic getKey function... */
-	keyparm intf_getKey( intf_thread_t *p_intf, int r_key)
-	{   
-	    keyparm reply;
-	    
-	    p_intf_key current = p_intf->p_keys;
-	    while(current != NULL && current->received_key != r_key)
-	    {    
-		current = current->next;
-	    }
-	    if(current == NULL)
-	    {   /* didn't find any key in the array */ 
-		reply.key=VLC_UNKNOWN;
-		reply.param=0;
-	    }
-	    else
-	    {
-		reply.key = current->forwarded.key;
-		reply.param = current->forwarded.param;
-	    }
-	    return reply;
-	}
-
-	/*****************************************************************************
-	 * intf_AssignNormalKeys: used for normal interfaces.
-	 *****************************************************************************
-	 * This function assign the basic key to the normal keys.
-	 *****************************************************************************/
+        if( i_best_score == 0 )
+        {
+        free( p_intf );
+        return( NULL );
+        }
+
+        /* Get the plugin functions */
+        ( (intf_getplugin_t *)
+          p_main->p_bank->p_info[ i_best_index ]->intf_GetPlugin )( p_intf );
+
+        /* Initialize structure */
+        p_intf->b_die =     0;
+        p_intf->p_vout =    NULL;
+        p_intf->p_input =   NULL;
+        p_intf->p_keys =    NULL;
+
+        /* Load channels - the pointer will be set to NULL on failure. The
+         * return value is ignored since the program can work without
+         * channels */
+        LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR, INTF_CHANNELS_DEFAULT ));
+
+        /* Start interfaces */
+        p_intf->p_console = intf_ConsoleCreate();
+        if( p_intf->p_console == NULL )
+        {
+        intf_ErrMsg("error: can't create control console\n");
+        free( p_intf );
+        return( NULL );
+        }
+        if( p_intf->p_sys_create( p_intf ) )
+        {
+        intf_ErrMsg("error: can't create interface\n");
+        intf_ConsoleDestroy( p_intf->p_console );
+        free( p_intf );
+        return( NULL );
+        }
+
+        intf_Msg("Interface initialized\n");
+        return( p_intf );
+    }
+
+    /*****************************************************************************
+     * intf_Run
+     *****************************************************************************
+     * Initialization script and main interface loop.
+     *****************************************************************************/
+    void intf_Run( intf_thread_t *p_intf )
+    {
+        if( p_main->p_playlist->p_list )
+        {
+        p_intf->p_input = input_CreateThread( INPUT_METHOD_TS_FILE, NULL, 0, 0, p_main->p_intf->p_vout, p_main->p_aout, NULL );
+        }
+        /* Execute the initialization script - if a positive number is returned,
+         * the script could be executed but failed */
+        else if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 )
+        {
+        intf_ErrMsg("warning: error(s) during startup script\n");
+        }
+
+        /* Main loop */
+        while(!p_intf->b_die)
+        {
+        /* Flush waiting messages */
+        intf_FlushMsg();
+
+        /* Manage specific interface */
+        p_intf->p_sys_manage( p_intf );
+
+        /* Check attached threads status */
+        if( (p_intf->p_vout != NULL) && p_intf->p_vout->b_error )
+        {
+            /* FIXME: add aout error detection ?? */
+            p_intf->b_die = 1;
+        }
+        if( (p_intf->p_input != NULL) && p_intf->p_input->b_error )
+        {
+            input_DestroyThread( p_intf->p_input, NULL );
+            p_intf->p_input = NULL;
+            intf_DbgMsg("Input thread destroyed\n");
+        }
+
+        /* Sleep to avoid using all CPU - since some interfaces needs to access
+         * keyboard events, a 100ms delay is a good compromise */
+        msleep( INTF_IDLE_SLEEP );
+        }
+    }
+
+    /*****************************************************************************
+     * intf_Destroy: clean interface after main loop
+     *****************************************************************************
+     * This function destroys specific interfaces and close output devices.
+     *****************************************************************************/
+    void intf_Destroy( intf_thread_t *p_intf )
+    {
+        p_intf_key  p_cur;
+        p_intf_key  p_next;
+        /* Destroy interfaces */
+        p_intf->p_sys_destroy( p_intf );
+        intf_ConsoleDestroy( p_intf->p_console );
+
+        /* Unload channels */
+        UnloadChannels( p_intf );
+
+        /* Destroy keymap */
+        
+        p_cur = p_intf->p_keys;
+        while( p_cur != NULL)
+        {
+        p_next = p_cur->next;
+        free(p_cur);
+        p_cur = p_next;
+         }
+         
+        
+        /* Free structure */
+        free( p_intf );
+    }
+
+    /*****************************************************************************
+     * intf_SelectChannel: change channel
+     *****************************************************************************
+     * Kill existing input, if any, and try to open a new one, using an input
+     * configuration table.
+     *****************************************************************************/
+    int intf_SelectChannel( intf_thread_t * p_intf, int i_channel )
+    {
+        intf_channel_t *    p_channel;                                /* channel */
+
+        /* Look for channel in array */
+        if( p_intf->p_channel != NULL )
+        {
+        for( p_channel = p_intf->p_channel; p_channel->i_channel != -1; p_channel++ )
+        {
+            if( p_channel->i_channel == i_channel )
+            {
+            /*
+             * Change channel
+             */
+
+            /* Kill existing input, if any */
+            if( p_intf->p_input != NULL )
+            {
+                input_DestroyThread( p_intf->p_input, NULL );
+            }
+
+            intf_Msg("Channel %d: %s\n", i_channel, p_channel->psz_description );
+
+            /* Open a new input */
+            p_intf->p_input = input_CreateThread( p_channel->i_input_method, p_channel->psz_input_source,
+                                  p_channel->i_input_port, p_channel->i_input_vlan,
+                                  p_intf->p_vout, p_main->p_aout, NULL );
+            return( p_intf->p_input == NULL );
+            }
+        }
+        }
+
+        /* Channel does not exist */
+        intf_Msg("Channel %d does not exist\n", i_channel );
+        return( 1 );
+    }
+
+    /*****************************************************************************
+     * intf_AssignKey: assign standartkeys                                       *
+     *****************************************************************************
+     * This function fills in the associative array that links the key pressed   *
+     * and the key we use internally. Support one extra parameter.               *
+     ****************************************************************************/
+
+void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
+{
+    p_intf_key  p_cur =  p_intf->p_keys;
+    if( p_cur == NULL )
+    {
+        p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
+        p_cur->received_key = r_key;
+        p_cur->forwarded.key = f_key;
+        p_cur->forwarded.param = param; 
+        p_cur->next = NULL;
+        p_intf->p_keys = p_cur;
+    } 
+    else 
+    {
+        while( p_cur->next != NULL && p_cur ->received_key != r_key)
+        {
+            p_cur = p_cur->next;
+        }
+        if( p_cur->next == NULL )
+        {   
+            p_cur->next  = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
+            p_cur = p_cur->next;
+            p_cur->next = NULL;
+            p_cur->forwarded.param = param; 
+            p_cur->received_key = r_key;
+        }
+        p_cur->forwarded.key = f_key;
+    }        
+}
+
+/* Basic getKey function... */
+keyparm intf_getKey( intf_thread_t *p_intf, int r_key)
+{   
+    keyparm reply;
+    
+    p_intf_key current = p_intf->p_keys;
+    while(current != NULL && current->received_key != r_key)
+    {    
+        current = current->next;
+    }
+    if(current == NULL)
+    {   /* didn't find any key in the array */ 
+        reply.key=INTF_KEY_UNKNOWN;
+        reply.param=0;
+    }
+    else
+    {
+        reply.key = current->forwarded.key;
+        reply.param = current->forwarded.param;
+    }
+    return reply;
+}
+
+/*****************************************************************************
+* intf_AssignNormalKeys: used for normal interfaces.
+*****************************************************************************
+* This function assign the basic key to the normal keys.
+*****************************************************************************/
 
 void intf_AssignNormalKeys( intf_thread_t *p_intf)
-	{
-	    p_intf->p_intf_getKey = intf_getKey;
-
-	    intf_AssignSKey( p_intf , 'Q', VLC_QUIT);
-	    intf_AssignSKey( p_intf , 'q', VLC_QUIT);
-	    intf_AssignSKey( p_intf ,  27, VLC_QUIT);
-	    intf_AssignSKey( p_intf ,   3, VLC_QUIT);
-	    intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0);
-	    intf_AssignKey( p_intf , '1', VLC_CHANNEL, 1);
-	    intf_AssignKey( p_intf , '2', VLC_CHANNEL, 2);
-	    intf_AssignKey( p_intf , '3', VLC_CHANNEL, 3);
-	    intf_AssignKey( p_intf , '4', VLC_CHANNEL, 4);
-	    intf_AssignKey( p_intf , '5', VLC_CHANNEL, 5);
-	    intf_AssignKey( p_intf , '6', VLC_CHANNEL, 6);
-	    intf_AssignKey( p_intf , '7', VLC_CHANNEL, 7);
-	    intf_AssignKey( p_intf , '8', VLC_CHANNEL, 8);
-	    intf_AssignKey( p_intf , '9', VLC_CHANNEL, 9);
-	    intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0);
-	    intf_AssignSKey( p_intf , '+', VLC_LOUDER);
-	    intf_AssignSKey( p_intf , '-', VLC_QUIETER);
-	    intf_AssignSKey( p_intf , 'm', VLC_MUTE);
-	    intf_AssignSKey( p_intf , 'M', VLC_MUTE);
-	    intf_AssignSKey( p_intf , 'g', VLC_LESS_GAMMA);
-	    intf_AssignSKey( p_intf , 'G', VLC_MORE_GAMMA);
-	    intf_AssignSKey( p_intf , 'c', VLC_GRAYSCALE);
-	    intf_AssignSKey( p_intf , ' ', VLC_INTERFACE);
-	    intf_AssignSKey( p_intf , 'i', VLC_INFO);
-	    intf_AssignSKey( p_intf , 's', VLC_SCALING);
+{
+    p_intf->p_intf_getKey = intf_getKey;
+
+    intf_AssignKey( p_intf , 'Q', INTF_KEY_QUIT, 0);
+    intf_AssignKey( p_intf , 'q', INTF_KEY_QUIT, 0);
+    intf_AssignKey( p_intf ,  27, INTF_KEY_QUIT, 0);
+    intf_AssignKey( p_intf ,   3, INTF_KEY_QUIT, 0);
+    intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
+    intf_AssignKey( p_intf , '1', INTF_KEY_SET_CHANNEL, 1);
+    intf_AssignKey( p_intf , '2', INTF_KEY_SET_CHANNEL, 2);
+    intf_AssignKey( p_intf , '3', INTF_KEY_SET_CHANNEL, 3);
+    intf_AssignKey( p_intf , '4', INTF_KEY_SET_CHANNEL, 4);
+    intf_AssignKey( p_intf , '5', INTF_KEY_SET_CHANNEL, 5);
+    intf_AssignKey( p_intf , '6', INTF_KEY_SET_CHANNEL, 6);
+    intf_AssignKey( p_intf , '7', INTF_KEY_SET_CHANNEL, 7);
+    intf_AssignKey( p_intf , '8', INTF_KEY_SET_CHANNEL, 8);
+    intf_AssignKey( p_intf , '9', INTF_KEY_SET_CHANNEL, 9);
+    intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
+    intf_AssignKey( p_intf , '+', INTF_KEY_INC_VOLUME, 0);
+    intf_AssignKey( p_intf , '-', INTF_KEY_DEC_VOLUME, 0);
+    intf_AssignKey( p_intf , 'm', INTF_KEY_TOGGLE_VOLUME, 0);
+    intf_AssignKey( p_intf , 'M', INTF_KEY_TOGGLE_VOLUME, 0);
+    intf_AssignKey( p_intf , 'g', INTF_KEY_DEC_GAMMA, 0);
+    intf_AssignKey( p_intf , 'G', INTF_KEY_INC_GAMMA, 0);
+    intf_AssignKey( p_intf , 'c', INTF_KEY_TOGGLE_GRAYSCALE, 0);
+    intf_AssignKey( p_intf , ' ', INTF_KEY_TOGGLE_INTERFACE, 0);
+    intf_AssignKey( p_intf , 'i', INTF_KEY_TOGGLE_INFO, 0);
+    intf_AssignKey( p_intf , 's', INTF_KEY_TOGGLE_SCALING, 0);
 }   
 
 /*****************************************************************************
@@ -402,29 +391,29 @@ void intf_AssignNormalKeys( intf_thread_t *p_intf)
 int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
 {
     static int i_volbackup;
-    keyparm i_reply;
+    keyparm k_reply;
     
-    i_reply = intf_getKey( p_intf, g_key); 
+    k_reply = intf_getKey( p_intf, g_key); 
     
-    switch( i_reply.key )
+    switch( k_reply.key )
     {
-    case VLC_QUIT:                                                  /* quit order */
+    case INTF_KEY_QUIT:                                                  /* quit order */
         p_intf->b_die = 1;
         break;
-    case VLC_CHANNEL:
+    case INTF_KEY_SET_CHANNEL:
         /* Change channel - return code is ignored since SelectChannel displays
          * its own error messages */
-        intf_SelectChannel( p_intf, i_reply.param - '0' );
+        intf_SelectChannel( p_intf, k_reply.param - '0' );
         break;
-    case VLC_LOUDER:                                                    /* volume + */
+    case INTF_KEY_INC_VOLUME:                                                    /* volume + */
         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol < VOLMAX) )
             p_main->p_aout->vol += VOLSTEP;
         break;
-    case VLC_QUIETER:                                                    /* volume - */
+    case INTF_KEY_DEC_VOLUME:                                                    /* volume - */
         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol > VOLSTEP) )
             p_main->p_aout->vol -= VOLSTEP;
         break;
-    case VLC_MUTE:                                                 /* toggle mute */
+    case INTF_KEY_TOGGLE_VOLUME:                                                 /* toggle mute */
         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol))
         {
             i_volbackup = p_main->p_aout->vol;
@@ -433,7 +422,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
         else if( (p_main->p_aout != NULL) && (!p_main->p_aout->vol))
             p_main->p_aout->vol = i_volbackup;
         break;
-    case VLC_LESS_GAMMA:                                                     /* gamma - */
+    case INTF_KEY_DEC_GAMMA:                                                     /* gamma - */
         if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );
@@ -442,7 +431,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
         }
         break;
-    case VLC_MORE_GAMMA:                                                     /* gamma + */
+    case INTF_KEY_INC_GAMMA:                                                     /* gamma + */
         if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );
@@ -451,7 +440,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
         }
         break;
-    case VLC_GRAYSCALE:                                            /* toggle grayscale */
+    case INTF_KEY_TOGGLE_GRAYSCALE:                                            /* toggle grayscale */
         if( p_intf->p_vout != NULL )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );
@@ -460,7 +449,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
         }
         break;
-    case VLC_INTERFACE:                                            /* toggle interface */
+    case INTF_KEY_TOGGLE_INTERFACE:                                            /* toggle interface */
         if( p_intf->p_vout != NULL )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );
@@ -469,7 +458,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
         }
         break;
-    case VLC_INFO:                                                 /* toggle info */
+    case INTF_KEY_TOGGLE_INFO:                                                 /* toggle info */
         if( p_intf->p_vout != NULL )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );
@@ -478,7 +467,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
         }
         break;
-    case VLC_SCALING:                                              /* toggle scaling */
+    case INTF_KEY_TOGGLE_SCALING:                                              /* toggle scaling */
         if( p_intf->p_vout != NULL )
         {
             vlc_mutex_lock( &p_intf->p_vout->change_lock );