curses 1.4.6 → 1.5.0

data/vendor/PDCurses/sdl1/pdcscrn.c

@@ -0,0 +1,414 @@
+/* Public Domain Curses */
+
+#include "pdcsdl.h"
+
+#include <stdlib.h>
+#ifndef PDC_WIDE
+#include "deffont.h"
+#endif
+#include "deficon.h"
+
+#ifdef PDC_WIDE
+# ifndef PDC_FONT_PATH
+#  ifdef _WIN32
+#define PDC_FONT_PATH "C:/Windows/Fonts/lucon.ttf"
+#  elif defined(__APPLE__)
+#define PDC_FONT_PATH "/Library/Fonts/Courier New.ttf"
+#  else
+#define PDC_FONT_PATH "/usr/share/fonts/truetype/freefont/FreeMono.ttf"
+#  endif
+# endif
+TTF_Font *pdc_ttffont = NULL;
+int pdc_font_size = 18;
+#endif
+
+SDL_Surface *pdc_screen = NULL, *pdc_font = NULL, *pdc_icon = NULL,
+            *pdc_back = NULL, *pdc_tileback = NULL;
+int pdc_sheight = 0, pdc_swidth = 0, pdc_yoffset = 0, pdc_xoffset = 0;
+
+SDL_Color pdc_color[256];
+Uint32 pdc_mapped[256];
+int pdc_fheight, pdc_fwidth, pdc_flastc;
+bool pdc_own_screen;
+
+/* special purpose function keys */
+static int PDC_shutdown_key[PDC_MAX_FUNCTION_KEYS] = { 0, 0, 0, 0, 0 };
+
+/* COLOR_PAIR to attribute encoding table. */
+
+static struct {short f, b;} atrtab[PDC_COLOR_PAIRS];
+
+static void _clean(void)
+{
+#ifdef PDC_WIDE
+    if (pdc_ttffont)
+    {
+        TTF_CloseFont(pdc_ttffont);
+        TTF_Quit();
+    }
+#endif
+    SDL_FreeSurface(pdc_tileback);
+    SDL_FreeSurface(pdc_back);
+    SDL_FreeSurface(pdc_icon);
+    SDL_FreeSurface(pdc_font);
+
+    SDL_Quit();
+}
+
+void PDC_retile(void)
+{
+    if (pdc_tileback)
+        SDL_FreeSurface(pdc_tileback);
+
+    pdc_tileback = SDL_DisplayFormat(pdc_screen);
+    if (pdc_tileback == NULL)
+        return;
+
+    if (pdc_back)
+    {
+        SDL_Rect dest;
+
+        dest.y = 0;
+
+        while (dest.y < pdc_tileback->h)
+        {
+            dest.x = 0;
+
+            while (dest.x < pdc_tileback->w)
+            {
+                SDL_BlitSurface(pdc_back, 0, pdc_tileback, &dest);
+                dest.x += pdc_back->w;
+            }
+
+            dest.y += pdc_back->h;
+        }
+
+        SDL_BlitSurface(pdc_tileback, 0, pdc_screen, 0);
+    }
+}
+
+void PDC_scr_close(void)
+{
+    PDC_LOG(("PDC_scr_close() - called\n"));
+}
+
+void PDC_scr_free(void)
+{
+    if (SP)
+        free(SP);
+}
+
+static int default_pdc_swidth = 80, default_pdc_sheight = 25;
+
+/* open the physical screen -- allocate SP, miscellaneous intialization */
+
+int PDC_scr_open(int argc, char **argv)
+{
+    int i, r, g, b;
+
+    PDC_LOG(("PDC_scr_open() - called\n"));
+
+    SP = calloc(1, sizeof(SCREEN));
+
+    if (!SP)
+        return ERR;
+
+    pdc_own_screen = !pdc_screen;
+
+    if (pdc_own_screen)
+    {
+        if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0)
+        {
+            fprintf(stderr, "Could not start SDL: %s\n", SDL_GetError());
+            return ERR;
+        }
+
+        atexit(_clean);
+    }
+
+#ifdef PDC_WIDE
+    if (!pdc_ttffont)
+    {
+        const char *ptsz, *fname;
+
+        if (TTF_Init() == -1)
+        {
+            fprintf(stderr, "Could not start SDL_TTF: %s\n", SDL_GetError());
+            return ERR;
+        }
+
+        ptsz = getenv("PDC_FONT_SIZE");
+        if (ptsz != NULL)
+           pdc_font_size = atoi(ptsz);
+        if (pdc_font_size <= 0)
+           pdc_font_size = 18;
+
+        fname = getenv("PDC_FONT");
+        pdc_ttffont = TTF_OpenFont(fname ? fname : PDC_FONT_PATH,
+                                   pdc_font_size);
+    }
+
+    if (!pdc_ttffont)
+    {
+        fprintf(stderr, "Could not load font\n");
+        return ERR;
+    }
+
+    TTF_SetFontKerning(pdc_ttffont, 0);
+    TTF_SetFontHinting(pdc_ttffont, TTF_HINTING_MONO);
+
+    SP->mono = FALSE;
+#else
+    if (!pdc_font)
+    {
+        const char *fname = getenv("PDC_FONT");
+        pdc_font = SDL_LoadBMP(fname ? fname : "pdcfont.bmp");
+    }
+
+    if (!pdc_font)
+        pdc_font = SDL_LoadBMP_RW(SDL_RWFromMem(deffont, sizeof(deffont)), 0);
+
+    if (!pdc_font)
+    {
+        fprintf(stderr, "Could not load font\n");
+        return ERR;
+    }
+
+    SP->mono = !pdc_font->format->palette;
+#endif
+
+    if (!SP->mono && !pdc_back)
+    {
+        const char *bname = getenv("PDC_BACKGROUND");
+        pdc_back = SDL_LoadBMP(bname ? bname : "pdcback.bmp");
+    }
+
+    if (!SP->mono && (pdc_back || !pdc_own_screen))
+    {
+        SP->orig_attr = TRUE;
+        SP->orig_fore = COLOR_WHITE;
+        SP->orig_back = -1;
+    }
+    else
+        SP->orig_attr = FALSE;
+
+#ifdef PDC_WIDE
+    TTF_SizeText(pdc_ttffont, "W", &pdc_fwidth, &pdc_fheight);
+#else
+    pdc_fheight = pdc_font->h / 8;
+    pdc_fwidth = pdc_font->w / 32;
+
+    if (!SP->mono)
+        pdc_flastc = pdc_font->format->palette->ncolors - 1;
+#endif
+
+    if (pdc_own_screen && !pdc_icon)
+    {
+        const char *iname = getenv("PDC_ICON");
+        pdc_icon = SDL_LoadBMP(iname ? iname : "pdcicon.bmp");
+
+        if (!pdc_icon)
+            pdc_icon = SDL_LoadBMP_RW(SDL_RWFromMem(deficon,
+                                                    sizeof(deficon)), 0);
+
+        if (pdc_icon)
+            SDL_WM_SetIcon(pdc_icon, NULL);
+    }
+
+    if (pdc_own_screen)
+    {
+        const char *env = getenv("PDC_LINES");
+        pdc_sheight = (env ? atoi(env) : default_pdc_sheight) * pdc_fheight;
+
+        env = getenv("PDC_COLS");
+        pdc_swidth = (env ? atoi(env) : default_pdc_swidth) * pdc_fwidth;
+
+        pdc_screen = SDL_SetVideoMode(pdc_swidth, pdc_sheight, 0,
+            SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE);
+    }
+    else
+    {
+        if (!pdc_sheight)
+            pdc_sheight = pdc_screen->h - pdc_yoffset;
+
+        if (!pdc_swidth)
+            pdc_swidth = pdc_screen->w - pdc_xoffset;
+    }
+
+    if (!pdc_screen)
+    {
+        fprintf(stderr, "Couldn't create a surface: %s\n", SDL_GetError());
+        return ERR;
+    }
+
+    if (SP->orig_attr)
+        PDC_retile();
+
+    COLORS = 256;       /* we have 256 colors in this flavor of PDCurses */
+    for (i = 0; i < 8; i++)
+    {
+        pdc_color[i].r = (i & COLOR_RED) ? 0xc0 : 0;
+        pdc_color[i].g = (i & COLOR_GREEN) ? 0xc0 : 0;
+        pdc_color[i].b = (i & COLOR_BLUE) ? 0xc0 : 0;
+
+        pdc_color[i + 8].r = (i & COLOR_RED) ? 0xff : 0x40;
+        pdc_color[i + 8].g = (i & COLOR_GREEN) ? 0xff : 0x40;
+        pdc_color[i + 8].b = (i & COLOR_BLUE) ? 0xff : 0x40;
+    }
+
+           /* 256-color xterm extended palette:  216 colors in a
+            6x6x6 color cube,  plus 24 (not 50) shades of gray */
+    i = 16;
+    for( r = 0; r < 6; r++)
+        for( g = 0; g < 6; g++)
+            for( b = 0; b < 6; b++, i++)
+            {
+                pdc_color[i].r = ( r ? r * 40 + 55 : 0);
+                pdc_color[i].g = ( g ? g * 40 + 55 : 0);
+                pdc_color[i].b = ( b ? b * 40 + 55 : 0);
+            }
+    for( i = 232; i < 256; i++)
+        pdc_color[i].r = pdc_color[i].g = pdc_color[i].b = (i - 232) * 10 + 8;
+    for (i = 0; i < 256; i++)
+        pdc_mapped[i] = SDL_MapRGB(pdc_screen->format, pdc_color[i].r,
+                                   pdc_color[i].g, pdc_color[i].b);
+
+    SDL_EnableUNICODE(1);
+
+    PDC_mouse_set();
+
+    if (pdc_own_screen)
+        PDC_set_title(argc ? argv[0] : "PDCurses");
+
+    SP->lines = PDC_get_rows();
+    SP->cols = PDC_get_columns();
+
+    SP->mouse_wait = PDC_CLICK_PERIOD;
+    SP->audible = FALSE;
+
+    PDC_reset_prog_mode();
+
+    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    */
+        default_pdc_swidth = ncols;
+        default_pdc_sheight = nlines;
+        return OK;
+    }
+
+    if (!pdc_own_screen)
+        return ERR;
+
+    if (nlines && ncols)
+    {
+        pdc_sheight = nlines * pdc_fheight;
+        pdc_swidth = ncols * pdc_fwidth;
+    }
+
+    SDL_FreeSurface(pdc_screen);
+
+    pdc_screen = SDL_SetVideoMode(pdc_swidth, pdc_sheight, 0,
+        SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE);
+
+    if (pdc_tileback)
+        PDC_retile();
+
+    SP->resized = FALSE;
+    SP->cursrow = SP->curscol = 0;
+
+    return OK;
+}
+
+void PDC_reset_prog_mode(void)
+{
+    PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
+
+    PDC_flushinp();
+    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+}
+
+void PDC_reset_shell_mode(void)
+{
+    PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
+
+    SDL_EnableKeyRepeat(0, 0);
+    PDC_flushinp();
+}
+
+void PDC_restore_screen_mode(int i)
+{
+}
+
+void PDC_save_screen_mode(int i)
+{
+}
+
+void PDC_init_pair(short pair, short fg, short bg)
+{
+    atrtab[pair].f = fg;
+    atrtab[pair].b = bg;
+}
+
+int PDC_pair_content(short pair, short *fg, short *bg)
+{
+    *fg = atrtab[pair].f;
+    *bg = atrtab[pair].b;
+
+    return OK;
+}
+
+bool PDC_can_change_color(void)
+{
+    return TRUE;
+}
+
+int PDC_color_content(short color, short *red, short *green, short *blue)
+{
+    *red = DIVROUND(pdc_color[color].r * 1000, 255);
+    *green = DIVROUND(pdc_color[color].g * 1000, 255);
+    *blue = DIVROUND(pdc_color[color].b * 1000, 255);
+
+    return OK;
+}
+
+int PDC_init_color(short color, short red, short green, short blue)
+{
+    pdc_color[color].r = DIVROUND(red * 255, 1000);
+    pdc_color[color].g = DIVROUND(green * 255, 1000);
+    pdc_color[color].b = DIVROUND(blue * 255, 1000);
+
+    pdc_mapped[color] = SDL_MapRGB(pdc_screen->format, pdc_color[color].r,
+                                   pdc_color[color].g, pdc_color[color].b);
+
+    wrefresh(curscr);
+
+    return OK;
+}
+
+/* Does nothing in the SDL flavors of PDCurses.  That may change,  eventually,
+allowing one to limit the range of user-resizable windows.  See X11 or Win32a
+versions of this function for details. */
+
+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)
+{
+}
+
+/* PDC_set_function_key() does nothing on this platform */
+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;
+    }
+    return( old_key);
+}

data/vendor/PDCurses/sdl1/pdcsdl.h

@@ -0,0 +1,31 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+#include <SDL.h>
+#ifdef PDC_WIDE
+#include <SDL_ttf.h>
+#endif
+
+#ifdef PDC_WIDE
+PDCEX TTF_Font *pdc_ttffont;
+PDCEX int pdc_font_size;
+#endif
+PDCEX SDL_Surface *pdc_screen, *pdc_font, *pdc_icon, *pdc_back;
+PDCEX int pdc_sheight, pdc_swidth, pdc_yoffset, pdc_xoffset;
+
+extern SDL_Surface *pdc_tileback;    /* used to regenerate the background
+                                        of "transparent" cells */
+extern SDL_Color pdc_color[256];      /* colors for font palette */
+extern Uint32 pdc_mapped[256];        /* colors for FillRect(), as
+                                        used in _highlight() */
+extern int pdc_fheight, pdc_fwidth;  /* font height and width */
+extern int pdc_flastc;               /* font palette's last color
+                                        (treated as the foreground) */
+extern bool pdc_own_screen;          /* if pdc_screen was not set
+                                        before initscr(), PDCurses is
+                                        responsible for (owns) it */
+extern Uint32 pdc_lastupdate;        /* time of last update, in ticks */
+
+void PDC_update_rects(void);
+void PDC_retile(void);

data/vendor/PDCurses/sdl1/pdcsetsc.c

@@ -0,0 +1,64 @@
+/* Public Domain Curses */
+
+#include "pdcsdl.h"
+
+/*man-start**************************************************************
+
+pdcsetsc
+--------
+
+### Synopsis
+
+    int PDC_set_blink(bool blinkon);
+    void PDC_set_title(const char *title);
+
+### Description
+
+   PDC_set_blink() toggles whether the A_BLINK attribute sets an
+   actual blink mode (TRUE), or sets the background color to high
+   intensity (FALSE). The default is platform-dependent (FALSE in
+   most cases). It returns OK if it could set the state to match
+   the given parameter, ERR otherwise. Current platforms also
+   adjust the value of COLORS according to this function -- 16 for
+   FALSE, and 8 for TRUE.
+
+   PDC_set_title() sets the title of the window in which the curses
+   program is running. This function may not do anything on some
+   platforms. (Currently it only works in Win32 and X11.)
+
+### Portability
+                             X/Open    BSD    SYS V
+    PDC_set_blink               -       -       -
+    PDC_set_title               -       -       -
+
+**man-end****************************************************************/
+
+int PDC_curs_set(int visibility)
+{
+    int ret_vis;
+
+    PDC_LOG(("PDC_curs_set() - called: visibility=%d\n", visibility));
+
+    ret_vis = SP->visibility;
+
+    SP->visibility = visibility;
+
+    PDC_gotoyx(SP->cursrow, SP->curscol);
+
+    return ret_vis;
+}
+
+void PDC_set_title(const char *title)
+{
+    PDC_LOG(("PDC_set_title() - called:<%s>\n", title));
+
+    SDL_WM_SetCaption(title, title);
+}
+
+int PDC_set_blink(bool blinkon)
+{
+//  if (pdc_color_started)       /* We've got 256 colors in this version */
+//      COLORS = 16;
+
+    return blinkon ? ERR : OK;
+}

data/vendor/PDCurses/sdl1/pdcutil.c

@@ -0,0 +1,40 @@
+/* Public Domain Curses */
+
+#include "pdcsdl.h"
+
+void PDC_beep(void)
+{
+    PDC_LOG(("PDC_beep() - called\n"));
+}
+
+void PDC_napms(int ms)
+{
+    PDC_LOG(("PDC_napms() - called: ms=%d\n", ms));
+
+    PDC_update_rects();
+    SDL_PumpEvents();
+    SDL_Delay(ms);
+}
+
+const char *PDC_sysname(void)
+{
+    return "SDL";
+}
+
+PDCEX PDC_version_info PDC_version = { PDC_PORT_SDL1,
+          PDC_VER_MAJOR, PDC_VER_MINOR, PDC_VER_CHANGE,
+          sizeof( chtype),
+               /* note that thus far,  'wide' and 'UTF8' versions exist */
+               /* only for SDL2, X11,  Win32,  and Win32a;  elsewhere, */
+               /* these will be FALSE */
+#ifdef PDC_WIDE
+          TRUE,
+#else
+          FALSE,
+#endif
+#ifdef PDC_FORCE_UTF8
+          TRUE,
+#else
+          FALSE,
+#endif
+          };

data/vendor/PDCurses/sdl1/sdltest.c

@@ -0,0 +1,79 @@
+/* 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.
+*/
+
+#include <SDL.h>
+#include <curses.h>
+#include <stdlib.h>
+#include <time.h>
+
+/* You could #include pdcsdl.h, or just add the relevant declarations 
+   here: */
+
+PDCEX SDL_Surface *pdc_screen;
+PDCEX int pdc_yoffset;
+
+int main(int argc, char **argv)
+{
+    char inp[60];
+    int i, j, seed;
+
+    seed = time((time_t *)0);
+    srand(seed);
+
+    /* Initialize SDL */
+
+    if (SDL_Init(SDL_INIT_VIDEO) < 0)
+        exit(1);
+
+    atexit(SDL_Quit);
+
+    pdc_screen = SDL_SetVideoMode(640, 480, 0, SDL_SWSURFACE|SDL_ANYFORMAT);
+
+    /* 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_UpdateRect(pdc_screen, 0, 0, 640, 416);
+
+    /* 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/PDCurses/sdl2/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.11)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "MinSizeRel" CACHE STRING "Choose the type of build, options are: Debug, Release, or MinSizeRel." FORCE)
+    message(STATUS "No build type specified, defaulting to MinSizeRel.")
+endif()
+
+project(sdl2 VERSION "${PROJECT_VERSION}" LANGUAGES C)
+message(STATUS "${PROJECT_NAME} version: ${PROJECT_VERSION}")
+
+message(STATUS "SDL2_LIBRARIES = ${SDL2_LIBRARIES}")
+message(STATUS "SDL2_INCLUDE_DIR = ${SDL2_INCLUDE_DIR}")
+message(STATUS "SDL2_LIBRARY_DIR = ${SDL2_LIBRARY_DIR}")
+if(PDC_WIDE)
+    message(STATUS "SDL2_TTF_LIBRARY = ${SDL2_TTF_LIBRARY}")
+    message(STATUS "SDL2_TTF_INCLUDE_DIR = ${SDL2_TTF_INCLUDE_DIR}")
+    message(STATUS "SDL2_TTF_LIBRARY_DIR = ${SDL2_TTF_LIBRARY_DIR}")
+endif()
+
+include_directories(${SDL2_INCLUDE_DIR} ${SDL2_TTF_INCLUDE_DIR})
+link_directories(${SDL2_LIBRARY_DIR} ${SDL2_TTF_LIBRARY_DIR})
+
+include(project_common)
+
+macro (sdl2_app dir targ)
+
+    set(bin_name "${PROJECT_NAME}_${targ}")
+
+    if(${targ} STREQUAL "tuidemo")
+        set(src_files ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/tuidemo.c ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/tui.c)
+    else()
+        set(src_files ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${targ}.c)
+    endif()
+
+    add_executable(${bin_name} ${src_files})
+
+    if(PDC_WIDE)
+        target_link_libraries(${bin_name} ${PDCURSE_PROJ} ${EXTRA_LIBS}
+            "${SDL2_LIBRARIES};${SDL2_TTF_LIBRARY};${FT2_LIBRARY};${ZLIB_LIBRARY};${SDL2_DEP_LIBRARIES}")
+    else()
+        target_link_libraries(${bin_name} ${PDCURSE_PROJ} ${EXTRA_LIBS}
+        "${SDL2_LIBRARIES};${SDL2_TTF_DEP_LIBRARIES};${SDL2_DEP_LIBRARIES}")
+    endif()
+
+    add_dependencies(${bin_name} ${PDCURSE_PROJ})
+    set_target_properties(${bin_name} PROPERTIES OUTPUT_NAME ${targ})
+
+    install(TARGETS ${bin_name} RUNTIME DESTINATION ${PDCURSES_DIST}/bin/${PROJECT_NAME} COMPONENT applications)
+    
+endmacro ()
+
+sdl2_app(../demos version)
+sdl2_app(../demos firework)
+sdl2_app(../demos ozdemo)
+sdl2_app(../demos newtest)
+sdl2_app(../demos ptest)
+sdl2_app(../demos rain)
+sdl2_app(../demos testcurs)
+sdl2_app(../demos tuidemo)
+sdl2_app(../demos worm)
+sdl2_app(../demos xmas)
+sdl2_app(./ sdltest)
+
+if(WIN32)
+    set_target_properties(${PROJECT_NAME}_newtest PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
+endif(WIN32)
+
+if(PDC_SDL2_DEPS_BUILD)
+    if(PDC_WIDE)
+        add_dependencies(${PDCURSE_PROJ} sdl2_ext sdl2_ttf_ext)
+    else()
+        add_dependencies(${PDCURSE_PROJ} sdl2_ext)
+    endif()
+endif()
+
+set(CPACK_COMPONENTS_ALL applications)