curses 1.3.0 → 1.4.2

data/vendor/PDCurses/wingui/pdcgetsc.c

@@ -0,0 +1,30 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+
+/* get the cursor size/shape */
+
+int PDC_get_cursor_mode(void)
+{
+    PDC_LOG(("PDC_get_cursor_mode() - called\n"));
+
+    return SP->visibility;
+}
+
+/* return number of screen rows */
+
+int PDC_get_rows(void)
+{
+    extern int PDC_n_rows;
+
+    PDC_LOG(("PDC_get_rows() - called\n"));
+    return( PDC_n_rows);
+}
+
+int PDC_get_columns(void)
+{
+    extern int PDC_n_cols;
+
+    PDC_LOG(("PDC_get_columns() - called\n"));
+    return( PDC_n_cols);
+}

data/vendor/PDCurses/wingui/pdckbd.c

@@ -0,0 +1,143 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+#include <tchar.h>
+
+/*man-start**************************************************************
+
+  Name:                                                         pdckbd
+
+  Synopsis:
+        unsigned long PDC_get_input_fd(void);
+
+  Description:
+        PDC_get_input_fd() returns the file descriptor that PDCurses
+        reads its input from. It can be used for select().  (For the
+        WinGUI version,  it's meaningless and returns zero.)
+
+  Portability                                X/Open    BSD    SYS V
+        PDC_get_input_fd                        -       -       -
+
+**man-end****************************************************************/
+
+
+unsigned long PDC_get_input_fd(void)
+{
+    PDC_LOG(("PDC_get_input_fd() - called\n"));
+
+    return 0L;
+}
+
+void PDC_set_keyboard_binary(bool on)
+{
+    PDC_LOG(("PDC_set_keyboard_binary() - called\n"));
+}
+
+/* check if a key or mouse event is waiting */
+
+#define KEY_QUEUE_SIZE    30
+
+extern int PDC_key_queue_low, PDC_key_queue_high;
+extern int PDC_key_queue[KEY_QUEUE_SIZE];
+static TCHAR *clipboard_contents;
+static long clipboard_len;
+
+int PDC_getclipboard_handle( HANDLE *handle);      /* pdcclip.c */
+
+      /* When copying the clipboard contents for use in the key */
+      /* queue,  we leave out the line feeds.  We also don't do */
+      /* it at all if 'clipboard_contents' is already full.     */
+void PDC_add_clipboard_to_key_queue( void)
+{
+    long i, j;
+    HANDLE handle;
+
+    if( !clipboard_contents)
+        if( PDC_getclipboard_handle( &handle) == PDC_CLIP_SUCCESS)
+        {
+#ifdef PDC_WIDE
+            const long len = (long)wcslen((wchar_t *)handle);
+#else
+            const long len = (long)strlen((char *)handle);
+#endif
+
+            clipboard_contents = (TCHAR *)calloc( len + 1, sizeof( TCHAR));
+            memcpy( clipboard_contents, (TCHAR *)handle, (len + 1) * sizeof( TCHAR));
+            CloseClipboard( );
+            for( i = j = 0; i < len; i++)
+                if( clipboard_contents[i] != 10)
+                    clipboard_contents[j++] = clipboard_contents[i];
+            clipboard_len = j;
+        }
+}
+
+/* PDCurses message/event callback */
+/* Calling PDC_napms for one millisecond ensures that the message loop */
+/* is called and messages in general,  and keyboard events in particular, */
+/* get processed.   */
+
+bool PDC_check_key(void)
+{
+    PDC_napms( 1);
+    if( PDC_key_queue_low != PDC_key_queue_high || clipboard_len)
+        return TRUE;
+    return FALSE;
+}
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    int rval = -1;
+
+    if( PDC_key_queue_low != PDC_key_queue_high)
+    {
+        rval = PDC_key_queue[PDC_key_queue_low++];
+        if( PDC_key_queue_low == KEY_QUEUE_SIZE)
+            PDC_key_queue_low = 0;
+    }
+    else if( clipboard_len)
+    {
+        rval = *clipboard_contents;
+        clipboard_len--;
+        memmove( clipboard_contents, clipboard_contents + 1, clipboard_len * sizeof( TCHAR));
+        if( !clipboard_len)
+        {
+            free( clipboard_contents);
+            clipboard_contents = NULL;
+        }
+    }
+
+    SP->key_code = (rval >= KEY_MIN && rval <= KEY_MAX);
+    return rval;
+}
+
+/* discard any pending keyboard or mouse input -- this is the core
+   routine for flushinp() */
+
+void PDC_flushinp(void)
+{
+    PDC_LOG(("PDC_flushinp() - called\n"));
+    PDC_key_queue_low = PDC_key_queue_high = 0;
+    if( clipboard_len)
+    {
+        free( clipboard_contents);
+        clipboard_contents = NULL;
+        clipboard_len = 0;
+    }
+}
+
+int PDC_mouse_set(void)
+{
+    /* If turning on mouse input: Set ENABLE_MOUSE_INPUT, and clear
+       all other flags, including the extended flags;
+       If turning off the mouse: Set QuickEdit Mode to the status it
+       had on startup, and clear all other flags */
+
+    return OK;
+}
+
+int PDC_modifiers_set(void)
+{
+    return OK;
+}

data/vendor/PDCurses/wingui/pdcscrn.c

@@ -0,0 +1,2797 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+#include <tchar.h>
+#include <stdint.h>
+#include <assert.h>
+
+/* COLOR_PAIR to attribute encoding table. */
+
+static short *color_pair_indices = (short *)NULL;
+COLORREF *pdc_rgbs = (COLORREF *)NULL;
+static int menu_shown = 1;
+static int min_lines = 25, max_lines = 25;
+static int min_cols = 80, max_cols = 80;
+
+#if defined( CHTYPE_LONG) && CHTYPE_LONG >= 2 && defined( PDC_WIDE)
+    #define USING_COMBINING_CHARACTER_SCHEME
+    int PDC_expand_combined_characters( const cchar_t c, cchar_t *added);  /* addch.c */
+#endif
+
+/* Some older versions of Microsoft C/C++ don't understand about
+inlined functions.  Until we puzzle out which ones do and which
+don't,  we'll just leave "inlined" functions as plain old static
+functions.        */
+
+#ifdef _MSC_VER
+#define INLINE static
+#else
+#define INLINE static inline
+#endif
+
+static int keep_size_within_bounds( int *lines, int *cols);
+INLINE int set_default_sizes_from_registry( const int n_cols, const int n_rows,
+               const int xloc, const int yloc, const int menu_shown);
+void PDC_transform_line_given_hdc( const HDC hdc, const int lineno,
+                             int x, int len, const chtype *srcp);
+
+#define N_COLORS 256
+
+#ifdef A_OVERLINE
+#define A_ALL_LINES (A_UNDERLINE | A_LEFTLINE | A_RIGHTLINE | A_OVERLINE | A_STRIKEOUT)
+#else
+#define A_ALL_LINES (A_UNDERLINE | A_LEFTLINE | A_RIGHTLINE)
+#endif
+
+   /* If PDC_MAX_MOUSE_BUTTONS is undefined,  it means the user hasn't     */
+   /* gotten a current 'curses.h' in which five-button mice are supported. */
+   /* To handle this gracefully,  we'll just fall back to three buttons.   */
+
+#ifndef PDC_MAX_MOUSE_BUTTONS
+   #define PDC_MAX_MOUSE_BUTTONS 3
+#endif
+
+#define VERTICAL_WHEEL_EVENT      PDC_MAX_MOUSE_BUTTONS
+#define HORIZONTAL_WHEEL_EVENT   (PDC_MAX_MOUSE_BUTTONS + 1)
+
+unsigned long pdc_key_modifiers = 0L;
+int PDC_show_ctrl_alts = 0;
+
+/* RR: Removed statis on next line */
+bool PDC_bDone = FALSE;
+static HWND originally_focussed_window;
+
+int debug_printf( const char *format, ...)
+{
+    static bool debugging = TRUE;
+
+    if( debugging)
+    {
+        const char *output_filename = getenv( "PDC_DEBUG");
+
+        if( !output_filename)
+            debugging = FALSE;       /* don't bother trying again */
+        else
+        {
+            FILE *ofile = fopen( output_filename, "a");
+
+            if( ofile)
+            {
+                va_list argptr;
+                va_start( argptr, format);
+                vfprintf( ofile, format, argptr);
+                va_end( argptr);
+                fclose( ofile);
+            }
+            else
+            {
+                printf( "Opening '%s' failed\n", output_filename);
+                exit( 0);
+                debugging = FALSE;       /* don't bother trying again */
+            }
+        }
+    }
+    return( 0);
+}
+
+HWND PDC_hWnd;
+static int PDC_argc = 0;
+static char **PDC_argv = NULL;
+
+static void final_cleanup( void)
+{
+    debug_printf( "final_cleanup: SP = %p\n", SP);
+    if (SP)
+    {
+        RECT rect;
+
+        GetWindowRect( PDC_hWnd, &rect);
+        set_default_sizes_from_registry( SP->cols, SP->lines,
+                  rect.left, rect.top, menu_shown);
+    }
+    PDC_LOG(( "final_cleanup: freeing fonts\n"));
+    PDC_transform_line( 0, 0, 0, NULL);  /* free any fonts */
+    if( originally_focussed_window)
+        SetForegroundWindow( originally_focussed_window);
+    if( PDC_argc)
+    {
+        int i;
+
+        for( i = 0; i < PDC_argc; i++)
+            free( PDC_argv[i]);
+        free( PDC_argv);
+        PDC_argc = 0;
+        PDC_argv = NULL;
+    }
+#ifdef USING_COMBINING_CHARACTER_SCHEME
+    PDC_expand_combined_characters( 0, NULL);       /* free internal buffer */
+#endif
+    debug_printf( "reset foreground window\n");
+}
+
+void PDC_scr_close(void)
+{
+    PDC_LOG(("PDC_scr_close() - called\n"));
+    final_cleanup( );
+    PDC_bDone = TRUE;
+}
+
+/* NOTE that PDC_scr_free( ) is called only from delscreen( ),    */
+/* which is rarely called.  It appears that most programs simply  */
+/* rely on the memory getting freed when the program terminates.  */
+/* It seems conceivable to me that we could get into some trouble */
+/* here,  if SP is freed and NULLed,  but then accessed again,    */
+/* possibly within the WinGUI window thread.                      */
+
+void PDC_scr_free(void)
+{
+    if (SP)
+        free(SP);
+    SP = (SCREEN *)NULL;
+
+    if (color_pair_indices)
+        free(color_pair_indices);
+    color_pair_indices = (short *)NULL;
+
+    if (pdc_rgbs)
+        free(pdc_rgbs);
+    pdc_rgbs = (COLORREF *)NULL;
+}
+
+int PDC_choose_a_new_font( void);                     /* pdcdisp.c */
+void PDC_add_clipboard_to_key_queue( void);           /* pdckbd.c */
+
+#define KEY_QUEUE_SIZE    30
+
+       /* By default,  the PDC_shutdown_key[] array contains 0       */
+       /* (i.e., there's no key that's supposed to be returned for   */
+       /* exit handling), and 22 = Ctrl-V (i.e.,  hit Ctrl-V to      */
+       /* paste text from the clipboard into the key queue);  then   */
+       /* Ctl-= (enlarge font) and Ctl-Minus (decrease font);  then  */
+       /* Ctl-, (select font from dialog).                           */
+
+static int PDC_shutdown_key[PDC_MAX_FUNCTION_KEYS] = { 0, 22, CTL_EQUAL, CTL_MINUS,
+                                 CTL_COMMA };
+int PDC_n_rows, PDC_n_cols;
+int PDC_cxChar, PDC_cyChar, PDC_key_queue_low = 0, PDC_key_queue_high = 0;
+int PDC_key_queue[KEY_QUEUE_SIZE];
+
+   /* If the following is true,  you can enter Unicode values by hitting */
+   /* Alt and holding it down while typing the value of the character on */
+   /* the numeric keypad (for decimal entry);  _or_ you can hit Alt-Padplus */
+   /* and then enter a hex value,  while holding down the Alt key.  In   */
+   /* either case,  when you release the Alt key,  the Unicode character */
+   /* is added to the queue.  For hex entry,  0-9 can come either from   */
+   /* the numeric keypad or the "usual" keyboard.                        */
+bool PDC_allow_numpad_unicode = TRUE;
+static int numpad_unicode_value = 0;
+
+static void adjust_font_size( const int font_size_change);
+
+static void add_key_to_queue( const int new_key)
+{
+    const int new_idx = ((PDC_key_queue_high + 1) % KEY_QUEUE_SIZE);
+                /* This is usually 10,  but is set to 16 if the user   */
+                /* hits ALT_PADPLUS and is about to enter a hex value: */
+    static int unicode_radix = 10;
+
+    if( PDC_allow_numpad_unicode)
+    {
+        int digit = -1;
+
+        if( new_key >= ALT_PAD0 && new_key <= ALT_PAD9)
+            digit = new_key - ALT_PAD0;
+                  /* In hex Unicode entry,  you can enter digits on both */
+                  /* the numeric and "standard" keyboards :              */
+        if( unicode_radix == 16 && new_key >= ALT_0 && new_key <= ALT_9)
+            digit = new_key - ALT_0;
+        if( unicode_radix == 16 && new_key >= ALT_A && new_key <= ALT_F)
+            digit = new_key - ALT_A + 10;
+        if( digit >= 0)
+        {
+            numpad_unicode_value = numpad_unicode_value * unicode_radix + digit;
+            return;
+        }
+        if( new_key == ALT_PADPLUS)
+        {                            /* signal to begin hex Unicode entry */
+            unicode_radix = 16;
+            return;
+        }
+    }
+    unicode_radix = 10;
+    if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_PASTE])
+        PDC_add_clipboard_to_key_queue( );
+    else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_ABORT])
+        exit( -1);
+    else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_ENLARGE_FONT])
+        adjust_font_size( 1);
+    else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_SHRINK_FONT])
+        adjust_font_size( -1);
+    else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_CHOOSE_FONT])
+    {
+        if( PDC_choose_a_new_font( ))
+            adjust_font_size( 0);
+    }
+    else if( new_idx != PDC_key_queue_low)
+    {
+        PDC_key_queue[PDC_key_queue_high] = new_key;
+        PDC_key_queue_high = new_idx;
+    }
+}
+
+/************************************************************************
+ *    Table for key code translation of function keys in keypad mode    *
+ *    These values are for strict IBM keyboard compatibles only         *
+ ************************************************************************/
+
+typedef struct
+{
+    unsigned short normal;
+    unsigned short shift;
+    unsigned short control;
+    unsigned short alt;
+    unsigned short extended;
+} KPTAB;
+
+
+static const KPTAB kptab[] =
+{
+    {0,          0,         0,           0,          0   }, /* 0  */
+    {0,          0,         0,           0,          0   }, /* 1   VK_LBUTTON */
+    {0,          0,         0,           0,          0   }, /* 2   VK_RBUTTON */
+    {CTL_PAUSE,  'a',       'b',         'c',        0   }, /* 3   VK_CANCEL  */
+    {0,          0,         0,           0,          0   }, /* 4   VK_MBUTTON */
+    {0,          0,         0,           0,          0   }, /* 5   */
+    {0,          0,         0,           0,          0   }, /* 6   */
+    {0,          0,         0,           0,          0   }, /* 7   */
+    {0x08,       0x08,      0x7F,        ALT_BKSP,   0   }, /* 8   VK_BACK    */
+    {0x09,       KEY_BTAB,  CTL_TAB,     ALT_TAB,    999 }, /* 9   VK_TAB     */
+    {0,          0,         0,           0,          0   }, /* 10  */
+    {0,          0,         0,           0,          0   }, /* 11  */
+    {KEY_B2,     0x35,      CTL_PAD5,    ALT_PAD5,   0   }, /* 12  VK_CLEAR   */
+    {0x0D,       0x0D,      CTL_ENTER,   ALT_ENTER,  1   }, /* 13  VK_RETURN  */
+    {0,          0,         0,           0,          0   }, /* 14  */
+    {0,          0,         0,           0,          0   }, /* 15  */
+    {0,          0,         0,           0,          0   }, /* 16  VK_SHIFT   HANDLED SEPARATELY */
+    {0,          0,         0,           0,          0   }, /* 17  VK_CONTROL HANDLED SEPARATELY */
+    {0,          0,         0,           0,          0   }, /* 18  VK_MENU    HANDLED SEPARATELY */
+    {KEY_PAUSE,  KEY_SPAUSE,CTL_PAUSE,   0,          0   }, /* 19  VK_PAUSE   */
+    {0,          0,         0,           0,          0   }, /* 20  VK_CAPITAL HANDLED SEPARATELY */
+    {0,          0,         0,           0,          0   }, /* 21  VK_HANGUL  */
+    {0,          0,         0,           0,          0   }, /* 22  */
+    {0,          0,         0,           0,          0   }, /* 23  VK_JUNJA   */
+    {0,          0,         0,           0,          0   }, /* 24  VK_FINAL   */
+    {0,          0,         0,           0,          0   }, /* 25  VK_HANJA   */
+    {0,          0,         0,           0,          0   }, /* 26  */
+    {0x1B,       0x1B,      0x1B,        ALT_ESC,    0   }, /* 27  VK_ESCAPE  */
+    {0,          0,         0,           0,          0   }, /* 28  VK_CONVERT */
+    {0,          0,         0,           0,          0   }, /* 29  VK_NONCONVERT */
+    {0,          0,         0,           0,          0   }, /* 30  VK_ACCEPT  */
+    {0,          0,         0,           0,          0   }, /* 31  VK_MODECHANGE */
+    {0x20,       0x20,      0x20,        0x20,       0   }, /* 32  VK_SPACE   */
+    {KEY_A3,     0x39,      CTL_PAD9,    ALT_PAD9,   3   }, /* 33  VK_PRIOR   */
+    {KEY_C3,     0x33,      CTL_PAD3,    ALT_PAD3,   4   }, /* 34  VK_NEXT    */
+    {KEY_C1,     0x31,      CTL_PAD1,    ALT_PAD1,   5   }, /* 35  VK_END     */
+    {KEY_A1,     0x37,      CTL_PAD7,    ALT_PAD7,   6   }, /* 36  VK_HOME    */
+    {KEY_B1,     0x34,      CTL_PAD4,    ALT_PAD4,   7   }, /* 37  VK_LEFT    */
+    {KEY_A2,     0x38,      CTL_PAD8,    ALT_PAD8,   8   }, /* 38  VK_UP      */
+    {KEY_B3,     0x36,      CTL_PAD6,    ALT_PAD6,   9   }, /* 39  VK_RIGHT   */
+    {KEY_C2,     0x32,      CTL_PAD2,    ALT_PAD2,   10  }, /* 40  VK_DOWN    */
+    {0,          0,         0,           0,          0   }, /* 41  VK_SELECT  */
+    {0,          0,         0,           0,          0   }, /* 42  VK_PRINT   */
+    {0,          0,         0,           0,          0   }, /* 43  VK_EXECUTE */
+    {KEY_PRINTSCREEN, 0,    0,       ALT_PRINTSCREEN, 0  }, /* 44  VK_SNAPSHOT*/
+    {PAD0,       0x30,      CTL_PAD0,    ALT_PAD0,   11  }, /* 45  VK_INSERT  */
+    {PADSTOP,    0x2E,      CTL_PADSTOP, ALT_PADSTOP,12  }, /* 46  VK_DELETE  */
+    {0,          0,         0,           0,          0   }, /* 47  VK_HELP    */
+    {0x30,       0x29,      CTL_0,       ALT_0,      0   }, /* 48  */
+    {0x31,       0x21,      CTL_1,       ALT_1,      0   }, /* 49  */
+    {0x32,       0x40,      CTL_2,       ALT_2,      0   }, /* 50  */
+    {0x33,       0x23,      CTL_3,       ALT_3,      0   }, /* 51  */
+    {0x34,       0x24,      CTL_4,       ALT_4,      0   }, /* 52  */
+    {0x35,       0x25,      CTL_5,       ALT_5,      0   }, /* 53  */
+    {0x36,       0x5E,      CTL_6,       ALT_6,      0   }, /* 54  */
+    {0x37,       0x26,      CTL_7,       ALT_7,      0   }, /* 55  */
+    {0x38,       0x2A,      CTL_8,       ALT_8,      0   }, /* 56  */
+    {0x39,       0x28,      CTL_9,       ALT_9,      0   }, /* 57  */
+    {0,          0,         0,           0,          0   }, /* 58  */
+    {0,          0,         0,           0,          0   }, /* 59  */
+    {0,          0,         0,           0,          0   }, /* 60  */
+    {0,          0,         0,           0,          0   }, /* 61  */
+    {0,          0,         0,           0,          0   }, /* 62  */
+    {0,          0,         0,           0,          0   }, /* 63  */
+    {0,          0,         0,           0,          0   }, /* 64  */
+    {0x61,       0x41,      0x01,        ALT_A,      0   }, /* 65  */
+    {0x62,       0x42,      0x02,        ALT_B,      0   }, /* 66  */
+    {0x63,       0x43,      0x03,        ALT_C,      0   }, /* 67  */
+    {0x64,       0x44,      0x04,        ALT_D,      0   }, /* 68  */
+    {0x65,       0x45,      0x05,        ALT_E,      0   }, /* 69  */
+    {0x66,       0x46,      0x06,        ALT_F,      0   }, /* 70  */
+    {0x67,       0x47,      0x07,        ALT_G,      0   }, /* 71  */
+    {0x68,       0x48,      0x08,        ALT_H,      0   }, /* 72  */
+    {0x69,       0x49,      0x09,        ALT_I,      0   }, /* 73  */
+    {0x6A,       0x4A,      0x0A,        ALT_J,      0   }, /* 74  */
+    {0x6B,       0x4B,      0x0B,        ALT_K,      0   }, /* 75  */
+    {0x6C,       0x4C,      0x0C,        ALT_L,      0   }, /* 76  */
+    {0x6D,       0x4D,      0x0D,        ALT_M,      0   }, /* 77  */
+    {0x6E,       0x4E,      0x0E,        ALT_N,      0   }, /* 78  */
+    {0x6F,       0x4F,      0x0F,        ALT_O,      0   }, /* 79  */
+    {0x70,       0x50,      0x10,        ALT_P,      0   }, /* 80  */
+    {0x71,       0x51,      0x11,        ALT_Q,      0   }, /* 81  */
+    {0x72,       0x52,      0x12,        ALT_R,      0   }, /* 82  */
+    {0x73,       0x53,      0x13,        ALT_S,      0   }, /* 83  */
+    {0x74,       0x54,      0x14,        ALT_T,      0   }, /* 84  */
+    {0x75,       0x55,      0x15,        ALT_U,      0   }, /* 85  */
+    {0x76,       0x56,      0x16,        ALT_V,      0   }, /* 86  */
+    {0x77,       0x57,      0x17,        ALT_W,      0   }, /* 87  */
+    {0x78,       0x58,      0x18,        ALT_X,      0   }, /* 88  */
+    {0x79,       0x59,      0x19,        ALT_Y,      0   }, /* 89  */
+    {0x7A,       0x5A,      0x1A,        ALT_Z,      0   }, /* 90  */
+    {0,          0,         0,           0,          0   }, /* 91  VK_LWIN    */
+    {0,          0,         0,           0,          0   }, /* 92  VK_RWIN    */
+    {KEY_APPS,   KEY_SAPPS, CTL_APPS,    ALT_APPS,   13  }, /* 93  VK_APPS    */
+    {0,          0,         0,           0,          0   }, /* 94  */
+    {0,          0,         0,           0,          0   }, /* 95  */
+    {0x30,       0,         CTL_PAD0,    ALT_PAD0,   0   }, /* 96  VK_NUMPAD0 */
+    {0x31,       0,         CTL_PAD1,    ALT_PAD1,   0   }, /* 97  VK_NUMPAD1 */
+    {0x32,       0,         CTL_PAD2,    ALT_PAD2,   0   }, /* 98  VK_NUMPAD2 */
+    {0x33,       0,         CTL_PAD3,    ALT_PAD3,   0   }, /* 99  VK_NUMPAD3 */
+    {0x34,       0,         CTL_PAD4,    ALT_PAD4,   0   }, /* 100 VK_NUMPAD4 */
+    {0x35,       0,         CTL_PAD5,    ALT_PAD5,   0   }, /* 101 VK_NUMPAD5 */
+    {0x36,       0,         CTL_PAD6,    ALT_PAD6,   0   }, /* 102 VK_NUMPAD6 */
+    {0x37,       0,         CTL_PAD7,    ALT_PAD7,   0   }, /* 103 VK_NUMPAD7 */
+    {0x38,       0,         CTL_PAD8,    ALT_PAD8,   0   }, /* 104 VK_NUMPAD8 */
+    {0x39,       0,         CTL_PAD9,    ALT_PAD9,   0   }, /* 105 VK_NUMPAD9 */
+    {PADSTAR,   SHF_PADSTAR,CTL_PADSTAR, ALT_PADSTAR,999 }, /* 106 VK_MULTIPLY*/
+    {PADPLUS,   SHF_PADPLUS,CTL_PADPLUS, ALT_PADPLUS,999 }, /* 107 VK_ADD     */
+    {0,          0,         0,           0,          0   }, /* 108 VK_SEPARATOR     */
+    {PADMINUS, SHF_PADMINUS,CTL_PADMINUS,ALT_PADMINUS,999}, /* 109 VK_SUBTRACT*/
+    {0x2E,       0,         CTL_PADSTOP, ALT_PADSTOP,0   }, /* 110 VK_DECIMAL */
+    {PADSLASH,  SHF_PADSLASH,CTL_PADSLASH,ALT_PADSLASH,2 }, /* 111 VK_DIVIDE  */
+    {KEY_F(1),   KEY_F(13), KEY_F(25),   KEY_F(37),  0   }, /* 112 VK_F1      */
+    {KEY_F(2),   KEY_F(14), KEY_F(26),   KEY_F(38),  0   }, /* 113 VK_F2      */
+    {KEY_F(3),   KEY_F(15), KEY_F(27),   KEY_F(39),  0   }, /* 114 VK_F3      */
+    {KEY_F(4),   KEY_F(16), KEY_F(28),   KEY_F(40),  0   }, /* 115 VK_F4      */
+    {KEY_F(5),   KEY_F(17), KEY_F(29),   KEY_F(41),  0   }, /* 116 VK_F5      */
+    {KEY_F(6),   KEY_F(18), KEY_F(30),   KEY_F(42),  0   }, /* 117 VK_F6      */
+    {KEY_F(7),   KEY_F(19), KEY_F(31),   KEY_F(43),  0   }, /* 118 VK_F7      */
+    {KEY_F(8),   KEY_F(20), KEY_F(32),   KEY_F(44),  0   }, /* 119 VK_F8      */
+    {KEY_F(9),   KEY_F(21), KEY_F(33),   KEY_F(45),  0   }, /* 120 VK_F9      */
+    {KEY_F(10),  KEY_F(22), KEY_F(34),   KEY_F(46),  0   }, /* 121 VK_F10     */
+    {KEY_F(11),  KEY_F(23), KEY_F(35),   KEY_F(47),  0   }, /* 122 VK_F11     */
+    {KEY_F(12),  KEY_F(24), KEY_F(36),   KEY_F(48),  0   }, /* 123 VK_F12     */
+
+    /* 124 through 218 */
+
+    {0, 0, 0, 0, 0},  /* 124 VK_F13 */
+    {0, 0, 0, 0, 0},  /* 125 VK_F14 */
+    {0, 0, 0, 0, 0},  /* 126 VK_F15 */
+    {0, 0, 0, 0, 0},  /* 127 VK_F16 */
+    {0, 0, 0, 0, 0},  /* 128 VK_F17 */
+    {0, 0, 0, 0, 0},  /* 129 VK_F18 */
+    {0, 0, 0, 0, 0},  /* 130 VK_F19 */
+    {0, 0, 0, 0, 0},  /* 131 VK_F20 */
+    {0, 0, 0, 0, 0},  /* 132 VK_F21 */
+    {0, 0, 0, 0, 0},  /* 133 VK_F22 */
+    {0, 0, 0, 0, 0},  /* 134 VK_F23 */
+    {0, 0, 0, 0, 0},  /* 135 VK_F24 */
+    {0, 0, 0, 0, 0},  /* 136 unassigned */
+    {0, 0, 0, 0, 0},  /* 137 unassigned */
+    {0, 0, 0, 0, 0},  /* 138 unassigned */
+    {0, 0, 0, 0, 0},  /* 139 unassigned */
+    {0, 0, 0, 0, 0},  /* 140 unassigned */
+    {0, 0, 0, 0, 0},  /* 141 unassigned */
+    {0, 0, 0, 0, 0},  /* 142 unassigned */
+    {0, 0, 0, 0, 0},  /* 143 unassigned */
+    {0, 0, 0, 0, 0},  /* 144 VK_NUMLOCK */
+    {KEY_SCROLLLOCK, 0, 0, ALT_SCROLLLOCK, 0},    /* 145 VKSCROLL */
+    {0, 0, 0, 0, 0},  /* 146 OEM specific */
+    {0, 0, 0, 0, 0},  /* 147 OEM specific */
+    {0, 0, 0, 0, 0},  /* 148 OEM specific */
+    {0, 0, 0, 0, 0},  /* 149 OEM specific */
+    {0, 0, 0, 0, 0},  /* 150 OEM specific */
+    {0, 0, 0, 0, 0},  /* 151 Unassigned */
+    {0, 0, 0, 0, 0},  /* 152 Unassigned */
+    {0, 0, 0, 0, 0},  /* 153 Unassigned */
+    {0, 0, 0, 0, 0},  /* 154 Unassigned */
+    {0, 0, 0, 0, 0},  /* 155 Unassigned */
+    {0, 0, 0, 0, 0},  /* 156 Unassigned */
+    {0, 0, 0, 0, 0},  /* 157 Unassigned */
+    {0, 0, 0, 0, 0},  /* 158 Unassigned */
+    {0, 0, 0, 0, 0},  /* 159 Unassigned */
+    {0, 0, 0, 0, 0},  /* 160 VK_LSHIFT */
+    {0, 0, 0, 0, 0},  /* 161 VK_RSHIFT */
+    {0, 0, 0, 0, 0},  /* 162 VK_LCONTROL */
+    {0, 0, 0, 0, 0},  /* 163 VK_RCONTROL */
+    {0, 0, 0, 0, 0},  /* 164 VK_LMENU */
+    {0, 0, 0, 0, 0},  /* 165 VK_RMENU */
+    {0, 0, 0, 0, 14},  /* 166 VK_BROWSER_BACK        */
+    {0, 0, 0, 0, 15},  /* 167 VK_BROWSER_FORWARD     */
+    {0, 0, 0, 0, 16},  /* 168 VK_BROWSER_REFRESH     */
+    {0, 0, 0, 0, 17},  /* 169 VK_BROWSER_STOP        */
+    {0, 0, 0, 0, 18},  /* 170 VK_BROWSER_SEARCH      */
+    {0, 0, 0, 0, 19},  /* 171 VK_BROWSER_FAVORITES   */
+    {0, 0, 0, 0, 20},  /* 172 VK_BROWSER_HOME        */
+    {0, 0, 0, 0, 21},  /* 173 VK_VOLUME_MUTE         */
+    {0, 0, 0, 0, 22},  /* 174 VK_VOLUME_DOWN         */
+    {0, 0, 0, 0, 23},  /* 175 VK_VOLUME_UP           */
+    {0, 0, 0, 0, 24},  /* 176 VK_MEDIA_NEXT_TRACK    */
+    {0, 0, 0, 0, 25},  /* 177 VK_MEDIA_PREV_TRACK    */
+    {0, 0, 0, 0, 26},  /* 178 VK_MEDIA_STOP          */
+    {0, 0, 0, 0, 27},  /* 179 VK_MEDIA_PLAY_PAUSE    */
+    {0, 0, 0, 0, 28},  /* 180 VK_LAUNCH_MAIL         */
+    {0, 0, 0, 0, 29},  /* 181 VK_LAUNCH_MEDIA_SELECT */
+    {0, 0, 0, 0, 30},  /* 182 VK_LAUNCH_APP1         */
+    {0, 0, 0, 0, 31},  /* 183 VK_LAUNCH_APP2         */
+    {0, 0, 0, 0, 0},  /* 184 Reserved */
+    {0, 0, 0, 0, 0},  /* 185 Reserved */
+    {';', ':', CTL_SEMICOLON, ALT_SEMICOLON, 0},  /* 186 VK_OEM_1      */
+    {'=', '+', CTL_EQUAL,     ALT_EQUAL,     0},  /* 187 VK_OEM_PLUS   */
+    {',', '<', CTL_COMMA,     ALT_COMMA,     0},  /* 188 VK_OEM_COMMA  */
+    {'-', '_', CTL_MINUS,     ALT_MINUS,     0},  /* 189 VK_OEM_MINUS  */
+    {'.', '>', CTL_STOP,      ALT_STOP,      0},  /* 190 VK_OEM_PERIOD */
+    {'/', '?', CTL_FSLASH,    ALT_FSLASH,    0},  /* 191 VK_OEM_2      */
+    {'`', '~', CTL_BQUOTE,    ALT_BQUOTE,    0},  /* 192 VK_OEM_3      */
+    {0, 0, 0, 0, 0},  /* 193 */
+    {0, 0, 0, 0, 0},  /* 194 */
+    {0, 0, 0, 0, 0},  /* 195 */
+    {0, 0, 0, 0, 0},  /* 196 */
+    {0, 0, 0, 0, 0},  /* 197 */
+    {0, 0, 0, 0, 0},  /* 198 */
+    {0, 0, 0, 0, 0},  /* 199 */
+    {0, 0, 0, 0, 0},  /* 200 */
+    {0, 0, 0, 0, 0},  /* 201 */
+    {0, 0, 0, 0, 0},  /* 202 */
+    {0, 0, 0, 0, 0},  /* 203 */
+    {0, 0, 0, 0, 0},  /* 204 */
+    {0, 0, 0, 0, 0},  /* 205 */
+    {0, 0, 0, 0, 0},  /* 206 */
+    {0, 0, 0, 0, 0},  /* 207 */
+    {0, 0, 0, 0, 0},  /* 208 */
+    {0, 0, 0, 0, 0},  /* 209 */
+    {0, 0, 0, 0, 0},  /* 210 */
+    {0, 0, 0, 0, 0},  /* 211 */
+    {0, 0, 0, 0, 0},  /* 212 */
+    {0, 0, 0, 0, 0},  /* 213 */
+    {0, 0, 0, 0, 0},  /* 214 */
+    {0, 0, 0, 0, 0},  /* 215 */
+    {0, 0, 0, 0, 0},  /* 216 */
+    {0, 0, 0, 0, 0},  /* 217 */
+    {0, 0, 0, 0, 0},  /* 218 */
+    {0x5B,       0x7B,      0x1B,        ALT_LBRACKET,0  }, /* 219 VK_OEM_4 */
+    {0x5C,       0x7C,      0x1C,        ALT_BSLASH, 0   }, /* 220 VK_OEM_5 */
+    {0x5D,       0x7D,      0x1D,        ALT_RBRACKET,0  }, /* 221 VK_OEM_6 */
+    {'\'',       '"',       0x27,        ALT_FQUOTE, 0   }, /* 222 VK_OEM_7 */
+    {0,          0,         0,           0,          0   }, /* 223 VK_OEM_8 */
+    {0,          0,         0,           0,          0   }, /* 224 */
+    {0,          0,         0,           0,          0   }  /* 225 */
+};
+/* End of kptab[] */
+
+static const KPTAB ext_kptab[] =
+{
+   {0,          0,              0,              0,          }, /*  0  MUST BE EMPTY */
+   {PADENTER,   SHF_PADENTER,   CTL_PADENTER,   ALT_PADENTER}, /*  1  13 */
+   {PADSLASH,   SHF_PADSLASH,   CTL_PADSLASH,   ALT_PADSLASH}, /*  2 111 */
+   {KEY_PPAGE,  KEY_SPREVIOUS,  CTL_PGUP,       ALT_PGUP    }, /*  3  33 */
+   {KEY_NPAGE,  KEY_SNEXT,      CTL_PGDN,       ALT_PGDN    }, /*  4  34 */
+   {KEY_END,    KEY_SEND,       CTL_END,        ALT_END     }, /*  5  35 */
+   {KEY_HOME,   KEY_SHOME,      CTL_HOME,       ALT_HOME    }, /*  6  36 */
+   {KEY_LEFT,   KEY_SLEFT,      CTL_LEFT,       ALT_LEFT    }, /*  7  37 */
+   {KEY_UP,     KEY_SUP,        CTL_UP,         ALT_UP      }, /*  8  38 */
+   {KEY_RIGHT,  KEY_SRIGHT,     CTL_RIGHT,      ALT_RIGHT   }, /*  9  39 */
+   {KEY_DOWN,   KEY_SDOWN,      CTL_DOWN,       ALT_DOWN    }, /* 10  40 */
+   {KEY_IC,     KEY_SIC,        CTL_INS,        ALT_INS     }, /* 11  45 */
+   {KEY_DC,     KEY_SDC,        CTL_DEL,        ALT_DEL     }, /* 12  46 */
+   {KEY_APPS,   KEY_SAPPS     , CTL_APPS,       ALT_APPS    }, /* 13  93  VK_APPS    */
+   {KEY_BROWSER_BACK, KEY_SBROWSER_BACK, KEY_CBROWSER_BACK, KEY_ABROWSER_BACK, }, /* 14 166 VK_BROWSER_BACK        */
+   {KEY_BROWSER_FWD,  KEY_SBROWSER_FWD,  KEY_CBROWSER_FWD,  KEY_ABROWSER_FWD,  }, /* 15 167 VK_BROWSER_FORWARD     */
+   {KEY_BROWSER_REF,  KEY_SBROWSER_REF,  KEY_CBROWSER_REF,  KEY_ABROWSER_REF,  }, /* 16 168 VK_BROWSER_REFRESH     */
+   {KEY_BROWSER_STOP, KEY_SBROWSER_STOP, KEY_CBROWSER_STOP, KEY_ABROWSER_STOP, }, /* 17 169 VK_BROWSER_STOP        */
+   {KEY_SEARCH,       KEY_SSEARCH,       KEY_CSEARCH,       KEY_ASEARCH,       }, /* 18 170 VK_BROWSER_SEARCH      */
+   {KEY_FAVORITES,    KEY_SFAVORITES,    KEY_CFAVORITES,    KEY_AFAVORITES,    }, /* 19 171 VK_BROWSER_FAVORITES   */
+   {KEY_BROWSER_HOME, KEY_SBROWSER_HOME, KEY_CBROWSER_HOME, KEY_ABROWSER_HOME, }, /* 20 172 VK_BROWSER_HOME        */
+   {KEY_VOLUME_MUTE,  KEY_SVOLUME_MUTE,  KEY_CVOLUME_MUTE,  KEY_AVOLUME_MUTE,  }, /* 21 173 VK_VOLUME_MUTE         */
+   {KEY_VOLUME_DOWN,  KEY_SVOLUME_DOWN,  KEY_CVOLUME_DOWN,  KEY_AVOLUME_DOWN,  }, /* 22 174 VK_VOLUME_DOWN         */
+   {KEY_VOLUME_UP,    KEY_SVOLUME_UP,    KEY_CVOLUME_UP,    KEY_AVOLUME_UP,    }, /* 23 175 VK_VOLUME_UP           */
+   {KEY_NEXT_TRACK,   KEY_SNEXT_TRACK,   KEY_CNEXT_TRACK,   KEY_ANEXT_TRACK,   }, /* 24 176 VK_MEDIA_NEXT_TRACK    */
+   {KEY_PREV_TRACK,   KEY_SPREV_TRACK,   KEY_CPREV_TRACK,   KEY_APREV_TRACK,   }, /* 25 177 VK_MEDIA_PREV_TRACK    */
+   {KEY_MEDIA_STOP,   KEY_SMEDIA_STOP,   KEY_CMEDIA_STOP,   KEY_AMEDIA_STOP,   }, /* 26 178 VK_MEDIA_STOP          */
+   {KEY_PLAY_PAUSE,   KEY_SPLAY_PAUSE,   KEY_CPLAY_PAUSE,   KEY_APLAY_PAUSE,   }, /* 27 179 VK_MEDIA_PLAY_PAUSE    */
+   {KEY_LAUNCH_MAIL,  KEY_SLAUNCH_MAIL,  KEY_CLAUNCH_MAIL,  KEY_ALAUNCH_MAIL,  }, /* 28 180 VK_LAUNCH_MAIL         */
+   {KEY_MEDIA_SELECT, KEY_SMEDIA_SELECT, KEY_CMEDIA_SELECT, KEY_AMEDIA_SELECT, }, /* 29 181 VK_LAUNCH_MEDIA_SELECT */
+   {KEY_LAUNCH_APP1,  KEY_SLAUNCH_APP1,  KEY_CLAUNCH_APP1,  KEY_ALAUNCH_APP1,  }, /* 30 182 VK_LAUNCH_APP1         */
+   {KEY_LAUNCH_APP2,  KEY_SLAUNCH_APP2,  KEY_CLAUNCH_APP2,  KEY_ALAUNCH_APP2,  }, /* 31 183 VK_LAUNCH_APP2         */
+};
+
+
+HFONT PDC_get_font_handle( const int is_bold);            /* pdcdisp.c */
+
+/* Mouse handling is done as follows:
+
+   What we want is a setup wherein,  if the user presses and releases a
+mouse button within SP->mouse_wait milliseconds,  there will be a
+KEY_MOUSE issued through getch( ) and the "button state" for that button
+will be set to BUTTON_CLICKED.
+
+   If the user presses and releases the button,  and it takes _longer_
+than SP->mouse_wait milliseconds,  then there should be a KEY_MOUSE
+issued with the "button state" set to BUTTON_PRESSED.  Then,  later,
+another KEY_MOUSE with a BUTTON_RELEASED.
+
+   To accomplish this:  when a message such as WM_LBUTTONDOWN,
+WM_RBUTTONDOWN,  or WM_MBUTTONDOWN is issued (and more recently WM_XBUTTONDOWN
+for five-button mice),  we set up a timer with a period of SP->mouse_wait
+milliseconds.  There are then two possibilities. The user will release the
+button quickly (so it's a "click") or they won't (and it's a "press/release").
+
+   In the first case,  we'll get the WM_xBUTTONUP message before the
+WM_TIMER one.  We'll kill the timer and set up the BUTTON_CLICKED state. (*)
+
+   In the second case,  we'll get the WM_TIMER message first,  so we'll
+set the BUTTON_PRESSED state and kill the timer.  Eventually,  the user
+will get around to letting go of the mouse button,  and we'll get that
+WM_xBUTTONUP message.  At that time,  we'll set the BUTTON_RELEASED state
+and add the second KEY_MOUSE to the key queue.
+
+   Also,  note that if there is already a KEY_MOUSE to the queue,  there's
+no point in adding another one.  At least at present,  the actual mouse
+events aren't queued anyway.  So if there was,  say,  a click and then a
+release without getch( ) being called in between,  you'd then have two
+KEY_MOUSEs on the queue,  but would have lost all information about what
+the first one actually was.  Hence the code near the end of this function
+to ensure there isn't already a KEY_MOUSE in the queue.
+
+   Also,  a note about wheel handling.  Pre-Vista,  you could just say
+"the wheel went up" or "the wheel went down".  Vista introduced the possibility
+that the mouse motion could be a smoothly varying quantity.  So on each
+mouse move,  we add in the amount moved,  then check to see if that's
+enough to trigger a wheel up/down event (or possibly several).  The idea
+is that whereas before,  each movement would be 120 units (the default),
+you might now get a series of 40-unit moves and should emit a wheel up/down
+event on every third move.
+
+   (*) Things are actually slightly more complicated than this.  In general,
+it'll just be a plain old BUTTON_CLICKED state.  But if there was another
+BUTTON_CLICKED within the last 2 * SP->mouse_wait milliseconds,  then this
+must be a _double_ click,  so we set the BUTTON_DOUBLE_CLICKED state.  And
+if,  within that time frame,  there was a double or triple click,  then we
+set the BUTTON_TRIPLE_CLICKED state.  There isn't a "quad" or higher state,
+so if you quadruple-click the mouse,  with each click separated by less
+than 2 * SP->mouse_wait milliseconds,  then the messages sent will be
+BUTTON_CLICKED,  BUTTON_DOUBLE_CLICKED,  BUTTON_TRIPLE_CLICKED,  and
+then another BUTTON_TRIPLE_CLICKED.                                     */
+
+static int set_mouse( const int button_index, const int button_state,
+                           const LPARAM lParam)
+{
+    int i, n_key_mouse_to_add = 1;
+    POINT pt;
+
+    pt.x = LOWORD( lParam);
+    pt.y = HIWORD( lParam);
+    if( button_index == -1)         /* mouse moved,  no button */
+        n_key_mouse_to_add = 1;
+    else
+    {
+        memset(&pdc_mouse_status, 0, sizeof(MOUSE_STATUS));
+        if( button_index < PDC_MAX_MOUSE_BUTTONS)
+        {
+            if( button_index < 3)
+               {
+               pdc_mouse_status.button[button_index] = (short)button_state;
+               pdc_mouse_status.changes = (1 << button_index);
+               }
+            else
+               {
+               pdc_mouse_status.xbutton[button_index - 3] = (short)button_state;
+               pdc_mouse_status.changes = (0x40 << button_index);
+               }
+        }
+        else                      /* actually a wheel mouse movement */
+        {                         /* button_state = number of units moved */
+            static int mouse_wheel_vertical_loc = 0;
+            static int mouse_wheel_horizontal_loc = 0;
+            const int mouse_wheel_sensitivity = 120;
+
+            n_key_mouse_to_add = 0;
+            if( button_index == VERTICAL_WHEEL_EVENT)
+            {
+                mouse_wheel_vertical_loc += button_state;
+                while( mouse_wheel_vertical_loc > mouse_wheel_sensitivity / 2)
+                {
+                    n_key_mouse_to_add++;
+                    mouse_wheel_vertical_loc -= mouse_wheel_sensitivity;
+                    pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_UP;
+                }
+                while( mouse_wheel_vertical_loc < -mouse_wheel_sensitivity / 2)
+                {
+                    n_key_mouse_to_add++;
+                    mouse_wheel_vertical_loc += mouse_wheel_sensitivity;
+                    pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_DOWN;
+                }
+             }
+             else       /* must be a horizontal event: */
+            {
+                mouse_wheel_horizontal_loc += button_state;
+                while( mouse_wheel_horizontal_loc > mouse_wheel_sensitivity / 2)
+                {
+                    n_key_mouse_to_add++;
+                    mouse_wheel_horizontal_loc -= mouse_wheel_sensitivity;
+                    pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_RIGHT;
+                }
+                while( mouse_wheel_horizontal_loc < -mouse_wheel_sensitivity / 2)
+                {
+                    n_key_mouse_to_add++;
+                    mouse_wheel_horizontal_loc += mouse_wheel_sensitivity;
+                    pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_LEFT;
+                }
+             }
+                        /* I think it may be that for wheel events,  we   */
+                        /* return x = y = -1,  rather than getting the    */
+                        /* actual mouse position.  I don't like this, but */
+                        /* I like messing up existing apps even less.     */
+            pt.x = -PDC_cxChar;
+            pt.y = -PDC_cyChar;
+/*          ScreenToClient( PDC_hWnd, &pt);      Wheel posns are in screen, */
+        }                         /* not client,  coords;  gotta xform them */
+    }
+    pdc_mouse_status.x = pt.x / PDC_cxChar;
+    pdc_mouse_status.y = pt.y / PDC_cyChar;
+/*  if( SP->save_key_modifiers)  */
+    {
+        int i, button_flags = 0;
+
+        if( GetKeyState( VK_MENU) & 0x8000)
+            button_flags |= PDC_BUTTON_ALT;
+
+        if( GetKeyState( VK_SHIFT) & 0x8000)
+            button_flags |= PDC_BUTTON_SHIFT;
+
+        if( GetKeyState( VK_CONTROL) & 0x8000)
+            button_flags |= PDC_BUTTON_CONTROL;
+
+        for (i = 0; i < 3; i++)
+            pdc_mouse_status.button[i] |= button_flags;
+        for (i = 0; i < PDC_N_EXTENDED_MOUSE_BUTTONS; i++)
+            pdc_mouse_status.xbutton[i] |= button_flags;
+    }
+                  /* If there is already a KEY_MOUSE in the queue,  we   */
+                  /* don't really want to add another one.  See above.   */
+    i = PDC_key_queue_low;
+    while( i != PDC_key_queue_high)
+    {
+        if( PDC_key_queue[i] == KEY_MOUSE)
+        {
+            debug_printf( "Mouse key already in queue\n");
+            return( 0);
+        }
+        i = (i + 1) % KEY_QUEUE_SIZE;
+    }
+                  /* If the window is maximized,  the click may occur just */
+                  /* outside the "real" screen area.  If so,  we again     */
+                  /* don't want to add a key to the queue:                 */
+    if( pdc_mouse_status.x >= PDC_n_cols || pdc_mouse_status.y >= PDC_n_rows)
+        n_key_mouse_to_add = 0;
+                  /* OK,  there isn't a KEY_MOUSE already in the queue.   */
+                  /* So we'll add one (or zero or more,  for wheel mice): */
+    while( n_key_mouse_to_add--)
+        add_key_to_queue( KEY_MOUSE);
+    return( 0);
+}
+
+      /* The following should be #defined in 'winuser.h',  but such is */
+      /* not always the case.  The following fixes the exceptions:     */
+#ifndef WM_MOUSEWHEEL
+    #define WM_MOUSEWHEEL                   0x020A
+#endif
+#ifndef WM_MOUSEHWHEEL
+    #define WM_MOUSEHWHEEL                  0x020E
+#endif
+#ifndef WM_XBUTTONDOWN
+    #define WM_XBUTTONDOWN                  0x020B
+    #define WM_XBUTTONUP                    0x020C
+#endif
+#ifndef MK_XBUTTON1
+    #define MK_XBUTTON1                     0x0020
+    #define MK_XBUTTON2                     0x0040
+#endif
+
+#ifdef USE_FALLBACK_FONT
+extern GLYPHSET *PDC_unicode_range_data;
+#endif         /* #ifdef USE_FALLBACK_FONT */
+
+int PDC_blink_state = 0;
+#define TIMER_ID_FOR_BLINKING 0x2000
+
+/* When first loading a font,  we use 'get_character_sizes' to briefly
+load the (non-bold,  non-italic flavor of the) font,  get its height and
+width,  and call GetFontUnicodeRanges to determine which characters are
+actually available from that font.  That set of ranges is used so that,
+when we come across characters not in the font,  we can switch to a
+"fallback" font (Unifont,  most likely).   */
+
+static void get_character_sizes( const HWND hwnd,
+                           int *xchar_size, int *ychar_size)
+{
+    HFONT hFont = PDC_get_font_handle( 0);
+    HFONT prev_font;
+    HDC hdc = GetDC (hwnd) ;
+    TEXTMETRIC tm ;
+#ifdef USE_FALLBACK_FONT
+    DWORD size;
+#endif
+
+    prev_font = SelectObject (hdc, hFont);
+    GetTextMetrics (hdc, &tm) ;
+#ifdef USE_FALLBACK_FONT
+    assert( !PDC_unicode_range_data);
+    size = GetFontUnicodeRanges( hdc, NULL);
+    PDC_unicode_range_data = (GLYPHSET *)calloc( 1, size);
+    PDC_unicode_range_data->cbThis = size;
+    size = GetFontUnicodeRanges( hdc, PDC_unicode_range_data);
+#endif         /* #ifdef USE_FALLBACK_FONT */
+    SelectObject( hdc, prev_font);
+    ReleaseDC (hwnd, hdc) ;
+    DeleteObject( hFont);
+    *xchar_size = tm.tmAveCharWidth ;
+    *ychar_size = tm.tmHeight;
+}
+
+INLINE void sort_out_rect( RECT *rect)
+{
+    int temp;
+
+    if( rect->left > rect->right)
+    {
+        temp = rect->right;
+        rect->right = rect->left;
+        rect->left = temp;
+    }
+    if( rect->top > rect->bottom)
+    {
+        temp = rect->bottom;
+        rect->bottom = rect->top;
+        rect->top = temp;
+    }
+}
+
+static int rectangle_from_chars_to_pixels( RECT *rect)
+{
+    int rval = 1;
+
+    if( rect->right == rect->left && rect->top == rect->bottom)
+        rval = 0;
+    sort_out_rect( rect);
+    if( rect->top < 0)
+        rval = 0;
+    rect->right++;
+    rect->bottom++;
+    rect->left *= PDC_cxChar;
+    rect->right *= PDC_cxChar;
+    rect->top *= PDC_cyChar;
+    rect->bottom *= PDC_cyChar;
+    return( rval);
+}
+
+/* When updating the mouse rectangle,  you _could_ just remove the old one
+and draw the new one.  But that sometimes caused flickering if the mouse
+area was large.  In such cases,  it's better to determine what areas
+actually changed,  and invert just those.  So the following checks to
+see if two overlapping rectangles are being drawn (this is the norm)
+and figures out the area that actually needs to be flipped.  It does
+seem to decrease flickering to near-zero.                      */
+
+static int PDC_selecting_rectangle = 1;
+
+int PDC_find_ends_of_selected_text( const int line,
+          const RECT *rect, int *x)
+{
+    int rval = 0, i;
+
+    if( (rect->top - line) * (rect->bottom - line) <= 0
+            && (rect->top != rect->bottom || rect->left != rect->right))
+    {
+        if( PDC_selecting_rectangle || rect->top == rect->bottom)
+        {
+            x[0] = min( rect->right, rect->left);
+            x[1] = max( rect->right, rect->left);
+            rval = 1;
+        }
+        else if( rect->top <= line && line <= rect->bottom)
+        {
+            x[0] = (line == rect->top ? rect->left : 0);
+            x[1] = (line == rect->bottom ? rect->right : SP->cols - 1);
+            rval = 1;
+        }
+        else if( rect->top >= line && line >= rect->bottom)
+        {
+            x[0] = (line == rect->bottom ? rect->right : 0);
+            x[1] = (line == rect->top ? rect->left : SP->cols - 1);
+            rval = 1;
+        }
+    }
+    if( rval)
+        for( i = 0; i < 2; i++)
+           if( x[i] > SP->cols - 1)
+               x[i] = SP->cols - 1;
+    return( rval);
+}
+
+/* Called in only one place,  so let's inline it */
+
+INLINE void show_mouse_rect( const HWND hwnd, RECT before, RECT after)
+{
+    if( before.top > -1 || after.top > -1)
+        if( memcmp( &after, &before, sizeof( RECT)))
+        {
+            const HDC hdc = GetDC( hwnd) ;
+
+            if( PDC_selecting_rectangle)
+            {
+                const int show_before = rectangle_from_chars_to_pixels( &before);
+                const int show_after  = rectangle_from_chars_to_pixels( &after);
+
+                if( show_before && show_after)
+                {
+                    RECT temp;
+
+                    if( before.top < after.top)
+                    {
+                        temp = before;   before = after;  after = temp;
+                    }
+                    if( before.top < after.bottom && after.right > before.left
+                                  && before.right > after.left)
+                    {
+                        const int tval = min( after.bottom, before.bottom);
+
+                        temp = after;
+                        temp.bottom = before.top;
+                        InvertRect( hdc, &temp);
+
+                        temp.top = temp.bottom;
+                        temp.bottom = tval;
+                        temp.right = max( after.right, before.right);
+                        temp.left = min( after.right, before.right);
+                        InvertRect( hdc, &temp);
+
+                        temp.right = max( after.left, before.left);
+                        temp.left = min( after.left, before.left);
+                        InvertRect( hdc, &temp);
+
+                        temp = (after.bottom > before.bottom ? after : before);
+                        temp.top = tval;
+                        InvertRect( hdc, &temp);
+                    }
+                }
+                else if( show_before)
+                    InvertRect( hdc, &before);
+                else if( show_after)
+                    InvertRect( hdc, &after);
+            }
+            else     /* _not_ selecting rectangle; selecting lines */
+            {
+                int line;
+
+                for( line = 0; line < SP->lines; line++)
+                {
+                    int x[4], n_rects = 0, i;
+
+                    n_rects = PDC_find_ends_of_selected_text( line, &before, x);
+                    n_rects += PDC_find_ends_of_selected_text( line, &after, x + n_rects * 2);
+                    if( n_rects == 2)
+                        if( x[0] == x[2] && x[1] == x[3])
+                            n_rects = 0;   /* Rects are same & will cancel */
+                    for( i = 0; i < n_rects; i++)
+                        {
+                        RECT trect;
+
+                        trect.left = x[i + i];
+                        trect.right = x[i + i + 1];
+                        trect.top = line;
+                        trect.bottom = line;
+                        rectangle_from_chars_to_pixels( &trect);
+                        InvertRect( hdc, &trect);
+                        }
+                }
+            }
+            ReleaseDC( hwnd, hdc) ;
+        }
+}
+
+/* Cygwin lacks _splitpath, _wsplitpath.  THE FOLLOWING ARE NOT FULLY
+TESTED IMPLEMENTATIONS OF THOSE TWO FUNCTIONS,  because the only use we
+make of them is to get fname.  (Though I did write a little test program,
+and they seem to work.) */
+
+#ifdef __CYGWIN__
+#ifdef PDC_WIDE
+static void my_wsplitpath( const wchar_t *path, wchar_t *drive,
+           wchar_t *dir, wchar_t *fname, wchar_t *ext)
+{
+    size_t i, loc = 0;
+
+    assert( path);
+    assert( fname);
+    if( path[0] && path[1] == ':')
+    {
+        if( drive)
+        {
+            drive[0] = path[0];
+            drive[1] = ':';
+            drive[2] = '\0';
+        }
+        path += 2;
+    }
+    else if( drive)
+        *drive = '\0';
+    for( i = 0; path[i]; i++)
+        if( path[i] == '/' || path[i] == '\\')
+            loc = i + 1;
+    if( dir)
+    {
+        memcpy( dir, path, loc * sizeof( wchar_t));
+        dir[loc] = '\0';
+    }
+    if( loc)
+        path += loc;
+    loc = 0;
+    while( path[loc] && path[loc] != '.')
+        loc++;
+    if( fname)
+    {
+        memcpy( fname, path, loc * sizeof( wchar_t));
+        fname[loc] = '\0';
+    }
+    if( ext)
+        wcscpy( ext, path + loc);
+}
+#endif            /* #ifdef PDC_WIDE */
+
+static void my_splitpath( const char *path, char *drive,
+           char *dir, char *fname, char *ext)
+{
+    size_t i, loc = 0;
+
+    assert( path);
+    assert( fname);
+    if( path[0] && path[1] == ':')
+    {
+        if( drive)
+        {
+            drive[0] = path[0];
+            drive[1] = ':';
+            drive[2] = '\0';
+        }
+        path += 2;
+    }
+    else if( drive)
+        *drive = '\0';
+    for( i = 0; path[i]; i++)
+        if( path[i] == '/' || path[i] == '\\')
+            loc = i + 1;
+    if( dir)
+    {
+        memcpy( dir, path, loc * sizeof( char));
+        dir[loc] = '\0';
+    }
+    if( loc)
+        path += loc;
+    loc = 0;
+    while( path[loc] && path[loc] != '.')
+        loc++;
+    if( fname)
+    {
+        memcpy( fname, path, loc * sizeof( char));
+        fname[loc] = '\0';
+    }
+    if( ext)
+        strcpy( ext, path + loc);
+}
+#else          /* non-Cygwin case : */
+   #define my_splitpath  _splitpath
+   #define my_wsplitpath _wsplitpath
+   #define GOT_ARGV_ARGC
+#endif            /* #ifdef __CYGWIN__ */
+
+/* This function looks at the full command line,  which includes a fully
+specified path to the executable and arguments;  and strips out just the
+name of the app,  with the arguments optionally appended.  Hence,
+
+C:\PDCURSES\WINGUI\TESTCURS.EXE arg1 arg2
+
+    would be reduced to 'Testcurs' (if include_args == 0) or
+'Testcurs arg1 arg2' (if include_args == 1).  The former case is used to
+create a (hopefully unique) registry key for the app,  so that the app's
+specific settings (screen and font size) will be stored for the next run.
+The latter case is used to generate a default window title.
+
+   Unfortunately,  this code has to do some pretty strange things.  In the
+Unicode (PDC_WIDE) case,  we really should use __wargv;  but that pointer
+may or may not be NULL.  If it's NULL, we fall back on __argv.  In at
+least one case,  where this code is compiled into a DLL using MinGW and
+then used in an app compiled with MS Visual C, __argv isn't set either,
+and we drop back to looking at GetCommandLine( ).  Which leads to a real
+oddity:  GetCommandLine( ) may return something such as,  say,
+
+"C:\PDCurses\WinGUI\testcurs.exe" -lRussian
+
+   ...which,  after being run through _splitpath or _wsplitpath,  becomes
+
+testcurs.exe" -lRussian
+
+   The .exe" is removed,  and the command-line arguments shifted or removed,
+depending on the value of include_args.  Pretty strange stuff.
+
+   However,  if one calls Xinitscr( ) and passed command-line arguments when
+starting this library,  those arguments will be stored in PDC_argc and
+PDC_argv,  and will be used instead of GetCommandLine.
+*/
+
+#ifdef UNICODE
+   #define my_stprintf wsprintf
+   #define my_tcslen   wcslen
+#ifdef __CYGWIN__
+                     /* Can't lowercase Unicode text in Cygwin */
+   #define my_tcslwr
+#elif defined _MSC_VER
+   #define my_tcslwr   _wcslwr
+#else
+   #define my_tcslwr   wcslwr
+#endif      /* __CYGWIN__ */
+   #define my_tcscat   wcscat
+   #define my_tcscpy   wcscpy
+   #define my_stscanf  swscanf
+
+#else /* UNICODE */
+
+   #define my_stprintf sprintf
+   #define my_tcslen   strlen
+   #define my_tcslwr   strlwr
+#ifdef _MSC_VER
+   #define strlwr     _strlwr
+#endif
+   #define my_tcscat   strcat
+   #define my_tcscpy   strcpy
+   #define my_stscanf  sscanf
+#endif /* UNICODE */
+
+
+static void get_app_name( TCHAR *buff, const size_t buff_size, const bool include_args)
+{
+    int i;
+    size_t buff_space;
+#ifdef GOT_ARGV_ARGC
+    int argc = (PDC_argc ? PDC_argc : __argc);
+    char **argv = (PDC_argc ? PDC_argv : __argv);
+#else
+    int argc = PDC_argc;
+    char **argv = PDC_argv;
+#endif
+
+#ifdef PDC_WIDE
+    wchar_t **wargv = __wargv;
+#ifdef GOT_ARGV_ARGC
+    /* in case we can not access the array directly try to get it otherwise */
+    if( !wargv) {
+        wchar_t *cmd_linew = GetCommandLine( );
+        if (cmd_linew) {
+            wargv = CommandLineToArgvW (cmd_linew, &argc);
+        }
+    }
+    if( wargv)
+    {
+        my_wsplitpath( wargv[0], NULL, NULL, buff, NULL);
+        if ( include_args)
+        {
+            buff_space = buff_size - my_tcslen( buff) - 1;
+            for ( i = 1; i < argc; i++)
+            {
+                size_t arg_len = my_tcslen( wargv[i]) + 1;
+                if ( buff_space < arg_len) {
+                    break;
+                }
+                buff_space -= arg_len;
+                wcscat( buff, L" ");
+                wcscat( buff, wargv[i]);
+            }
+        }
+    }
+    else
+#endif      /* #ifdef GOT_ARGV_ARGC */
+       if( argv)
+    {
+        char tbuff[MAX_PATH];
+        my_splitpath( argv[0], NULL, NULL, tbuff, NULL);
+        if ( include_args)
+        {
+            buff_space = buff_size - strlen( tbuff) - 1;
+            for ( i = 1; i < argc; i++)
+            {
+                size_t arg_len = strlen( argv[i]) + 1;
+                if ( buff_space < arg_len) {
+                    break;
+                }
+                buff_space -= arg_len;
+                strcat( tbuff, " ");
+                strcat( tbuff, argv[i]);
+            }
+        }
+        mbstowcs( buff, tbuff, strlen( tbuff) + 1);
+    }
+    else         /* no __argv or PDC_argv pointer available */
+    {
+        wchar_t *tptr;
+
+        my_wsplitpath( GetCommandLine( ), NULL, NULL, buff, NULL);
+        my_tcslwr( buff + 1);
+        tptr = wcsstr( buff, L".exe\"");
+        if( tptr)
+        {
+            if( include_args)
+                memmove( tptr, tptr + 5, wcslen( tptr + 4) * sizeof( wchar_t));
+            else
+                *tptr = '\0';
+        }
+    }
+#else       /* non-Unicode case */
+    if( argv)
+    {
+        my_splitpath( argv[0], NULL, NULL, buff, NULL);
+        debug_printf( "Path: %s;  exe: %s\n", argv[0], buff);
+        if ( include_args)
+        {
+            buff_space = buff_size - my_tcslen( buff) - 1;
+            for ( i = 1; i < argc; i++)
+            {
+                size_t arg_len = my_tcslen( argv[i]) + 1;
+                if ( buff_space < arg_len) {
+                    break;
+                }
+                buff_space -= arg_len;
+                strcat( buff, " ");
+                strcat( buff, argv[i]);
+            }
+        }
+    }
+    else         /* no __argv pointer available */
+    {
+        char *tptr;
+
+        my_splitpath( GetCommandLine( ), NULL, NULL, buff, NULL);
+        strlwr( buff + 1);
+        tptr = strstr( buff, ".exe\"");
+        if( tptr)
+        {
+            if( include_args)
+                memmove( tptr, tptr + 5, strlen( tptr + 4));
+            else
+                *tptr = '\0';
+        }
+    }
+#endif
+    my_tcslwr( buff + 1);
+}
+
+/* This function extracts the first icon from the executable that is
+executing this DLL */
+
+INLINE HICON get_app_icon( )
+{
+#ifdef PDC_WIDE
+    wchar_t filename[MAX_PATH];
+#else
+    char filename[MAX_PATH];
+#endif
+
+    HICON icon = NULL;
+    if ( GetModuleFileName( NULL, filename, sizeof(filename) ) != 0 )
+       icon = ExtractIcon( 0, filename, 0 );
+    return icon;
+}
+
+extern TCHAR PDC_font_name[];
+
+/* This flavor of Curses tries to store the window and font sizes on
+an app-by-app basis.  To do this,  it uses the above get_app_name( )
+function,  then sets or gets a corresponding value from the Windoze
+registry.  The benefit should be that one can have one screen size/font
+for,  say,  Testcurs,  while having different settings for,  say,  Firework
+or Rain or one's own programs.  */
+
+INLINE int set_default_sizes_from_registry( const int n_cols, const int n_rows,
+               const int xloc, const int yloc, const int menu_shown)
+{
+    DWORD is_new_key;
+    HKEY hNewKey;
+    long rval = RegCreateKeyEx( HKEY_CURRENT_USER, _T( "SOFTWARE\\PDCurses"),
+                            0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
+                            0, &hNewKey, &is_new_key);
+
+    if( rval == ERROR_SUCCESS)
+    {
+        TCHAR buff[180];
+        TCHAR key_name[MAX_PATH];
+        extern int PDC_font_size;
+
+        if( IsZoomed( PDC_hWnd))    /* -1x-1 indicates a maximized window */
+            my_stprintf( buff,
+                      _T( "-1x-1,%d,0,0,%d"), PDC_font_size, menu_shown);
+        else
+            my_stprintf( buff,
+                      _T( "%dx%d,%d,%d,%d,%d"), n_cols, n_rows, PDC_font_size,
+                       xloc, yloc, menu_shown);
+        my_stprintf( buff + my_tcslen( buff),
+                  _T(";%d,%d,%d,%d:"),
+                  min_lines, max_lines,
+                  min_cols, max_cols);
+        my_tcscat( buff, PDC_font_name);
+
+        get_app_name( key_name, MAX_PATH, FALSE);
+        rval = RegSetValueEx( hNewKey, key_name, 0, REG_SZ,
+                       (BYTE *)buff, (DWORD)( my_tcslen( buff) * sizeof( TCHAR)));
+        RegCloseKey( hNewKey);
+    }
+    debug_printf( "Size: %d %d; %d\n", n_cols, n_rows, rval);
+    return( rval != ERROR_SUCCESS);
+}
+
+/* If the window is maximized,  there will usually be a fractional
+character width at the right and bottom edges.  The following code fills
+that in with a black brush.  It takes the "paint rectangle",  the area
+passed with a WM_PAINT message that specifies what chunk of the client
+area needs to be redrawn.
+
+    If the window is _not_ maximized,  this shouldn't happen;  the window
+width/height should always be an integral multiple of the character
+width/height,  with no slivers at the right and bottom edges. */
+
+static void fix_up_edges( const HDC hdc, const RECT *rect)
+{
+    const int x = PDC_n_cols * PDC_cxChar;
+    const int y = PDC_n_rows * PDC_cyChar;
+
+    if( rect->right >= x || rect->bottom >= y)
+    {
+        const HBRUSH hOldBrush =
+                      SelectObject( hdc, GetStockObject( BLACK_BRUSH));
+
+        SelectObject( hdc, GetStockObject( NULL_PEN));
+        if( rect->right >= x)
+           Rectangle( hdc, x, rect->top, rect->right + 1, rect->bottom + 1);
+        if( rect->bottom >= y)
+           Rectangle( hdc, rect->left, y, rect->right + 1, rect->bottom + 1);
+        SelectObject( hdc, hOldBrush);
+    }
+}
+
+static void adjust_font_size( const int font_size_change)
+{
+    extern int PDC_font_size;
+
+    PDC_font_size += font_size_change;
+    if( PDC_font_size < 2)
+        PDC_font_size = 2;
+    PDC_transform_line( 0, 0, 0, NULL);    /* free any fonts  */
+    get_character_sizes( PDC_hWnd, &PDC_cxChar, &PDC_cyChar);
+          /* When the font size changes,  do we want to keep  */
+          /* the window the same size (except to remove any   */
+          /* fractional character)?  Or do we keep the number */
+          /* of rows/columns the same?  For the nonce,  I'm   */
+          /* keeping the window size fixed if the window is   */
+          /* maximized,  but keeping the number of rows/lines */
+          /* fixed if it's windowed.  That's my opinion.  If  */
+          /* you disagree,  I have others.                    */
+    if( IsZoomed( PDC_hWnd))
+    {
+        RECT client_rect;
+        HDC hdc;
+
+        GetClientRect( PDC_hWnd, &client_rect);
+        PDC_n_rows = client_rect.bottom / PDC_cyChar;
+        PDC_n_cols = client_rect.right / PDC_cxChar;
+        keep_size_within_bounds( &PDC_n_rows, &PDC_n_cols);
+        PDC_resize_screen( PDC_n_rows, PDC_n_cols);
+        add_key_to_queue( KEY_RESIZE);
+        SP->resized = TRUE;
+        hdc = GetDC (PDC_hWnd) ;
+        GetClientRect( PDC_hWnd, &client_rect);
+        fix_up_edges( hdc, &client_rect);
+        ReleaseDC( PDC_hWnd, hdc) ;
+    }
+    else
+    {
+        PDC_resize_screen( PDC_n_rows, PDC_n_cols);
+        InvalidateRect( PDC_hWnd, NULL, FALSE);
+    }
+}
+
+         /* PDC_mouse_rect is the area currently highlit by dragging the */
+         /* mouse.  It's global,  sadly,  because we need to ensure that */
+         /* the highlighting is respected when the text within that      */
+         /* rectangle is redrawn by PDC_transform_line(). */
+RECT PDC_mouse_rect = { -1, -1, -1, -1 };
+
+int PDC_setclipboard_raw( const char *contents, long length,
+            const bool translate_multibyte_to_wide_char);
+
+/* Called in only one place (when the left mouse button goes up), */
+/* so we should inline it :   */
+
+INLINE void HandleBlockCopy( void)
+{
+    int i, j, len, x[2];
+    TCHAR *buff, *tptr;
+
+            /* Make a first pass to determine how much text is blocked: */
+    for( i = len = 0; i < SP->lines; i++)
+        if( PDC_find_ends_of_selected_text( i, &PDC_mouse_rect, x))
+            len += x[1] - x[0] + 3;
+    buff = tptr = (TCHAR *)malloc( (len + 1) * sizeof( TCHAR));
+            /* Make second pass to copy that text to a buffer: */
+    for( i = len = 0; i < SP->lines; i++)
+        if( PDC_find_ends_of_selected_text( i, &PDC_mouse_rect, x))
+        {
+            const chtype *cptr = curscr->_y[i];
+
+            for( j = 0; j < x[1] - x[0] + 1; j++)
+                tptr[j] = (TCHAR)cptr[j + x[0]];
+            while( j > 0 && tptr[j - 1] == ' ')
+                j--;          /* remove trailing spaces */
+            tptr += j;
+            *tptr++ = (TCHAR)13;
+            *tptr++ = (TCHAR)10;
+        }
+    if( tptr != buff)   /* at least one line read in */
+    {
+       tptr[-2] = '\0';       /* cut off the last CR/LF */
+       PDC_setclipboard_raw( (char *)buff, (long)( tptr - buff), FALSE);
+    }
+    free( buff);
+}
+
+#define WM_ENLARGE_FONT       (WM_USER + 1)
+#define WM_SHRINK_FONT        (WM_USER + 2)
+#define WM_MARK_AND_COPY      (WM_USER + 3)
+#define WM_TOGGLE_MENU        (WM_USER + 4)
+#define WM_EXIT_GRACELESSLY   (WM_USER + 5)
+#define WM_CHOOSE_FONT        (WM_USER + 6)
+
+static int add_resize_key = 1;
+
+/*man-start**************************************************************
+
+Resize limits
+-------------
+
+### Synopsis
+
+    void PDC_set_resize_limits( const int new_min_lines,
+                                const int new_max_lines,
+                                const int new_min_cols,
+                                const int new_max_cols);
+
+### Description
+
+   For platforms supporting resizable windows (SDLx, WinGUI, X11).  Some
+   programs may be unprepared for a resize event;  for these,  calling
+   this function with the max and min limits equal ensures that no
+   user resizing can be done.  Other programs may require at least a
+   certain number,  and/or no more than a certain number,  of columns
+   and/or lines.
+
+### Portability
+
+   PDCurses-only function.
+
+**man-end****************************************************************/
+
+void PDC_set_resize_limits( const int new_min_lines, const int new_max_lines,
+                  const int new_min_cols, const int new_max_cols)
+{
+    min_lines = max( new_min_lines, 2);
+    max_lines = max( new_max_lines, min_lines);
+    min_cols = max( new_min_cols, 2);
+    max_cols = max( new_max_cols, min_cols);
+}
+
+      /* The screen should hold the characters (PDC_cxChar * n_default_columns */
+      /* pixels wide,  similarly high).  In width,  we need two frame widths,  */
+      /* one on each side.  Vertically,  we need two frame heights,  plus room */
+      /* for the application title and the menu.  */
+
+static void adjust_window_size( int *xpixels, int *ypixels, int window_style,
+               const int menu_shown)
+{
+    RECT rect;
+
+    rect.left = rect.top = 0;
+    rect.right = *xpixels;
+    rect.bottom = *ypixels;
+/*  printf( "Adjusting to %d, %d\n", *xpixels, *ypixels); */
+    AdjustWindowRect( &rect, window_style, menu_shown);
+    *xpixels = rect.right - rect.left;
+    *ypixels = rect.bottom - rect.top;
+}
+
+static int keep_size_within_bounds( int *lines, int *cols)
+{
+    int rval = 0;
+
+    if( *lines < min_lines)
+    {
+        *lines = min_lines;
+        rval = 1;
+    }
+    else if( *lines > max_lines)
+    {
+        *lines = max_lines;
+        rval = 2;
+    }
+    if( *cols < min_cols)
+    {
+        *cols = min_cols;
+        rval |= 4;
+    }
+    else if( *cols > max_cols)
+    {
+        *cols = max_cols;
+        rval |= 8;
+    }
+    return( rval);
+}
+
+INLINE int get_default_sizes_from_registry( int *n_cols, int *n_rows,
+                                     int *xloc, int *yloc, int *menu_shown)
+{
+    TCHAR data[100];
+    DWORD size_out = sizeof( data);
+    HKEY hKey = 0;
+    long rval = RegOpenKeyEx( HKEY_CURRENT_USER, _T( "SOFTWARE\\PDCurses"),
+                        0, KEY_READ, &hKey);
+
+    if( !hKey)
+        return( 1);
+    if( rval == ERROR_SUCCESS)
+    {
+        TCHAR key_name[MAX_PATH];
+
+        get_app_name( key_name, MAX_PATH, FALSE);
+        rval = RegQueryValueEx( hKey, key_name,
+                        NULL, NULL, (BYTE *)data, &size_out);
+        if( rval == ERROR_SUCCESS)
+        {
+            extern int PDC_font_size;
+            int x = -1, y = -1, bytes_read = 0;
+
+            my_stscanf( data, _T( "%dx%d,%d,%d,%d,%d;%d,%d,%d,%d:%n"),
+                             &x, &y, &PDC_font_size,
+                             xloc, yloc, menu_shown,
+                             &min_lines, &max_lines,
+                             &min_cols, &max_cols,
+                             &bytes_read);
+            if( bytes_read > 0 && data[bytes_read - 1] == ':')
+               my_tcscpy( PDC_font_name, data + bytes_read);
+            if( n_cols)
+                *n_cols = x;
+            if( n_rows)
+                *n_rows = y;
+            if( *n_cols > 0 && *n_rows > 0)   /* i.e.,  not maximized */
+                keep_size_within_bounds( n_rows, n_cols);
+        }
+        RegCloseKey( hKey);
+    }
+    if( rval != ERROR_SUCCESS)
+        debug_printf( "get_default_sizes_from_registry error: %d\n", rval);
+    return( rval != ERROR_SUCCESS);
+}
+
+/* Ensure that the dragged rectangle    */
+/* is an even multiple of the char size */
+INLINE void HandleSizing( WPARAM wParam, LPARAM lParam )
+{
+    RECT *rect = (RECT *)lParam;
+    RECT window_rect, client_rect;
+    int hadd, vadd, width, height;
+    int n_rows, n_cols;
+    int rounded_width, rounded_height;
+
+    GetWindowRect( PDC_hWnd, &window_rect);
+    GetClientRect( PDC_hWnd, &client_rect);
+    hadd = (window_rect.right - window_rect.left) - client_rect.right;
+    vadd = (window_rect.bottom - window_rect.top) - client_rect.bottom;
+    width = rect->right - rect->left - hadd;
+    height = rect->bottom - rect->top - vadd;
+
+    n_cols = (width + PDC_cxChar / 2) / PDC_cxChar;
+    n_rows = (height + PDC_cyChar / 2) / PDC_cyChar;
+    keep_size_within_bounds( &n_rows, &n_cols);
+
+    rounded_width = hadd + n_cols * PDC_cxChar;
+    rounded_height = vadd + n_rows * PDC_cyChar;
+
+    if( wParam == WMSZ_BOTTOM || wParam == WMSZ_BOTTOMLEFT
+                              || wParam == WMSZ_BOTTOMRIGHT)
+        rect->bottom = rect->top + rounded_height;
+    if( wParam == WMSZ_TOP || wParam == WMSZ_TOPLEFT
+                           || wParam == WMSZ_TOPRIGHT)
+        rect->top = rect->bottom - rounded_height;
+    if( wParam == WMSZ_RIGHT || wParam == WMSZ_BOTTOMRIGHT
+                             || wParam == WMSZ_TOPRIGHT)
+        rect->right = rect->left + rounded_width;
+    if( wParam == WMSZ_LEFT || wParam == WMSZ_BOTTOMLEFT
+                            || wParam == WMSZ_TOPLEFT)
+        rect->left = rect->right - rounded_width;
+}
+
+/* Under Wine,  it appears that the code to force the window size to be
+an integral number of columns and rows doesn't work.  This is because
+WM_SIZING messages aren't sent (this is apparently fixed as of Wine 1.7.18,
+though I've not tried it yet;  I'm still on Wine 1.6,  the stable branch.)
+You can therefore end up in a loop where the code keeps trying to resize a
+window that isn't actually resizing.  So,  _when running in Wine only_,
+we want that code not to be executed... which means having to figure out:
+are we running under Wine?  Which means that when PDCurses/WinGUI is
+initialized,  we set the following 'wine_version' pointer.  One could
+actually call wine_version(),  if not NULL,  to get the current Wine
+version.      */
+
+typedef const char *(CDECL *wine_version_func)(void);
+
+static wine_version_func wine_version;
+
+static void HandleSize( const WPARAM wParam, const LPARAM lParam)
+{
+    static WPARAM prev_wParam = (WPARAM)-99;
+    const unsigned n_xpixels = LOWORD (lParam);
+    const unsigned n_ypixels = HIWORD (lParam);
+    unsigned new_n_rows, new_n_cols;
+
+    debug_printf( "WM_SIZE: wParam %x %d %d %d\n", (unsigned)wParam,
+                  n_xpixels, n_ypixels, SP->resized);
+/*  if( wine_version)
+        printf( "Wine version: %s\n", wine_version( ));  */
+
+
+    if( wParam == SIZE_MINIMIZED )
+    {
+        prev_wParam = SIZE_MINIMIZED;
+        return;
+    }
+    new_n_rows = n_ypixels / PDC_cyChar;
+    new_n_cols = n_xpixels / PDC_cxChar;
+    debug_printf( "Size was %d x %d; will be %d x %d\n",
+                PDC_n_rows, PDC_n_cols, new_n_rows, new_n_cols);
+    SP->resized = FALSE;
+
+    /* If the window will have a different number of rows */
+    /* or columns,  we put KEY_RESIZE in the key queue.   */
+    /* We don't do this if */
+    /* the resizing is the result of the window being    */
+    /* initialized,  or as a result of PDC_resize_screen */
+    /* being called.  In the latter case,  the user      */
+    /* presumably already knows the screen's been resized. */
+    if( PDC_n_rows != (int)new_n_rows || PDC_n_cols != (int)new_n_cols)
+    {
+        PDC_n_cols = new_n_cols;
+        PDC_n_rows = new_n_rows;
+        debug_printf( "prev_wParam = %d; add_resize_key = %d\n",
+                      (int)prev_wParam, add_resize_key);
+        if( prev_wParam != (WPARAM)-99 && add_resize_key)
+        {
+            /* don't add a key when the window is initialized */
+            add_key_to_queue( KEY_RESIZE);
+            SP->resized = TRUE;
+        }
+    }
+    else if( wine_version)
+        return;
+
+    add_resize_key = 1;
+    if( wParam == SIZE_RESTORED &&
+        ( n_xpixels % PDC_cxChar || n_ypixels % PDC_cyChar))
+    {
+        int new_xpixels = PDC_cxChar * PDC_n_cols;
+        int new_ypixels = PDC_cyChar * PDC_n_rows;
+
+        adjust_window_size( &new_xpixels, &new_ypixels,
+                            GetWindowLong( PDC_hWnd, GWL_STYLE), menu_shown);
+        debug_printf( "Irregular size\n");
+        SetWindowPos( PDC_hWnd, 0, 0, 0,
+                      new_xpixels, new_ypixels,
+                      SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
+
+    }
+
+    /* If the window has been restored from minimized form, */
+    /* we should repaint.  Otherwise,  don't.               */
+    prev_wParam = wParam;
+}
+
+static void HandleMouseMove( WPARAM wParam, LPARAM lParam,
+                      int* ptr_modified_key_to_return )
+{
+    const int mouse_x = LOWORD( lParam) / PDC_cxChar;
+    const int mouse_y = HIWORD( lParam) / PDC_cyChar;
+    static int prev_mouse_x, prev_mouse_y;
+
+    if( mouse_x != prev_mouse_x || mouse_y != prev_mouse_y)
+    {
+        int report_event = 0;
+
+        prev_mouse_x = mouse_x;
+        prev_mouse_y = mouse_y;
+        if( wParam & MK_LBUTTON)
+        {
+            PDC_mouse_rect.left = mouse_x;
+            PDC_mouse_rect.top = mouse_y;
+            if( SP->_trap_mbe & BUTTON1_MOVED)
+                report_event |= PDC_MOUSE_MOVED | 1;
+        }
+        if( wParam & MK_MBUTTON)
+            if( SP->_trap_mbe & BUTTON2_MOVED)
+                report_event |= PDC_MOUSE_MOVED | 2;
+        if( wParam & MK_RBUTTON)
+            if( SP->_trap_mbe & BUTTON3_MOVED)
+                report_event |= PDC_MOUSE_MOVED | 4;
+
+#ifdef CANT_DO_THINGS_THIS_WAY
+         /* Logic would dictate the following lines.  But with PDCurses */
+         /* as it's currently set up,  we've run out of bits and there  */
+         /* is no BUTTON4_MOVED or BUTTON5_MOVED.  Perhaps we need to   */
+         /* redefine _trap_mbe to be a 64-bit quantity?                 */
+            if( wParam & MK_XBUTTON1)
+                if( SP->_trap_mbe & BUTTON4_MOVED)
+                    report_event |= PDC_MOUSE_MOVED | 8;
+            if( wParam & MK_XBUTTON2)
+                if( SP->_trap_mbe & BUTTON5_MOVED)
+                    report_event |= PDC_MOUSE_MOVED | 16;
+#endif
+
+        if( !report_event)
+            if( SP->_trap_mbe & REPORT_MOUSE_POSITION)
+               report_event = PDC_MOUSE_POSITION;
+        if( report_event)
+        {
+            int i;
+
+            pdc_mouse_status.changes = report_event;
+            for( i = 0; i < 3; i++)
+            {
+                pdc_mouse_status.button[i] = (((report_event >> i) & 1) ?
+                    BUTTON_MOVED : 0);
+            }
+            *ptr_modified_key_to_return = 0;
+            set_mouse( -1, 0, lParam );
+        }             /* -1 to 'set_mouse' signals mouse move; 0 is ignored */
+    }
+}
+
+static void HandlePaint( HWND hwnd )
+{
+    PAINTSTRUCT ps;
+    HDC hdc;
+    RECT rect;
+
+    GetUpdateRect( hwnd, &rect, FALSE);
+/*  printf( "In HandlePaint: %ld %ld, %ld %ld\n",
+               rect.left, rect.top, rect.right, rect.bottom); */
+
+    hdc = BeginPaint( hwnd, &ps);
+
+    fix_up_edges( hdc, &rect);
+
+    if( curscr && curscr->_y)
+    {
+        int i, x1, n_chars;
+
+        x1 = rect.left / PDC_cxChar;
+        n_chars = rect.right / PDC_cxChar - x1 + 1;
+        if( n_chars > SP->cols - x1)
+            n_chars = SP->cols - x1;
+        if( n_chars > 0)
+        for( i = rect.top / PDC_cyChar; i <= rect.bottom / PDC_cyChar; i++)
+             if( i < SP->lines && curscr->_y[i])
+                 PDC_transform_line_given_hdc( hdc, i, x1,
+                                               n_chars, curscr->_y[i] + x1);
+    }
+    EndPaint( hwnd, &ps );
+}
+
+static bool key_already_handled = FALSE;
+
+static void HandleSyskeyDown( const WPARAM wParam, const LPARAM lParam,
+               int *ptr_modified_key_to_return )
+{
+    const int shift_pressed = (GetKeyState( VK_SHIFT) & 0x8000);
+    const int ctrl_pressed = (GetKeyState( VK_CONTROL) & 0x8000);
+    const int alt_pressed = (GetKeyState( VK_MENU) & 0x8000);
+    const int extended = ((lParam & 0x01000000) != 0);
+    const int repeated = (int)( lParam >> 30) & 1;
+    const KPTAB *kptr = kptab + wParam;
+    int key = 0;
+    static int repeat_count;
+
+    if( !repeated)
+        *ptr_modified_key_to_return = 0;
+
+    if( repeated)
+        repeat_count++;
+    else
+        repeat_count = 0;
+    if( SP->return_key_modifiers && !repeated)
+    {                     /* See notes above this function */
+        if( wParam == VK_SHIFT)
+        {
+            if( GetKeyState( VK_LSHIFT) & 0x8000)
+                *ptr_modified_key_to_return = KEY_SHIFT_L;
+            else if( GetKeyState( VK_RSHIFT) & 0x8000)
+                *ptr_modified_key_to_return = KEY_SHIFT_R;
+            else if(( HIWORD( lParam) & 0xff) == 0x36)
+                *ptr_modified_key_to_return = KEY_SHIFT_R;
+            else
+                *ptr_modified_key_to_return = KEY_SHIFT_L;
+        }
+        if( wParam == VK_CONTROL)
+            *ptr_modified_key_to_return =
+                                 (extended ? KEY_CONTROL_R : KEY_CONTROL_L);
+        if( wParam == VK_MENU)
+            *ptr_modified_key_to_return =
+                                 (extended ? KEY_ALT_R : KEY_ALT_L);
+    }
+
+    if( !key)           /* it's not a shift, ctl, alt handled above */
+    {
+        if( extended && kptr->extended != 999)
+            kptr = ext_kptab + kptr->extended;
+
+        if( alt_pressed)
+            key = kptr->alt;
+        else if( ctrl_pressed)
+            key = kptr->control;
+        else if( shift_pressed)
+            key = kptr->shift;
+        else
+            key = kptr->normal;
+    }
+
+    /* On non-US keyboards,  people hit Alt-Gr ("Alt-Ctrl" to */
+    /* those on US keyboards) to get characters not otherwise */
+    /* available:  accented characters,  local currency symbols, */
+    /* etc.  So we default to suppressing Alt-Ctrl-letter combos.     */
+    /* However,  apps can set PDC_show_ctrl_alts if they know they're */
+    /* running on a US keyboard layout (or other layout that doesn't  */
+    /* make special use of Ctrl-Alt... for example,  I use the Dvorak */
+    /* layout;  it's fine with PDC_show_ctrl_alts = 1.)               */
+    if( key >= KEY_MIN && key <= KEY_MAX)
+        if( !ctrl_pressed || !alt_pressed || PDC_show_ctrl_alts)
+            {
+            add_key_to_queue( key);
+            if( wParam == VK_MULTIPLY || wParam == VK_DIVIDE
+                   || wParam == VK_ADD || wParam == VK_SUBTRACT
+                   || wParam == VK_RETURN)
+               if( !alt_pressed)
+                  key_already_handled = TRUE;
+            }
+    pdc_key_modifiers = 0;
+    /* Save the key modifiers if required. Do this first to allow to
+       detect e.g. a pressed CTRL key after a hit of NUMLOCK. */
+
+    if (SP->save_key_modifiers)
+    {
+        if( alt_pressed)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_ALT;
+
+        if( shift_pressed)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_SHIFT;
+
+        if( ctrl_pressed)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_CONTROL;
+
+        if( GetKeyState( VK_NUMLOCK) & 1)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_NUMLOCK;
+
+        if( repeat_count)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_REPEAT;
+    }
+}
+
+/* Blinking text is supposed to blink twice a second.  Therefore,
+HandleTimer( ) is called every .5 seconds.
+
+   In truth,  it's not so much 'blinking' as 'changing certain types of
+text' that happens.  If text is really blinking (i.e.,  PDC_set_blink(TRUE)
+has been called),  we need to flip that text.  Or if text _was_ blinking
+and we've just called PDC_set_blink(FALSE),  all that text has to be
+redrawn in 'standout' mode.  Also,  if PDC_set_line_color() has been
+called,  all text with left/right/under/over/strikeout lines needs to
+be redrawn.
+
+   So.  After determining which attributes require redrawing (if any),
+we run through all of 'curscr' and look for text with those attributes
+set.  If we find such text,  we run it through PDC_transform_line.
+(To speed matters up slightly,  we skip over text at the start and end
+of each line that lacks the desired attributes. We could conceivably
+get more clever;  as it stands,  if the very first and very last
+characters are blinking,  we redraw the entire line,  even though
+everything in between may not require it.  But it would probably be a
+lot of code for little benefit.)
+
+   Note that by default,  we'll usually find that the line color hasn't
+changed and the 'blink mode' is still FALSE.  In that case,  attr_to_seek
+will be zero and the only thing we'll do here is to blink the cursor. */
+
+static void HandleTimer( const WPARAM wParam )
+{
+    int i;           /* see WndProc() notes */
+    extern int PDC_really_blinking;          /* see 'pdcsetsc.c' */
+    static int previously_really_blinking = 0;
+    static int prev_line_color = -1;
+    chtype attr_to_seek = 0;
+
+    if( prev_line_color != SP->line_color)
+        attr_to_seek = A_ALL_LINES;
+    if( PDC_really_blinking || previously_really_blinking)
+        attr_to_seek |= A_BLINK;
+    prev_line_color = SP->line_color;
+    previously_really_blinking = PDC_really_blinking;
+    PDC_blink_state ^= 1;
+    if( attr_to_seek)
+    {
+        for( i = 0; i < SP->lines; i++)
+        {
+            if( curscr->_y[i])
+            {
+                int j = 0, n_chars;
+                chtype *line = curscr->_y[i];
+
+                /* skip over starting text that isn't blinking: */
+                while( j < SP->cols && !(*line & attr_to_seek))
+                {
+                    j++;
+                    line++;
+                }
+                n_chars = SP->cols - j;
+                /* then skip over text at the end that's not blinking: */
+                while( n_chars && !(line[n_chars - 1] & attr_to_seek))
+                {
+                    n_chars--;
+                }
+                if( n_chars)
+                    PDC_transform_line( i, j, n_chars, line);
+            }
+/*          else
+                MessageBox( 0, "NULL _y[] found\n", "PDCurses", MB_OK);  */
+        }
+    }
+    if( SP->cursrow >=SP->lines || SP->curscol >= SP->cols
+        || SP->cursrow < 0 || SP->curscol < 0
+        || !curscr->_y || !curscr->_y[SP->cursrow])
+            debug_printf( "Cursor off-screen: %d %d, %d %d\n",
+                          SP->cursrow, SP->curscol, SP->lines, SP->cols);
+    else if( PDC_CURSOR_IS_BLINKING)
+             PDC_transform_line( SP->cursrow, SP->curscol, 1,
+                                 curscr->_y[SP->cursrow] + SP->curscol);
+}
+
+      /* Options to enlarge/shrink the font are currently commented out. */
+
+static HMENU set_menu( void)
+{
+    const HMENU hMenu = CreateMenu( );
+#ifdef PDC_WIDE
+    AppendMenu( hMenu, MF_STRING, WM_CHOOSE_FONT, L"Font");
+    AppendMenu( hMenu, MF_STRING, WM_PASTE, L"Paste");
+#else
+    AppendMenu( hMenu, MF_STRING, WM_CHOOSE_FONT, "Font");
+    AppendMenu( hMenu, MF_STRING, WM_PASTE, "Paste");
+#endif
+    return( hMenu);
+}
+
+INLINE void HandleMenuToggle( bool *ptr_ignore_resize)
+{
+    const bool is_zoomed = IsZoomed( PDC_hWnd);
+    HMENU hMenu;
+
+    menu_shown ^= 1;
+    hMenu = GetSystemMenu( PDC_hWnd, FALSE);
+    CheckMenuItem( hMenu, WM_TOGGLE_MENU, MF_BYCOMMAND
+                   | (menu_shown ? MF_CHECKED : MF_UNCHECKED));
+
+    if( !is_zoomed)
+        *ptr_ignore_resize = TRUE;
+    if( !menu_shown)
+    {
+        hMenu = GetMenu( PDC_hWnd);   /* destroy existing menu */
+        DestroyMenu( hMenu);
+        hMenu = CreateMenu( );        /* then set an empty menu */
+        SetMenu( PDC_hWnd, hMenu);
+    }
+    else
+    {
+        SetMenu( PDC_hWnd, set_menu( ));
+    }
+    *ptr_ignore_resize = FALSE;
+
+    if( !is_zoomed)
+    {
+        PDC_resize_screen( PDC_n_rows, PDC_n_cols );
+    }
+
+    InvalidateRect( PDC_hWnd, NULL, FALSE);
+}
+
+INLINE uint64_t milliseconds_since_1970( void)
+{
+   FILETIME ft;
+   const uint64_t jd_1601 = 2305813;  /* actually 2305813.5 */
+   const uint64_t jd_1970 = 2440587;  /* actually 2440587.5 */
+   const uint64_t ten_million = 10000000;
+   const uint64_t diff = (jd_1970 - jd_1601) * ten_million * 86400;
+   uint64_t decimicroseconds_since_1970;   /* i.e.,  time in units of 1e-7 seconds */
+
+   GetSystemTimeAsFileTime( &ft);
+   decimicroseconds_since_1970 = ((uint64_t)ft.dwLowDateTime |
+                                ((uint64_t)ft.dwHighDateTime << 32)) - diff;
+   return( decimicroseconds_since_1970 / 10000);
+}
+
+/* Note that there are two types of WM_TIMER timer messages.  One type
+indicates that SP->mouse_wait milliseconds have elapsed since a mouse
+button was pressed;  that's handled as described in the above notes.
+The other type,  issued every half second,  indicates that blinking
+should take place.  For these,  HandleTimer() is called (see above).
+
+   On WM_PAINT,  we determine what parts of 'curscr' would be covered by
+the update rectangle,  and run those through PDC_transform_line.
+
+   For determining left/right shift, alt,  and control,  I borrowed code
+from SDL.  Note that the Win32 version of PDCurses doesn't work correctly
+here for Win9x;  it just does GetKeyState( VK_LSHIFT),  etc.,  which is
+apparently not supported in Win9x.  So no matter which shift (or alt or
+Ctrl key) is hit,  the right-hand variant is returned in that library.
+The SDL handling,  and hence the handling below,  _does_ work on Win9x.
+Note,  though,  that in Win9x,  detection of the Shift keys is hardware
+dependent;  if you've an unusual keyboard,  both Shift keys may be
+detected as right, or both as left. */
+
+#if defined(_WIN32) && defined(__GNUC__)
+#define ALIGN_STACK __attribute__((force_align_arg_pointer))
+#else
+#define ALIGN_STACK
+#endif
+
+static LRESULT ALIGN_STACK CALLBACK WndProc (const HWND hwnd,
+                          const UINT message,
+                          const WPARAM wParam,
+                          const LPARAM lParam)
+{
+    int button_down = -1, button_up = -1;
+    static int mouse_buttons_pressed = 0;
+    static LPARAM mouse_lParam;
+    static uint64_t last_click_time[PDC_MAX_MOUSE_BUTTONS];
+                               /* in millisec since 1970 */
+    static int modified_key_to_return = 0;
+    const RECT before_rect = PDC_mouse_rect;
+    static bool ignore_resize = FALSE;
+
+    PDC_hWnd = hwnd;
+    if( !hwnd)
+        debug_printf( "Null hWnd: msg %u, wParam %x, lParam %lx\n",
+                     message, wParam, lParam);
+
+    switch (message)
+    {
+    case WM_SIZING:
+        HandleSizing( wParam, lParam );
+        return( TRUE );
+
+    case WM_SIZE:
+                /* If ignore_resize = 1,  don't bother resizing; */
+                /* the final window size has yet to be set       */
+        if( ignore_resize == FALSE)
+           HandleSize( wParam, lParam);
+        return 0 ;
+
+    case WM_MOUSEWHEEL:
+        debug_printf( "Mouse wheel: %x %lx\n", wParam, lParam);
+        modified_key_to_return = 0;
+        set_mouse( VERTICAL_WHEEL_EVENT, (short)( HIWORD(wParam)), lParam);
+        break;
+
+    case WM_MOUSEHWHEEL:
+        debug_printf( "Mouse horiz wheel: %x %lx\n", wParam, lParam);
+        modified_key_to_return = 0;
+        set_mouse( HORIZONTAL_WHEEL_EVENT, (short)( HIWORD(wParam)), lParam);
+        break;
+
+    case WM_MOUSEMOVE:
+        HandleMouseMove( wParam, lParam, &modified_key_to_return );
+        break;
+
+    case WM_LBUTTONDOWN:
+        PDC_mouse_rect.left = PDC_mouse_rect.right =
+                                  LOWORD( lParam) / PDC_cxChar;
+        PDC_mouse_rect.top = PDC_mouse_rect.bottom =
+                                  HIWORD( lParam) / PDC_cyChar;
+        PDC_selecting_rectangle = (wParam & MK_SHIFT);
+        SetCapture( hwnd);
+        button_down = 0;
+        break;
+
+    case WM_LBUTTONUP:
+        button_up = 0;
+        ReleaseCapture( );
+        if( (PDC_mouse_rect.left != PDC_mouse_rect.right ||
+             PDC_mouse_rect.top != PDC_mouse_rect.bottom) &&
+             (PDC_mouse_rect.right >= 0 && PDC_mouse_rect.left >= 0
+                        && curscr && curscr->_y) )
+        {
+            /* RR: will crash sometimes */
+            /* As an example on double-click of the title bar */
+            HandleBlockCopy();
+        }
+        PDC_mouse_rect.top = PDC_mouse_rect.bottom = -1;  /* now hide rect */
+        break;
+
+    case WM_RBUTTONDOWN:
+        button_down = 2;
+        SetCapture( hwnd);
+        break;
+
+    case WM_RBUTTONUP:
+        button_up = 2;
+        ReleaseCapture( );
+        break;
+
+    case WM_MBUTTONDOWN:
+        button_down = 1;
+        SetCapture( hwnd);
+        break;
+
+    case WM_MBUTTONUP:
+        button_up = 1;
+        ReleaseCapture( );
+        break;
+
+#if( PDC_MAX_MOUSE_BUTTONS >= 5)
+             /* WinGUI can support five mouse buttons.  But some may wish */
+             /* to leave PDC_MAX_MOUSE_BUTTONS=3,  for compatibility      */
+             /* with older PDCurses libraries.  Hence the above #if.      */
+    case WM_XBUTTONDOWN:
+        button_down = ((wParam & MK_XBUTTON1) ? 3 : 4);
+        SetCapture( hwnd);
+        break;
+
+    case WM_XBUTTONUP:
+#ifdef WRONG_WAY
+          /* You'd think we'd use the following line,  wouldn't you?      */
+          /* But we can't,  because an XBUTTONUP message doesn't actually */
+          /* tell you which button was released!  So we'll assume that    */
+          /* the released xbutton matches a pressed one;  and we've kept  */
+          /* track of which buttons are currently pressed.                */
+        button_up = ((wParam & MK_XBUTTON1) ? 3 : 4);
+#endif
+        button_up = (((mouse_buttons_pressed & 8) ||
+                 pdc_mouse_status.xbutton[0] & BUTTON_PRESSED) ? 3 : 4);
+        ReleaseCapture( );
+        break;
+#endif         /* #if( PDC_MAX_MOUSE_BUTTONS >= 5) */
+
+    case WM_MOVE:
+        return 0 ;
+
+    case WM_ERASEBKGND:      /* no need to erase background;  it'll */
+        return( 0);         /* all get painted over anyway */
+
+      /* The WM_PAINT routine is sort of "borrowed" from doupdate( ) from */
+      /* refresh.c.  I'm not entirely sure that this is what ought to be  */
+      /* done,  though it does appear to work correctly.                  */
+    case WM_PAINT:
+        if( hwnd && curscr )
+        {
+            HandlePaint( hwnd );
+        }
+        break;
+
+    case WM_KEYUP:
+    case WM_SYSKEYUP:
+        if( wParam == VK_MENU && numpad_unicode_value)
+        {
+            modified_key_to_return = numpad_unicode_value;
+            numpad_unicode_value = 0;
+            pdc_key_modifiers = 0;
+        }
+        if( modified_key_to_return )
+        {
+            add_key_to_queue( modified_key_to_return );
+            modified_key_to_return = 0;
+        }
+        break;
+
+    case WM_CHAR:       /* _Don't_ add Shift-Tab;  it's handled elsewhere */
+        if( wParam != 9 || !(GetKeyState( VK_SHIFT) & 0x8000))
+            if( !key_already_handled)
+               add_key_to_queue( (int)wParam );
+        key_already_handled = FALSE;
+        break;
+
+    case WM_KEYDOWN:
+    case WM_SYSKEYDOWN:
+        if( wParam < 225 && wParam > 0 )
+        {
+            HandleSyskeyDown( wParam, lParam, &modified_key_to_return );
+        }
+        return 0 ;
+
+    case WM_SYSCHAR:
+        return 0 ;
+
+    case WM_TIMER:
+        /* see notes above this function */
+        if( wParam != TIMER_ID_FOR_BLINKING )
+        {
+            static const int remap_table[PDC_MAX_MOUSE_BUTTONS] =
+                    { BUTTON1_PRESSED, BUTTON2_PRESSED, BUTTON3_PRESSED,
+                      BUTTON4_PRESSED, BUTTON5_PRESSED };
+
+            modified_key_to_return = 0;
+            if( SP && (SP->_trap_mbe & remap_table[wParam]))
+                set_mouse( (const int) wParam, BUTTON_PRESSED, mouse_lParam);
+            KillTimer( PDC_hWnd, (int)wParam);
+            mouse_buttons_pressed ^= (1 << wParam);
+        }
+        else if( SP && curscr && curscr->_y)
+        {
+            /* blink the blinking text */
+            HandleTimer( wParam );
+        }
+        break;
+
+    case WM_CLOSE:
+        {
+            if( !PDC_shutdown_key[FUNCTION_KEY_SHUT_DOWN])
+            {
+                final_cleanup( );
+                PDC_bDone = TRUE;
+                exit( 0);
+            }
+            else
+                add_key_to_queue( PDC_shutdown_key[FUNCTION_KEY_SHUT_DOWN]);
+        }
+        return( 0);
+
+    case WM_COMMAND:
+    case WM_SYSCOMMAND:
+        if( wParam == WM_EXIT_GRACELESSLY)
+        {
+            final_cleanup( );
+            PDC_bDone = TRUE;
+            exit( 0);
+        }
+        else if( wParam == WM_ENLARGE_FONT || wParam == WM_SHRINK_FONT)
+        {
+            adjust_font_size( (wParam == WM_ENLARGE_FONT) ? 1 : -1);
+            return( 0);
+        }
+        else if( wParam == WM_CHOOSE_FONT)
+        {
+            if( PDC_choose_a_new_font( ))
+                adjust_font_size( 0);
+            return( 0);
+        }
+        else if( wParam == WM_PASTE)
+        {
+            PDC_add_clipboard_to_key_queue( );
+        }
+        else if( wParam == WM_TOGGLE_MENU)
+        {
+            HandleMenuToggle( &ignore_resize);
+        }
+        break;
+
+    case WM_DESTROY:
+        PDC_LOG(("WM_DESTROY\n"));
+        PostQuitMessage (0) ;
+        PDC_bDone = TRUE;
+        return 0 ;
+    }
+
+    if( hwnd)
+       show_mouse_rect( hwnd, before_rect, PDC_mouse_rect);
+
+    if( button_down >= 0)
+    {
+        modified_key_to_return = 0;
+        SetTimer( hwnd, button_down, SP->mouse_wait, NULL);
+        mouse_buttons_pressed |= (1 << button_down);
+        mouse_lParam = lParam;
+    }
+    if( button_up >= 0)
+    {
+        int message_to_send = -1;
+
+        modified_key_to_return = 0;
+        if( (mouse_buttons_pressed >> button_up) & 1)
+        {
+            const uint64_t curr_click_time =
+                             milliseconds_since_1970( );
+            static const int double_remap_table[PDC_MAX_MOUSE_BUTTONS] =
+                      { BUTTON1_DOUBLE_CLICKED, BUTTON2_DOUBLE_CLICKED,
+                        BUTTON3_DOUBLE_CLICKED, BUTTON4_DOUBLE_CLICKED,
+                        BUTTON5_DOUBLE_CLICKED };
+            static const int triple_remap_table[PDC_MAX_MOUSE_BUTTONS] =
+                      { BUTTON1_TRIPLE_CLICKED, BUTTON2_TRIPLE_CLICKED,
+                        BUTTON3_TRIPLE_CLICKED, BUTTON4_TRIPLE_CLICKED,
+                        BUTTON5_TRIPLE_CLICKED };
+            static int n_previous_clicks;
+
+            if( curr_click_time <
+                             last_click_time[button_up] + 2 * SP->mouse_wait)
+               n_previous_clicks++;       /* 'n_previous_clicks' will be  */
+            else                         /* zero for a "normal" click, 1  */
+               n_previous_clicks = 0;   /* for a dblclick, 2 for a triple */
+
+            if( n_previous_clicks >= 2 &&
+                            (SP->_trap_mbe & triple_remap_table[button_up]))
+                message_to_send = BUTTON_TRIPLE_CLICKED;
+            else if( n_previous_clicks >= 1 &&
+                            (SP->_trap_mbe & double_remap_table[button_up]))
+                message_to_send = BUTTON_DOUBLE_CLICKED;
+            else         /* either it's not a doubleclick, or we aren't */
+            {            /* checking for double clicks */
+                static const int remap_table[PDC_MAX_MOUSE_BUTTONS] =
+                          { BUTTON1_CLICKED, BUTTON2_CLICKED, BUTTON3_CLICKED,
+                            BUTTON4_CLICKED, BUTTON5_CLICKED };
+
+                if( SP->_trap_mbe & remap_table[button_up])
+                    message_to_send = BUTTON_CLICKED;
+            }
+            KillTimer( hwnd, button_up);
+            mouse_buttons_pressed ^= (1 << button_up);
+            last_click_time[button_up] = curr_click_time;
+        }
+        if( message_to_send == -1)   /* might just send as a 'released' msg */
+        {
+            static const int remap_table[PDC_MAX_MOUSE_BUTTONS] =
+                     { BUTTON1_RELEASED, BUTTON2_RELEASED, BUTTON3_RELEASED,
+                       BUTTON4_RELEASED, BUTTON5_RELEASED };
+
+            if( SP->_trap_mbe & remap_table[button_up])
+                message_to_send = BUTTON_RELEASED;
+        }
+        if( message_to_send != -1)
+            set_mouse( button_up, message_to_send, lParam);
+    }
+
+    return DefWindowProc( hwnd, message, wParam, lParam) ;
+}
+
+      /* Default behaviour is that,  when one clicks on the 'close' button, */
+      /* exit( 0) is called,  just as in the SDL and X11 versions.  But if  */
+      /* one wishes,  one can call PDC_set_shutdown_key to cause those      */
+      /* buttons to put a specified character into the input queue.  It's   */
+      /* then the application's problem to exit gracefully,  perhaps with   */
+      /* messages such as 'are you sure' and so forth.                      */
+      /*   If you've set a shutdown key,  there's always a risk that the    */
+      /* program will get stuck in a loop and never process said key.  So   */
+      /* when the key is set,  a 'Kill' item is appended to the system menu */
+      /* so that the user still has some way to terminate the app,  albeit  */
+      /* with extreme prejudice (i.e.,  click on 'Kill' and exit is called  */
+      /* and the app exits gracelessly.)                                    */
+
+int PDC_set_function_key( const unsigned function, const int new_key)
+{
+    int old_key = -1;
+
+    if( function < PDC_MAX_FUNCTION_KEYS)
+    {
+         old_key = PDC_shutdown_key[function];
+         PDC_shutdown_key[function] = new_key;
+    }
+
+    if( function == FUNCTION_KEY_SHUT_DOWN)
+        if( (new_key && !old_key) || (old_key && !new_key))
+        {
+            HMENU hMenu = GetSystemMenu( PDC_hWnd, FALSE);
+
+            if( new_key)
+                AppendMenu( hMenu, MF_STRING, WM_EXIT_GRACELESSLY, _T( "Kill"));
+            else
+                RemoveMenu( hMenu, WM_EXIT_GRACELESSLY, MF_BYCOMMAND);
+        }
+    return( old_key);
+}
+
+/* https://msdn.microsoft.com/en-us/library/windows/desktop/dd162826(v=vs.85).aspx
+The code at the above link provides general methods for positioning a window
+on a multiple-display setup.  The only instance we're using is the
+MONITOR_WORKAREA one,  which ensures that even if monitor geometry changes,
+the window will still be entirely on-screen.
+
+These functions entered the Win32 API with Windows 2000.  If
+MONITOR_DEFAULTTONEAREST isn't defined,  we shouldn't try to do this.  */
+
+#ifdef MONITOR_DEFAULTTONEAREST
+
+static void clip_or_center_rect_to_monitor( LPRECT prc)
+{
+    HMONITOR hMonitor;
+    MONITORINFO mi;
+    RECT        rc;
+    const int   w = prc->right  - prc->left;
+    const int   h = prc->bottom - prc->top;
+
+    hMonitor = MonitorFromRect(prc, MONITOR_DEFAULTTONEAREST);
+
+    mi.cbSize = sizeof(mi);
+    GetMonitorInfo(hMonitor, &mi);
+
+    rc = mi.rcMonitor;
+
+    prc->left   = max(rc.left, min(rc.right-w,  prc->left));
+    prc->top    = max(rc.top,  min(rc.bottom-h, prc->top));
+    prc->right  = prc->left + w;
+    prc->bottom = prc->top  + h;
+}
+
+static void clip_or_center_window_to_monitor( HWND hwnd)
+{
+    RECT rc;
+
+    GetWindowRect(hwnd, &rc);
+    clip_or_center_rect_to_monitor(&rc);
+    SetWindowPos(hwnd, NULL, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
+}
+#endif
+
+/* By default,  the user cannot resize the window.  This is because
+many apps don't handle KEY_RESIZE,  and one can get odd behavior
+in such cases.  There are two ways around this.  If you call
+PDC_set_resize_limits( ) before initwin( ),  telling WinGUI exactly how
+large/small the window can be,  the window will be user-resizable.  Or
+you can set ttytype[0...3] to contain the resize limits.   A call such as
+
+PDC_set_resize_limits( 42, 42, 135, 135);
+
+   will result in the window being fixed at 42 lines by 135 columns.
+
+PDC_set_resize_limits( 20, 50, 70, 200);
+
+   will mean the window can have 20 to 50 lines and 70 to 200 columns.
+The user will be able to resize the window freely within those limits.
+See 'newtest.c' (in the 'demos' folder) for an example.
+
+   This function is used in only one place (PDC_scr_open( )),  so
+it's inlined. */
+
+INLINE int set_up_window( void)
+{
+    /* create the dialog window  */
+    WNDCLASS   wndclass ;
+    HMENU hMenu;
+    HANDLE hInstance = GetModuleHandleA( NULL);
+    int n_default_columns = 80;
+    int n_default_rows = 25;
+    int xsize, ysize, window_style;
+    int xloc = CW_USEDEFAULT;
+    int yloc = CW_USEDEFAULT;
+    TCHAR WindowTitle[MAX_PATH];
+    const TCHAR *AppName = _T( "Curses_App");
+    HICON icon;
+    static bool wndclass_has_been_registered = FALSE;
+
+    if( !hInstance)
+        debug_printf( "No instance: %d\n", GetLastError( ));
+    originally_focussed_window = GetForegroundWindow( );
+    debug_printf( "hInstance %x\nOriginal window %x\n", hInstance, originally_focussed_window);
+    /* set the window icon from the icon in the process */
+    icon = get_app_icon();
+    if( !icon )
+       icon = LoadIcon( NULL, IDI_APPLICATION);
+    if( !wndclass_has_been_registered)
+    {
+        ATOM rval;
+
+        wndclass.style         = CS_VREDRAW ;
+        wndclass.lpfnWndProc   = WndProc ;
+        wndclass.cbClsExtra    = 0 ;
+        wndclass.cbWndExtra    = 0 ;
+        wndclass.hInstance     = hInstance ;
+        wndclass.hIcon         = icon;
+        wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
+        wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
+        wndclass.lpszMenuName  = NULL ;
+        wndclass.lpszClassName = AppName ;
+
+        rval = RegisterClass( &wndclass) ;
+        if( !rval)
+        {
+            const DWORD last_error = GetLastError( );
+
+            debug_printf( "RegisterClass failed: GetLastError = %lx\n", last_error);
+            return( -1);
+        }
+        wndclass_has_been_registered = TRUE;
+    }
+
+    get_app_name( WindowTitle, MAX_PATH, TRUE);
+#ifdef PDC_WIDE
+    debug_printf( "WindowTitle = '%ls'\n", WindowTitle);
+#endif
+
+    get_default_sizes_from_registry( &n_default_columns, &n_default_rows, &xloc, &yloc,
+                     &menu_shown);
+    if( PDC_n_rows > 2 && PDC_n_cols > 2)
+    {
+        n_default_columns = PDC_n_cols;
+        n_default_rows    = PDC_n_rows;
+    }
+    if( ttytype[1])
+        PDC_set_resize_limits( (unsigned char)ttytype[0],
+                               (unsigned char)ttytype[1],
+                               (unsigned char)ttytype[2],
+                               (unsigned char)ttytype[3]);
+    debug_printf( "Size %d x %d,  loc %d x %d;  menu %d\n",
+               n_default_columns, n_default_rows, xloc, yloc, menu_shown);
+    get_character_sizes( NULL, &PDC_cxChar, &PDC_cyChar);
+
+    if( min_lines != max_lines || min_cols != max_cols)
+        window_style = ((n_default_columns == -1) ?
+                    WS_MAXIMIZE | WS_OVERLAPPEDWINDOW : WS_OVERLAPPEDWINDOW);
+    else  /* fixed-size window:  looks "normal",  but w/o a maximize box */
+        window_style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+
+    if( n_default_columns == -1)
+        xsize = ysize = CW_USEDEFAULT;
+    else
+    {
+        keep_size_within_bounds( &n_default_rows, &n_default_columns);
+        xsize = PDC_cxChar * n_default_columns;
+        ysize = PDC_cyChar * n_default_rows;
+        adjust_window_size( &xsize, &ysize, window_style, menu_shown);
+    }
+
+    PDC_hWnd = CreateWindow( AppName, WindowTitle, window_style,
+                    xloc, yloc,
+                    xsize, ysize,
+                    NULL, (menu_shown ? set_menu( ) : NULL),
+                    hInstance, NULL) ;
+
+    if( !PDC_hWnd)
+    {
+        const DWORD last_error = GetLastError( );
+
+        debug_printf( "CreateWindow failed; GetLastError = %ld", last_error);
+        return( -2);
+    }
+
+    hMenu = GetSystemMenu( PDC_hWnd, FALSE);
+    AppendMenu( hMenu, MF_STRING | (menu_shown ? MF_CHECKED : MF_UNCHECKED), WM_TOGGLE_MENU, _T( "Menu"));
+    AppendMenu( hMenu, MF_STRING, WM_CHOOSE_FONT, _T( "Choose Font"));
+
+    debug_printf( "menu set\n");
+
+    ShowWindow (PDC_hWnd,
+                    (n_default_columns == -1) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL);
+    debug_printf( "window shown\n");
+    ValidateRect( PDC_hWnd, NULL);       /* don't try repainting */
+    UpdateWindow (PDC_hWnd) ;
+    debug_printf( "window updated\n");
+    SetTimer( PDC_hWnd, TIMER_ID_FOR_BLINKING, 500, NULL);
+    debug_printf( "timer set\n");
+
+#ifdef MONITOR_DEFAULTTONEAREST
+    /* if the window is off-screen, move it on screen. */
+    clip_or_center_window_to_monitor( PDC_hWnd);
+#endif
+
+    return( 0);
+}
+
+/* open the physical screen -- allocate SP, miscellaneous intialization,
+   and may save the existing screen for later restoration.
+
+   Deciding on a for-real maximum screen size has proven difficult.
+   But there is really no particularly good reason to set such a maximum.
+   If one does,  you get some tricky issues:  suppose the user drags the
+   window to create a screen larger than MAX_LINES or MAX_COLUMNS?  My
+   hope is to evade that problem by just setting those constants to be...
+   well... unrealistically large.  */
+
+#define MAX_LINES   50000
+#define MAX_COLUMNS 50000
+
+int PDC_scr_open( int argc, char **argv)
+{
+    int i, r, g, b;
+    HMODULE hntdll = GetModuleHandle( _T("ntdll.dll"));
+
+    if( hntdll)
+        wine_version = (wine_version_func)GetProcAddress(hntdll, "wine_get_version");
+
+    PDC_LOG(("PDC_scr_open() - called\n"));
+    SP = calloc(1, sizeof(SCREEN));
+    color_pair_indices = (short *)calloc(PDC_COLOR_PAIRS * 2, sizeof( short));
+    pdc_rgbs = (COLORREF *)calloc(N_COLORS, sizeof( COLORREF));
+    if (!SP || !color_pair_indices || !pdc_rgbs)
+        return ERR;
+
+    debug_printf( "colors alloc\n");
+    COLORS = N_COLORS;  /* should give this a try and see if it works! */
+    for( i = 0; i < 16; i++)
+    {
+        const int intensity = ((i & 8) ? 0xff : 0xc0);
+
+        pdc_rgbs[i] = RGB( ((i & COLOR_RED) ? intensity : 0),
+                           ((i & COLOR_GREEN) ? intensity : 0),
+                           ((i & COLOR_BLUE) ? intensity : 0));
+    }
+           /* 256-color xterm extended palette:  216 colors in a
+            6x6x6 color cube,  plus 24 (not 50) shades of gray */
+    for( r = 0; r < 6; r++)
+        for( g = 0; g < 6; g++)
+            for( b = 0; b < 6; b++)
+                pdc_rgbs[i++] = RGB( r ? r * 40 + 55 : 0,
+                                   g ? g * 40 + 55 : 0,
+                                   b ? b * 40 + 55 : 0);
+    for( i = 0; i < 24; i++)
+        pdc_rgbs[i + 232] = RGB( i * 10 + 8, i * 10 + 8, i * 10 + 8);
+    SP->mouse_wait = PDC_CLICK_PERIOD;
+    SP->visibility = 0;                /* no cursor,  by default */
+    SP->curscol = SP->cursrow = 0;
+    SP->audible = TRUE;
+    SP->mono = FALSE;
+
+    /* note: we parse the non-wide argc (see comment in header),
+       therefore using non-wide char handling here */
+    if( argc && argv)         /* store a copy of the input arguments */
+    {
+        PDC_argc = argc;
+        PDC_argv = (char **)calloc( argc + 1, sizeof( char *));
+        for( i = 0; i < argc; i++)
+        {
+            PDC_argv[i] = (char *)malloc( strlen( argv[i]) + 1);
+            strcpy( PDC_argv[i], argv[i]);
+        }
+    }
+
+    if( set_up_window( ))
+    {
+        fprintf( stderr, "set_up_window failed\n");
+        return ERR;
+    }
+    debug_printf( "Back from set_up_window\n");
+    while( !PDC_get_rows( ))     /* wait for screen to be drawn and */
+      ;                          /* actual size to be determined    */
+
+    debug_printf( "Back from PDC_get_rows\n");
+    SP->lines = PDC_get_rows();
+    SP->cols = PDC_get_columns();
+
+    if (SP->lines < 2 || SP->lines > MAX_LINES
+       || SP->cols < 2 || SP->cols > MAX_COLUMNS)
+    {
+        fprintf(stderr, "LINES value must be >= 2 and <= %d: got %d\n",
+                MAX_LINES, SP->lines);
+        fprintf(stderr, "COLS value must be >= 2 and <= %d: got %d\n",
+                MAX_COLUMNS, SP->cols);
+
+        return ERR;
+    }
+
+/*  PDC_reset_prog_mode();   doesn't do anything anyway */
+    debug_printf( "...we're done\n");
+    return OK;
+}
+
+/* the core of resize_term() */
+
+int PDC_resize_screen( int nlines, int ncols)
+{
+    if( !stdscr)        /* window hasn't been created yet;  we're */
+    {                   /* specifying its size before doing so    */
+        PDC_n_rows = nlines;
+        PDC_n_cols = ncols;
+        return OK;
+    }
+    SP->resized = FALSE;
+    debug_printf( "Incoming: %d %d\n", nlines, ncols);
+    if( nlines >= 2 && ncols >= 2 && PDC_cxChar && PDC_cyChar && PDC_hWnd &&
+                  !IsZoomed( PDC_hWnd) /* && WaitResult == WAIT_OBJECT_0 */)
+    {
+        RECT rect, client_rect;
+        int new_width;
+        int new_height;
+
+        GetWindowRect( PDC_hWnd, &rect);
+        GetClientRect( PDC_hWnd, &client_rect);
+        debug_printf( "Outgoing: %d %d\n", nlines, ncols);
+        new_width = ncols * PDC_cxChar;
+        new_height = nlines * PDC_cyChar;
+
+        if( new_width != client_rect.right || new_height != client_rect.bottom)
+        {                    /* check to make sure size actually changed */
+            add_resize_key = 0;
+            SetWindowPos( PDC_hWnd, 0, 0, 0,
+                   new_width + (rect.right - rect.left) - client_rect.right,
+                   new_height + (rect.bottom - rect.top) - client_rect.bottom,
+                  SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
+        }
+    }
+    return OK;
+}
+
+void PDC_reset_prog_mode(void)
+{
+    PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
+#ifdef NOT_CURRENTLY_IN_USE
+    if( PDC_bDone == FALSE && PDC_hWnd)
+    {
+        PDC_bDone = TRUE;
+        SetForegroundWindow( PDC_hWnd);
+    }
+#endif
+}
+
+void PDC_reset_shell_mode(void)
+{
+}
+
+void PDC_restore_screen_mode(int i)
+{
+}
+
+void PDC_save_screen_mode(int i)
+{
+}
+
+/* NOTE:  as with PDC_init_color() (see below),  this function has to
+redraw all text with color attribute 'pair' to match the newly-set
+foreground and background colors.  The loops to go through every character
+in curscr,  looking for those that need to be redrawn and ignoring
+those at the front and start of each line,  are very similar. */
+
+static short get_pair( const chtype ch)
+{
+   return( (short)( (ch & A_COLOR) >> PDC_COLOR_SHIFT));
+}
+
+void PDC_init_pair( short pair, short fg, short bg)
+{
+    if( color_pair_indices[pair] != fg ||
+        color_pair_indices[pair + PDC_COLOR_PAIRS] != bg)
+    {
+        color_pair_indices[pair] = fg;
+        color_pair_indices[pair + PDC_COLOR_PAIRS] = bg;
+        /* Possibly go through curscr and redraw everything with that color! */
+        if( curscr && curscr->_y)
+        {
+            int i;
+
+            for( i = 0; i < SP->lines; i++)
+                if( curscr->_y[i])
+                {
+                    int j = 0, n_chars;
+                    chtype *line = curscr->_y[i];
+
+             /* skip over starting text that isn't of the desired color: */
+                    while( j < SP->cols && get_pair( *line) != pair)
+                    {
+                        j++;
+                        line++;
+                    }
+                    n_chars = SP->cols - j;
+            /* then skip over text at the end that's not the right color: */
+                    while( n_chars && get_pair( line[n_chars - 1]) != pair)
+                        n_chars--;
+                    if( n_chars)
+                        PDC_transform_line( i, j, n_chars, line);
+                }
+        }
+    }
+}
+
+int PDC_pair_content( short pair, short *fg, short *bg)
+{
+    *fg = color_pair_indices[pair];
+    *bg = color_pair_indices[pair + PDC_COLOR_PAIRS];
+    return OK;
+}
+
+bool PDC_can_change_color(void)
+{
+    return TRUE;
+}
+
+int PDC_color_content( short color, short *red, short *green, short *blue)
+{
+    COLORREF col = pdc_rgbs[color];
+
+    *red = DIVROUND(GetRValue(col) * 1000, 255);
+    *green = DIVROUND(GetGValue(col) * 1000, 255);
+    *blue = DIVROUND(GetBValue(col) * 1000, 255);
+
+    return OK;
+}
+
+/* We have an odd problem when changing colors with PDC_init_color().  On
+palette-based systems,  you just change the palette and the hardware takes
+care of the rest.  Here,  though,  we actually need to redraw any text that's
+drawn in the specified color.  So we gotta look at each character and see if
+either the foreground or background matches the index that we're changing.
+Then, that text gets redrawn.  For speed/simplicity,  the code looks for the
+first and last character in each line that would be affected, then draws those
+in between (frequently,  this will be zero characters, i.e., no text on that
+particular line happens to use the color index in question.)  See similar code
+above for PDC_init_pair(),  to handle basically the same problem. */
+
+static int color_used_for_this_char( const chtype c, const int idx)
+{
+    const int color = get_pair( c);
+    const int rval = (color_pair_indices[color] == idx ||
+                     color_pair_indices[color + PDC_COLOR_PAIRS] == idx);
+
+    return( rval);
+}
+
+int PDC_init_color( short color, short red, short green, short blue)
+{
+    const COLORREF new_rgb = RGB(DIVROUND(red * 255, 1000),
+                                 DIVROUND(green * 255, 1000),
+                                 DIVROUND(blue * 255, 1000));
+
+    if( pdc_rgbs[color] != new_rgb)
+    {
+        pdc_rgbs[color] = new_rgb;
+        /* Possibly go through curscr and redraw everything with that color! */
+        if( curscr && curscr->_y)
+        {
+            int i;
+
+            for( i = 0; i < SP->lines; i++)
+                if( curscr->_y[i])
+                {
+                    int j = 0, n_chars;
+                    chtype *line = curscr->_y[i];
+
+             /* skip over starting text that isn't of the desired color: */
+                    while( j < SP->cols
+                                 && !color_used_for_this_char( *line, color))
+                    {
+                        j++;
+                        line++;
+                    }
+                    n_chars = SP->cols - j;
+            /* then skip over text at the end that's not the right color: */
+                    while( n_chars &&
+                         !color_used_for_this_char( line[n_chars - 1], color))
+                        n_chars--;
+                    if( n_chars)
+                        PDC_transform_line( i, j, n_chars, line);
+                }
+        }
+    }
+    return OK;
+}