most of Q2's keyboard handling ported over - what this means: keypad is now separatel...

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@2650 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/console.c b/console.c
index e323915b2c35b0a5069750a94644ba7daf41d420..6c5c6497f3c723a55b85410ab6efe23b938d92b1 100644 (file)
--- a/console.c
+++ b/console.c
@@ -120,12 +120,10 @@ void Con_ClearNotify (void)
 Con_MessageMode_f
 ================
 */
 Con_MessageMode_f
 ================
 */

-extern qboolean team_message;
-

 void Con_MessageMode_f (void)
 {
        key_dest = key_message;
 void Con_MessageMode_f (void)
 {
        key_dest = key_message;

-       team_message = false;
+       chat_team = false;

 }
 
 
 }
 
 


@@ -137,7 +135,7 @@ Con_MessageMode2_f
 void Con_MessageMode2_f (void)
 {
        key_dest = key_message;
 void Con_MessageMode2_f (void)
 {
        key_dest = key_message;

-       team_message = true;
+       chat_team = true;

 }
 
 
 }
 
 


@@ -539,7 +537,7 @@ void Con_DrawNotify (void)
                x = 0;
 
                // LordHavoc: speedup, and other improvements
                x = 0;
 
                // LordHavoc: speedup, and other improvements

-               if (team_message)
+               if (chat_team)

                        sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
                else
                        sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
                        sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
                else
                        sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));

diff --git a/keys.c b/keys.c
index eacffff03444352a4069f3d23cccd08593f8363b..9b018bde264c4df41b8c317c9075ef748116ca8d 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -30,7 +30,6 @@ key up events are sent even if in console mode
 char key_lines[32][MAXCMDLINE];
 int key_linepos;
 int shift_down = false;
 char key_lines[32][MAXCMDLINE];
 int key_linepos;
 int shift_down = false;

-int key_lastpress;

 int key_insert;        // insert key toggle (for editing)
 
 int edit_line = 0;
 int key_insert;        // insert key toggle (for editing)
 
 int edit_line = 0;


@@ -39,8 +38,6 @@ int history_line = 0;
 int key_consoleactive;
 keydest_t key_dest;
 
 int key_consoleactive;
 keydest_t key_dest;
 

-int key_count;                 // incremented every key event
-

 char *keybindings[256];
 qboolean consolekeys[256];     // if true, can't be rebound while in console
 qboolean menubound[256];       // if true, can't be rebound while in menu
 char *keybindings[256];
 qboolean consolekeys[256];     // if true, can't be rebound while in console
 qboolean menubound[256];       // if true, can't be rebound while in menu


@@ -132,10 +129,26 @@ keyname_t keynames[] =
        {"AUX31", K_AUX31},
        {"AUX32", K_AUX32},
 
        {"AUX31", K_AUX31},
        {"AUX32", K_AUX32},
 

-       {"PAUSE", K_PAUSE},
+       {"KP_HOME",                     K_KP_HOME },
+       {"KP_UPARROW",          K_KP_UPARROW },
+       {"KP_PGUP",                     K_KP_PGUP },
+       {"KP_LEFTARROW",        K_KP_LEFTARROW },
+       {"KP_5",                        K_KP_5 },
+       {"KP_RIGHTARROW",       K_KP_RIGHTARROW },
+       {"KP_END",                      K_KP_END },
+       {"KP_DOWNARROW",        K_KP_DOWNARROW },
+       {"KP_PGDN",                     K_KP_PGDN },
+       {"KP_ENTER",            K_KP_ENTER },
+       {"KP_INS",                      K_KP_INS },
+       {"KP_DEL",                      K_KP_DEL },
+       {"KP_SLASH",            K_KP_SLASH },
+       {"KP_MINUS",            K_KP_MINUS },
+       {"KP_PLUS",                     K_KP_PLUS },
+
+       {"MWHEELUP", K_MWHEELUP },
+       {"MWHEELDOWN", K_MWHEELDOWN },

 
 

-       {"MWHEELUP", K_MWHEELUP},
-       {"MWHEELDOWN", K_MWHEELDOWN},
+       {"PAUSE", K_PAUSE},

 
        {"SEMICOLON", ';'},     // because a raw semicolon seperates commands
 
 
        {"SEMICOLON", ';'},     // because a raw semicolon seperates commands
 


@@ -160,7 +173,87 @@ Interactive line editing and console scrollback
 */
 void Key_Console (int key)
 {
 */
 void Key_Console (int key)
 {

-       if (key == K_ENTER)
+       // LordHavoc: copied most of this from Q2 to improve keyboard handling
+       switch (key)
+       {
+       case K_KP_SLASH:
+               key = '/';
+               break;
+       case K_KP_MINUS:
+               key = '-';
+               break;
+       case K_KP_PLUS:
+               key = '+';
+               break;
+       case K_KP_HOME:
+               key = '7';
+               break;
+       case K_KP_UPARROW:
+               key = '8';
+               break;
+       case K_KP_PGUP:
+               key = '9';
+               break;
+       case K_KP_LEFTARROW:
+               key = '4';
+               break;
+       case K_KP_5:
+               key = '5';
+               break;
+       case K_KP_RIGHTARROW:
+               key = '6';
+               break;
+       case K_KP_END:
+               key = '1';
+               break;
+       case K_KP_DOWNARROW:
+               key = '2';
+               break;
+       case K_KP_PGDN:
+               key = '3';
+               break;
+       case K_KP_INS:
+               key = '0';
+               break;
+       case K_KP_DEL:
+               key = '.';
+               break;
+       }
+
+       // LordHavoc: FIXME: implement this sometime
+       #if 0
+       if ((toupper(key) == 'V' && keydown[K_CTRL]) || ((key == K_INS || key == K_KP_INS) && keydown[K_SHIFT]))
+       {
+               char *cbd;
+               if ((cbd = Sys_GetClipboardData()) != 0)
+               {
+                       int i;
+                       strtok(cbd, "\n\r\b");
+                       i = strlen(cbd);
+                       if (i + key_linepos >= MAXCMDLINE)
+                               i= MAXCMDLINE - key_linepos;
+                       if (i > 0)
+                       {
+                               cbd[i]=0;
+                               strcat(key_lines[edit_line], cbd);
+                               key_linepos += i;
+                       }
+                       free(cbd);
+               }
+               return;
+       }
+       #endif
+
+       if (key == 'l')
+       {
+               if (keydown[K_CTRL])
+               {
+                       Cbuf_AddText ("clear\n");
+                       return;
+               }
+       }
+
+       if (key == K_ENTER || key == K_KP_ENTER)

        {
                Cbuf_AddText (key_lines[edit_line]+1);  // skip the ]
                Cbuf_AddText ("\n");
        {
                Cbuf_AddText (key_lines[edit_line]+1);  // skip the ]
                Cbuf_AddText ("\n");


@@ -185,6 +278,7 @@ void Key_Console (int key)
                // by EvilTypeGuy eviltypeguy@qeradiant.com
                // Thanks to Fett, Taniwha
                Con_CompleteCommandLine();
                // by EvilTypeGuy eviltypeguy@qeradiant.com
                // Thanks to Fett, Taniwha
                Con_CompleteCommandLine();

+               return;

        }
 
        // Advanced Console Editing by Radix radix@planetquake.com
        }
 
        // Advanced Console Editing by Radix radix@planetquake.com


@@ -192,14 +286,15 @@ void Key_Console (int key)
 
        // left arrow will just move left one without erasing, backspace will
        // actually erase charcter
 
        // left arrow will just move left one without erasing, backspace will
        // actually erase charcter

-       if (key == K_LEFTARROW)
+       if (key == K_LEFTARROW || key == K_KP_LEFTARROW)

        {
                if (key_linepos > 1)
                        key_linepos--;
                return;
        }
 
        {
                if (key_linepos > 1)
                        key_linepos--;
                return;
        }
 

-       if (key == K_BACKSPACE) // delete char before cursor
+       // delete char before cursor
+       if (key == K_BACKSPACE || (key == 'h' && keydown[K_CTRL]))

        {
                if (key_linepos > 1)
                {
        {
                if (key_linepos > 1)
                {


@@ -209,7 +304,8 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_DEL)               // delete char on cursor
+       // delete char on cursor
+       if (key == K_DEL || key == K_KP_DEL)

        {
                if ((size_t)key_linepos < strlen(key_lines[edit_line]))
                        strcpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);
        {
                if ((size_t)key_linepos < strlen(key_lines[edit_line]))
                        strcpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);


@@ -219,7 +315,7 @@ void Key_Console (int key)
 
        // if we're at the end, get one character from previous line,
        // otherwise just go right one
 
        // if we're at the end, get one character from previous line,
        // otherwise just go right one

-       if (key == K_RIGHTARROW)
+       if (key == K_RIGHTARROW || key == K_KP_RIGHTARROW)

        {
                if (strlen(key_lines[edit_line]) == (size_t)key_linepos)
                {
        {
                if (strlen(key_lines[edit_line]) == (size_t)key_linepos)
                {


@@ -236,7 +332,7 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_INS) // toggle insert mode
+       if (key == K_INS || key == K_KP_INS) // toggle insert mode

        {
                key_insert ^= 1;
                return;
        {
                key_insert ^= 1;
                return;


@@ -244,7 +340,7 @@ void Key_Console (int key)
 
        // End Advanced Console Editing
 
 
        // End Advanced Console Editing
 

-       if (key == K_UPARROW)
+       if (key == K_UPARROW || key == K_KP_UPARROW || (key == 'p' && keydown[K_CTRL]))

        {
                do
                {
        {
                do
                {


@@ -258,7 +354,7 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_DOWNARROW)
+       if (key == K_DOWNARROW || key == K_KP_DOWNARROW || (key == 'n' && keydown[K_CTRL]))

        {
                if (history_line == edit_line) return;
                do
        {
                if (history_line == edit_line) return;
                do


@@ -280,7 +376,7 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_PGUP || key==K_MWHEELUP)
+       if (key == K_PGUP || key == K_KP_PGUP || key == K_MWHEELUP)

        {
                con_backscroll += ((int) scr_conlines >> 4);
                if (con_backscroll > con_totallines - (vid.conheight>>3) - 1)
        {
                con_backscroll += ((int) scr_conlines >> 4);
                if (con_backscroll > con_totallines - (vid.conheight>>3) - 1)


@@ -288,7 +384,7 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_PGDN || key==K_MWHEELDOWN)
+       if (key == K_PGDN || key == K_KP_PGDN || key == K_MWHEELDOWN)

        {
                con_backscroll -= ((int) scr_conlines >> 4);
                if (con_backscroll < 0)
        {
                con_backscroll -= ((int) scr_conlines >> 4);
                if (con_backscroll < 0)


@@ -296,22 +392,21 @@ void Key_Console (int key)
                return;
        }
 
                return;
        }
 

-       if (key == K_HOME)
+       if (key == K_HOME || key == K_KP_HOME)

        {
                con_backscroll = con_totallines - (vid.conheight>>3) - 1;
                return;
        }
 
        {
                con_backscroll = con_totallines - (vid.conheight>>3) - 1;
                return;
        }
 

-       if (key == K_END)
+       if (key == K_END || key == K_KP_END)

        {
                con_backscroll = 0;
                return;
        }
 
        {
                con_backscroll = 0;
                return;
        }
 

+       // non printable

        if (key < 32 || key > 127)
        if (key < 32 || key > 127)

-               return; // non printable
-
-
+               return;

 
        if (key_linepos < MAXCMDLINE-1)
        {
 
        if (key_linepos < MAXCMDLINE-1)
        {


@@ -342,16 +437,15 @@ void Key_Console (int key)
 //============================================================================
 
 // LordHavoc: increased messagemode length (was 32)
 //============================================================================
 
 // LordHavoc: increased messagemode length (was 32)

+qboolean chat_team = false;

 char chat_buffer[256];
 char chat_buffer[256];

-qboolean team_message = false;
+int chat_bufferlen = 0;

 
 void Key_Message (int key)
 {
 
 void Key_Message (int key)
 {

-       static int chat_bufferlen = 0;
-
-       if (key == K_ENTER)
+       if (key == K_ENTER || key == K_KP_ENTER)

        {
        {

-               if (team_message)
+               if (chat_team)

                        Cbuf_AddText ("say_team \"");
                else
                        Cbuf_AddText ("say \"");
                        Cbuf_AddText ("say_team \"");
                else
                        Cbuf_AddText ("say \"");


@@ -372,8 +466,9 @@ void Key_Message (int key)
                return;
        }
 
                return;
        }
 

+       // non printable

        if (key < 32 || key > 127)
        if (key < 32 || key > 127)

-               return; // non printable
+               return;

 
        if (key == K_BACKSPACE)
        {
 
        if (key == K_BACKSPACE)
        {


@@ -385,8 +480,7 @@ void Key_Message (int key)
                return;
        }
 
                return;
        }
 

-       // LordHavoc: increased messagemode length (was 31)
-       if (chat_bufferlen == 240)
+       if (chat_bufferlen == sizeof(chat_buffer) - 1)

                return; // all full
 
        chat_buffer[chat_bufferlen++] = key;
                return; // all full
 
        chat_buffer[chat_bufferlen++] = key;


@@ -458,9 +552,9 @@ Key_SetBinding
 */
 void Key_SetBinding (int keynum, char *binding)
 {
 */
 void Key_SetBinding (int keynum, char *binding)
 {

-       char    *new;
-       int             l;
-                       
+       char *new;
+       int l;
+

        if (keynum < 0 || keynum >= 256)
                return;
 
        if (keynum < 0 || keynum >= 256)
                return;
 


@@ -470,13 +564,13 @@ void Key_SetBinding (int keynum, char *binding)
                Z_Free (keybindings[keynum]);
                keybindings[keynum] = NULL;
        }
                Z_Free (keybindings[keynum]);
                keybindings[keynum] = NULL;
        }

-                       
+

 // allocate memory for new binding
 // allocate memory for new binding

-       l = strlen (binding);   
+       l = strlen (binding);

        new = Z_Malloc (l+1);
        strcpy (new, binding);
        new[l] = 0;
        new = Z_Malloc (l+1);
        strcpy (new, binding);
        new[l] = 0;

-       keybindings[keynum] = new;      
+       keybindings[keynum] = new;

 }
 
 /*
 }
 
 /*


@@ -486,7 +580,7 @@ Key_Unbind_f
 */
 void Key_Unbind_f (void)
 {
 */
 void Key_Unbind_f (void)
 {

-       int             b;
+       int b;

 
        if (Cmd_Argc() != 2)
        {
 
        if (Cmd_Argc() != 2)
        {


@@ -495,7 +589,7 @@ void Key_Unbind_f (void)
        }
 
        b = Key_StringToKeynum (Cmd_Argv(1));
        }
 
        b = Key_StringToKeynum (Cmd_Argv(1));

-       if (b==-1)
+       if (b == -1)

        {
                Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
                return;
        {
                Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
                return;


@@ -506,9 +600,9 @@ void Key_Unbind_f (void)
 
 void Key_Unbindall_f (void)
 {
 
 void Key_Unbindall_f (void)
 {

-       int             i;
+       int i;

 
 

-       for (i=0 ; i<256 ; i++)
+       for (i = 0;i < 256;i++)

                if (keybindings[i])
                        Key_SetBinding (i, "");
 }
                if (keybindings[i])
                        Key_SetBinding (i, "");
 }


@@ -521,8 +615,8 @@ Key_Bind_f
 */
 void Key_Bind_f (void)
 {
 */
 void Key_Bind_f (void)
 {

-       int                     i, c, b;
-       char            cmd[1024];
+       int i, c, b;
+       char cmd[1024];

 
        c = Cmd_Argc();
 
 
        c = Cmd_Argc();
 


@@ -532,7 +626,7 @@ void Key_Bind_f (void)
                return;
        }
        b = Key_StringToKeynum (Cmd_Argv(1));
                return;
        }
        b = Key_StringToKeynum (Cmd_Argv(1));

-       if (b==-1)
+       if (b == -1)

        {
                Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
                return;
        {
                Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
                return;


@@ -548,7 +642,8 @@ void Key_Bind_f (void)
        }
 
 // copy the rest of the command line
        }
 
 // copy the rest of the command line

-       cmd[0] = 0;             // start out with a null string
+       // start out with a null string
+       cmd[0] = 0;

        for (i=2 ; i< c ; i++)
        {
                if (i > 2)
        for (i=2 ; i< c ; i++)
        {
                if (i > 2)


@@ -568,12 +663,27 @@ Writes lines containing "bind key value"
 */
 void Key_WriteBindings (QFile *f)
 {
 */
 void Key_WriteBindings (QFile *f)
 {

-       int             i;
+       int i;

 
 

-       for (i=0 ; i<256 ; i++)
-               if (keybindings[i])
-                       if (*keybindings[i])
-                               Qprintf (f, "bind \"%s\" \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
+       for (i = 0;i < 256;i++)
+               if (keybindings[i] && *keybindings[i])
+                       Qprintf (f, "bind \"%s\" \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
+}
+
+
+/*
+============
+Key_Bindlist_f
+
+============
+*/
+void Key_Bindlist_f (void)
+{
+       int i;
+
+       for (i = 0;i < 256;i++)
+               if (keybindings[i] && keybindings[i][0])
+                       Con_Printf ("%s \"%s\"\n", Key_KeynumToString(i), keybindings[i]);

 }
 
 
 }
 
 


@@ -584,13 +694,13 @@ Key_Init
 */
 void Key_Init (void)
 {
 */
 void Key_Init (void)
 {

-       int             i;
+       int i;

 
        // LordHavoc: clear keybindings array so bounds checking won't freak
        for (i = 0;i < 256;i++)
                keybindings[i] = NULL;
 
 
        // LordHavoc: clear keybindings array so bounds checking won't freak
        for (i = 0;i < 256;i++)
                keybindings[i] = NULL;
 

-       for (i=0 ; i<32 ; i++)
+       for (i = 0;i < 32;i++)

        {
                key_lines[i][0] = ']';
                key_lines[i][1] = 0;
        {
                key_lines[i][0] = ']';
                key_lines[i][1] = 0;


@@ -600,28 +710,35 @@ void Key_Init (void)
 //
 // init ascii characters in console mode
 //
 //
 // init ascii characters in console mode
 //

-       for (i=32 ; i<128 ; i++)
+       for (i = 32;i < 128;i++)

                consolekeys[i] = true;
                consolekeys[i] = true;

-       consolekeys[K_ENTER] = true;
+       consolekeys[K_ENTER] = true;consolekeys[K_KP_ENTER] = true;

        consolekeys[K_TAB] = true;
        consolekeys[K_TAB] = true;

-       consolekeys[K_LEFTARROW] = true;
-       consolekeys[K_RIGHTARROW] = true;
-       consolekeys[K_UPARROW] = true;
-       consolekeys[K_DOWNARROW] = true;
+       consolekeys[K_LEFTARROW] = true;consolekeys[K_KP_LEFTARROW] = true;
+       consolekeys[K_RIGHTARROW] = true;consolekeys[K_KP_RIGHTARROW] = true;
+       consolekeys[K_UPARROW] = true;consolekeys[K_KP_UPARROW] = true;
+       consolekeys[K_DOWNARROW] = true;consolekeys[K_KP_DOWNARROW] = true;

        consolekeys[K_BACKSPACE] = true;
        consolekeys[K_BACKSPACE] = true;

-       consolekeys[K_DEL] = true;
-       consolekeys[K_INS] = true;
-       consolekeys[K_PGUP] = true;
-       consolekeys[K_PGDN] = true;
+       consolekeys[K_HOME] = true;consolekeys[K_KP_HOME] = true;
+       consolekeys[K_END] = true;consolekeys[K_KP_END] = true;
+       consolekeys[K_PGUP] = true;consolekeys[K_KP_PGUP] = true;
+       consolekeys[K_PGDN] = true;consolekeys[K_KP_PGDN] = true;

        consolekeys[K_SHIFT] = true;
        consolekeys[K_SHIFT] = true;

+       consolekeys[K_INS] = true;consolekeys[K_KP_INS] = true;
+       consolekeys[K_DEL] = true;consolekeys[K_KP_DEL] = true;
+       consolekeys[K_KP_SLASH] = true;
+       consolekeys[K_KP_PLUS] = true;
+       consolekeys[K_KP_MINUS] = true;
+       consolekeys[K_KP_5] = true;

        consolekeys[K_MWHEELUP] = true;
        consolekeys[K_MWHEELDOWN] = true;
        consolekeys[K_MWHEELUP] = true;
        consolekeys[K_MWHEELDOWN] = true;

+

        consolekeys['`'] = false;
        consolekeys['~'] = false;
 
        consolekeys['`'] = false;
        consolekeys['~'] = false;
 

-       for (i=0 ; i<256 ; i++)
+       for (i = 0;i < 256;i++)

                keyshift[i] = i;
                keyshift[i] = i;

-       for (i='a' ; i<='z' ; i++)
+       for (i = 'a';i <= 'z';i++)

                keyshift[i] = i - 'a' + 'A';
        keyshift['1'] = '!';
        keyshift['2'] = '@';
                keyshift[i] = i - 'a' + 'A';
        keyshift['1'] = '!';
        keyshift['2'] = '@';


@@ -655,6 +772,7 @@ void Key_Init (void)
        Cmd_AddCommand ("bind",Key_Bind_f);
        Cmd_AddCommand ("unbind",Key_Unbind_f);
        Cmd_AddCommand ("unbindall",Key_Unbindall_f);
        Cmd_AddCommand ("bind",Key_Bind_f);
        Cmd_AddCommand ("unbind",Key_Unbind_f);
        Cmd_AddCommand ("unbindall",Key_Unbindall_f);

+       Cmd_AddCommand ("bindlist",Key_Bindlist_f);

 }
 
 /*
 }
 
 /*


@@ -672,24 +790,24 @@ void Key_Event (int key, qboolean down)
 
        keydown[key] = down;
 
 
        keydown[key] = down;
 

-       if (!down)
-               key_repeats[key] = 0;
-
-       key_lastpress = key;
-       key_count++;
-       if (key_count <= 0)
-               return;         // just catching keys for Con_NotifyBox
-
-// update auto-repeat status
+       // update auto-repeat status

        if (down)
        {
                key_repeats[key]++;
        if (down)
        {
                key_repeats[key]++;

-               if (key != K_BACKSPACE && key != K_PAUSE && key_repeats[key] > 1)
+               if (key != K_BACKSPACE
+                && key != K_PAUSE
+                && key != K_PGUP
+                && key != K_KP_PGUP
+                && key != K_PGDN
+                && key != K_KP_PGDN
+                && key_repeats[key] > 1)

                        return; // ignore most autorepeats
 
                if (key >= 200 && !keybindings[key])
                        return; // ignore most autorepeats
 
                if (key >= 200 && !keybindings[key])

-                       Con_Printf ("%s is unbound, hit F4 to set.\n", Key_KeynumToString (key) );
+                       Con_Printf ("%s is unbound, hit F4 to set.\n", Key_KeynumToString (key));

        }
        }

+       else
+               key_repeats[key] = 0;

 
        if (key == K_SHIFT)
                shift_down = down;
 
        if (key == K_SHIFT)
                shift_down = down;


@@ -718,7 +836,14 @@ void Key_Event (int key, qboolean down)
                return;
        }
 
                return;
        }
 

-       // LordHavoc: hack to make toggleconsole always work
+       // console key is hardcoded, so the user can never unbind it
+       if (key == '`' || key == '~')
+       {
+               if (down)
+                       Con_ToggleConsole_f ();
+               return;
+       }
+

        if (down)
        {
                kb = keybindings[key];
        if (down)
        {
                kb = keybindings[key];


@@ -775,15 +900,11 @@ void Key_Event (int key, qboolean down)
                // during demo playback, most keys bring up the main menu
                //
                if (cls.demoplayback && down && consolekeys[key] && key_dest == key_game)
                // during demo playback, most keys bring up the main menu
                //
                if (cls.demoplayback && down && consolekeys[key] && key_dest == key_game)

-               {
-                       M_ToggleMenu_f ();
-                       return;
-               }
+                       key = K_ESCAPE;

 
                //
                // if not a consolekey, send to the interpreter no matter what mode is
                //
 
                //
                // if not a consolekey, send to the interpreter no matter what mode is
                //

-               //if ((key_dest == key_console && !consolekeys[key])

                if ((key_consoleactive && !consolekeys[key])
                 || (key_dest == key_menu && menubound[key])
                 || key_dest == key_game)
                if ((key_consoleactive && !consolekeys[key])
                 || (key_dest == key_menu && menubound[key])
                 || key_dest == key_game)


@@ -792,7 +913,8 @@ void Key_Event (int key, qboolean down)
                        if (kb)
                        {
                                if (kb[0] == '+')
                        if (kb)
                        {
                                if (kb[0] == '+')

-                               {       // button commands add keynum as a parm
+                               {
+                                       // button commands add keynum as a parm

                                        sprintf (cmd, "%s %i\n", kb, key);
                                        Cbuf_AddText (cmd);
                                }
                                        sprintf (cmd, "%s %i\n", kb, key);
                                        Cbuf_AddText (cmd);
                                }

diff --git a/keys.h b/keys.h
index 57d32eedf8df84df3d25a42d33b113c29213e79d..fcd39ce41ede714d8bcaf322da30d95b9364d7b9 100644 (file)
--- a/keys.h
+++ b/keys.h
@@ -8,7 +8,7 @@ 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
 
 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.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 
 See the GNU General Public License for more details.
 
 
 See the GNU General Public License for more details.
 


@@ -21,131 +21,123 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifndef KEYS_H
 #define KEYS_H
 
 #ifndef KEYS_H
 #define KEYS_H
 

+//

 // these are the key numbers that should be passed to Key_Event
 // these are the key numbers that should be passed to Key_Event

+//
+#define        K_TAB                   9
+#define        K_ENTER                 13
+#define        K_ESCAPE                27
+#define        K_SPACE                 32
+
+// normal keys should be passed as lowercased ascii
+
+#define        K_BACKSPACE             127
+#define        K_UPARROW               128
+#define        K_DOWNARROW             129
+#define        K_LEFTARROW             130
+#define        K_RIGHTARROW    131
+
+#define        K_ALT                   132
+#define        K_CTRL                  133
+#define        K_SHIFT                 134
+#define        K_F1                    135
+#define        K_F2                    136
+#define        K_F3                    137
+#define        K_F4                    138
+#define        K_F5                    139
+#define        K_F6                    140
+#define        K_F7                    141
+#define        K_F8                    142
+#define        K_F9                    143
+#define        K_F10                   144
+#define        K_F11                   145
+#define        K_F12                   146
+#define        K_INS                   147
+#define        K_DEL                   148
+#define        K_PGDN                  149
+#define        K_PGUP                  150
+#define        K_HOME                  151
+#define        K_END                   152
+
+#define K_KP_HOME              160
+#define K_KP_UPARROW   161
+#define K_KP_PGUP              162
+#define        K_KP_LEFTARROW  163
+#define K_KP_5                 164
+#define K_KP_RIGHTARROW        165
+#define K_KP_END               166
+#define K_KP_DOWNARROW 167
+#define K_KP_PGDN              168
+#define        K_KP_ENTER              169
+#define K_KP_INS               170
+#define        K_KP_DEL                171
+#define K_KP_SLASH             172
+#define K_KP_MINUS             173
+#define K_KP_PLUS              174
+
+#define K_PAUSE                        255
+
+//
+// mouse buttons generate virtual keys
+//
+#define        K_MOUSE1                200
+#define        K_MOUSE2                201
+#define        K_MOUSE3                202
+
+//
+// joystick buttons
+//
+#define        K_JOY1                  203
+#define        K_JOY2                  204
+#define        K_JOY3                  205
+#define        K_JOY4                  206
+
+//
+// aux keys are for multi-buttoned joysticks to generate so they can use
+// the normal binding process
+//
+#define        K_AUX1                  207
+#define        K_AUX2                  208
+#define        K_AUX3                  209
+#define        K_AUX4                  210
+#define        K_AUX5                  211
+#define        K_AUX6                  212
+#define        K_AUX7                  213
+#define        K_AUX8                  214
+#define        K_AUX9                  215
+#define        K_AUX10                 216
+#define        K_AUX11                 217
+#define        K_AUX12                 218
+#define        K_AUX13                 219
+#define        K_AUX14                 220
+#define        K_AUX15                 221
+#define        K_AUX16                 222
+#define        K_AUX17                 223
+#define        K_AUX18                 224
+#define        K_AUX19                 225
+#define        K_AUX20                 226
+#define        K_AUX21                 227
+#define        K_AUX22                 228
+#define        K_AUX23                 229
+#define        K_AUX24                 230
+#define        K_AUX25                 231
+#define        K_AUX26                 232
+#define        K_AUX27                 233
+#define        K_AUX28                 234
+#define        K_AUX29                 235
+#define        K_AUX30                 236
+#define        K_AUX31                 237
+#define        K_AUX32                 238
+
+#define K_MWHEELDOWN   239
+#define K_MWHEELUP             240

 
 

-typedef enum {
-       K_TAB = 9,
-       K_ENTER = 13,
-       K_ESCAPE = 27,
-       K_SPACE = 32,
-
-       // normal keys should be passed as lowercased ascii
-
-       K_BACKSPACE = 127,
-
-       K_CAPSLOCK,
-       K_PRNTSCR,
-       K_SCRLCK,
-       K_PAUSE,
-
-       K_UPARROW,
-       K_DOWNARROW,
-       K_LEFTARROW,
-       K_RIGHTARROW,
-
-       K_ALT,
-       K_CTRL,
-       K_SHIFT,
-       K_F1,
-       K_F2,
-       K_F3,
-       K_F4,
-       K_F5,
-       K_F6,
-       K_F7,
-       K_F8,
-       K_F9,
-       K_F10,
-       K_F11,
-       K_F12,
-       K_INS,
-       K_DEL,
-       K_PGDN,
-       K_PGUP,
-       K_HOME,
-       K_END,
-
-
-       // Keypad stuff..
-
-       KP_NUMLCK,
-       KP_DIVIDE,
-       KP_MULTIPLY,
-
-       KP_HOME,
-       KP_UPARROW,
-       KP_PGUP,
-       KP_MINUS,
-
-       KP_LEFTARROW,
-       KP_5,
-       KP_RIGHTARROW,
-       KP_PLUS,
-
-       KP_END,
-       KP_DOWNARROW,
-       KP_PGDN,
-
-
-       KP_INS,
-       KP_DEL,
-       KP_ENTER,
-
-       // mouse buttons generate virtual keys
-       K_MOUSE1 = 200,
-       K_MOUSE2,
-       K_MOUSE3,
-
-       // joystick buttons
-       K_JOY1,
-       K_JOY2,
-       K_JOY3,
-       K_JOY4,
-
-       //
-       //// aux keys are for multi-buttoned joysticks to generate so they can use
-       //// the normal binding process
-       ////
-       //
-       K_AUX1,
-       K_AUX2,
-       K_AUX3,
-       K_AUX4,
-       K_AUX5,
-       K_AUX6,
-       K_AUX7,
-       K_AUX8,
-       K_AUX9,
-       K_AUX10,
-       K_AUX11,
-       K_AUX12,
-       K_AUX13,
-       K_AUX14,
-       K_AUX15,
-       K_AUX16,
-       K_AUX17,
-       K_AUX18,
-       K_AUX19,
-       K_AUX20,
-       K_AUX21,
-       K_AUX22,
-       K_AUX23,
-       K_AUX24,
-       K_AUX25,
-       K_AUX26,
-       K_AUX27,
-       K_AUX28,
-       K_AUX29,
-       K_AUX30,
-       K_AUX31,
-       K_AUX32,
-
-       // JACK: Intellimouse(c) Mouse Wheel Support
-
-       K_MWHEELUP,
-       K_MWHEELDOWN
-} keynum_t;
+extern char *keybindings[256];
+extern int key_repeats[256];

 
 

+extern char chat_buffer[256];
+extern int chat_bufferlen;
+extern qboolean chat_team;

 
 typedef enum {key_game, key_message, key_menu} keydest_t;
 
 
 typedef enum {key_game, key_message, key_menu} keydest_t;
 


@@ -156,10 +148,6 @@ typedef enum {key_game, key_message, key_menu} keydest_t;
 #define KEY_CONSOLEACTIVE_FORCED 2
 extern int key_consoleactive;
 extern keydest_t key_dest;
 #define KEY_CONSOLEACTIVE_FORCED 2
 extern int key_consoleactive;
 extern keydest_t key_dest;

-extern char *keybindings[256];
-extern int key_repeats[256];
-extern int key_count;                  // incremented every key event
-extern int key_lastpress;

 
 void Key_Event (int key, qboolean down);
 void Key_Init (void);
 
 void Key_Event (int key, qboolean down);
 void Key_Init (void);

diff --git a/vid_glx.c b/vid_glx.c
index a8a8407a7a5ba444d2ff1c0cad7ceef31816ce35..fc4cdcb735793508f5631d2c5bb43fcfecd254c6 100644 (file)
--- a/vid_glx.c
+++ b/vid_glx.c
@@ -106,105 +106,127 @@ static Colormap vidx11_colormap;
 
 /*-----------------------------------------------------------------------*/
 
 
 /*-----------------------------------------------------------------------*/
 

-static int
-XLateKey(XKeyEvent *ev)
+static int XLateKey(XKeyEvent *ev)

 {
        int key = 0;
 {
        int key = 0;

+       char buf[64];

        KeySym keysym;
 
        KeySym keysym;
 

-       keysym = XLookupKeysym(ev, 0);
+       XLookupString(ev, buf, sizeof buf, &keysym, 0);

 
        switch(keysym)
        {
 
        switch(keysym)
        {

-               case XK_KP_Page_Up:     key = KP_PGUP; break;
-               case XK_Page_Up:        key = K_PGUP; break;
+               case XK_KP_Page_Up:      key = K_KP_PGUP; break;
+               case XK_Page_Up:         key = K_PGUP; break;

 
 

-               case XK_KP_Page_Down:   key = KP_PGDN; break;
-               case XK_Page_Down:      key = K_PGDN; break;
+               case XK_KP_Page_Down: key = K_KP_PGDN; break;
+               case XK_Page_Down:       key = K_PGDN; break;

 
 

-               case XK_KP_Home:        key = KP_HOME; break;
-               case XK_Home:           key = K_HOME; break;
+               case XK_KP_Home: key = K_KP_HOME; break;
+               case XK_Home:    key = K_HOME; break;

 
 

-               case XK_KP_End:         key = KP_END; break;
-               case XK_End:            key = K_END; break;
+               case XK_KP_End:  key = K_KP_END; break;
+               case XK_End:     key = K_END; break;

 
 

-               case XK_KP_Left:        key = KP_LEFTARROW; break;
-               case XK_Left:           key = K_LEFTARROW; break;
+               case XK_KP_Left: key = K_KP_LEFTARROW; break;
+               case XK_Left:    key = K_LEFTARROW; break;

 
 

-               case XK_KP_Right:       key = KP_RIGHTARROW; break;
-               case XK_Right:          key = K_RIGHTARROW; break;
+               case XK_KP_Right: key = K_KP_RIGHTARROW; break;
+               case XK_Right:  key = K_RIGHTARROW;             break;

 
 

-               case XK_KP_Down:        key = KP_DOWNARROW; break;
-               case XK_Down:           key = K_DOWNARROW; break;
+               case XK_KP_Down: key = K_KP_DOWNARROW; break;
+               case XK_Down:    key = K_DOWNARROW; break;

 
 

-               case XK_KP_Up:          key = KP_UPARROW; break;
-               case XK_Up:                     key = K_UPARROW; break;
+               case XK_KP_Up:   key = K_KP_UPARROW; break;
+               case XK_Up:              key = K_UPARROW;        break;

 
 

-               case XK_Escape:         key = K_ESCAPE; break;
+               case XK_Escape: key = K_ESCAPE;         break;

 
 

-               case XK_KP_Enter:       key = KP_ENTER; break;
-               case XK_Return:         key = K_ENTER; break;
+               case XK_KP_Enter: key = K_KP_ENTER;     break;
+               case XK_Return: key = K_ENTER;           break;

 
 

-               case XK_Tab:            key = K_TAB; break;
+               case XK_Tab:            key = K_TAB;                     break;

 
 

-               case XK_F1:                     key = K_F1; break;
-               case XK_F2:                     key = K_F2; break;
-               case XK_F3:                     key = K_F3; break;
-               case XK_F4:                     key = K_F4; break;
-               case XK_F5:                     key = K_F5; break;
-               case XK_F6:                     key = K_F6; break;
-               case XK_F7:                     key = K_F7; break;
-               case XK_F8:                     key = K_F8; break;
-               case XK_F9:                     key = K_F9; break;
-               case XK_F10:            key = K_F10; break;
-               case XK_F11:            key = K_F11; break;
-               case XK_F12:            key = K_F12; break;
+               case XK_F1:              key = K_F1;                            break;

 
 

-               case XK_BackSpace:      key = K_BACKSPACE; break;
+               case XK_F2:              key = K_F2;                            break;

 
 

-               case XK_KP_Delete:      key = KP_DEL; break;
-               case XK_Delete:         key = K_DEL; break;
+               case XK_F3:              key = K_F3;                            break;

 
 

-               case XK_Pause:          key = K_PAUSE; break;
+               case XK_F4:              key = K_F4;                            break;
+
+               case XK_F5:              key = K_F5;                            break;
+
+               case XK_F6:              key = K_F6;                            break;
+
+               case XK_F7:              key = K_F7;                            break;
+
+               case XK_F8:              key = K_F8;                            break;
+
+               case XK_F9:              key = K_F9;                            break;
+
+               case XK_F10:            key = K_F10;                     break;
+
+               case XK_F11:            key = K_F11;                     break;
+
+               case XK_F12:            key = K_F12;                     break;
+
+               case XK_BackSpace: key = K_BACKSPACE; break;
+
+               case XK_KP_Delete: key = K_KP_DEL; break;
+               case XK_Delete: key = K_DEL; break;
+
+               case XK_Pause:  key = K_PAUSE;           break;

 
                case XK_Shift_L:
 
                case XK_Shift_L:

-               case XK_Shift_R:        key = K_SHIFT; break;
+               case XK_Shift_R:        key = K_SHIFT;          break;

 
                case XK_Execute:
                case XK_Control_L:
 
                case XK_Execute:
                case XK_Control_L:

-               case XK_Control_R:      key = K_CTRL; break;
+               case XK_Control_R:      key = K_CTRL;            break;

 
 

-               case XK_Mode_switch:

                case XK_Alt_L:
                case XK_Meta_L:
                case XK_Alt_R:
                case XK_Alt_L:
                case XK_Meta_L:
                case XK_Alt_R:

-               case XK_Meta_R:         key = K_ALT; break;
+               case XK_Meta_R: key = K_ALT;                    break;

 
 

-               case XK_Caps_Lock:      key = K_CAPSLOCK; break;
-               case XK_KP_Begin:       key = KP_5; break;
+               case XK_KP_Begin: key = K_KP_5; break;

 
 

-               case XK_Insert:         key = K_INS; break;
-               case XK_KP_Insert:      key = KP_INS; break;
+               case XK_Insert:key = K_INS; break;
+               case XK_KP_Insert: key = K_KP_INS; break;

 
 

-               case XK_KP_Multiply:    key = KP_MULTIPLY; break;
-               case XK_KP_Add:         key = KP_PLUS; break;
-               case XK_KP_Subtract:    key = KP_MINUS; break;
-               case XK_KP_Divide:      key = KP_DIVIDE; break;
+               case XK_KP_Multiply: key = '*'; break;
+               case XK_KP_Add:  key = K_KP_PLUS; break;
+               case XK_KP_Subtract: key = K_KP_MINUS; break;
+               case XK_KP_Divide: key = K_KP_SLASH; break;

 
 

-               /* For Sun keyboards */
-               case XK_F27:            key = K_HOME; break;
-               case XK_F29:            key = K_PGUP; break;
-               case XK_F33:            key = K_END; break;
-               case XK_F35:            key = K_PGDN; break;
+#if 0
+               case 0x021: key = '1';break;/* [!] */
+               case 0x040: key = '2';break;/* [@] */
+               case 0x023: key = '3';break;/* [#] */
+               case 0x024: key = '4';break;/* [$] */
+               case 0x025: key = '5';break;/* [%] */
+               case 0x05e: key = '6';break;/* [^] */
+               case 0x026: key = '7';break;/* [&] */
+               case 0x02a: key = '8';break;/* [*] */
+               case 0x028: key = '9';;break;/* [(] */
+               case 0x029: key = '0';break;/* [)] */
+               case 0x05f: key = '-';break;/* [_] */
+               case 0x02b: key = '=';break;/* [+] */
+               case 0x07c: key = '\'';break;/* [|] */
+               case 0x07d: key = '[';break;/* [}] */
+               case 0x07b: key = ']';break;/* [{] */
+               case 0x022: key = '\'';break;/* ["] */
+               case 0x03a: key = ';';break;/* [:] */
+               case 0x03f: key = '/';break;/* [?] */
+               case 0x03e: key = '.';break;/* [>] */
+               case 0x03c: key = ',';break;/* [<] */
+#endif

 
                default:
 
                default:

-                       if (keysym < 128)
-                       {
-                               /* ASCII keys */
-                               key = keysym;
-                               if ((key >= 'A') && (key <= 'Z'))
-                                       key = key + ('a' - 'A');
-                       }
+                       key = *(unsigned char*)buf;
+                       if (key >= 'A' && key <= 'Z')
+                               key = key - 'A' + 'a';

                        break;
        }
 
                        break;
        }
 

diff --git a/vid_wgl.c b/vid_wgl.c
index 789f64d3dfb7d5bf54089821072e4ea095bc8268..97a889f8066e597a7dd02c535c2bd888b44061aa 100644 (file)
--- a/vid_wgl.c
+++ b/vid_wgl.c
@@ -321,15 +321,15 @@ void VID_Finish (void)
 
 qbyte scantokey[128] =
 {
 
 qbyte scantokey[128] =
 {

-//     0           1      2     3     4     5       6       7      8         9      A       B           C     D            E           F
-       0          ,27    ,'1'  ,'2'  ,'3'  ,'4'    ,'5'    ,'6'   ,'7'      ,'8'   ,'9'    ,'0'        ,'-'  ,'='         ,K_BACKSPACE,9     , // 0
-       'q'        ,'w'   ,'e'  ,'r'  ,'t'  ,'y'    ,'u'    ,'i'   ,'o'      ,'p'   ,'['    ,']'        ,13   ,K_CTRL      ,'a'        ,'s'   , // 1
-       'd'        ,'f'   ,'g'  ,'h'  ,'j'  ,'k'    ,'l'    ,';'   ,'\''     ,'`'   ,K_SHIFT,'\\'       ,'z'  ,'x'         ,'c'        ,'v'   , // 2
-       'b'        ,'n'   ,'m'  ,','  ,'.'  ,'/'    ,K_SHIFT,'*'   ,K_ALT    ,' '   ,0      ,K_F1       ,K_F2 ,K_F3        ,K_F4       ,K_F5  , // 3
-       K_F6       ,K_F7  ,K_F8 ,K_F9 ,K_F10,K_PAUSE,0      ,K_HOME,K_UPARROW,K_PGUP,'-'    ,K_LEFTARROW,'5'  ,K_RIGHTARROW,'+'        ,K_END , // 4
-       K_DOWNARROW,K_PGDN,K_INS,K_DEL,0    ,0      ,0      ,K_F11 ,K_F12    ,0     ,0      ,0          ,0    ,0           ,0          ,0     , // 5
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0    ,0           ,0          ,0     , // 6
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0    ,0           ,0          ,0       // 7
+//  0           1       2    3     4     5       6       7      8         9      A          B           C       D           E           F
+       0          ,27    ,'1'  ,'2'  ,'3'  ,'4'    ,'5'    ,'6'   ,'7'      ,'8'   ,'9'       ,'0'        ,'-'   ,'='         ,K_BACKSPACE,9    ,//0
+       'q'        ,'w'   ,'e'  ,'r'  ,'t'  ,'y'    ,'u'    ,'i'   ,'o'      ,'p'   ,'['       ,']'        ,13    ,K_CTRL      ,'a'        ,'s'  ,//1
+       'd'        ,'f'   ,'g'  ,'h'  ,'j'  ,'k'    ,'l'    ,';'   ,'\''     ,'`'   ,K_SHIFT   ,'\\'       ,'z'   ,'x'         ,'c'        ,'v'  ,//2
+       'b'        ,'n'   ,'m'  ,','  ,'.'  ,'/'    ,K_SHIFT,'*'   ,K_ALT    ,' '   ,0         ,K_F1       ,K_F2  ,K_F3        ,K_F4       ,K_F5 ,//3
+       K_F6       ,K_F7  ,K_F8 ,K_F9 ,K_F10,K_PAUSE,0      ,K_HOME,K_UPARROW,K_PGUP,K_KP_MINUS,K_LEFTARROW,K_KP_5,K_RIGHTARROW,K_KP_PLUS  ,K_END,//4
+       K_DOWNARROW,K_PGDN,K_INS,K_DEL,0    ,0      ,0      ,K_F11 ,K_F12    ,0     ,0         ,0          ,0     ,0           ,0          ,0    ,//5
+       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0         ,0          ,0     ,0           ,0          ,0    ,//6
+       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0         ,0          ,0     ,0           ,0          ,0     //7

 };
 
 
 };
 
 


@@ -342,12 +342,62 @@ Map from windows to quake keynums
 */
 int MapKey (int key, int virtualkey)
 {
 */
 int MapKey (int key, int virtualkey)
 {

-       key = (key>>16)&255;
-       if (key > 127)
-               return 0;
-       if (scantokey[key] == 0)
-               Con_DPrintf("key 0x%02x has no translation\n", key);
-       return scantokey[key];
+       int result;
+       int modified = (key >> 16) & 255;
+       qboolean is_extended = false;
+
+       if (modified < 128 && scantokey[modified])
+               result = scantokey[modified];
+       else
+       {
+               result = 0;
+               Con_DPrintf("key 0x%02x (0x%8x, 0x%8x) has no translation\n", modified, key, virtualkey);
+       }
+
+       if (key & (1 << 24))
+               is_extended = true;
+
+       if ( !is_extended )
+       {
+               switch ( result )
+               {
+               case K_HOME:
+                       return K_KP_HOME;
+               case K_UPARROW:
+                       return K_KP_UPARROW;
+               case K_PGUP:
+                       return K_KP_PGUP;
+               case K_LEFTARROW:
+                       return K_KP_LEFTARROW;
+               case K_RIGHTARROW:
+                       return K_KP_RIGHTARROW;
+               case K_END:
+                       return K_KP_END;
+               case K_DOWNARROW:
+                       return K_KP_DOWNARROW;
+               case K_PGDN:
+                       return K_KP_PGDN;
+               case K_INS:
+                       return K_KP_INS;
+               case K_DEL:
+                       return K_KP_DEL;
+               default:
+                       return result;
+               }
+       }
+       else
+       {
+               switch ( result )
+               {
+               case 0x0D:
+                       return K_KP_ENTER;
+               case 0x2F:
+                       return K_KP_SLASH;
+               case 0xAF:
+                       return K_KP_PLUS;
+               }
+               return result;
+       }

 }
 
 /*
 }
 
 /*