curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/demos/ptest.c

@@ -0,0 +1,315 @@
+#include <curses.h>
+#include <panel.h>
+#include <stdlib.h>
+
+PANEL *p1, *p2, *p3, *p4, *p5;
+WINDOW *w4, *w5;
+static SCREEN *screen_pointer;
+
+long nap_msec = 1;
+
+const char *mod[] =
+{
+    "test ", "TEST ", "(**) ", "*()* ", "<--> ", "LAST "
+};
+
+void pflush(void)
+{
+    update_panels();
+    doupdate();
+}
+
+void sizecheck(void)
+{
+    if (COLS < 70 || LINES < 23)
+    {
+        mvprintw( 1, 1, "A window at least 70x23 is required for this demo.  Hit a key");
+        refresh();
+        getch( );
+        endwin();
+        delscreen( screen_pointer);
+        exit(-1);
+    }
+}
+
+void backfill(void)
+{
+    int y, x;
+
+    erase();
+
+    for (y = 0; y < LINES - 1; y++)
+        for (x = 0; x < COLS; x++)
+            printw("%d", (y + x) % 10);
+}
+
+void wait_a_while(long msec)
+{
+    int c;
+
+    if (msec != 1)
+        timeout(msec);
+
+    c = getch();
+
+#ifdef KEY_RESIZE
+    while( c == KEY_RESIZE)
+    {
+# ifdef PDCURSES
+        resize_term(0, 0);
+# endif
+        sizecheck();
+        backfill();
+        pflush();
+        c = getch();
+    }
+#endif
+    if (c == 'q')
+    {
+        endwin();
+        delscreen( screen_pointer);
+        exit(1);
+    }
+}
+
+void saywhat(const char *text)
+{
+    mvprintw(LINES - 1, 0, "%-20.20s", text);
+}
+
+/* mkpanel - alloc a win and panel and associate them */
+
+PANEL *mkpanel(int rows, int cols, int tly, int tlx)
+{
+    WINDOW *win = newwin(rows, cols, tly, tlx);
+    PANEL *pan = (PANEL *)0;
+
+    if (win)
+    {
+        pan = new_panel(win);
+
+        if (!pan)
+            delwin(win);
+    }
+
+    return pan;
+}
+
+void rmpanel(PANEL *pan)
+{
+    WINDOW *win = panel_window( pan);
+
+    del_panel(pan);
+    delwin(win);
+}
+
+void fill_panel( const PANEL *pan)
+{
+    WINDOW *win = panel_window( pan);
+    char num = *((char *)panel_userptr( pan) + 1);
+    int y, x, maxy, maxx;
+
+    box(win, 0, 0);
+    mvwprintw(win, 1, 1, "-pan%c-", num);
+    getmaxyx(win, maxy, maxx);
+
+    for (y = 2; y < maxy - 1; y++)
+        for (x = 1; x < maxx - 1; x++)
+            mvwaddch(win, y, x, num);
+}
+
+int main(int argc, char **argv)
+{
+    int itmp, y;
+
+    if (argc > 1 && atol(argv[1]))
+        nap_msec = atol(argv[1]);
+
+    screen_pointer = newterm(NULL, stdout, stdin);
+
+    keypad(stdscr, TRUE);
+    sizecheck();
+    backfill();
+
+    for (y = 0; y < 5; y++)
+    {
+        p1 = mkpanel(10, 10, 0, 0);
+        set_panel_userptr(p1, "p1");
+
+        p2 = mkpanel(14, 14, 5, 5);
+        set_panel_userptr(p2, "p2");
+
+        p3 = mkpanel(6, 8, 12, 12);
+        set_panel_userptr(p3, "p3");
+
+        p4 = mkpanel(10, 10, 10, 30);
+        w4 = panel_window(p4);
+        set_panel_userptr(p4, "p4");
+
+        p5 = mkpanel(10, 10, 13, 37);
+        w5 = panel_window(p5);
+        set_panel_userptr(p5, "p5");
+
+        fill_panel(p1);
+        fill_panel(p2);
+        fill_panel(p3);
+        fill_panel(p4);
+        fill_panel(p5);
+        hide_panel(p4);
+        hide_panel(p5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("h3 s1 s2 s4 s5;");
+        move_panel(p1, 0, 0);
+        hide_panel(p3);
+        show_panel(p1);
+        show_panel(p2);
+        show_panel(p4);
+        show_panel(p5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("s1;");
+        show_panel(p1);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("s2;");
+        show_panel(p2);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("m2;");
+        move_panel(p2, 10, 10);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("s3;");
+        show_panel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("m3;");
+        move_panel(p3, 5, 5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("b3;");
+        bottom_panel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("s4;");
+        show_panel(p4);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("s5;");
+        show_panel(p5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t3;");
+        top_panel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t1;");
+        top_panel(p1);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t2;");
+        top_panel(p2);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t3;");
+        top_panel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t4;");
+        top_panel(p4);
+        pflush();
+        wait_a_while(nap_msec);
+
+        for (itmp = 0; itmp < 6; itmp++)
+        {
+            saywhat("m4;");
+            mvwaddstr(w4, 3, 1, mod[itmp]);
+            move_panel(p4, 4, itmp * 10);
+            mvwaddstr(w5, 4, 1, mod[itmp]);
+            pflush();
+            wait_a_while(nap_msec);
+
+            saywhat("m5;");
+            mvwaddstr(w4, 4, 1, mod[itmp]);
+            move_panel(p5, 7, itmp * 10 + 6);
+            mvwaddstr(w5, 3, 1, mod[itmp]);
+            pflush();
+            wait_a_while(nap_msec);
+        }
+
+        saywhat("m4;");
+        move_panel(p4, 4, itmp * 10);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t5;");
+        top_panel(p5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t2;");
+        top_panel(p2);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("t1;");
+        top_panel(p1);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("d2;");
+        rmpanel(p2);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("h3;");
+        hide_panel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("d1;");
+        rmpanel(p1);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("d4; ");
+        rmpanel(p4);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("d5; ");
+        rmpanel(p5);
+        pflush();
+        wait_a_while(nap_msec);
+
+        saywhat("d3; ");
+        rmpanel(p3);
+        pflush();
+        wait_a_while(nap_msec);
+
+        if (nap_msec == 1)
+            break;
+
+        nap_msec = 100L;
+    }
+
+    endwin();
+    delscreen( screen_pointer);          /* says all memory was freed */
+
+    return 0;
+}   /* end of main */

data/vendor/PDCursesMod/demos/rain.c

@@ -0,0 +1,161 @@
+/****************************************************************************
+ * Copyright (c) 2002 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+#include <curses.h>
+#include <stdlib.h>
+#include <time.h>
+
+/* rain 1980-11-03 EPS/CITHEP */
+
+static int next_j(int j)
+{
+    if (j == 0)
+        j = 4;
+    else
+        --j;
+
+    if (has_colors())
+    {
+        int z = rand() % 3;
+        chtype color = COLOR_PAIR(z);
+
+        if (z)
+            color |= A_BOLD;
+
+        attrset(color);
+    }
+
+    return j;
+}
+
+#define INTENTIONALLY_UNUSED_PARAMETER( param) (void)(param)
+
+int main(int argc, char *argv[])
+{
+    time_t seed;
+    int x, y, j, r, c;
+    static int xpos[5], ypos[5];
+
+#ifdef XCURSES
+    Xinitscr(argc, argv);
+#else
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    initscr();
+#endif
+    seed = time((time_t *)0);
+    srand( (unsigned)seed);
+
+    if (has_colors())
+    {
+        short bg = COLOR_BLACK;
+
+        start_color();
+
+#if defined(NCURSES_VERSION) || (defined(PDC_BUILD) && PDC_BUILD > 3000)
+        if (use_default_colors() == OK)
+            bg = -1;
+#endif
+        init_pair(1, COLOR_BLUE, bg);
+        init_pair(2, COLOR_CYAN, bg);
+    }
+
+    nl();
+    noecho();
+    curs_set(0);
+    timeout(0);
+    keypad(stdscr, TRUE);
+
+    r = LINES - 4;
+    c = COLS - 4;
+
+    for (j = 5; --j >= 0;)
+    {
+        xpos[j] = rand() % c + 2;
+        ypos[j] = rand() % r + 2;
+    }
+
+    for (j = 0;;)
+    {
+        x = rand() % c + 2;
+        y = rand() % r + 2;
+
+        mvaddch(y, x, '.');
+
+        mvaddch(ypos[j], xpos[j], 'o');
+
+        j = next_j(j);
+        mvaddch(ypos[j], xpos[j], 'O');
+
+        j = next_j(j);
+        mvaddch(ypos[j] - 1, xpos[j], '-');
+        mvaddstr(ypos[j], xpos[j] - 1, "|.|");
+        mvaddch(ypos[j] + 1, xpos[j], '-');
+
+        j = next_j(j);
+        mvaddch(ypos[j] - 2, xpos[j], '-');
+        mvaddstr(ypos[j] - 1, xpos[j] - 1, "/ \\");
+        mvaddstr(ypos[j], xpos[j] - 2, "| O |");
+        mvaddstr(ypos[j] + 1, xpos[j] - 1, "\\ /");
+        mvaddch(ypos[j] + 2, xpos[j], '-');
+
+        j = next_j(j);
+        mvaddch(ypos[j] - 2, xpos[j], ' ');
+        mvaddstr(ypos[j] - 1, xpos[j] - 1, "   ");
+        mvaddstr(ypos[j], xpos[j] - 2, "     ");
+        mvaddstr(ypos[j] + 1, xpos[j] - 1, "   ");
+        mvaddch(ypos[j] + 2, xpos[j], ' ');
+
+        xpos[j] = x;
+        ypos[j] = y;
+
+        switch (getch())
+        {
+        case 'q':
+        case 'Q':
+            curs_set(1);
+            endwin();
+            return EXIT_SUCCESS;
+        case 's':
+            nodelay(stdscr, FALSE);
+            break;
+        case ' ':
+            nodelay(stdscr, TRUE);
+#ifdef KEY_RESIZE
+            break;
+        case KEY_RESIZE:
+# ifdef PDCURSES
+            resize_term(0, 0);
+# endif
+            r = LINES - 4;
+            c = COLS - 4;
+#endif
+        }
+        napms(50);
+    }
+}

data/vendor/PDCursesMod/demos/snprintf.c

@@ -0,0 +1,30 @@
+#if (defined(_MSC_VER) && _MSC_VER < 1900) || defined( __DMC__)
+
+   /* Bodge to get around shortcomings of older MSVCs and of the
+Digital Mars C compiler.  Some configurations lack any sort of
+range-checked snprintf;  in such cases,  we may overwrite the end
+of the buffer.  Some MSVCs have a 'sort of' snprintf,  but it
+won't take a NULL string to determine the necessary buffer size,
+and it won't put a '\0' at the end of the string if it would
+overflow.  Basically,  there's no "safe" way to do an snprintf
+in such situations,  but this will work as long as you don't
+actually overflow the buffer. */
+
+#include <stdarg.h>
+
+int snprintf( char *string, const size_t max_len, const char *format, ...)
+{
+   va_list argptr;
+   int rval;
+
+   va_start( argptr, format);
+#if _MSC_VER <= 1100 || defined( __DMC__)
+   rval = vsprintf( string, format, argptr);
+#else
+   rval = vsnprintf( string, max_len, format, argptr);
+#endif
+   string[max_len - 1] = '\0';
+   va_end( argptr);
+   return( rval);
+}
+#endif

data/vendor/PDCursesMod/demos/speed.c

@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <curses.h>
+
+/* PDCurses/ncurses speed test.  Initializes *curses,  displays
+semi-random numbers on the screen for 3000 milliseconds = 3 seconds,
+and then tells you how many frames per second you got (i.e.,  how
+many complete screen refreshes).
+
+   Results on my somewhat elderly machine,  all in Xubuntu 18.04 :
+
+SDL1 : 140 fps in wide mode,  340 in non-wide
+SDL2: 233 fps in wide mode, 624 fps in non-wide mode
+X11 wide mode: 180 fps first time,  800 fps subsequently
+ncurses : 3700 fps in wide mode
+VT : 3600 fps in wide mode,  4500 fps in non-wide mode
+WinGUI : 280 fps,  both modes (through Wine)
+WinCon : 840 fps,  wide mode;  75 fps in non-wide
+DOS (with DosBox) : 223 fps
+DOSVGA (with DosBox) : 50 fps
+
+   SDL2 uses TrueType (R) fonts in wide mode,  as opposed to simple
+bitmapped fonts in 8-bit mode.  So its ability to be blazingly fast
+in the latter is unsurprising.
+
+   X11,  I'll guess,  has some sort of optimization for wide-char fonts
+(because they get more use),  and perhaps some sort of caching that
+would account for why the first load is a little slower.
+
+   Dunno why Win32 console has such a huge variation,  and haven't
+tested it under "real" Windows.
+*/
+
+#define INTENTIONALLY_UNUSED_PARAMETER( param) (void)(param)
+
+/* millisec_timer( ) returns the wall-clock time,  in milliseconds.
+Call with TRUE to (re)set it,  FALSE to find out the elapsed time
+since then.
+
+   ftime() is consided obsolete.  But it's all we have for
+millisecond precision on older compilers/systems.  We'll
+use gettimeofday() when available.        */
+
+#if defined(__TURBOC__) || defined(__EMX__) || defined(__DJGPP__) || \
+    defined( __DMC__) || defined(__WATCOMC__) || defined(_MSC_VER)
+#include <sys/timeb.h>
+
+static long millisec_timer( const bool reset)
+{
+    struct timeb t;
+    static struct timeb t0;
+
+    ftime( &t);
+    if( reset)                            /* first time */
+       t0 = t;
+    return( (long)(t.time - t0.time) * 1000L + (long)( t.millitm - t0.millitm));
+}
+#else
+#include <sys/time.h>
+
+static long millisec_timer( const bool reset)
+{
+    struct timeval t;
+    static struct timeval t0;
+
+    gettimeofday( &t, NULL);
+    if( reset)                            /* first time */
+       t0 = t;
+    return( (t.tv_sec - t0.tv_sec) * 1000 + (t.tv_usec - t0.tv_usec) / 1000);
+}
+#endif
+
+int main( const int argc, char **argv)
+{
+    unsigned n_frames = 0;
+    SCREEN *screen_pointer;
+
+    resize_term( 30, 90);
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    screen_pointer = newterm(NULL, stdout, stdin);
+    cbreak( );
+    noecho();
+    start_color( );
+    init_pair( 1, COLOR_GREEN, COLOR_BLACK);
+    init_pair( 2, COLOR_BLUE, COLOR_BLACK);
+    refresh();
+    keypad( stdscr, 1);
+    nodelay(stdscr, TRUE);
+    millisec_timer( TRUE);
+    if( argc == 2)
+      curs_set( 0);
+    while( millisec_timer( FALSE) < 3000L && getch( ) != 'q')
+      {
+      char buff[11];
+      int i, j;
+      const int lines = 25, cols = 80;
+
+      n_frames++;
+      sprintf( buff, " %9u", (n_frames * 31415926u) % 1000000000u);
+      attrset(A_BOLD | COLOR_PAIR( 0));
+      for( i = 0; i < lines; i++)
+         {
+         move( i, 0);
+         for( j = 0; j + 10 < cols; j += 10)
+            {
+            if( j == 20 || i == 8)
+               attrset( COLOR_PAIR( 1));
+            else if( j == 50 || i == 16)
+               attrset( COLOR_PAIR( 2));
+            else
+               attrset( A_NORMAL);
+            addstr( buff);
+            }
+         }
+      }
+    nodelay(stdscr, FALSE);
+    move( LINES / 2, COLS / 2 - 20);
+    printw( "  %u frames/sec  ", n_frames / 3);
+    getch( );
+    endwin();
+    delscreen( screen_pointer);
+    printf( "%u frames per second\n", n_frames / 3);
+    return( 0);
+}