curses 1.3.0 → 1.4.2

data/vendor/PDCurses/vt/pdcgetsc.c

@@ -0,0 +1,27 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+int PDC_get_cursor_mode(void)
+{
+    PDC_LOG(("PDC_get_cursor_mode() - called\n"));
+
+    return SP->visibility;
+}
+
+
+int PDC_get_columns(void)
+{
+    extern int PDC_cols;
+
+    PDC_LOG(("PDC_get_columns() - called\n"));
+    return( PDC_cols);
+}
+
+int PDC_get_rows(void)
+{
+    extern int PDC_rows;
+
+    PDC_LOG(("PDC_get_rows() - called\n"));
+    return( PDC_rows);
+}

data/vendor/PDCurses/vt/pdckbd.c

@@ -0,0 +1,394 @@
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#if defined( _WIN32) || defined( DOS)
+   #include <conio.h>
+   #define USE_CONIO
+#else
+   #include <sys/select.h>
+   #include <unistd.h>
+#endif
+#include "curspriv.h"
+
+#if defined( __BORLANDC__) || defined( DOS)
+   #define WINDOWS_VERSION_OF_KBHIT kbhit
+#else
+   #define WINDOWS_VERSION_OF_KBHIT _kbhit
+#endif
+
+/* Modified from the accepted answer at
+
+https://stackoverflow.com/questions/33025599/move-the-cursor-in-a-c-program
+
+_kbhit( ) returns -1 if no key has been hit,  and the keycode if one
+has been hit.  You can just loop on it until the return value is >= 0.
+Hitting a function or arrow or similar key will cause 27 (escape) to
+be returned,  followed by cryptic codes that depend on what terminal
+emulation is in place.
+
+   Further info on VT100/ANSI control sequences is at
+
+https://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html
+*/
+
+extern bool PDC_resize_occurred;
+
+static bool check_key( int *c)
+{
+    bool rval;
+#ifndef USE_CONIO
+    const int STDIN = 0;
+    struct timeval timeout;
+    fd_set rdset;
+
+    if( PDC_resize_occurred)
+       return( TRUE);
+    FD_ZERO( &rdset);
+    FD_SET( STDIN, &rdset);
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 0;
+    if( select( STDIN + 1, &rdset, NULL, NULL, &timeout) > 0)
+       {
+       rval = TRUE;
+       if( c)
+          *c = getchar( );
+       }
+    else
+       rval = FALSE;
+#else
+    if( WINDOWS_VERSION_OF_KBHIT( ))
+       {
+       rval = TRUE;
+       if( c)
+          *c = _getch( );
+       }
+    else
+       rval = FALSE;
+#endif
+    return( rval);
+}
+
+bool PDC_check_key( void)
+{
+   return( check_key( NULL));
+}
+
+void PDC_flushinp( void)
+{
+   int thrown_away_char;
+
+   while( check_key( &thrown_away_char))
+      ;
+}
+
+#ifdef USE_CONIO
+static int xlate_vt_codes_for_dos( const int key1, const int key2)
+{
+   static const int tbl[] =   {
+      KEY_UP,      72,
+      KEY_DOWN,    80,
+      KEY_LEFT,    75,
+      KEY_RIGHT,   77,
+      KEY_F(11),  133,
+      KEY_F(12),  134,
+      KEY_IC,      82,
+      KEY_DC,      83,
+      KEY_PPAGE,   73,
+      KEY_NPAGE,   81,
+      KEY_HOME, 2, '[', 'H',
+      KEY_END,  2, 'O', 'F',
+
+      KEY_F(1),   59,
+      KEY_F(2),   60,
+      KEY_F(3),   61,
+      KEY_F(4),   62,
+      KEY_F(5),   63,
+      KEY_F(6),   64,
+      KEY_F(7),   65,
+      KEY_F(8),   66,
+      KEY_F(9),   67,
+      KEY_F(10),   68,
+      0, 0 };
+   int i, rval = 0;
+
+   for( i = 0; tbl[i] && !rval; i += 2)
+      if( key2 == tbl[i + 1])
+         rval = tbl[i];
+   return( rval);
+}
+
+#endif
+/* Mouse events include six bytes.  First three are
+
+ESC [ M
+
+   Next byte is 96 for mouse wheel up,  97 for down,  or (for more
+"traditional" mouse events) 32 plus :
+
+   0 for button 1
+   1 for button 2
+   2 for button 3
+   3 for release
+   4 if Shift is pressed
+   8 if Alt (Meta) is pressed
+   16 if Ctrl is pressed
+
+   Note that 'release' doesn't tell you _which_ is released.  If only
+one has been pressed (the usual case),  it's presumably the one you
+released.  If two or more buttons are pressed simultaneously,  the
+"releases" are reported in the numerical order of the buttons,  not
+the order in which they're actually released (which we don't know).
+
+   My tilt mouse reports 'tilt left' as a left button (1) and 'tilt right'
+as a middle button press.  Wheel events get shift,  alt,  ctrl added in
+(but that doesn't seem to be getting through in PDCurses... to be fixed).
+Button events only get Ctrl (though I think you might get the other events
+on some terminals).
+
+   "Correct" mouse handling will require that we detect a button-down,
+then hold off for SP->mouse_wait to see if we get a release event.  */
+
+static int xlate_vt_codes( const int *c, const int count)
+{
+   static const int tbl[] =  {
+               KEY_UP,   2, '[', 'A',
+               KEY_DOWN, 2, '[', 'B',
+               KEY_LEFT, 2, '[', 'D',
+               KEY_RIGHT,2, '[', 'C',
+               KEY_HOME, 2, 'O', 'H',
+               KEY_HOME, 2, '[', 'H',
+               KEY_END,  2, 'O', 'F',
+               KEY_END,  2, '[', 'F',
+               KEY_B2,   2, '[', 'E',
+               KEY_IC,   3, '[', '2', '~',
+               KEY_DC,   3, '[', '3', '~',
+               KEY_PPAGE, 3, '[', '5', '~',
+               KEY_NPAGE, 3, '[', '6', '~',
+
+               CTL_LEFT,  5, '[', '1', ';', '5', 'D',
+               CTL_RIGHT, 5, '[', '1', ';', '5', 'C',
+               CTL_UP,    5, '[', '1', ';', '5', 'A',
+               CTL_DOWN,  5, '[', '1', ';', '5', 'B',
+
+               ALT_PGUP, 5, '[', '5', ';', '3', '~',
+               ALT_PGDN, 5, '[', '6', ';', '3', '~',
+
+               KEY_F(1), 3, '[', '[', 'A',      /* Linux console */
+               KEY_F(2), 3, '[', '[', 'B',
+               KEY_F(3), 3, '[', '[', 'C',
+               KEY_F(4), 3, '[', '[', 'D',
+               KEY_F(5), 3, '[', '[', 'E',
+               KEY_END,  3, '[', '4', '~',
+               KEY_HOME, 3, '[', '1', '~',
+
+               KEY_F(1), 2, 'O', 'P',
+               KEY_F(1), 4, '[', '1', '1', '~',
+               KEY_F(2), 2, 'O', 'Q',
+               KEY_F(2), 4, '[', '1', '2', '~',
+               KEY_F(3), 2, 'O', 'R',
+               KEY_F(3), 4, '[', '1', '3', '~',
+               KEY_F(4), 2, 'O', 'S',
+               KEY_F(4), 4, '[', '1', '4', '~',
+               KEY_F(5), 4, '[', '1', '5', '~',
+               KEY_F(6), 4, '[', '1', '7', '~',
+               KEY_F(7), 4, '[', '1', '8', '~',
+               KEY_F(8), 4, '[', '1', '9', '~',
+               KEY_F(9), 4, '[', '2', '0', '~',
+               KEY_F(10), 4, '[', '2', '1', '~',
+               KEY_F(11), 4, '[', '2', '3', '~',
+               KEY_F(12), 4, '[', '2', '4', '~',
+               KEY_F(13), 5, '[', '1', ';', '2', 'P',      /* shift-f1 */
+               KEY_F(14), 5, '[', '1', ';', '2', 'Q',
+               KEY_F(15), 5, '[', '1', ';', '2', 'R',
+               KEY_F(16), 5, '[', '1', ';', '2', 'S',
+               KEY_F(17), 6, '[', '1', '5', ';', '2', '~',  /* shift-f5 */
+               KEY_F(18), 6, '[', '1', '7', ';', '2', '~',
+               KEY_F(19), 6, '[', '1', '8', ';', '2', '~',
+               KEY_F(20), 6, '[', '1', '9', ';', '2', '~',
+               KEY_F(21), 6, '[', '2', '0', ';', '2', '~',
+               KEY_F(22), 6, '[', '2', '1', ';', '2', '~',
+               KEY_F(23), 6, '[', '2', '3', ';', '2', '~',  /* shift-f11 */
+               KEY_F(24), 6, '[', '2', '4', ';', '2', '~',
+               27, 0,
+               0 };
+   int i, rval = -1;
+   const int *tptr;
+
+   if( count == 1)
+      {
+      if( c[0] >= 'a' && c[0] <= 'z')
+         rval = ALT_A + c[0] - 'a';
+      if( c[0] >= '0' && c[0] <= '9')
+         rval = ALT_0 + c[0] - '0';
+      }
+   else if( count == 5 && c[0] == '[' && c[1] == 'M')
+      rval = KEY_MOUSE;
+   for( tptr = tbl; rval == -1 && *tptr; tptr += 2 + tptr[1])
+      if( count == tptr[1])
+         {
+         i = 0;
+         while( tptr[i + 2] == c[i] && i < count)
+            i++;
+         if( i == count)
+            rval = tptr[0];
+         }
+   return( rval);
+}
+
+int PDC_get_key( void)
+{
+   int rval = -1;
+
+   if( PDC_resize_occurred)
+      {
+      PDC_resize_occurred = FALSE;
+      return( KEY_RESIZE);
+      }
+   if( check_key( &rval))
+      {
+      int c[13];
+
+#ifdef USE_CONIO
+      SP->key_code = (rval == 0 || rval == 224);
+      if( SP->key_code)
+         {
+         int key2;
+
+         while( !check_key( &key2))
+            ;
+         rval = xlate_vt_codes_for_dos( rval, key2);
+         return( rval);
+         }
+
+#endif
+      SP->key_code = (rval == 27);
+      if( rval == 27)
+         {
+         int count = 0;
+
+         while( count < 6 && check_key( &c[count])
+                  && (rval = xlate_vt_codes( c, count + 1)) == -1)
+            count++;
+         if( rval == KEY_MOUSE)
+            {
+            int idx = (c[2] & 3), flags = 0, i;
+            const bool release = (idx == 3);
+            static int held = 0;
+
+            if( c[2] & 4)
+               flags |= PDC_BUTTON_SHIFT;
+            if( c[2] & 8)
+               flags |= PDC_BUTTON_ALT;
+            if( c[2] & 16)
+               flags |= PDC_BUTTON_CONTROL;
+            if( (c[2] & 0x60) == 0x40)    /* mouse move */
+               {
+               int report_event = 0;
+
+               if( idx == 0 && (SP->_trap_mbe & BUTTON1_MOVED))
+                  report_event |= 1;
+               if( idx == 1 && (SP->_trap_mbe & BUTTON2_MOVED))
+                  report_event |= 2;
+               if( idx == 2 && (SP->_trap_mbe & BUTTON3_MOVED))
+                  report_event |= 4;
+               if( report_event)
+                  report_event |= PDC_MOUSE_MOVED;
+               else if( SP->_trap_mbe & REPORT_MOUSE_POSITION)
+                  report_event = PDC_MOUSE_POSITION;
+               pdc_mouse_status.changes = report_event;
+               for( i = 0; i < 3; i++)
+                  pdc_mouse_status.button[i] = (i == idx ? BUTTON_MOVED : 0);
+               idx = 3;
+               }
+            else if( idx == 3)         /* it's a release */
+               {
+               idx = 0;
+               while( idx < 3 && !((held >> idx) & 1))
+                  idx++;
+               held ^= (1 << idx);
+               }
+            if( idx < 3)
+               {
+               memset(&pdc_mouse_status, 0, sizeof(MOUSE_STATUS));
+               pdc_mouse_status.button[idx] =
+                              (release ? BUTTON_RELEASED : BUTTON_PRESSED);
+               if( (c[2] & 0x60) == 0x60)    /* actually mouse wheel event */
+                  pdc_mouse_status.changes =
+                        (idx ? PDC_MOUSE_WHEEL_DOWN : PDC_MOUSE_WHEEL_UP);
+               else     /* "normal" mouse button */
+                  pdc_mouse_status.changes = (1 << idx);
+               if( !release && !(c[2] & 64))   /* wait for a possible release */
+                  {
+                  int n_events = 0;
+
+                  while( n_events < 5)
+                     {
+                     PDC_napms( SP->mouse_wait);
+                     if( check_key( c))
+                        {
+                        count = 0;
+                        while( count < 5 && check_key( &c[count]))
+                           count++;
+                        n_events++;
+                        }
+                     else
+                        break;
+                     }
+                  if( !n_events)   /* just a click,  no release(s) */
+                     held ^= (1 << idx);
+                  else if( n_events == 1)
+                      pdc_mouse_status.button[idx] = BUTTON_CLICKED;
+                  else if( n_events <= 3)
+                      pdc_mouse_status.button[idx] = BUTTON_DOUBLE_CLICKED;
+                  else if( n_events <= 5)
+                      pdc_mouse_status.button[idx] = BUTTON_TRIPLE_CLICKED;
+                  }
+               }
+            for( i = 0; i < 3; i++)
+               pdc_mouse_status.button[i] |= flags;
+            pdc_mouse_status.x = (unsigned char)( c[3] - ' ' - 1);
+            pdc_mouse_status.y = (unsigned char)( c[4] - ' ' - 1);
+            }
+         }
+      else if( (rval & 0xc0) == 0xc0)      /* start of UTF-8 */
+         {
+         check_key( &c[0]);
+         assert( (c[0] & 0xc0) == 0x80);
+         c[0] &= 0x3f;
+         if( !(rval & 0x20))      /* two-byte : U+0080 to U+07ff */
+            rval = c[0] | ((rval & 0x1f) << 6);
+         else if( !(rval & 0x10))   /* three-byte : U+0800 - U+ffff */
+            {
+            check_key( &c[1]);
+            assert( (c[1] & 0xc0) == 0x80);
+            c[1] &= 0x3f;
+            rval = (c[1] | (c[0] << 6) | ((rval & 0xf) << 12));
+            }
+            /* Else... four-byte SMP char */
+         }
+      else if( rval == 127)
+         rval = 8;
+      }
+   return( rval);
+}
+
+int PDC_modifiers_set( void)
+{
+   return( OK);
+}
+
+int PDC_mouse_set( void)
+{
+   return(  OK);
+}
+
+void PDC_set_keyboard_binary( bool on)
+{
+   return;
+}
+
+unsigned long PDC_get_input_fd( void)
+{
+   return( 0);
+}
+

data/vendor/PDCurses/vt/pdcscrn.c

@@ -0,0 +1,434 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#if !defined( _WIN32) && !defined( DOS)
+#define USE_TERMIOS
+#include <unistd.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+
+static struct termios orig_term;
+#endif
+#include <assert.h>
+#include "curspriv.h"
+#include "pdcvt.h"
+
+#ifdef DOS
+bool PDC_is_ansi = TRUE;
+#else
+bool PDC_is_ansi = FALSE;
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
+#ifndef ENABLE_VIRTUAL_TERMINAL_INPUT
+#define ENABLE_VIRTUAL_TERMINAL_INPUT      0x0200
+#endif
+#ifndef DISABLE_NEWLINE_AUTO_RETURN
+#define DISABLE_NEWLINE_AUTO_RETURN        0x0008
+#endif
+
+/* In DOS/Windows,  we have two possible modes of operation.  If we can
+successfully use SetConsoleMode to ENABLE_VIRTUAL_TERMINAL_INPUT,
+we have access to most of what we'd use on xterm.  If not,  we can only
+use what ANSI.SYS or ANSI.COM (or their NANSI or NNANSI variants) support.
+We'll get sixteen colors,  no mouse events,  no resizable windows,  etc.
+
+   So we check the return value from SetConsoleMode and set PDC_is_ansi
+accordingly.  (In DOS,  PDC_is_ansi is always true -- there's no xterm-like
+support there.  On non-MS platforms,  PDC_is_ansi is always false...
+though that should be revisited for the Linux console,  and probably
+elsewhere.)  */
+
+static int set_win10_for_vt_codes( const bool setting_mode)
+{
+    const HANDLE hIn = GetStdHandle( STD_INPUT_HANDLE);
+    HANDLE hOut;
+    DWORD dwMode = 0;
+    static DWORD old_input_mode;
+    const DWORD out_mask = ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                               | DISABLE_NEWLINE_AUTO_RETURN;
+
+    if( hIn == INVALID_HANDLE_VALUE)
+        return GetLastError( );
+    PDC_is_ansi = TRUE;
+    if( setting_mode)
+        {
+        GetConsoleMode( hIn, &old_input_mode);
+        dwMode = ENABLE_VIRTUAL_TERMINAL_INPUT;
+        }
+    else       /* restoring initial mode */
+        dwMode = old_input_mode;
+    if( !SetConsoleMode( hIn, dwMode))
+        return GetLastError( );
+        /* Set output mode to handle virtual terminal sequences */
+    hOut = GetStdHandle( STD_OUTPUT_HANDLE);
+    if( hOut == INVALID_HANDLE_VALUE)
+        return GetLastError( );
+
+    if( !GetConsoleMode( hOut, &dwMode))
+        return GetLastError( );
+    if( setting_mode)
+        dwMode |= out_mask;
+    else                    /* clearing VT mode,  not setting it */
+        dwMode &= ~out_mask;
+    if( !SetConsoleMode( hOut, dwMode))
+        return GetLastError( );
+              /* If we've gotten this far,  the terminal has been  */
+              /* set up to process xterm-like sequences : */
+    PDC_is_ansi = FALSE;
+    return( 0);
+}
+#endif
+
+int PDC_rows = -1, PDC_cols = -1;
+bool PDC_resize_occurred = FALSE;
+const int STDIN = 0;
+chtype PDC_capabilities = 0;
+
+/* COLOR_PAIR to attribute encoding table. */
+
+static short *color_pair_indices = (short *)NULL;
+PACKED_RGB *pdc_rgbs = (PACKED_RGB *)NULL;
+
+unsigned long pdc_key_modifiers = 0L;
+
+void PDC_reset_prog_mode( void)
+{
+}
+
+void PDC_reset_shell_mode( void)
+{
+}
+
+static int initial_PDC_rows, initial_PDC_cols;
+
+int PDC_resize_screen(int nlines, int ncols)
+{
+   if( PDC_rows == -1)     /* initscr( ) hasn't been called;  we're just */
+      {                    /* setting desired size at startup */
+      initial_PDC_rows = nlines;
+      initial_PDC_cols = ncols;
+      }
+   else if( nlines > 1 && ncols > 1 && !PDC_is_ansi)
+      {
+      printf( "\033[8;%d;%dt", nlines, ncols);
+      PDC_rows = nlines;
+      PDC_cols = ncols;
+      }
+   return( 0);
+}
+
+void PDC_restore_screen_mode(int i)
+{
+}
+
+void PDC_save_screen_mode(int i)
+{
+}
+
+void PDC_scr_close( void)
+{
+   printf( "\0338");         /* restore cursor & attribs (VT100) */
+   printf( "\033[m");         /* set default screen attributes */
+   printf( "\033[?47l");      /* restore screen */
+   PDC_gotoyx( PDC_cols - 1, 0);
+   printf( "\033[?1000l");        /* turn off mouse events */
+#ifdef _WIN32
+   set_win10_for_vt_codes( FALSE);
+#else
+   #if !defined( DOS)
+      tcsetattr( STDIN, TCSANOW, &orig_term);
+   #endif
+#endif
+   return;
+}
+
+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 = (PACKED_RGB *)NULL;
+}
+
+#ifdef USE_TERMIOS
+static void sigwinchHandler( int sig)
+{
+   struct winsize ws;
+
+   if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) != -1)
+      if( PDC_rows != ws.ws_row || PDC_cols != ws.ws_col)
+         {
+         PDC_rows = ws.ws_row;
+         PDC_cols = ws.ws_col;
+         PDC_resize_occurred = TRUE;
+         }
+}
+#endif
+
+#define MAX_LINES 1000
+#define MAX_COLUMNS 1000
+
+int PDC_scr_open(int argc, char **argv)
+{
+    int i, r, g, b, n_colors;
+    char *capabilities = getenv( "PDC_VT");
+    const char *colorterm = getenv( "COLORTERM");
+#ifdef USE_TERMIOS
+    struct sigaction sa;
+    struct termios term;
+#endif
+#ifdef _WIN32
+    set_win10_for_vt_codes( TRUE);
+#endif
+
+    PDC_LOG(("PDC_scr_open called\n"));
+    if( colorterm && !strcmp( colorterm, "truecolor"))
+       PDC_capabilities |= A_RGB_COLOR;
+    if( capabilities)      /* these should really come from terminfo! */
+       {
+       if( strstr( capabilities, "RGB"))
+          PDC_capabilities |= A_RGB_COLOR;
+       if( strstr( capabilities, "UND"))
+          PDC_capabilities |= A_UNDERLINE;
+       if( strstr( capabilities, "BLI"))
+          PDC_capabilities |= A_BLINK;
+       if( strstr( capabilities, "DIM"))
+          PDC_capabilities |= A_DIM;
+       if( strstr( capabilities, "STA"))
+          PDC_capabilities |= A_STANDOUT;
+       }
+    SP = calloc(1, sizeof(SCREEN));
+    color_pair_indices = (short *)calloc( PDC_COLOR_PAIRS * 2, sizeof( short));
+    n_colors = (PDC_is_ansi ? 16 : 256);
+    pdc_rgbs = (PACKED_RGB *)calloc( n_colors, sizeof( PACKED_RGB));
+    assert( SP && color_pair_indices && pdc_rgbs);
+    if (!SP || !color_pair_indices || !pdc_rgbs)
+        return ERR;
+
+    COLORS = n_colors;  /* should give this a try and see if it works! */
+    for( i = 0; i < 16 && i < n_colors; i++)
+    {
+        const int intensity = ((i & 8) ? 0xff : 0xc0);
+
+        pdc_rgbs[i] = PACK_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++)
+                if( i < n_colors)
+                    pdc_rgbs[i++] = PACK_RGB( r ? r * 40 + 55 : 0,
+                                   g ? g * 40 + 55 : 0,
+                                   b ? b * 40 + 55 : 0);
+    for( i = 0; i < 24; i++)
+        if( i + 232 < n_colors)
+            pdc_rgbs[i + 232] = PACK_RGB( i * 10 + 8, i * 10 + 8, i * 10 + 8);
+    setbuf( stdin, NULL);
+    setbuf( stdout, NULL);
+#ifdef USE_TERMIOS
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+    sa.sa_handler = sigwinchHandler;
+    if (sigaction(SIGWINCH, &sa, NULL) == -1)
+    {
+        fprintf( stderr, "Sigaction failed\n");
+        return( -1);
+    }
+    sigwinchHandler( 0);
+#else
+    {
+        const char *env = getenv("PDC_LINES");
+
+        PDC_rows = (env ? atoi( env) : 25);
+        env = getenv( "PDC_COLS");
+        PDC_cols = (env ? atoi( env) : 80);
+    }
+#endif
+    SP->mouse_wait = PDC_CLICK_PERIOD;
+    SP->visibility = 0;                /* no cursor,  by default */
+    SP->curscol = SP->cursrow = 0;
+    SP->audible = TRUE;
+    SP->mono = FALSE;
+
+    while( PDC_get_rows( ) < 1 && PDC_get_columns( ) < 1)
+      ;     /* wait for screen to be drawn and size determined */
+    if( initial_PDC_rows > 1 && initial_PDC_cols > 1)
+    {
+        PDC_resize_screen( initial_PDC_rows, initial_PDC_cols);
+        while( PDC_get_rows( ) != initial_PDC_rows
+            && PDC_get_columns( ) != initial_PDC_rows)
+           ;
+    }
+
+    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;
+    }
+
+#ifdef USE_TERMIOS
+    tcgetattr( STDIN, &orig_term);
+    memcpy( &term, &orig_term, sizeof( term));
+    term.c_lflag &= ~(ICANON | ECHO);
+    tcsetattr( STDIN, TCSANOW, &term);
+#endif
+    printf( "\033[?47h");      /* Save screen */
+    if( !PDC_is_ansi)
+        printf( "\033[?1000h");  /* enable mouse events,  at least on xterm */
+               /* NOTE: could send 1003h to get mouse motion events as well */
+    printf( "\0337");         /* save cursor & attribs (VT100) */
+    PDC_resize_occurred = FALSE;
+    PDC_LOG(("PDC_scr_open exit\n"));
+/*  PDC_reset_prog_mode();   doesn't do anything anyway */
+    return( 0);
+}
+
+int PDC_set_function_key( const unsigned function, const int new_key)
+{
+   return( 0);
+}
+
+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)
+{
+   return;
+}
+
+/* PDC_init_color(), PDC_init_pair(),  and PDC_set_blink() all share a common
+issue : after adjusting the display characteristic in question,  all relevant
+text should be redrawn.  Call PDC_init_pair( 3, ...),  and all text using
+color pair 3 should be redrawn;  call PDC_init_color( 5, ...) and all text
+using color index 5 for either foreground or background should be redrawn;
+turn "real blinking" on/off,  and all blinking text should be redrawn.
+(On platforms where blinking text is controlled by a timer and redrawn every
+half second or so,  such as X11,  SDLx,  and Win32a,  this function can be
+used for that purpose as well.)
+
+   PDC_show_changes( ) will look for relevant chains of text and redraw them.
+For speed/simplicity,  the code looks for the first and last character in
+each line that would be affected, then draws those in between.  Often --
+perhaps usually -- this will be zero characters, i.e., no text on that
+particular line happens to have an attribute requiring redrawing. */
+
+static short get_pair( const chtype ch)
+
+{
+   return( (short)( (ch & A_COLOR) >> PDC_COLOR_SHIFT) & (COLOR_PAIRS - 1));
+}
+
+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);
+}
+
+void PDC_show_changes( const short pair, const short idx, const chtype attr)
+{
+    if( curscr && curscr->_y)
+    {
+        int i;
+
+        for( i = 0; i < SP->lines - 1; i++)
+            if( curscr->_y[i])
+            {
+                int j = 0, n_chars;
+                chtype *line = curscr->_y[i];
+
+         /* skip over starting text that isn't changed : */
+                while( j < SP->cols && get_pair( *line) != pair
+                       && !color_used_for_this_char( *line, idx)
+                       && !(attr & *line))
+                {
+                    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
+                       && !color_used_for_this_char( line[n_chars - 1], idx)
+                       && !(attr & line[n_chars - 1]))
+                    n_chars--;
+                assert( n_chars >= 0);
+                if( n_chars)
+                    PDC_transform_line( i, j, n_chars, line);
+            }
+    }
+}
+
+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;
+        PDC_show_changes( pair, -1, 0);
+    }
+}
+
+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)
+{
+    PACKED_RGB col = pdc_rgbs[color];
+
+    *red = DIVROUND( Get_RValue(col) * 1000, 255);
+    *green = DIVROUND( Get_GValue(col) * 1000, 255);
+    *blue = DIVROUND( Get_BValue(col) * 1000, 255);
+
+    return OK;
+}
+
+int PDC_init_color( short color, short red, short green, short blue)
+{
+    const PACKED_RGB new_rgb = PACK_RGB(DIVROUND(red * 255, 1000),
+                                 DIVROUND(green * 255, 1000),
+                                 DIVROUND(blue * 255, 1000));
+
+    if( pdc_rgbs[color] != new_rgb)
+    {
+        pdc_rgbs[color] = new_rgb;
+        PDC_show_changes( -1, color, 0);
+    }
+    return OK;
+}