curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/sdl2/pdcscrn.c

@@ -0,0 +1,529 @@
+/* PDCurses */
+
+#include "pdcsdl.h"
+
+#include <stdlib.h>
+#include <limits.h>
+#ifndef PDC_WIDE
+# include "../common/font437.h"
+#endif
+#include "../common/iconbmp.h"
+#include "../common/pdccolor.h"
+#include "../common/pdccolor.c"
+
+#ifdef PDC_WIDE
+# ifndef PDC_FONT_PATH
+#  ifdef _WIN32
+#   define PDC_FONT_PATH "C:/Windows/Fonts/consola.ttf"
+#  elif defined(__APPLE__)
+#   define PDC_FONT_PATH "/System/Library/Fonts/Menlo.ttc"
+#  else
+#   define PDC_FONT_PATH "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
+#   define PDC_FONT_PATH2 "/usr/share/fonts/dejavu-sans-mono-fonts/DejaVuSansMono.ttf"
+#  endif
+# endif
+TTF_Font *pdc_ttffont = NULL;
+int pdc_font_size =
+# ifdef _WIN32
+ 16;
+# else
+ 17;
+# endif
+int pdc_sdl_render_mode = PDC_SDL_RENDER_BLENDED;
+#endif
+
+SDL_Window *pdc_window = NULL;
+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;
+
+int pdc_fheight, pdc_fwidth, pdc_fthick, pdc_flastc;
+bool pdc_own_window;
+
+#ifndef PDC_WIDE
+
+/* Load a bitmap from bmp_rw and also determine its palette size.
+   ->format->palette->ncolors may be greater than the actual size.
+   To get the real palette size, some custom bitmap parsing is needed. */
+
+static SDL_Surface *_load_bmp_and_palette_size(SDL_RWops *bmp_rw, int *palette_size)
+{
+    SDL_Surface *bmp = NULL;
+    Sint64 start_offset;
+
+    *palette_size = -1;
+    if (!bmp_rw)
+        return( NULL);
+
+    start_offset = SDL_RWtell(bmp_rw);
+
+    /* Non-monochromatic bitmaps only */
+    if( start_offset >= 0 && (bmp = SDL_LoadBMP_RW(bmp_rw, 0)) != NULL
+                            && bmp->format->palette)
+    {
+        *palette_size = bmp->format->palette->ncolors;
+
+        /* Offsets from https://en.wikipedia.org/wiki/BMP_file_format#DIB_header_(bitmap_information_header) */
+        if (SDL_RWseek(bmp_rw, start_offset + 14, RW_SEEK_SET) >= 0)
+        {
+            const Uint32 header_size = SDL_ReadLE32(bmp_rw);
+
+            /* If the info header is at least 40 bytes in size, palette size
+               information is available. */
+            if (header_size >= 40
+                    && SDL_RWseek(bmp_rw, start_offset + 46, RW_SEEK_SET) >= 0)
+            {
+                Uint32 num_colors = SDL_ReadLE32(bmp_rw);
+
+                if (num_colors > 0 && num_colors <= (Uint32)INT_MAX &&
+                    (int)num_colors <= bmp->format->palette->ncolors)
+                         *palette_size = (int)num_colors;
+                else
+                {
+                    /* Fall back to calculating num_colors from bits_per_pixel. */
+
+                    if (SDL_RWseek(bmp_rw, start_offset + 28, RW_SEEK_SET) >= 0)
+                    {
+                        const Uint16 bits_per_pixel = SDL_ReadLE16(bmp_rw);
+
+                        num_colors = (Uint32)1 << bits_per_pixel;
+                        if (num_colors > 0 && num_colors <= (Uint32)INT_MAX &&
+                            (int)num_colors <= bmp->format->palette->ncolors)
+                                      *palette_size = (int)num_colors;
+                    }
+                }
+            }
+        }
+    }
+
+    SDL_RWclose(bmp_rw);
+    return bmp;
+}
+
+#endif
+
+static void _clean(void)
+{
+#ifdef PDC_WIDE
+    if (pdc_ttffont)
+    {
+        TTF_CloseFont(pdc_ttffont);
+        TTF_Quit();
+        pdc_ttffont = NULL;
+    }
+#endif
+    if( pdc_tileback)
+        SDL_FreeSurface(pdc_tileback);
+    if( pdc_back)
+        SDL_FreeSurface(pdc_back);
+    if( pdc_icon)
+        SDL_FreeSurface(pdc_icon);
+    if( pdc_font)
+        SDL_FreeSurface(pdc_font);
+    if( pdc_screen)
+        SDL_FreeSurface(pdc_screen);
+    pdc_screen = pdc_tileback = pdc_back = pdc_icon = pdc_font = NULL;
+    if( pdc_own_window && pdc_window)
+    {
+        SDL_DestroyWindow(pdc_window);
+        pdc_window = NULL;
+    }
+
+    SDL_Quit();
+    pdc_sheight = pdc_swidth = 0;
+}
+
+void PDC_retile(void)
+{
+    if (pdc_tileback)
+        SDL_FreeSurface(pdc_tileback);
+
+    pdc_tileback = SDL_ConvertSurface(pdc_screen, pdc_screen->format, 0);
+    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)
+{
+    PDC_free_palette( );
+    _clean( );
+}
+
+
+/* find the display where the mouse pointer is */
+
+int _get_displaynum(void)
+{
+    const int displays = SDL_GetNumVideoDisplays();
+
+    if (displays > 1)
+    {
+        int i, xpos, ypos;
+        SDL_Rect size;
+
+        SDL_GetGlobalMouseState(&xpos, &ypos);
+        for (i = 0; i < displays; i++)
+        {
+            SDL_GetDisplayBounds(i, &size);
+            if (size.x <= xpos && xpos < size.x + size.w &&
+                size.y <= ypos && ypos < size.y + size.h)
+                return i;
+        }
+    }
+
+    return 0;
+}
+
+/* open the physical screen -- miscellaneous initialization */
+
+int PDC_scr_open(void)
+{
+    SDL_Event event;
+    int displaynum = 0;
+#ifdef PDC_WIDE
+    const char *ptsz, *fname;
+#endif
+
+    PDC_LOG(("PDC_scr_open() - called\n"));
+
+    pdc_own_window = !pdc_window;
+
+    if (pdc_own_window)
+    {
+        if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_EVENTS) < 0)
+        {
+            fprintf(stderr, "Could not start SDL: %s\n", SDL_GetError());
+            return ERR;
+        }
+
+        atexit(_clean);
+
+        displaynum = _get_displaynum();
+    }
+
+#ifdef PDC_WIDE
+    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);
+# ifdef PDC_FONT_PATH2
+    if (!pdc_ttffont && !fname)
+    {
+        pdc_ttffont = TTF_OpenFont(PDC_FONT_PATH2,
+                                   pdc_font_size);
+    }
+# endif
+
+    if (!pdc_ttffont)
+    {
+        if (fname)
+            fprintf(stderr, "Could not load specified font: %s\n",fname);
+        else
+        {
+# ifdef PDC_FONT_PATH2
+            fprintf(stderr, "Could not load default font: %s or %s\n",
+                    PDC_FONT_PATH, PDC_FONT_PATH2);
+# else
+            fprintf(stderr, "Could not load default font: %s\n",
+                    PDC_FONT_PATH);
+# endif
+
+        }
+        return ERR;
+    }
+
+    TTF_SetFontKerning(pdc_ttffont, 0);
+    TTF_SetFontHinting(pdc_ttffont, TTF_HINTING_MONO);
+
+    SP->mono = FALSE;
+#else
+    if (pdc_font)
+    {
+        if (pdc_font->format->palette)
+            pdc_flastc = pdc_font->format->palette->ncolors - 1;
+    }
+    else
+    {
+        int palette_size;
+
+        const char *fname = getenv("PDC_FONT");
+        SDL_RWops *file = SDL_RWFromFile(fname ? fname : "pdcfont.bmp", "r");
+        if (file)
+            pdc_font = _load_bmp_and_palette_size(file, &palette_size);
+
+        if (!pdc_font)
+            pdc_font = _load_bmp_and_palette_size(
+                SDL_RWFromMem(font437, sizeof(font437)), &palette_size);
+
+        if (!pdc_font)
+        {
+            fprintf(stderr, "Could not load font\n");
+            return ERR;
+        }
+
+        if (pdc_font->format->palette)
+            pdc_flastc = palette_size - 1;
+    }
+
+    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_window))
+    {
+        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);
+    pdc_fthick = pdc_font_size / 20 + 1;
+#else
+    pdc_fheight = pdc_font->h / 8;
+    pdc_fwidth = pdc_font->w / 32;
+    pdc_fthick = 1;
+#endif
+
+    if (pdc_own_window && !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(iconbmp,
+                                                    sizeof(iconbmp)), 0);
+    }
+
+    if (pdc_own_window)
+    {
+        if( !pdc_sheight)
+        {
+            const char *env = getenv("PDC_LINES");
+            pdc_sheight = (env ? atoi(env) : 25);
+        }
+        pdc_sheight *= pdc_fheight;
+
+        if( !pdc_swidth)
+        {
+            const char *env = getenv("PDC_COLS");
+            pdc_swidth = (env ? atoi(env) : 80);
+        }
+        pdc_swidth *= pdc_fwidth;
+
+        pdc_window = SDL_CreateWindow("PDCurses",
+            SDL_WINDOWPOS_CENTERED_DISPLAY(displaynum),
+            SDL_WINDOWPOS_CENTERED_DISPLAY(displaynum),
+            pdc_swidth, pdc_sheight, SDL_WINDOW_RESIZABLE);
+
+        if (pdc_window == NULL)
+        {
+            fprintf(stderr, "Could not open SDL window: %s\n", SDL_GetError());
+            return ERR;
+        }
+
+        SDL_SetWindowIcon(pdc_window, pdc_icon);
+    }
+
+    /* Events must be pumped before calling SDL_GetWindowSurface, or
+       initial modifiers (e.g. numlock) will be ignored and out-of-sync. */
+
+    SDL_PumpEvents();
+
+    /* Wait until window is exposed before getting surface */
+
+    while (SDL_PollEvent(&event))
+        if (SDL_WINDOWEVENT == event.type &&
+            SDL_WINDOWEVENT_EXPOSED == event.window.event)
+            break;
+
+    if( !pdc_screen)
+    {
+        pdc_screen = SDL_GetWindowSurface(pdc_window);
+
+        if( !pdc_screen)
+        {
+            fprintf(stderr, "Could not open SDL window surface: %s\n",
+                    SDL_GetError());
+            return ERR;
+        }
+    }
+
+    if (!pdc_sheight)
+        pdc_sheight = pdc_screen->h - pdc_yoffset;
+
+    if (!pdc_swidth)
+        pdc_swidth = pdc_screen->w - pdc_xoffset;
+
+    if (SP->orig_attr)
+        PDC_retile();
+
+    SDL_StartTextInput();
+
+    PDC_mouse_set();
+
+    SP->mouse_wait = PDC_CLICK_PERIOD;
+    SP->audible = FALSE;
+
+    SP->termattrs = A_COLOR | WA_UNDERLINE | WA_LEFT | WA_RIGHT |
+                    WA_REVERSE | WA_STRIKEOUT | WA_TOP | WA_BLINK | WA_DIM | WA_BOLD;
+#ifdef PDC_WIDE
+    SP->termattrs |= WA_ITALIC;
+#endif
+
+    PDC_reset_prog_mode();
+
+    return OK;
+}
+
+/* the core of resize_term() */
+
+int PDC_resize_screen(int nlines, int ncols)
+{
+    if( !stdscr)     /* Specifying the  initial screen size */
+    {                /* before calling initscr().           */
+        pdc_sheight = nlines;
+        pdc_swidth = ncols;
+        return OK;
+    }
+
+    if (!pdc_own_window)
+        return ERR;
+
+    if (nlines && ncols)
+    {
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+        SDL_Rect max;
+        int top, left, bottom, right;
+
+        SDL_GetDisplayUsableBounds(0, &max);
+        SDL_GetWindowBordersSize(pdc_window, &top, &left, &bottom, &right);
+        max.h -= top + bottom;
+        max.w -= left + right;
+
+        while (nlines * pdc_fheight > max.h)
+            nlines--;
+        while (ncols * pdc_fwidth > max.w)
+            ncols--;
+#endif
+        pdc_sheight = nlines * pdc_fheight;
+        pdc_swidth = ncols * pdc_fwidth;
+
+        SDL_SetWindowSize(pdc_window, pdc_swidth, pdc_sheight);
+        pdc_screen = SDL_GetWindowSurface(pdc_window);
+    }
+
+    if (pdc_tileback)
+        PDC_retile();
+
+    return OK;
+}
+
+void PDC_reset_prog_mode(void)
+{
+    PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
+
+    PDC_flushinp();
+}
+
+void PDC_reset_shell_mode(void)
+{
+    PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
+
+    PDC_flushinp();
+}
+
+void PDC_restore_screen_mode(int i)
+{
+   INTENTIONALLY_UNUSED_PARAMETER( i);
+}
+
+void PDC_save_screen_mode(int i)
+{
+   INTENTIONALLY_UNUSED_PARAMETER( i);
+}
+
+bool PDC_can_change_color(void)
+{
+    return TRUE;
+}
+
+int PDC_color_content( int color, int *red, int *green, int *blue)
+{
+    const PACKED_RGB col = PDC_get_palette_entry( 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( int color, int red, int green, int blue)
+{
+    const PACKED_RGB new_rgb = PACK_RGB(DIVROUND(red * 255, 1000),
+                                 DIVROUND(green * 255, 1000),
+                                 DIVROUND(blue * 255, 1000));
+
+    if( !PDC_set_palette_entry( color, new_rgb))
+        curscr->_clear = TRUE;
+    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)
+{
+   INTENTIONALLY_UNUSED_PARAMETER( new_min_lines);
+   INTENTIONALLY_UNUSED_PARAMETER( new_max_lines);
+   INTENTIONALLY_UNUSED_PARAMETER( new_min_cols);
+   INTENTIONALLY_UNUSED_PARAMETER( new_max_cols);
+}

data/vendor/PDCursesMod/sdl2/pdcsdl.h

@@ -0,0 +1,46 @@
+/* PDCurses */
+
+#if defined( PDC_FORCE_UTF8) && !defined( PDC_WIDE)
+   #define PDC_WIDE
+#endif
+
+#include <SDL.h>
+#ifdef PDC_WIDE
+# include <SDL_ttf.h>
+#if SDL_TTF_VERSION_ATLEAST(2,0,18)
+/* SDL_ttf 2.0.18 introduced the the functions we use for rendering
+   individual characters beyond the BMP. */
+#define PDC_SDL_SUPPLEMENTARY_PLANES_SUPPORT 1
+#endif
+#endif
+
+#include <curspriv.h>
+
+#ifdef PDC_WIDE
+PDCEX  TTF_Font *pdc_ttffont;
+PDCEX  int pdc_font_size;
+#define PDC_SDL_RENDER_SOLID 1
+#define PDC_SDL_RENDER_SHADED 2
+#define PDC_SDL_RENDER_BLENDED 3
+
+PDCEX int pdc_sdl_render_mode;
+#endif
+PDCEX  SDL_Window *pdc_window;
+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 int pdc_fheight, pdc_fwidth;  /* font height and width */
+extern int pdc_fthick;               /* thickness for highlights and
+                                        rendered ACS glyphs */
+extern int pdc_flastc;               /* font palette's last color
+                                        (treated as the foreground) */
+extern bool pdc_own_window;          /* if pdc_window was not set
+                                        before initscr(), PDCurses is
+                                        responsible for (owns) it */
+
+PDCEX  void PDC_update_rects(void);
+PDCEX  void PDC_retile(void);
+
+extern void PDC_pump_and_peep(void);

data/vendor/PDCursesMod/sdl2/pdcsetsc.c

@@ -0,0 +1,99 @@
+/* PDCurses */
+
+#include "pdcsdl.h"
+
+/*man-start**************************************************************
+
+pdcsetsc
+--------
+
+### Synopsis
+
+    int PDC_set_blink(bool blinkon);
+    int PDC_set_bold(bool boldon);
+    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.
+
+   PDC_set_bold() toggles whether the A_BOLD attribute selects an actual
+   bold font (TRUE), or sets the foreground color to high intensity
+   (FALSE). It returns OK if it could set the state to match the given
+   parameter, ERR otherwise.
+
+   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.
+
+### Portability
+                             X/Open  ncurses  NetBSD
+    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_SetWindowTitle(pdc_window, title);
+}
+
+int PDC_set_blink(bool blinkon)
+{
+    if (!SP)
+        return ERR;
+
+    if (SP->color_started)                 /* see ../common/pdccolor.txt */
+        COLORS = 256 + (256 * 256 * 256);
+
+    if (blinkon)
+    {
+        if (!(SP->termattrs & A_BLINK))
+            SP->termattrs |= A_BLINK;
+    }
+    else
+    {
+        if (SP->termattrs & A_BLINK)
+            SP->termattrs &= ~A_BLINK;
+    }
+
+    return OK;
+}
+
+int PDC_set_bold(bool boldon)
+{
+    if (!SP)
+        return ERR;
+
+#ifdef PDC_WIDE
+    if (boldon)
+        SP->termattrs |= A_BOLD;
+    else
+        SP->termattrs &= ~A_BOLD;
+
+    return OK;
+#else
+    return boldon ? ERR : OK;
+#endif
+}

data/vendor/PDCursesMod/sdl2/pdcutil.c

@@ -0,0 +1,35 @@
+/* PDCurses */
+
+#include "pdcsdl.h"
+
+void PDC_beep(void)
+{
+    PDC_LOG(("PDC_beep() - called\n"));
+}
+
+void PDC_check_for_blinking( void);
+
+void PDC_napms(int ms)
+{
+    PDC_LOG(("PDC_napms() - called: ms=%d\n", ms));
+
+    while (ms > 50)
+    {
+        PDC_pump_and_peep();
+        SDL_Delay(50);
+        ms -= 50;
+        PDC_check_for_blinking( );
+        PDC_doupdate();
+    }
+    PDC_pump_and_peep();
+    SDL_Delay(ms);
+    PDC_check_for_blinking( );
+    PDC_doupdate();
+}
+
+const char *PDC_sysname(void)
+{
+    return "SDL2";
+}
+
+enum PDC_port PDC_port_val = PDC_PORT_SDL2;