--- /dev/null
+/* SCCS Id: @(#)nhdefkey.c 3.4 $Date$ */
+/* Copyright (c) NetHack PC Development Team 2003 */
+/* NetHack may be freely redistributed. See license for details. */
+
+/*
+ * This is the default NetHack keystroke processing.
+ * It can be built as a run-time loadable dll (nhdefkey.dll).
+ * Alternative keystroke handlers can be built using the
+ * entry points in this file as a template.
+ *
+ * Use the defaults.nh "altkeyhandler" option to set a
+ * different dll name (without the ".DLL" extension) to
+ * get different processing. Ensure that the dll referenced
+ * in defaults.nh exists in the same directory as NetHack in
+ * order for it to load successfully.
+ *
+ */
+
+static char where_to_get_source[] = "http://www.nethack.org/";
+static char author[] = "The NetHack Development Team";
+
+#include "hack.h"
+#include "wintty.h"
+#include "win32api.h"
+
+extern HANDLE hConIn;
+extern INPUT_RECORD ir;
+char dllname[512];
+char *shortdllname;
+
+static INPUT_RECORD bogus_key;
+
+int WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved)
+{
+ char dlltmpname[512];
+ char *tmp = dlltmpname, *tmp2;
+ *(tmp + GetModuleFileName(hInstance, tmp, 511)) = '\0';
+ (void)strcpy(dllname, tmp);
+ tmp2 = strrchr(dllname, '\\');
+ if (tmp2) {
+ tmp2++;
+ shortdllname = tmp2;
+ }
+ /* A bogus key that will be filtered when received, to keep ReadConsole
+ * from blocking */
+ bogus_key.EventType = KEY_EVENT;
+ bogus_key.Event.KeyEvent.bKeyDown = 1;
+ bogus_key.Event.KeyEvent.wRepeatCount = 1;
+ bogus_key.Event.KeyEvent.wVirtualKeyCode = 0;
+ bogus_key.Event.KeyEvent.wVirtualScanCode = 0;
+ bogus_key.Event.KeyEvent.uChar.AsciiChar = (uchar)0x80;
+ bogus_key.Event.KeyEvent.dwControlKeyState = 0;
+ return TRUE;
+}
+
+/*
+ * Keyboard translation tables.
+ * (Adopted from the MSDOS port)
+ */
+
+#define KEYPADLO 0x47
+#define KEYPADHI 0x53
+
+#define PADKEYS (KEYPADHI - KEYPADLO + 1)
+#define iskeypad(x) (KEYPADLO <= (x) && (x) <= KEYPADHI)
+#define isnumkeypad(x) (KEYPADLO <= (x) && (x) <= 0x51 && (x) != 0x4A && (x) != 0x4E)
+
+/*
+ * Keypad keys are translated to the normal values below.
+ * Shifted keypad keys are translated to the
+ * shift values below.
+ */
+
+static const struct pad {
+ uchar normal, shift, cntrl;
+} keypad[PADKEYS] = {
+ {'y', 'Y', C('y')}, /* 7 */
+ {'k', 'K', C('k')}, /* 8 */
+ {'u', 'U', C('u')}, /* 9 */
+ {'m', C('p'), C('p')}, /* - */
+ {'h', 'H', C('h')}, /* 4 */
+ {'g', 'G', 'g'}, /* 5 */
+ {'l', 'L', C('l')}, /* 6 */
+ {'+', 'P', C('p')}, /* + */
+ {'b', 'B', C('b')}, /* 1 */
+ {'j', 'J', C('j')}, /* 2 */
+ {'n', 'N', C('n')}, /* 3 */
+ {'i', 'I', C('i')}, /* Ins */
+ {'.', ':', ':'} /* Del */
+}, numpad[PADKEYS] = {
+ {'7', M('7'), '7'}, /* 7 */
+ {'8', M('8'), '8'}, /* 8 */
+ {'9', M('9'), '9'}, /* 9 */
+ {'m', C('p'), C('p')}, /* - */
+ {'4', M('4'), '4'}, /* 4 */
+ {'g', 'G', 'g'}, /* 5 */
+ {'6', M('6'), '6'}, /* 6 */
+ {'+', 'P', C('p')}, /* + */
+ {'1', M('1'), '1'}, /* 1 */
+ {'2', M('2'), '2'}, /* 2 */
+ {'3', M('3'), '3'}, /* 3 */
+ {'i', 'I', C('i')}, /* Ins */
+ {'.', ':', ':'} /* Del */
+};
+
+#define inmap(x,vk) (((x) > 'A' && (x) < 'Z') || (vk) == 0xBF || (x) == '2')
+
+/* Use process_keystroke for key commands, process_keystroke2 for prompts */
+/* int FDECL(process_keystroke, (INPUT_RECORD *ir, boolean *valid, int portdebug)); */
+int FDECL(process_keystroke2, (HANDLE,INPUT_RECORD *ir, boolean *valid));
+static int FDECL(is_altseq, (unsigned long shiftstate));
+
+static int
+is_altseq(shiftstate)
+unsigned long shiftstate;
+{
+ /* We need to distinguish the Alt keys from the AltGr key.
+ * On NT-based Windows, AltGr signals as right Alt and left Ctrl together;
+ * on 95-based Windows, AltGr signals as right Alt only.
+ * So on NT, we signal Alt if either Alt is pressed and left Ctrl is not,
+ * and on 95, we signal Alt for left Alt only. */
+ switch (shiftstate & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED | LEFT_CTRL_PRESSED)) {
+ case LEFT_ALT_PRESSED:
+ case LEFT_ALT_PRESSED | LEFT_CTRL_PRESSED:
+ return 1;
+
+ case RIGHT_ALT_PRESSED:
+ case RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED:
+ return (GetVersion() & 0x80000000) == 0;
+
+ default:
+ return 0;
+ }
+}
+
+int __declspec(dllexport) __stdcall
+ProcessKeystroke(hConIn, ir, valid, numberpad, portdebug)
+HANDLE hConIn;
+INPUT_RECORD *ir;
+boolean *valid;
+boolean numberpad;
+int portdebug;
+{
+ int metaflags = 0, k = 0;
+ int keycode, vk;
+ unsigned char ch, pre_ch, mk = 0;
+ unsigned short int scan;
+ unsigned long shiftstate;
+ int altseq = 0;
+ const struct pad *kpad;
+ DWORD count;
+
+ shiftstate = 0L;
+ ch = pre_ch = ir->Event.KeyEvent.uChar.AsciiChar;
+ scan = ir->Event.KeyEvent.wVirtualScanCode;
+ vk = ir->Event.KeyEvent.wVirtualKeyCode;
+ keycode = MapVirtualKey(vk, 2);
+ shiftstate = ir->Event.KeyEvent.dwControlKeyState;
+ if (scan == 0 && vk == 0) {
+ /* It's the bogus_key */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ *valid = FALSE;
+ return 0;
+ }
+
+ if (is_altseq(shiftstate)) {
+ if (ch || inmap(keycode,vk)) altseq = 1;
+ else altseq = -1; /* invalid altseq */
+ }
+ if (ch || (iskeypad(scan)) || (altseq > 0))
+ *valid = TRUE;
+ /* if (!valid) return 0; */
+ /*
+ * shiftstate can be checked to see if various special
+ * keys were pressed at the same time as the key.
+ * Currently we are using the ALT & SHIFT & CONTROLS.
+ *
+ * RIGHT_ALT_PRESSED, LEFT_ALT_PRESSED,
+ * RIGHT_CTRL_PRESSED, LEFT_CTRL_PRESSED,
+ * SHIFT_PRESSED,NUMLOCK_ON, SCROLLLOCK_ON,
+ * CAPSLOCK_ON, ENHANCED_KEY
+ *
+ * are all valid bit masks to use on shiftstate.
+ * eg. (shiftstate & LEFT_CTRL_PRESSED) is true if the
+ * left control key was pressed with the keystroke.
+ */
+ if (iskeypad(scan)) {
+ ReadConsoleInput(hConIn,ir,1,&count);
+ kpad = numberpad ? numpad : keypad;
+ if (shiftstate & SHIFT_PRESSED) {
+ ch = kpad[scan - KEYPADLO].shift;
+ }
+ else if (shiftstate & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) {
+ ch = kpad[scan - KEYPADLO].cntrl;
+ }
+ else {
+ ch = kpad[scan - KEYPADLO].normal;
+ }
+ }
+ else if (altseq > 0) { /* ALT sequence */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ if (vk == 0xBF) ch = M('?');
+ else ch = M(tolower(keycode));
+ }
+ else if (ch < 32 && !isnumkeypad(scan)) {
+ /* Control code; ReadConsole seems to filter some of these,
+ * including ESC */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ }
+ /* Attempt to work better with international keyboards. */
+ else {
+ CHAR ch2;
+ DWORD written;
+ /* The bogus_key guarantees that ReadConsole will return,
+ * and does not itself do anything */
+ WriteConsoleInput(hConIn, &bogus_key, 1, &written);
+ ReadConsole(hConIn,&ch2,1,&count,NULL);
+ /* Prevent high characters from being interpreted as alt
+ * sequences; also filter the bogus_key */
+ if (ch2 & 0x80)
+ *valid = FALSE;
+ else
+ ch = ch2;
+ if (ch == 0) *valid = FALSE;
+ }
+ if (ch == '\r') ch = '\n';
+#ifdef PORT_DEBUG
+ if (portdebug) {
+ char buf[BUFSZ];
+ Sprintf(buf,
+ "PORTDEBUG: ch=%u, scan=%u, vk=%d, pre=%d, shiftstate=0x%X (ESC to end)\n",
+ ch, scan, vk, pre_ch, shiftstate);
+ fprintf(stdout, "\n%s", buf);
+ }
+#endif
+ return ch;
+}
+
+int process_keystroke2(hConIn, ir, valid)
+HANDLE hConIn;
+INPUT_RECORD *ir;
+boolean *valid;
+{
+ /* Use these values for the numeric keypad */
+ static const char keypad_nums[] = "789-456+1230.";
+
+ unsigned char ch;
+ int vk;
+ unsigned short int scan;
+ unsigned long shiftstate;
+ int altseq;
+ DWORD count;
+
+ ch = ir->Event.KeyEvent.uChar.AsciiChar;
+ vk = ir->Event.KeyEvent.wVirtualKeyCode;
+ scan = ir->Event.KeyEvent.wVirtualScanCode;
+ shiftstate = ir->Event.KeyEvent.dwControlKeyState;
+
+ if (scan == 0 && vk == 0) {
+ /* It's the bogus_key */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ *valid = FALSE;
+ return 0;
+ }
+
+ altseq = is_altseq(shiftstate);
+ if (ch || (iskeypad(scan)) || altseq)
+ *valid = TRUE;
+ /* if (!valid) return 0; */
+ /*
+ * shiftstate can be checked to see if various special
+ * keys were pressed at the same time as the key.
+ * Currently we are using the ALT & SHIFT & CONTROLS.
+ *
+ * RIGHT_ALT_PRESSED, LEFT_ALT_PRESSED,
+ * RIGHT_CTRL_PRESSED, LEFT_CTRL_PRESSED,
+ * SHIFT_PRESSED,NUMLOCK_ON, SCROLLLOCK_ON,
+ * CAPSLOCK_ON, ENHANCED_KEY
+ *
+ * are all valid bit masks to use on shiftstate.
+ * eg. (shiftstate & LEFT_CTRL_PRESSED) is true if the
+ * left control key was pressed with the keystroke.
+ */
+ if (iskeypad(scan) && !altseq) {
+ ReadConsoleInput(hConIn,ir,1,&count);
+ ch = keypad_nums[scan - KEYPADLO];
+ }
+ else if (ch < 32 && !isnumkeypad(scan)) {
+ /* Control code; ReadConsole seems to filter some of these,
+ * including ESC */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ }
+ /* Attempt to work better with international keyboards. */
+ else {
+ CHAR ch2;
+ ReadConsole(hConIn,&ch2,1,&count,NULL);
+ ch = ch2 & 0xFF;
+ if (ch == 0) *valid = FALSE;
+ }
+ if (ch == '\r') ch = '\n';
+ return ch;
+}
+
+int __declspec(dllexport) __stdcall
+CheckInput(hConIn, ir, count, numpad, mode, mod, cc)
+HANDLE hConIn;
+INPUT_RECORD *ir;
+int *count, *mod;
+boolean numpad;
+coord *cc;
+{
+ int ch;
+ boolean valid = 0, done = 0;
+ while (!done) {
+ *count = 0;
+ WaitForSingleObject(hConIn, INFINITE);
+ PeekConsoleInput(hConIn,ir,1,count);
+ if (mode == 0) {
+ if ((ir->EventType == KEY_EVENT) && ir->Event.KeyEvent.bKeyDown) {
+ ch = process_keystroke2(hConIn, ir, &valid);
+ done = valid;
+ } else
+ ReadConsoleInput(hConIn,ir,1,count);
+ } else {
+ ch = 0;
+ if (count > 0) {
+ if (ir->EventType == KEY_EVENT && ir->Event.KeyEvent.bKeyDown) {
+ ch = ProcessKeystroke(hConIn, ir, &valid, numpad,
+#ifdef PORTDEBUG
+ 1);
+#else
+ 0);
+#endif
+ if (valid) return ch;
+ } else {
+ ReadConsoleInput(hConIn,ir,1,count);
+ if (ir->EventType == MOUSE_EVENT) {
+ if ((ir->Event.MouseEvent.dwEventFlags == 0) &&
+ (ir->Event.MouseEvent.dwButtonState & MOUSEMASK)) {
+ cc->x = ir->Event.MouseEvent.dwMousePosition.X + 1;
+ cc->y = ir->Event.MouseEvent.dwMousePosition.Y - 1;
+
+ if (ir->Event.MouseEvent.dwButtonState & LEFTBUTTON)
+ *mod = CLICK_1;
+ else if (ir->Event.MouseEvent.dwButtonState & RIGHTBUTTON)
+ *mod = CLICK_2;
+#if 0 /* middle button */
+ else if (ir->Event.MouseEvent.dwButtonState & MIDBUTTON)
+ *mod = CLICK_3;
+#endif
+ return 0;
+ }
+ }
+#if 0
+ /* We ignore these types of console events */
+ else if (ir->EventType == FOCUS_EVENT) {
+ }
+ else if (ir->EventType == MENU_EVENT) {
+ }
+#endif
+ }
+ } else
+ done = 1;
+ }
+ }
+ *mod = 0;
+ return ch;
+}
+
+int __declspec(dllexport) __stdcall
+NHkbhit(hConIn, ir)
+HANDLE hConIn;
+INPUT_RECORD *ir;
+{
+ int done = 0; /* true = "stop searching" */
+ int retval; /* true = "we had a match" */
+ DWORD count;
+ unsigned short int scan;
+ unsigned char ch;
+ unsigned long shiftstate;
+ int altseq = 0, keycode, vk;
+ done = 0;
+ retval = 0;
+ while (!done)
+ {
+ count = 0;
+ PeekConsoleInput(hConIn,ir,1,&count);
+ if (count > 0) {
+ if (ir->EventType == KEY_EVENT && ir->Event.KeyEvent.bKeyDown) {
+ ch = ir->Event.KeyEvent.uChar.AsciiChar;
+ scan = ir->Event.KeyEvent.wVirtualScanCode;
+ shiftstate = ir->Event.KeyEvent.dwControlKeyState;
+ vk = ir->Event.KeyEvent.wVirtualKeyCode;
+ keycode = MapVirtualKey(vk, 2);
+ if (is_altseq(shiftstate)) {
+ if (ch || inmap(keycode,vk)) altseq = 1;
+ else altseq = -1; /* invalid altseq */
+ }
+ if (ch || iskeypad(scan) || altseq) {
+ done = 1; /* Stop looking */
+ retval = 1; /* Found what we sought */
+ }
+ }
+ else if ((ir->EventType == MOUSE_EVENT &&
+ (ir->Event.MouseEvent.dwButtonState & MOUSEMASK))) {
+ done = 1;
+ retval = 1;
+ }
+
+ else /* Discard it, it's an insignificant event */
+ ReadConsoleInput(hConIn,ir,1,&count);
+ } else /* There are no events in console event queue */ {
+ done = 1; /* Stop looking */
+ retval = 0;
+ }
+ }
+ return retval;
+}
+
+
+int __declspec(dllexport) __stdcall
+SourceWhere(buf)
+char **buf;
+{
+ if (!buf) return 0;
+ *buf = where_to_get_source;
+ return 1;
+}
+
+int __declspec(dllexport) __stdcall
+SourceAuthor(buf)
+char **buf;
+{
+ if (!buf) return 0;
+ *buf = author;
+ return 1;
+}
+
+int __declspec(dllexport) __stdcall
+KeyHandlerName(buf, full)
+char **buf;
+int full;
+{
+ if (!buf) return 0;
+ if (full) *buf = dllname;
+ else *buf = shortdllname;
+ return 1;
+}
+
projects / nethack / commitdiff