To apply this file, cd to the top of the Tuxbox CVS tree
(containing a subdirectory cdk), then use a command like

   patch -p1 < kabr-2006-03-26.diff

This file patches the following files:
	apps/tuxbox/neutrino/src/driver/rcinput.h apps/tuxbox/neutrino/src/driver/rcinput.cpp apps/tuxbox/neutrino/src/driver/framebuffer.h apps/tuxbox/neutrino/src/driver/framebuffer.cpp

diff -Naur old/apps/tuxbox/neutrino/src/driver/framebuffer.cpp new/apps/tuxbox/neutrino/src/driver/framebuffer.cpp
--- old/apps/tuxbox/neutrino/src/driver/framebuffer.cpp	2005-04-21 12:07:36.000000000 +0200
+++ new/apps/tuxbox/neutrino/src/driver/framebuffer.cpp	2006-03-25 13:21:19.000000000 +0100
@@ -225,6 +225,11 @@
 	return (active || (virtual_fb != NULL));
 }
 
+bool CFrameBuffer::get_active() const
+{
+	return active;
+}
+
 t_fb_var_screeninfo *CFrameBuffer::getScreenInfo()
 {
 	return &screeninfo;
diff -Naur old/apps/tuxbox/neutrino/src/driver/framebuffer.h new/apps/tuxbox/neutrino/src/driver/framebuffer.h
--- old/apps/tuxbox/neutrino/src/driver/framebuffer.h	2004-03-17 19:44:44.000000000 +0100
+++ new/apps/tuxbox/neutrino/src/driver/framebuffer.h	2006-03-25 13:22:47.000000000 +0100
@@ -104,6 +104,7 @@
 		fb_pixel_t * getFrameBufferPointer() const; // pointer to framebuffer
 		unsigned int getStride() const;             // size of a single line in the framebuffer (in bytes)
 		bool getActive() const;                     // is framebuffer active?
+		bool get_active() const; // Status of active
 
 		void setTransparency( int tr = 0 );
 		void setBlendLevel(int blev1, int blev2);
diff -Naur old/apps/tuxbox/neutrino/src/driver/rcinput.cpp new/apps/tuxbox/neutrino/src/driver/rcinput.cpp
--- old/apps/tuxbox/neutrino/src/driver/rcinput.cpp	2006-03-26 22:32:38.000000000 +0200
+++ new/apps/tuxbox/neutrino/src/driver/rcinput.cpp	2006-03-26 22:30:49.000000000 +0200
@@ -59,6 +59,7 @@
 
 #include <global.h>
 #include <neutrino.h>
+#include <fstream>
 
 #ifdef OLD_RC_API
 const char * const RC_EVENT_DEVICE[NUMBER_OF_EVENT_DEVICES] = {"/dev/dbox/rc0"};
@@ -76,6 +77,260 @@
 #endif /* KEYBOARD_INSTEAD_OF_REMOTE_CONTROL */
 
 
+#define SCRIPT00	0xFFF00000
+#define RELOAD_CONF	SCRIPT00 + 21
+
+struct key{
+  char *name;
+  unsigned code;
+};
+
+static const struct key keyname[] = {
+  {"KEY_0", 		KEY_0},
+  {"KEY_1", 		KEY_1},
+  {"KEY_2", 		KEY_2},
+  {"KEY_3", 		KEY_3},
+  {"KEY_4", 		KEY_4},
+  {"KEY_5", 		KEY_5},
+  {"KEY_6", 		KEY_6},
+  {"KEY_7", 		KEY_7},
+  {"KEY_8", 		KEY_8},
+  {"KEY_9", 		KEY_9},
+  {"KEY_RIGHT",		KEY_RIGHT},
+  {"KEY_LEFT",		KEY_LEFT},
+  {"KEY_UP",		KEY_UP},
+  {"KEY_DOWN",		KEY_DOWN},
+  {"KEY_OK",		KEY_OK},
+  {"KEY_MUTE",		KEY_MUTE},
+  {"KEY_POWER",		KEY_POWER},
+  {"KEY_GREEN",		KEY_GREEN},
+  {"KEY_YELLOW",	KEY_YELLOW},
+  {"KEY_RED",		KEY_RED},
+  {"KEY_BLUE",		KEY_BLUE},
+  {"KEY_VOLUMEUP",	KEY_VOLUMEUP},
+  {"KEY_VOLUMEDOWN",	KEY_VOLUMEDOWN},
+  {"KEY_HELP",		KEY_HELP},
+  {"KEY_SETUP",		KEY_SETUP},
+  {"KEY_TOPLEFT",	KEY_TOPLEFT},
+  {"KEY_TOPRIGHT", 	KEY_TOPRIGHT},
+  {"KEY_BOTTOMLEFT",	KEY_BOTTOMLEFT},
+  {"KEY_BOTTOMRIGHT",	KEY_BOTTOMRIGHT},
+  {"KEY_HOME",		KEY_HOME},
+  {"KEY_PAGEDOWN",	KEY_PAGEDOWN},
+  {"KEY_PAGEUP",	KEY_PAGEUP},
+  {"KEY_ESC",		KEY_ESC},
+  {"KEY_MINUS",		KEY_MINUS},
+  {"KEY_HYPHEN",	KEY_MINUS}, // Strictly speaking, wrong
+  {"KEY_EQUAL",		KEY_EQUAL},
+  {"KEY_BACKSPACE",	KEY_BACKSPACE},
+  {"KEY_TAB",		KEY_TAB},
+  {"KEY_Q",		KEY_Q},
+  {"KEY_W",		KEY_W},
+  {"KEY_E",		KEY_E},
+  {"KEY_R",		KEY_R},
+  {"KEY_T",		KEY_T},
+  {"KEY_Y",		KEY_Y},
+  {"KEY_U",		KEY_U},
+  {"KEY_I",		KEY_I},
+  {"KEY_O",		KEY_O},
+  {"KEY_P",		KEY_P},
+  {"KEY_LEFTBRACE",	KEY_LEFTBRACE},
+  {"KEY_RIGHTBRACE",	KEY_RIGHTBRACE},
+  {"KEY_ENTER",		KEY_ENTER},
+  {"KEY_LEFTCTRL",	KEY_LEFTCTRL},
+  {"KEY_A",		KEY_A},
+  {"KEY_S",		KEY_S},
+  {"KEY_D",		KEY_D},
+  {"KEY_F",		KEY_F},
+  {"KEY_G",		KEY_G},
+  {"KEY_H",		KEY_H},
+  {"KEY_J",		KEY_J},
+  {"KEY_K",		KEY_K},
+  {"KEY_L",		KEY_L},
+  {"KEY_SEMICOLON",	KEY_SEMICOLON},
+  {"KEY_APOSTROPHE",	KEY_APOSTROPHE},
+  {"KEY_GRAVE",		KEY_GRAVE},
+  {"KEY_LEFTSHIFT",	KEY_LEFTSHIFT},
+  {"KEY_BACKSLASH",	KEY_BACKSLASH},
+  {"KEY_Z",		KEY_Z},
+  {"KEY_X",		KEY_X},
+  {"KEY_C",		KEY_C},
+  {"KEY_V",		KEY_V},
+  {"KEY_B",		KEY_B},
+  {"KEY_N",		KEY_N},
+  {"KEY_M",		KEY_M},
+  {"KEY_COMMA",		KEY_COMMA}, 	
+  {"KEY_DOT",		KEY_DOT}, 		
+  {"KEY_SLASH",		KEY_SLASH}, 	
+  {"KEY_RIGHTSHIFT",	KEY_RIGHTSHIFT}, 	
+  {"KEY_KPASTERISK",	KEY_KPASTERISK}, 	
+  {"KEY_LEFTALT",	KEY_LEFTALT}, 	
+  {"KEY_SPACE",		KEY_SPACE}, 	
+  {"KEY_CAPSLOCK",	KEY_CAPSLOCK}, 
+  {"KEY_F1",		KEY_F1}, 	
+  {"KEY_F2",		KEY_F2}, 	
+  {"KEY_F3",		KEY_F3}, 	
+  {"KEY_F4",		KEY_F4}, 	
+  {"KEY_F5",		KEY_F5}, 	
+  {"KEY_F6",		KEY_F6}, 	
+  {"KEY_F7",		KEY_F7}, 	
+  {"KEY_F8",		KEY_F8}, 	
+  {"KEY_F9",		KEY_F9}, 	
+  {"KEY_F10",		KEY_F10}, 	 
+  {"KEY_NUMLOCK",	KEY_NUMLOCK}, 	 
+  {"KEY_SCROLLLOCK",	KEY_SCROLLLOCK}, 
+  {"KEY_KP7",		KEY_KP7},	
+  {"KEY_KP8",		KEY_KP8},	
+  {"KEY_KP9",		KEY_KP9},		
+  {"KEY_KPMINUS",	KEY_KPMINUS},		
+  {"KEY_KP4",		KEY_KP4},	
+  {"KEY_KP5",		KEY_KP5},	
+  {"KEY_KP6",		KEY_KP6},	
+  {"KEY_KPPLUS",	KEY_KPPLUS},	
+  {"KEY_KP1",		KEY_KP1},		
+  {"KEY_KP2",		KEY_KP2},		
+  {"KEY_KP3",		KEY_KP3},		
+  {"KEY_KP0",		KEY_KP0},		
+  {"KEY_KPDOT",		KEY_KPDOT},		
+  {"KEY_102ND",		KEY_102ND}, 	 	
+  {"KEY_KPENTER",	KEY_KPENTER},	
+  {"KEY_KPSLASH",	KEY_KPSLASH},	
+  {"KEY_SYSRQ",		KEY_SYSRQ}, 
+  {"KEY_RIGHTALT",	KEY_RIGHTALT}, 
+  {"KEY_END",		KEY_END}, 	 
+  {"KEY_INSERT",	KEY_INSERT}, 
+  {"KEY_DELETE",	KEY_DELETE}, 
+  {"KEY_PAUSE",		KEY_PAUSE}, 	
+  {"KEY_LEFTMETA",	KEY_LEFTMETA},
+  {"KEY_RIGHTMETA",	KEY_RIGHTMETA},
+  {"KEY_BTNLEFT",	BTN_LEFT}, 
+  {"KEY_BTNRIGHT",	BTN_RIGHT},
+#if 0
+  {"PAUSE100MS",	PAUSE0+100},
+  {"PAUSE250MS",	PAUSE0+250},
+  {"PAUSE500MS",	PAUSE0+500},
+  {"PAUSE1000MS",	PAUSE0+1000},
+  {"PAUSE100",		PAUSE0+100},
+  {"PAUSE250",		PAUSE0+250},
+  {"PAUSE500",		PAUSE0+500},
+  {"PAUSE1000",		PAUSE0+1000},
+#endif
+#if 1
+  {"SCRIPT01",		SCRIPT00+1},
+  {"SCRIPT02",		SCRIPT00+2},
+  {"SCRIPT03",		SCRIPT00+3},
+  {"SCRIPT04",		SCRIPT00+4},
+  {"SCRIPT05",		SCRIPT00+5},
+  {"SCRIPT06",		SCRIPT00+6},
+  {"SCRIPT07",		SCRIPT00+7},
+  {"SCRIPT08",		SCRIPT00+8},
+  {"SCRIPT09",		SCRIPT00+9},
+  {"SCRIPT10",		SCRIPT00+10},
+  {"SCRIPT11",		SCRIPT00+11},
+  {"SCRIPT12",		SCRIPT00+12},
+  {"SCRIPT13",		SCRIPT00+13},
+  {"SCRIPT14",		SCRIPT00+14},
+  {"SCRIPT15",		SCRIPT00+15},
+  {"SCRIPT16",		SCRIPT00+16},
+  {"SCRIPT17",		SCRIPT00+17},
+  {"SCRIPT18",		SCRIPT00+18},
+  {"SCRIPT19",		SCRIPT00+19},
+  {"SCRIPT20",		SCRIPT00+20},
+#endif
+  {"RELOAD_CONF",	RELOAD_CONF},
+
+
+#if 1
+  {"SHOW_EPG",			NeutrinoMessages::SHOW_EPG},
+  {"SHOW_INFOBAR",		NeutrinoMessages::SHOW_INFOBAR},
+  {"VCR_ON",			NeutrinoMessages::VCR_ON},
+  {"VCR_OFF",			NeutrinoMessages::VCR_OFF},
+  {"STANDBY_ON",		NeutrinoMessages::STANDBY_ON},
+  {"STANDBY_OFF",		NeutrinoMessages::STANDBY_OFF},
+  {"STANDBY_TOGGLE",		NeutrinoMessages::STANDBY_TOGGLE},
+  {"SHUTDOWN",			NeutrinoMessages::SHUTDOWN},
+  {"ANNOUNCE_SHUTDOWN",		NeutrinoMessages::ANNOUNCE_SHUTDOWN},
+  {"ANNOUNCE_ZAPTO",		NeutrinoMessages::ANNOUNCE_ZAPTO},
+  {"ZAPTO",			NeutrinoMessages::ZAPTO},
+  {"ANNOUNCE_RECORD",		NeutrinoMessages::ANNOUNCE_RECORD},
+  {"RECORD_START",		NeutrinoMessages::RECORD_START},
+  {"RECORD_STOP",		NeutrinoMessages::RECORD_STOP},
+  {"ANNOUNCE_SLEEPTIMER", 	NeutrinoMessages::ANNOUNCE_SLEEPTIMER},
+  {"SLEEPTIMER",		NeutrinoMessages::SLEEPTIMER},
+  {"CHANGEMODE",		NeutrinoMessages::CHANGEMODE},
+  {"REMIND",			NeutrinoMessages::REMIND},
+  {"LOCK_RC",			NeutrinoMessages::LOCK_RC},
+  {"UNLOCK_RC",			NeutrinoMessages::UNLOCK_RC},
+
+  {"EVT_VOLCHANGED",		NeutrinoMessages::EVT_VOLCHANGED},
+  {"EVT_MUTECHANGED",		NeutrinoMessages::EVT_MUTECHANGED},
+  {"EVT_VCRCHANGED",		NeutrinoMessages::EVT_VCRCHANGED},
+  {"EVT_MODECHANGED",		NeutrinoMessages::EVT_MODECHANGED},
+  {"EVT_BOUQUETSCHANGED", 	NeutrinoMessages::EVT_BOUQUETSCHANGED},
+//		EVT_SERVICESCHANGED                      = CRCInput::RC_Events + 7,
+  {"EVT_SCAN_COMPLETE",		NeutrinoMessages::EVT_SCAN_COMPLETE},
+  {"EVT_SCAN_NUM_TRANSPONDERS",	NeutrinoMessages::EVT_SCAN_NUM_TRANSPONDERS},
+  {"EVT_SCAN_NUM_CHANNELS",	NeutrinoMessages::EVT_SCAN_NUM_CHANNELS},
+  {"EVT_SHUTDOWN",		NeutrinoMessages::EVT_SHUTDOWN},
+  {"EVT_TIMER",			NeutrinoMessages::EVT_TIMER},
+  {"EVT_PROGRAMLOCKSTATUS",	NeutrinoMessages::EVT_PROGRAMLOCKSTATUS},
+  {"EVT_RECORDMODE",		NeutrinoMessages::EVT_RECORDMODE},
+#ifndef SKIP_CA_STATUS
+  {"EVT_ZAP_CA_CLEAR",		NeutrinoMessages::EVT_ZAP_CA_CLEAR},
+  {"EVT_ZAP_CA_LOCK",		NeutrinoMessages::EVT_ZAP_CA_LOCK},
+  {"EVT_ZAP_CA_FTA",		NeutrinoMessages::EVT_ZAP_CA_FTA},
+#endif
+  {"EVT_SCAN_FAILED",		NeutrinoMessages::EVT_SCAN_FAILED},
+  {"EVT_SCAN_REPORT_NUM_SCANNED_TRANSPONDERS",	NeutrinoMessages::EVT_SCAN_REPORT_NUM_SCANNED_TRANSPONDERS},
+  {"EVT_SCAN_REPORT_FREQUENCY",	NeutrinoMessages::EVT_SCAN_REPORT_FREQUENCY},
+  {"EVT_SCAN_FOUND_RADIO_CHAN",	NeutrinoMessages::EVT_SCAN_FOUND_RADIO_CHAN},
+  {"EVT_SCAN_FOUND_DATA_CHAN",	NeutrinoMessages::EVT_SCAN_FOUND_DATA_CHAN},
+  {"EVT_SCAN_FOUND_TV_CHAN",	NeutrinoMessages::EVT_SCAN_FOUND_TV_CHAN},
+  {"EVT_SCAN_REPORT_FREQUENCYP",	NeutrinoMessages::EVT_SCAN_REPORT_FREQUENCYP},
+  {"EVT_ZAP_MOTOR",		NeutrinoMessages::EVT_ZAP_MOTOR},
+				/* sectionsd */
+  {"EVT_SERVICES_UPD",		NeutrinoMessages::EVT_SERVICES_UPD},
+
+
+  {"EVT_CURRENTEPG",		NeutrinoMessages::EVT_CURRENTEPG},
+  {"EVT_NEXTEPG",		NeutrinoMessages::EVT_NEXTEPG},
+  {"EVT_POPUP",			NeutrinoMessages::EVT_POPUP},
+  {"EVT_EXTMSG",		NeutrinoMessages::EVT_EXTMSG},
+  {"EVT_START_PLUGIN",		NeutrinoMessages::EVT_START_PLUGIN},
+
+				/* sectionsd */
+  {"EVT_CURRENTNEXT_EPG",	NeutrinoMessages::EVT_CURRENTNEXT_EPG},
+  {"EVT_TIMESET",		NeutrinoMessages::EVT_TIMESET},
+
+				/* "sectionsd" events triggered by neutrino */
+  {"EVT_NOEPG_YET",		NeutrinoMessages::EVT_NOEPG_YET},
+
+				/* "timerd" events triggered by neutrino */
+  {"EVT_NEXTPROGRAM",		NeutrinoMessages::EVT_NEXTPROGRAM},
+
+				/* zapit */
+  {"EVT_SCAN_FOUND_A_CHAN",	NeutrinoMessages::EVT_SCAN_FOUND_A_CHAN},
+  {"EVT_SCAN_PROVIDER",		NeutrinoMessages::EVT_SCAN_PROVIDER},
+  {"EVT_SCAN_SATELLITE",	NeutrinoMessages::EVT_SCAN_SATELLITE},
+  {"EVT_SCAN_SERVICENAME",	NeutrinoMessages::EVT_SCAN_SERVICENAME},
+  {"EVT_ZAP_COMPLETE",		NeutrinoMessages::EVT_ZAP_COMPLETE},
+  {"EVT_ZAP_FAILED",		NeutrinoMessages::EVT_ZAP_FAILED},
+  {"EVT_ZAP_ISNVOD",		NeutrinoMessages::EVT_ZAP_ISNVOD},
+  {"EVT_ZAP_SUB_COMPLETE",	NeutrinoMessages::EVT_ZAP_SUB_COMPLETE},
+  {"EVT_ZAP_SUB_FAILED",	NeutrinoMessages::EVT_ZAP_SUB_FAILED},
+
+				/* "zapit" events triggered by neutrino */
+  {"EVT_ZAP_GOT_SUBSERVICES",	NeutrinoMessages::EVT_ZAP_GOT_SUBSERVICES},
+  {"EVT_ZAP_GOTAPIDS",		NeutrinoMessages::EVT_ZAP_GOTAPIDS},
+  {"EVT_ZAP_GOTPIDS",		NeutrinoMessages::EVT_ZAP_GOTPIDS},
+
+				/* neutrino */
+  {"EVT_RECORDING_ENDED",	NeutrinoMessages::EVT_RECORDING_ENDED},
+#endif
+
+  {"",				CRCInput::RC_nokey /* was: 0xFFFFFFFF*/}
+};
+
 /**************************************************************************
 *	Constructor - opens rc-input device and starts threads
 *
@@ -142,9 +397,115 @@
 		fd_rc[i] = -1;
 	}
 
+	reload_conf();
+
 	open();
 }
 
+void CRCInput::reload_conf() {
+  debug_user_translate = false;
+  no_neutrinoevents_when_vc = false;
+
+  for (unsigned int i = 0; i < max_scripts; i++)
+    script_name[i] = 0;
+  
+  for (unsigned int i = 0; i < KEY_MAX; i++) {
+    user_translate_table[i] = i;
+    user_translate_data[i] = 0;
+  }
+
+  std::ifstream rc_conf(RC_CONF_PATH);
+  if (rc_conf.good()) {
+    std::string line, keyword, argument, action, data;
+    while (getline(rc_conf, line)) {
+      if (line[0] != '#') {	// Skip comments
+	int s = line.find("=");
+	if (s != -1) {
+	  keyword = trim(line.substr(0,s));
+	  argument = line.substr(s+1);
+	  if (keyword.substr(0,6) == "SCRIPT")
+	    s = argument.find_first_of("#");
+	  else
+	    s = argument.find_first_of(";#");
+	  argument = trim(argument.substr(0,s));
+	  s = argument.find_first_of("(");
+	  if (s != -1) {
+	    action = argument.substr(0, s);
+	    data = argument.substr(s+1);
+	    s = data.find_last_of(")");
+	    data = trim(data.substr(0,s));
+	  } else {
+	    action = argument;
+	    data = "";
+	  }		
+	  unsigned keycode = keyname2keycode(keyword);
+	  
+	  if (keyword == "DEBUG") {
+	    debug_user_translate = (argument == "ON" || argument == "YES");
+	    printf("[rcinput] debug_user_translate is now %s\n", argument.c_str());
+	  } else if (keyword == "NO_NEUTRINOEVENTS_WHEN_VC") {
+	    no_neutrinoevents_when_vc = (argument == "ON" || argument == "YES");
+	    printf("[rcinput] no_neutrinoevents_when_vc is now %s\n", argument.c_str());
+	  } else if (keycode > SCRIPT00 && keycode <= SCRIPT00+max_scripts) {
+	    char *buf = (char *) malloc((argument.length()+1)*sizeof(char));
+	    strcpy(buf, argument.c_str());
+	    script_name[keycode-SCRIPT00-1] = buf;
+	  } else if (keycode != CRCInput::RC_nokey) {
+	    unsigned keyaction = keyname2keycode(action);
+	    if (keyaction != CRCInput::RC_nokey) {
+	      if (debug_user_translate) {
+		if (data == "")
+		  printf("[rcinput] Binding %s -> %s\n", keyword.c_str(), argument.c_str());
+		else
+		  printf("[rcinput] Binding %s -> %s(%s)\n", keyword.c_str(), action.c_str(), data.c_str());
+	      }
+	      user_translate_table[keycode] = keyaction;
+	      if (data != "") {
+		char *data_str = (char *) malloc((data.length()+1)*sizeof(char));
+		strcpy(data_str, data.c_str());
+		user_translate_data[keycode] = (neutrino_msg_data_t) data_str;
+	      } else
+		user_translate_data[keycode] = 0;
+	    } else
+	      //if (debug_user_translate)
+	      printf("[rcinput] Key Action `%s' not recognized\n", argument.c_str());
+	  } else
+	    //if (debug_user_translate)
+	    printf("[rcinput] Key `%s' not recognized\n", keyword.c_str());
+	}
+      }
+    }
+  }
+  else
+    printf("[[rcinput] Could not open "  RC_CONF_PATH "%u %u\n", NeutrinoMessages::SHUTDOWN, KEY_MAX);
+}
+
+unsigned CRCInput::keyname2keycode(std::string the_keyname)
+{
+  unsigned int i = 0;
+  while (the_keyname != keyname[i].name && keyname[i].code != RC_nokey)
+    i++;
+  return keyname[i].code;
+}
+
+const char *CRCInput::keycode2keyname(unsigned the_keycode)
+{
+  unsigned int i = 0;
+  while (the_keycode != keyname[i].code && keyname[i].code != RC_nokey)
+    i++;
+  return keyname[i].name;
+}
+
+std::string CRCInput::trim(std::string s)
+{
+  const char *whitespace = " \t\r\n";
+  int beg = s.find_first_not_of(whitespace);
+  if (beg == -1)
+    return "";
+  int end = s.find_last_not_of(whitespace);
+  return s.substr(beg, end+1);
+}
+
 void CRCInput::open()
 {
 	close();
@@ -1181,10 +1542,19 @@
 									*msg  = (trkey == RC_standby_release) ? RC_standby : trkey;
 									*data = (trkey == RC_standby_release) ? 1 : 0; /* <- button released / pressed */
 #else /* OLD_RC_API */
-									*msg = trkey;
-									*data = 0; /* <- button pressed */
+									neutrino_msg_data_t the_data;
+									*msg = user_translate(trkey, the_data);
+									if (the_data) {
+									  // Neutrino (see neutrino.cpp) is supposed to free the
+									  // memory allocated. This probably is not working.
+									  unsigned char *buf = new unsigned char[(strlen((char *)the_data)+1)*sizeof(unsigned char)];
+									  strcpy((char *)buf, (char *) the_data);
+									  *data =(neutrino_msg_t)  buf; 
+									} else
+									  *data = 0; /* <- button pressed */
 #endif /* OLD_RC_API */
-									return;
+									if (*msg != RC_nokey)
+									  return;
 								}
 							}
 						}
@@ -1488,6 +1858,7 @@
 			  return "btn_left";
 			case RC_btn_right:
 			  return "btn_right";
+
 			case RC_top_left:
 			  return "top_left";
 			case RC_top_right:
@@ -1636,3 +2007,45 @@
 		return RC_nokey;
 #endif /* OLD_RC_API */
 }
+
+int CRCInput::user_translate(int code, neutrino_msg_data_t &data) {
+  unsigned int ucode = (unsigned) code;
+
+  if (! CFrameBuffer::getInstance()->get_active() && no_neutrinoevents_when_vc) {
+    if (debug_user_translate)
+      printf("[rcinput] key %s rejected (virtual console open)\n", keycode2keyname(ucode));
+    return RC_nokey;
+  }
+
+  if (user_translate_table[ucode] != ucode) {
+    if (debug_user_translate)
+      printf("[rcinput] user_translate: %s -> %s(%s)\n", keycode2keyname(ucode),
+	     keycode2keyname(user_translate_table[ucode]),
+	     (const char *) user_translate_data[code]);
+    ucode = user_translate_table[code];
+    data = user_translate_data[code];
+  } else {
+    data = 0;
+    if (debug_user_translate)
+      printf("[rcinput] user_translate: %s NOT translated\n", keycode2keyname(ucode));
+  }
+
+  if (ucode == RELOAD_CONF) {
+    reload_conf();
+    return RC_nokey;
+  } else if (ucode > SCRIPT00 && ucode <= SCRIPT00+max_scripts) {
+    const char *cmd = script_name[ucode-SCRIPT00-1];
+    if (cmd) {
+      if (debug_user_translate)
+	printf("[rcinput] user_translate SCRIPT%u, content: `%s', now trying to execute...\n",  ucode-SCRIPT00, cmd);
+      int result = system(cmd);
+      if (debug_user_translate)
+	printf(".... return code: %d\n", result);
+    } else
+      if (debug_user_translate)
+	printf("[rcinput] user_translate SCRIPT%u: NOT defined\n", ucode-SCRIPT00);
+    
+    return RC_nokey;
+  } else
+    return ucode;
+}
diff -Naur old/apps/tuxbox/neutrino/src/driver/rcinput.h new/apps/tuxbox/neutrino/src/driver/rcinput.h
--- old/apps/tuxbox/neutrino/src/driver/rcinput.h	2006-03-26 22:32:38.000000000 +0200
+++ new/apps/tuxbox/neutrino/src/driver/rcinput.h	2006-03-26 22:27:02.000000000 +0200
@@ -81,6 +81,7 @@
 
 #define NEUTRINO_UDS_NAME "/tmp/neutrino.sock"
 
+#define RC_CONF_PATH "/var/tuxbox/config/rc.conf"
 
 class CRCInput
 {
@@ -99,6 +100,11 @@
 			bool			correct_time;
 		};
 
+		struct key {
+		  char *name;
+		  unsigned code;
+		};
+
 		uint               timerid;
 		std::vector<timer> timers;
 
@@ -123,6 +129,18 @@
 
 		int checkTimers();
 
+		unsigned user_translate_table[KEY_MAX];
+		neutrino_msg_data_t user_translate_data[KEY_MAX];
+		unsigned keyname2keycode(std::string);
+		const char *keycode2keyname(unsigned);
+		std::string trim(std::string);
+		enum { max_scripts = 20 };
+		const char *script_name[max_scripts];
+		int user_translate(int, neutrino_msg_data_t &);
+		bool debug_user_translate;
+		bool no_neutrinoevents_when_vc;
+		void reload_conf();
+
 	public:
 		//rc-code definitions
 		static const neutrino_msg_t RC_MaxRC    = KEY_MAX;    /* /include/linux/input.h: #define KEY_MAX                 0x1ff */