curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/demos/tui.h

@@ -0,0 +1,65 @@
+/*
+ * 'textual user interface'
+ *
+ * Author : P.J. Kunst <kunst@prl.philips.nl>
+ * Date   : 25-02-93
+ */
+
+#ifndef _TUI_H_
+#define _TUI_H_
+
+#include <curses.h>
+
+#ifdef A_COLOR
+#define A_ATTR  (A_ATTRIBUTES ^ A_COLOR)  /* A_BLINK, A_REVERSE, A_BOLD */
+#else
+#define A_ATTR  (A_ATTRIBUTES)            /* standard UNIX attributes */
+#endif
+
+#define MAXSTRLEN  256
+#define KEY_ESC    0x1b     /* Escape */
+
+typedef void (*FUNC)(void);
+
+typedef struct
+{
+    char *name; /* item label */
+    FUNC  func; /* (pointer to) function */
+    char *desc; /* function description */
+} menu;
+
+/* ANSI C function prototypes: */
+
+void    clsbody(void);
+int     bodylen(void);
+WINDOW *bodywin(void);
+
+void    rmerror(void);
+void    rmstatus(void);
+
+void    titlemsg(const char *msg);
+void    bodymsg(char *msg);
+void    errormsg(char *msg);
+void    statusmsg(char *msg);
+
+bool    keypressed(void);
+int     getkey(void);
+int     waitforkey(void);
+
+void    DoExit(void);
+void    startmenu(menu *mp, char *title);
+void    domenu(menu *mp);
+
+int     weditstr(WINDOW *win, char *buf, int field);
+WINDOW *winputbox( const WINDOW *win, int nlines, int ncols);
+int     getstrings(char *desc[], char *buf[], int field);
+
+#define editstr(s,f)           (weditstr(stdscr,s,f))
+#define mveditstr(y,x,s,f)     (move(y,x)==ERR?ERR:editstr(s,f))
+#define mvweditstr(w,y,x,s,f)  (wmove(w,y,x)==ERR?ERR:weditstr(w,s,f))
+
+#define inputbox(l,c)          (winputbox(stdscr,l,c))
+#define mvinputbox(y,x,l,c)    (move(y,x)==ERR?w:inputbox(l,c))
+#define mvwinputbox(w,y,x,l,c) (wmove(w,y,x)==ERR?w:winputbox(w,l,c))
+
+#endif

data/vendor/PDCursesMod/demos/tuidemo.c

@@ -0,0 +1,231 @@
+/*
+ * Author : P.J. Kunst <kunst@prl.philips.nl>
+ * Date   : 1993-02-25
+ *
+ * Purpose: This program demonstrates the use of the 'curses' library
+ *          for the creation of (simple) menu-operated programs.
+ *          In the PDCurses version, use is made of colors for the
+ *          highlighting of subwindows (title bar, status bar etc).
+ *
+ * Acknowledgement: some ideas were borrowed from Mark Hessling's
+ *                  version of the 'testcurs' program.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
+#include "tui.h"
+
+/* change this if source at other location */
+
+#ifdef PDC_FORCE_UTF8
+# define FNAME "../demos/UTF-8-demo.txt"
+#else
+# define FNAME "../demos/tui.c"
+#endif
+
+/**************************** strings entry box ***************************/
+
+void address(void)
+{
+    char *fieldname[6] =
+    {
+        "Name", "Street", "City", "State", "Country", (char *)0
+    };
+
+    char *fieldbuf[5];
+    WINDOW *wbody = bodywin();
+    int i, field = 50;
+
+    for (i = 0; i < 5; i++)
+        fieldbuf[i] = calloc(1, field + 1);
+
+    if (getstrings(fieldname, fieldbuf, field) != KEY_ESC)
+    {
+        for (i = 0; fieldname[i]; i++)
+            wprintw(wbody, "%10s : %s\n",
+                fieldname[i], fieldbuf[i]);
+
+        wrefresh(wbody);
+    }
+
+    for (i = 0; i < 5; i++)
+        free(fieldbuf[i]);
+}
+
+/**************************** string entry box ****************************/
+
+char *getfname(char *desc, char *fname, int field)
+{
+    char *fieldname[2];
+    char *fieldbuf[1];
+
+    fieldname[0] = desc;
+    fieldname[1] = 0;
+    fieldbuf[0] = fname;
+
+    return (getstrings(fieldname, fieldbuf, field) == KEY_ESC) ? NULL : fname;
+}
+
+/**************************** a very simple file browser ******************/
+
+void showfile( const char *fname)
+{
+    int bh = bodylen();
+    FILE *fp;
+    char buf[MAXSTRLEN];
+
+    statusmsg("FileBrowser: Hit key to continue, Q to quit");
+
+    if ((fp = fopen(fname, "r")) != NULL)   /* file available? */
+    {
+        bool ateof = FALSE;
+
+        while (!ateof)
+        {
+            int i;
+
+            clsbody();
+
+            for (i = 0; i < bh - 1 && !ateof; i++)
+            {
+                if (fgets(buf, MAXSTRLEN, fp))
+                    bodymsg(buf);
+                else
+                    ateof = TRUE;
+            }
+
+            switch (waitforkey())
+            {
+            case 'Q':
+            case 'q':
+            case 0x1b:
+                ateof = TRUE;
+            }
+        }
+
+        fclose(fp);
+    }
+    else
+    {
+        sprintf(buf, "ERROR: file '%s' not found", fname);
+        errormsg(buf);
+    }
+}
+
+/***************************** forward declarations ***********************/
+
+void sub0(void), sub1(void), sub2(void), sub3(void);
+void func1(void), func2(void);
+void subfunc1(void), subfunc2(void);
+void subsub(void);
+
+/***************************** menus initialization ***********************/
+
+menu MainMenu[] =
+{
+    { "Asub", sub0, "Go inside first submenu" },
+    { "Bsub", sub1, "Go inside second submenu" },
+    { "Csub", sub2, "Go inside third submenu" },
+    { "Dsub", sub3, "Go inside fourth submenu" },
+    { "", (FUNC)0, "" }   /* always add this as the last item! */
+};
+
+menu SubMenu0[] =
+{
+    { "Exit", DoExit, "Terminate program" },
+    { "", (FUNC)0, "" }
+};
+
+menu SubMenu1[] =
+{
+    { "OneBeep", func1, "Sound one beep" },
+    { "TwoBeeps", func2, "Sound two beeps" },
+    { "", (FUNC)0, "" }
+};
+
+menu SubMenu2[] =
+{
+    { "Browse", subfunc1, "Source file lister" },
+    { "Input", subfunc2, "Interactive file lister" },
+    { "Address", address, "Get address data" },
+    { "", (FUNC)0, "" }
+};
+
+menu SubMenu3[] =
+{
+    { "SubSub", subsub, "Go inside sub-submenu" },
+    { "", (FUNC)0, "" }
+};
+
+/***************************** main menu functions ************************/
+
+void sub0(void)
+{
+    domenu(SubMenu0);
+}
+
+void sub1(void)
+{
+    domenu(SubMenu1);
+}
+
+void sub2(void)
+{
+    domenu(SubMenu2);
+}
+
+void sub3(void)
+{
+    domenu(SubMenu3);
+}
+
+/***************************** submenu1 functions *************************/
+
+void func1(void)
+{
+    beep();
+    bodymsg("One beep! ");
+}
+
+void func2(void)
+{
+    beep();
+    bodymsg("Two beeps! ");
+    beep();
+}
+
+/***************************** submenu2 functions *************************/
+
+void subfunc1(void)
+{
+    showfile(FNAME);
+}
+
+void subfunc2(void)
+{
+    char fname[MAXSTRLEN];
+
+    strcpy(fname, FNAME);
+    if (getfname ("File to browse:", fname, 50))
+        showfile(fname);
+}
+
+/***************************** submenu3 functions *************************/
+
+void subsub(void)
+{
+    domenu(SubMenu2);
+}
+
+/***************************** start main menu  ***************************/
+
+int main( void)
+{
+    setlocale(LC_ALL, "");
+
+    startmenu(MainMenu, "TUI - 'textual user interface' demonstration program");
+
+    return 0;
+}

data/vendor/PDCursesMod/demos/version.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <curses.h>
+
+/* Example usage of the PDC_get_version function declared in curses.h.  The
+general idea is that,  while we have various macros defined to tell us
+which version of PDCurses we're using (PDC_VER_MAJOR,  PDC_VER_MINOR,
+PDC_WIDE,  etc.),  these may not match the library to which we are linked;
+it may have been compiled with different flags,  or a different chtype size
+(16,  32,  or 64-bit),  etc. This is a small issue with static libraries,
+but with DLLs (Windows and OS/2) or shared libraries (*nix and *BSD),  we
+may not really control which DLL/shared library happens to be available.
+
+In such cases,  the PDC_VERSION structure tells us how the library was
+compiled.
+
+Note that this can be used even though we never call initscr().  The idea
+is that version checking can be done without attempting function calls,
+some of which would fail if (for example) the library had been compiled
+with wide characters and the application had not,  or the version numbers
+didn't match,  or the size of chtypes differed.  */
+
+int main( void)
+{
+   static const char *port_text[] = { "X11", "Win32 console", "Win32a",
+         "DOS", "OS/2", "SDL1", "SDL2", "VT", "DOSVGA", "Plan9", "Linux FB",
+         "OpenGL" };
+   PDC_VERSION vinfo;
+
+   printf( "Compiled as version %d.%d.%d, chtype size %d\n",
+            PDC_VER_MAJOR, PDC_VER_MINOR, PDC_VER_CHANGE,
+            (int)sizeof( chtype));
+#ifdef PDC_WIDE
+   printf( "Compiled with PDC_WIDE defined\n");
+#else
+   printf( "Compiled with PDC_WIDE undefined\n");
+#endif
+#ifdef PDC_FORCE_UTF8
+   printf( "Compiled with PDC_FORCE_UTF8 defined\n");
+#else
+   printf( "Compiled with PDC_FORCE_UTF8 undefined\n");
+#endif
+
+   PDC_get_version( &vinfo);
+   printf( "\nInformation on the library :\n");
+   printf( "PDCurses version %d.%d.%d, chtype size %d\n",
+         (int)vinfo.major, (int)vinfo.minor,
+         (int)vinfo.change, (int)vinfo.csize);
+   printf( "Port %d (%s)\n",
+         vinfo.port,
+         port_text[vinfo.port]);
+   printf( "debug = %c   is_wide = %c    is_utf8 = %c\n",
+         vinfo.flags & PDC_VFLAG_DEBUG ? 'Y' : 'N',
+         vinfo.flags & PDC_VFLAG_WIDE ? 'Y' : 'N',
+         vinfo.flags & PDC_VFLAG_UTF8 ? 'Y' : 'N');
+   printf( "is_rgb = %c    is_dll = %c\n",
+         vinfo.flags & PDC_VFLAG_RGB ? 'Y' : 'N',
+         vinfo.flags & PDC_VFLAG_DLL ? 'Y' : 'N');
+   printf( "longname is '%s'\n", longname( ));
+   printf( "Curses version string is '%s'\n", curses_version( ));
+
+   if( vinfo.major != PDC_VER_MAJOR
+             || vinfo.minor != PDC_VER_MINOR
+             || vinfo.change != PDC_VER_CHANGE)
+      printf( "Versions do not match!\n");
+   return( 0);
+}

data/vendor/PDCursesMod/demos/widetest.c

@@ -0,0 +1,130 @@
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
+#include <curses.h>
+
+#define INTENTIONALLY_UNUSED_PARAMETER( param) (void)(param)
+
+/* Code to test combining and SMP (Unicode past 64K) capabilities,
+and the getcchar()/setcchar() functions.     */
+
+#ifndef WACS_S1
+int main( const int argc, const char *argv[])
+{
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+    fprintf( stderr, "'widetest' only works with wide-character builds.\n");
+    return( -1);
+}
+
+#else
+
+#define LINELEN 59
+
+int main( const int argc, const char *argv[])
+{
+    const wchar_t *precomposed_string = L"\xc5ngstrom Pi\xf1" L"ata Fa\xe7"
+               L"ade \xc6sop caf\xe9 No\xebl c\xf4te (precomposed)";
+    const wchar_t *combining_string = L"A\x30angstrom\x327\x302 Pin\x303" L"ata Fac\x327"
+#if defined( WCHAR_MAX) && WCHAR_MAX <= 65535
+               L"ade \xc6sop cafe\x301 Noe\x308l co\x302te \xd834\xdd1e (combining)";
+#else
+               L"ade \xc6sop cafe\x301 Noe\x308l co\x302te \x1d11e (combining)";
+#endif
+    int n, i, j, shuffle[LINELEN];
+    short color_pair;
+    wchar_t array[10];
+    cchar_t wcval;
+    attr_t attrs;
+    SCREEN *screen_pointer;
+
+    INTENTIONALLY_UNUSED_PARAMETER( argc);
+    INTENTIONALLY_UNUSED_PARAMETER( argv);
+    setlocale(LC_ALL, ".utf8");
+    screen_pointer = newterm(NULL, stdout, stdin);
+    mvaddwstr( 1, 1, precomposed_string);
+    mvaddwstr( 2, 1, combining_string);
+    mvaddstr( 4, 2, "The top line was done using precomposed characters;  for example,");
+    mvaddstr( 5, 2, "A-ring was done with U+00C5.  The lower line was done using");
+    mvaddstr( 6, 2, "combining characters;  for example,  A-ring was U+0041 ('ordinary'");
+    mvaddstr( 7, 2, "ASCII uppercase A) followed by U+030A (combining ring).  The test");
+    mvaddstr( 8, 2, "here is that both lines should look the same.  (On some systems,");
+    mvaddstr( 9, 2, "font rendering will make them not _exactly_ the same.  But they");
+    mvaddstr( 10, 2, "should be recognizably similar.)");
+    mvaddwstr( 12, 2, L"One character _should_ differ.  The 'm' in '\xc5ngstrom' on the");
+    mvaddstr( 13, 2, "second line should have a cedilla _and_ a circumflex.  This");
+    mvaddstr( 14, 2, "tests display of more than one added combining character.");
+    mvaddstr( 16, 2, "Also,  the 'treble clef' symbol (Unicode U+1D11E) is added to the");
+    mvaddstr( 17, 2, "second line,  to test SMP display.  This will probably not show");
+    mvaddstr( 18, 2, "up correctly.  Few fonts support SMP characters.");
+    mvaddstr( 20, 2, "Hit a key to continue.");
+    while( getch( ) == KEY_RESIZE)
+        resize_term( 0, 0);
+    move( 4, 1);
+    clrtobot( );
+    for( i = 0; i < LINELEN; i++)
+    {
+        char buff[80];
+
+        move( 2, i + 1);
+        in_wch( &wcval);
+        n = getcchar( &wcval, NULL, &attrs, &color_pair, NULL);
+        getcchar( &wcval, array, &attrs, &color_pair, NULL);
+        sprintf( buff, "%d: ", n);
+        mvaddstr( 11 + i % (LINES - 11), 16 * (i / (LINES - 11)), buff);
+        j = 0;
+        while( array[j] > 0xff)
+           j++;
+        printw( "%c ", (char)array[j]);
+        for( j = 0; array[j]; j++)
+        {
+            sprintf( buff, "%x ", (unsigned)array[j]);
+            addstr( buff);
+        }
+    }
+    mvaddstr( 5, 14, "Here, getcchar() is used to 'fetch' data about characters");
+    mvaddstr( 6, 14, "on the second line,  and the wide character (or,  for the");
+    mvaddstr( 7, 14, "combined cases,  characters) is/are shown.  This is used to");
+    mvaddstr( 8, 14, "verify that getcchar() is actually returning the characters");
+    mvaddstr( 9, 14, "it ought to.  Hit a key...");
+    while( getch( ) == KEY_RESIZE)
+        resize_term( 0, 0);
+    move( 3, 1);
+    clrtobot( );
+    mvaddstr( 7, 2, "Here, getcchar() is again used to 'fetch' the same characters");
+    mvaddstr( 8, 2, "from both lines,  and setcchar() is used to copy them to two");
+    mvaddstr( 9, 2, "lower lines.  The copying is mixed up a bit and slowed down");
+    mvaddstr( 10, 2, "to take about two seconds.");
+    for( i = 0; i < LINELEN; i++)
+        shuffle[i] = i;
+    for( i = LINELEN - 1; i; i--)
+    {                            /* ignore slight bias in shuffling */
+        const int loc = rand( ) % i, tval = shuffle[loc];
+
+        shuffle[loc] = shuffle[i];
+        shuffle[i] = tval;
+    }
+    for( i = 0; i < LINELEN; i++)
+        for( j = 1; j < 3; j++)
+        {
+            const int x = (j == 1 ? shuffle[i] : shuffle[shuffle[i]]) + 1;
+            cchar_t wcval_out;
+
+            move( j, x);
+            in_wch( &wcval);
+            getcchar( &wcval, array, &attrs, &color_pair, NULL);
+            move( j + 3, x);
+            setcchar( &wcval_out, array, attrs, color_pair, NULL);
+            add_wch( &wcval_out);
+            napms( 30);
+            refresh( );
+        }
+    mvaddstr( 11, 2, "Done!  Hit any key");
+    while( getch( ) == KEY_RESIZE)
+        resize_term( 0, 0);
+    endwin( );
+                            /* Not really needed,  but ensures Valgrind  */
+    delscreen( screen_pointer);          /* says all memory was freed */
+    return( -1);
+}
+#endif