curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/sdl2/sdltest.c

@@ -0,0 +1,91 @@
+/* Here's a simple example of combining SDL and PDCurses functionality.
+   The top portion of the window is devoted to SDL, with a four-line
+   (assuming the default 8x16 font) stdscr at the bottom.
+*/
+
+#define SDL_MAIN_HANDLED
+
+#include <SDL.h>
+#include <curses.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define INTENTIONALLY_UNUSED_PARAMETER( param) (void)(param)
+
+#include "pdcsdl.h"
+
+int main(int argc, char **argv)
+{
+    char inp[60];
+    int i, j;
+    const unsigned seed = (unsigned)time((time_t *)0);
+
+    srand(seed);
+
+    /* Initialize SDL */
+
+    if (SDL_Init(SDL_INIT_VIDEO) < 0)
+        exit(1);
+
+#ifdef PDC_WIDE
+    if( argc > 1)
+    {
+         pdc_sdl_render_mode = atoi( argv[1]);
+    }
+#else
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+#endif
+
+    atexit(SDL_Quit);
+
+    pdc_window = SDL_CreateWindow("PDCurses for SDL", SDL_WINDOWPOS_UNDEFINED,
+                                  SDL_WINDOWPOS_UNDEFINED, 640, 480, 0);
+    pdc_screen = SDL_GetWindowSurface(pdc_window);
+
+    /* Initialize PDCurses */
+
+    pdc_yoffset = 416;  /* 480 - 4 * 16 */
+
+    initscr();
+    start_color();
+    scrollok(stdscr, TRUE);
+
+    PDC_set_title("PDCurses for SDL");
+
+    /* Do some SDL stuff */
+
+    for (i = 640, j = 416; j; i -= 2, j -= 2)
+    {
+        SDL_Rect dest;
+
+        dest.x = (640 - i) / 2;
+        dest.y = (416 - j) / 2;
+        dest.w = i;
+        dest.h = j;
+
+        SDL_FillRect(pdc_screen, &dest,
+                     SDL_MapRGB(pdc_screen->format, rand() % 256,
+                                rand() % 256, rand() % 256));
+    }
+
+    SDL_UpdateWindowSurface(pdc_window);
+
+    /* Do some curses stuff */
+
+    init_pair(1, COLOR_WHITE + 8, COLOR_BLUE);
+    bkgd(COLOR_PAIR(1));
+
+    addstr("This is a demo of ");
+    attron(A_UNDERLINE);
+    addstr("PDCurses for SDL");
+    attroff(A_UNDERLINE);
+    addstr(".\nYour comments here: ");
+    getnstr(inp, 59);
+    addstr("Press any key to exit.");
+
+    getch();
+    endwin();
+
+    return 0;
+}

data/vendor/PDCursesMod/sdl2/versions.mif

@@ -0,0 +1,2 @@
+SDLBASE = C:\SDL2-2.0.10
+TTFBASE = C:\SDL2_ttf-2.0.15

data/vendor/PDCursesMod/term.h

@@ -0,0 +1,48 @@
+/* Public Domain Curses */
+
+/* PDCurses doesn't operate with terminfo, but we need these functions for 
+   compatibility, to allow some things (notably, interface libraries for 
+   other languages) to be compiled. Anyone who tries to actually _use_ 
+   them will be disappointed, since they only return ERR. */
+
+#ifndef __PDCURSES_TERM_H__
+#define __PDCURSES_TERM_H__ 1
+
+#include <curses.h>
+
+#if defined(__cplusplus) || defined(__cplusplus__) || defined(__CPLUSPLUS)
+extern "C"
+{
+#endif
+
+typedef struct
+{
+    const char *_termname;
+} TERMINAL;
+
+/* PDCEX is defined in curses.h */
+PDCEX  TERMINAL *cur_term;
+
+PDCEX  int     del_curterm(TERMINAL *);
+PDCEX  int     putp(const char *);
+PDCEX  int     restartterm(const char *, int, int *);
+PDCEX  TERMINAL *set_curterm(TERMINAL *);
+PDCEX  int     setterm(const char *);
+PDCEX  int     setupterm(const char *, int, int *);
+PDCEX  int     tgetent(char *, const char *);
+PDCEX  int     tgetflag(const char *);
+PDCEX  int     tgetnum(const char *);
+PDCEX  char   *tgetstr(const char *, char **);
+PDCEX  char   *tgoto(const char *, int, int);
+PDCEX  int     tigetflag(const char *);
+PDCEX  int     tigetnum(const char *);
+PDCEX  char   *tigetstr(const char *);
+PDCEX  char   *tparm(const char *, long, long, long, long, long, 
+                     long, long, long, long);
+PDCEX  int     tputs(const char *, int, int (*)(int));
+
+#if defined(__cplusplus) || defined(__cplusplus__) || defined(__CPLUSPLUS)
+}
+#endif
+
+#endif /* __PDCURSES_TERM_H__ */

data/vendor/PDCursesMod/tests/README.md

@@ -0,0 +1,16 @@
+Miscellaneous Small Test Programs
+=================================
+
+From time to time,  small test programs for very specific bugs or features are written,  sometimes in response to an issue raised on GitHub.  They tend to be as minimal as possible,  to avoid side issues.  In almost all cases,  they will be used briefly until the bug is fixed or feature tested,  then ignored.  However,  they may be useful if further bugs/issues are found,  or as examples of how the functions are used.  Each is documented with comments at the top of the source file.
+
+There are several that may eventually be added to this directory.  As a start,  we have :
+
+- `brk_test.c` - test to make sure that Ctrl-C stops the program in `noraw()` mode,  and does not stop it in `raw()` mode.
+- `del_test.c` - test to explore some problems in deleting windows that have subwindows.
+- `focus.c` - example use of `define_key()`,  and checking out ability to detect focus changes in the console.
+- `ins_del.c`- tests `wscrl()`, `winsertln()`, `wdeleteln()`,  and `winsdelln()`
+- `keytest.c` - tests the speed of keyboard input on the various platforms.  This arose from [issue #197](https://github.com/Bill-Gray/PDCursesMod/issues/197).
+- `naptest.c` - tests the `napms()` function on DOS and DOSVGA.
+- `opaque.c` - tests some relatively new functions to access `SCREEN` elements.
+- `restart.c` - tests the ability to shut Curses down completely,  do "traditional" input/output,  then restart Curses.
+- `ripoff.c` - tests the `ripoffline()` and SLK functions.

data/vendor/PDCursesMod/tests/brk_test.c

@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include <string.h>
+#include <curses.h>
+
+/* Example to test whether Ctrl-C actually stops the program.  It should
+do so when noraw( ) is on,  and shouldn't when raw( ) is on.  Compile with
+
+gcc -Wall -Wextra -pedantic -o brk_test brk_test.c -lncurses
+gcc -Wall -Wextra -pedantic -I.. -o brk_test brk_test.c libpdcurses.a
+*/
+
+int main( void)
+{
+    int c;
+
+    initscr();
+    cbreak( );
+    noecho( );
+    clear( );
+    echo( );
+    keypad( stdscr, 1);
+
+    mvprintw( 1, 2, "%s - test of Ctrl-C stopping curses", longname( ));
+    mvaddstr( 3, 2, "raw( ) is on.  Hit Ctrl-C and the code won't break.");
+    mvaddstr( 4, 2, "Hit Enter when you're done :");
+    move( 5, 2);
+    raw( );
+    c = 0;
+    while( c != 13 && c != 10)
+      c = getch( );
+
+    mvaddstr( 6, 2, "noraw( ) is on.  Hit Ctrl-C and the code will now break.");
+    mvaddstr( 7, 2, "Hit Enter when you're done :");
+    move( 8, 2);
+    noraw( );
+    c = 0;
+    while( c != 13 && c != 10)
+      c = getch( );
+
+    endwin( );
+    return( 0);
+}

data/vendor/PDCursesMod/tests/del_test.c

@@ -0,0 +1,95 @@
+#include <curses.h>
+#include <stdlib.h>
+
+/* What happens when you call delwin( ) on a window that has a
+subwindow?   Or call delwin( ) twice?  (tl;dr : don't do those
+things;  they will cause segfaults in many Curses variants.)
+
+   To test,  compile with
+
+gcc -Wall -Wextra -pedantic -o del_test del_test.c -lncurses
+
+   On ncurses-6.2,  one gets the behavior listed below : failure,
+success,  success,  failure.  If instead windows were deleted
+recursively,  you'd expect a success (both windows freed) followed
+by three failures (because the windows in question have both been
+deleted).
+
+   Thomas Dickey notes,  at
+
+https://lists.gnu.org/archive/html/bug-ncurses/2022-08/msg00012.html
+
+   that "fwiw, NetBSD curses hangs (infinite loop) on the first delwin
+in [this] example,  while Solaris dumps core on the last delwin."
+'Original' PDCurses deletes 'win' the first time (it can't tell that
+it still has a subwindow and shouldn't be deleted),  which causes it
+to crash the second time 'win' is deleted.
+
+   We were not clear as to what is 'supposed' to be done here
+according to the X/Open and SVr4 standards.  But in actual practice,
+it's clearly dangerous to do either of the things described in the
+two questions above.  Portable curses code should delete windows
+only once,  and should never delete a window with a subwindow.
+PDCursesMod will assert() if you attempt to do either of these.
+More generally,  it maintains a list of "current" windows and will
+assert() if you pass a pointer to delwin() that isn't actually a
+valid window.   */
+
+#if defined(PDC_99) || defined(__WATCOMC__)
+# if !defined( HAVE_SNPRINTF) && !defined( __DMC__)
+#  define HAVE_SNPRINTF 1   /* have snprintf() */
+# endif
+#endif
+
+#if !defined( HAVE_SNPRINTF)
+   #define snprintf _snprintf
+#endif
+
+int main( void)
+{
+    WINDOW *win, *sub;
+    SCREEN *screen = newterm( NULL, NULL, NULL);
+    char buff[90];
+    int line = 1;
+
+    noecho();
+    mvaddstr( line++, 1, "Code to test deleting windows.  References :");
+    mvaddstr( line++, 1, "https://www.invisible-island.net/ncurses/man/curs_window.3x.html");
+    mvprintw( line++, 1, "https://lists.gnu.org/archive/html/bug-ncurses/2022-08/msg00006.html");
+    mvprintw( line++, 1, "Source code for this program (del_test.c)");
+    line++;
+    win = newwin( 0, 0, 0, 0);
+    snprintf( buff, sizeof( buff), "Allocated new window %p    %s", (void *)win, longname( ));
+    mvaddstr( line++, 1, buff);
+    sub = subwin( win, 10, 10, 10, 10);
+    snprintf( buff, sizeof( buff), "Sub window %p    %s", (void *)sub, curses_version( ));
+    mvaddstr( line++, 1, buff);
+    mvaddstr( line++, 1, "Next step will attempt to delete the window.  Should fail,  since");
+    mvaddstr( line++, 1, "it has a subwindow.  Hit any key :");
+    getch( );
+    snprintf( buff, sizeof( buff), "Window deleted with return value %d", delwin( win));
+    mvaddstr( line++, 1, buff);
+    line++;
+    mvaddstr( line++, 1, "Will now attempt to delete the sub-window.");
+    mvaddstr( line++, 1, "That ought to succeed.  Hit any key :");
+    getch( );
+    snprintf( buff, sizeof( buff), "Deleted sub : %d (should succeed)", delwin( sub));
+    mvaddstr( line++, 1, buff);
+    line++;
+    mvaddstr( line++, 1, "Will now attempt to delete the parent window.  This should succeed,");
+    mvaddstr( line++, 1, "since it no longer has a sub-window.  Hit any key :");
+    getch( );
+    snprintf( buff, sizeof( buff), "Deleted win : %d", delwin( win));
+    mvaddstr( line++, 1, buff);
+    line++;
+    mvaddstr( line++, 1, "Now we'll delete that window again,  which should fail.");
+    mvaddstr( line++, 1, "Hit any key :");
+    getch( );
+    snprintf( buff, sizeof( buff), "Deleted win : %d", delwin( win));
+    mvaddstr( line++, 1, buff);
+    mvaddstr( line++, 1, "And we're done.  Hit any key to exit :");
+    getch( );
+    endwin( );
+    delscreen( screen);
+    return(0);
+}

data/vendor/PDCursesMod/tests/focus.c

@@ -0,0 +1,53 @@
+#include <curses.h>
+
+/* Test code for define_key().  At present,  this function
+does nothing in PDCurses*.  It could be added to the VT and
+Linux framebuffer/DRM platforms,  if that proves desirable.
+More generally,  though,  I'm thinking that the ability to get
+KEY_FOCUS_IN and KEY_FOCUS_OUT via getch(), on all platforms,
+might be useful.  At present,  our programs have no way of
+knowing if they've lost/regained focus.
+
+   If we did such a thing,  the following bits would still be
+needed for portable programs.  That is to say,  if you weren't
+using PDCursesMod,  you would need to #define KEY_FOCUS_*,  make
+the two calls to define_key(),  and emit the control sequence
+so that those events would be sent to the program.   */
+
+#ifdef NCURSES_VERSION
+   #define KEY_FOCUS_IN    (KEY_MAX + 1)
+   #define KEY_FOCUS_OUT   (KEY_MAX + 2)
+#endif
+
+int main( void)
+{
+   int input;
+   SCREEN *screen_pointer = newterm(NULL, stdout, stdin);
+
+   noecho();
+   cbreak();
+   keypad( stdscr, 1);
+#ifdef NCURSES_VERSION
+   define_key( "\033[I", KEY_FOCUS_IN);
+   define_key( "\033[O", KEY_FOCUS_OUT);
+   printf( "\033[?1004h");   /* control sequence to turn focus events on */
+#endif
+   addstr( longname());
+   printw( "  Hit 'q' to quit.\n");
+   while( (input = getch()) != 'q')
+#ifdef NCURSES_VERSION
+      if( input == KEY_FOCUS_IN)
+         addstr( "KEY_FOCUS_IN ");
+      else if( input == KEY_FOCUS_OUT)
+         addstr( "KEY_FOCUS_OUT ");
+      else
+#endif
+      {
+         addstr( keyname( input));
+         addch( ' ');
+      }
+   endwin( );
+                            /* Not really needed,  but ensures Valgrind  */
+   delscreen( screen_pointer);          /* says all memory was freed */
+   return( 0);
+}

data/vendor/PDCursesMod/tests/ins_del.c

@@ -0,0 +1,108 @@
+#include <curses.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* Program to test the insertln()/deleteln()/wscrl() functions.
+Prompted by https://github.com/wmcbrine/PDCurses/issues/165 .
+
+gcc -Wall -Wextra -pedantic -o ins_del ins_del.c -lncursesw    */
+
+#define INTENTIONALLY_UNUSED_PARAMETER( param) (void)(param)
+
+int main( const int argc, const char **argv)
+{
+    SCREEN *screen_pointer;
+    WINDOW *win;
+    int i, c = 0, cursor_y = 7;
+    int top_scroll = 3, bottom_scroll = 10;
+    int scroll_rate = 1;
+    int rval;
+    int reset_screen = 1;
+
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+    screen_pointer = newterm(NULL, stdout, stdin);
+    noecho( );
+    raw( );
+    start_color( );
+    mvprintw( 0, 0, "Test of insertln(), deleteln(), wscrl()");
+    mvprintw( 1, 0, "Up/down to move cursor up/down; 'i'/'d' to insert/delete line");
+    mvprintw( 2, 0, "'u' to scroll up, 's' to scroll down _within marked region_");
+    mvprintw( 3, 0, "Any number 0...9 to set number of lines to scroll");
+    mvprintw( 4, 0, "'q' to quit         Space to reset");
+    mvaddstr( 6 + top_scroll, 0, "Top scroll->");
+    mvaddstr( 6 + bottom_scroll, 0, "Bottom scroll->");
+    refresh( );
+    win = newwin( 14, 30, 6, 16);
+    init_pair( 1, COLOR_WHITE, COLOR_BLUE);
+    wbkgd( win, '.' | COLOR_PAIR( 1));
+    scrollok( win, TRUE);
+            /* For PDCurses,  the cursor must be within the scroll region */
+            /* you're setting.  For ncurses and PDCursesMod,  it doesn't. */
+#if defined( __PDCURSES__) && !defined( __PDCURSESMOD__)
+    wmove( win, top_scroll, 0);
+#endif
+    rval = wsetscrreg( win, top_scroll, bottom_scroll);
+    if( OK != rval)
+    {
+        attr_on( A_REVERSE, NULL);
+        mvaddstr( 5, 0, "wsetscrreg( ) failed");
+        attr_off( A_REVERSE, NULL);
+    }
+    wclear( win);
+    keypad( win, TRUE);
+    while( c != 'q')
+      {
+      if( reset_screen)
+         for( i = 0; i < 14; i++)
+            mvwprintw( win, i, 0, "This is line %d", i);
+      reset_screen = 0;
+      wmove( win, cursor_y, 1);
+      wsyncup( win);
+      wrefresh( win);
+      c = wgetch( win);
+      if( c >= '0' && c <= '9')
+         scroll_rate = c - '0';
+      else switch( c)
+         {
+         case KEY_UP:
+            cursor_y--;
+            break;
+         case KEY_DOWN:
+            cursor_y++;
+            break;
+         case 'i':
+            winsertln( win);
+            break;
+         case 'd':
+            wdeleteln( win);
+            break;
+         case 's':
+            wscrl( win, -scroll_rate);
+            break;
+         case 'u':
+            wscrl( win, scroll_rate);
+            break;
+         case 'D':
+            winsdelln( win, -scroll_rate);
+            break;
+         case 'I':
+            winsdelln( win, scroll_rate);
+            break;
+         case ' ':
+            reset_screen = 1;
+            break;
+         case 'q':
+            break;
+         default:
+            flash( );
+            beep( );
+            break;
+         }
+      }
+    endwin();
+                            /* Not really needed,  but ensures Valgrind  */
+    delscreen( screen_pointer);          /* says all memory was freed */
+    return( 0);
+}

data/vendor/PDCursesMod/tests/keytest.c

@@ -0,0 +1,87 @@
+#include <curses.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* Small program to find out how many times a second you can call
+getch( ) with no timeout;  i.e.,  how fast is getch( ) on various
+platforms and curses implementations?  A result of investigating
+
+https://github.com/Bill-Gray/PDCursesMod/issues/197
+
+We note the starting time and go into a tight loop checking getch( ).  When
+the time (in seconds) changes,  we post an updated count of iterations and
+of iterations/second to the screen.  The count between screen updates is
+doubled if a second hasn't passed and halved if two seconds have passed;  this
+quickly sets 'freq' to a point where you get an update every second or so.
+
+WinGUI on Wine : about 1.5 million/s
+WinCon on Wine : about 20000/s
+SDL2: 260000/s
+SDL1: 520000/s
+DOS in DOSBox: 35000/s
+VT,  Linux framebuffer : 1.4 million/s
+   (getch( ) code for those two is basically the same)
+X11: 360000/s
+ncurses : 1.6 million/s
+
+   From old habit,  I avoid calling getch( ) at every pass through a
+tight loop.  In the following,  I might say "if( i % (freq / 4) == 1),
+do a getch()",  i.e.,  check for key input only about four times a
+second.  But a fast getch( ) is still a good idea; most people just
+assume it'll return almost instantly.
+
+   NOTE that the above timings predate some work to speed up getch( )
+_immensely_ on most platforms.  See pdcurses/getch.c.
+If PDC_check_key( ) returns FALSE,  we assume it will continue to do
+so for the current millisecond.  Thus,  we only call PDC_check_key( )
+a thousand times a second.  If PDC_check_key( ) is slow,  and time
+checking is fast,  this results in a _huge_ speedup.  This raised
+the SDLs to about 20 million/s,  X11 to 11 million/s,  and WinGUI
+to about 6.7 million/s.  DOS and DOSVGA are the odd systems out;  their
+time checks are about as fast as key checks.  (Exact results may vary
+with compilers and,  of course,  machines.)  */
+
+#ifdef __PDCURSESMOD__
+PDCEX long PDC_millisecs( void);    /* undocumented function;  see getch.c */
+#else    /* if we're not in PDCursesMod,  we have to supply the function */
+#include <sys/time.h>
+
+long PDC_millisecs( void)
+{
+    struct timeval t;
+
+    gettimeofday( &t, NULL);
+    return( t.tv_sec * 1000 + t.tv_usec / 1000);
+}
+#endif
+
+int main( const int argc, const char **argv)
+{
+    long i, freq = 8, prev_t, t0;
+
+    initscr( );
+    timeout( argc > 1 ? atoi( argv[1]) : 0);
+    mvprintw( 1, 0, "Test of raw getch( ) speed");
+    mvprintw( 2, 0, "Let run a few seconds until calls/second stabilizes;");
+    mvprintw( 3, 0, "then hit any key to exit");
+    t0 = prev_t = PDC_millisecs( );
+    for( i = 0; getch() == ERR; ++i) {
+        if( i % freq == 1)   {
+           const long t = PDC_millisecs( );
+
+           if( t - prev_t > 1000)   /* update once a second */
+           {
+               mvprintw( 4, 0, "  %.0f calls/sec  ",
+                          (double)i * 1000. / (double)( t - t0));
+               prev_t = t;
+               freq /= 2;
+           }
+           else
+              freq += freq;
+           refresh();
+        }
+    }
+    endwin();
+    puts("Done.");
+    return( 0);
+}

data/vendor/PDCursesMod/tests/naptest.c

@@ -0,0 +1,43 @@
+#include <curses.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Quick,  somewhat dirty test code for the weirdnesses that occur
+in the DOS PDC_napms() code.  For example,  naps have to be broken
+into 18-minute segments,  midnight crossing requires special handling,
+and some odd math has to be done to get timing as exact as possible
+while avoiding integer overflows.  Compiles (in Digital Mars C/C++) as
+
+dmc -I.. -msd -DCHTYPE_32 -o+space naptest.exe pdcurses.lib naptest.c
+
+   (also tested with OpenWATCOM).
+
+   Note that a 'special' PDC_napmsl() function,  taking a long integer
+for an argument,  is used.  Otherwise,  we couldn't do any testing
+past 32.767 seconds.  We also borrow PDCursesMod's internal millisecond
+counter.  */
+
+void PDC_napmsl( long ms);
+PDCEX long    PDC_millisecs( void);
+
+int main( const int argc, const char **argv)
+{
+   long nap_time, t1, t2;
+
+   if( argc != 2)
+      {
+      fprintf( stderr, "naptest needs a nap time,  in milliseconds,  on the command line\n");
+      return( -1);
+      }
+   nap_time = atol( argv[1]);
+   printf( "Napping %ld milliseconds\n", nap_time);
+   t1 = PDC_millisecs( );
+   printf( "Start millisecond count : %ld\n", t1);
+   PDC_napmsl( nap_time);
+   t2 = PDC_millisecs( );
+   printf( "Final millisecond count : %ld\n", t2);
+   printf( "Elapsed time: %ld ms\n", t2 - t1);
+   printf( "Hit enter:");
+   getchar( );
+   return( 0);
+}

data/vendor/PDCursesMod/tests/opaque.c

@@ -0,0 +1,42 @@
+#include <curses.h>
+
+/* Code to test is_cbreak(), is_echo(), is_nl(), is_raw().  These
+were added to ncurses on 2023 Aug 12,  and to PDCursesMod later.
+As far as I know,  they don't exist elsewhere.  Compile with :
+
+gcc -Wall -Wextra -pedantic -o opaque opaque.c -lncurses
+gcc -Wall -Wextra -pedantic -I.. -o opaque opaque.c libpdcurses.a
+*/
+
+#ifdef PDC_VERSION_PATCH
+   #if PDC_VERSION_PATCH >= 20240311
+      #define _HAVE_OPAQUE_SCREEN_FUNCS
+   #endif
+#endif
+
+#ifdef NCURSES_VERSION_PATCH
+   #if NCURSES_VERSION_PATCH >= 20230812
+      #define _HAVE_OPAQUE_SCREEN_FUNCS
+   #endif
+#endif
+
+int main(void)
+{
+   SCREEN *screen_pointer = newterm( NULL, stdout, stdin);
+
+   intrflush(stdscr, FALSE);
+
+#ifdef _HAVE_OPAQUE_SCREEN_FUNCS
+   printw( "cbreak = %d   echo = %d   nl = %d   raw = %d\n",
+         is_cbreak(), is_echo(), is_nl(), is_raw());
+#else
+   addstr( "is_cbreak(), is_echo(), is_nl(), is_raw() are not available\n");
+#endif
+
+   addstr("Hit a key to exit :");
+   getch( );
+   endwin();
+                             /* Not really needed,  but ensures Valgrind  */
+   delscreen( screen_pointer);          /* says all memory was freed */
+   return( 0);
+}