curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/vt/pdcscrn.c

@@ -0,0 +1,492 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#if !defined( _WIN32) && !defined( DOS)
+#define USE_TERMIOS
+#include <unistd.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+
+static struct termios orig_term;
+#endif
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef MOUSE_MOVED
+#endif
+
+#include <assert.h>
+#include "curspriv.h"
+#include "pdcvt.h"
+#include "../common/pdccolor.h"
+#include "../common/pdccolor.c"
+
+#ifdef DOS
+int PDC_is_ansi = TRUE;
+#else
+int PDC_is_ansi = FALSE;
+#endif
+
+int PDC_rows = -1, PDC_cols = -1;
+bool PDC_resize_occurred = FALSE;
+
+#ifdef _WIN32
+
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
+#ifndef ENABLE_VIRTUAL_TERMINAL_INPUT
+#define ENABLE_VIRTUAL_TERMINAL_INPUT      0x0200
+#endif
+#ifndef DISABLE_NEWLINE_AUTO_RETURN
+#define DISABLE_NEWLINE_AUTO_RETURN        0x0008
+#endif
+
+/* Modified version of suggested Wine detection technique at
+
+https://www.winehq.org/pipermail/wine-devel/2008-September/069387.html
+
+Note that odd casting is required to avoid warnings/errors. */
+
+typedef const char *(CDECL *wine_ver_func)();
+#define VOID_FN_PTR (void(*)(void))
+
+static int _wine_version( void)
+{
+    wine_ver_func pwine_get_version;
+    HMODULE hntdll = (HMODULE)GetModuleHandle( "ntdll.dll");
+
+    if(!hntdll)            /* not running on NT,  i.e.,  WinME/98/95 */
+        return( -1);
+
+    pwine_get_version = (wine_ver_func) VOID_FN_PTR
+                    GetProcAddress( hntdll, "wine_get_version");
+    if( pwine_get_version)
+    {
+        const char *version_string = (const char *)pwine_get_version( );
+
+        return( atoi( version_string));
+    }
+    else         /* Wine not found;  we're on 'real' Windows(R) NT */
+        return( 0);
+}
+
+/* In DOS/Windows,  we have two possible modes of operation.  If we can
+successfully use SetConsoleMode to ENABLE_VIRTUAL_TERMINAL_INPUT,
+we have access to most of what we'd use on xterm.  If not,  we can only
+use what ANSI.SYS or ANSI.COM (or their NANSI or NNANSI variants) support.
+We'll get sixteen colors,  no mouse events,  no resizable windows,  etc.
+
+   So we check the return value from SetConsoleMode and set PDC_is_ansi
+accordingly.  (In DOS,  PDC_is_ansi is always true -- there's no xterm-like
+support there.  On non-MS platforms,  PDC_is_ansi is always false...
+though that should be revisited for the Linux console,  and probably
+elsewhere.)  */
+
+static int PDC_get_screen_size( int *n_cols, int *n_rows)
+{
+    const HANDLE hOut = GetStdHandle( STD_OUTPUT_HANDLE);
+    CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
+
+    assert( INVALID_HANDLE_VALUE != hOut);
+    GetConsoleScreenBufferInfo( hOut, &ScreenBufferInfo);
+    *n_cols = ScreenBufferInfo.srWindow.Right - ScreenBufferInfo.srWindow.Left + 1;
+    *n_rows = ScreenBufferInfo.srWindow.Bottom - ScreenBufferInfo.srWindow.Top + 1;
+    return( 0);
+}
+
+int PDC_wine_version;
+
+static int set_win10_for_vt_codes( const bool setting_mode)
+{
+    const HANDLE hIn = GetStdHandle( STD_INPUT_HANDLE);
+    HANDLE hOut;
+    DWORD dwMode = 0;
+    static DWORD old_input_mode;
+    static UINT old_code_page = 0;
+    const DWORD out_mask = ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                               | DISABLE_NEWLINE_AUTO_RETURN;
+
+    if( hIn == INVALID_HANDLE_VALUE)
+        return GetLastError( );
+    PDC_is_ansi = TRUE;
+    if( setting_mode)
+        {
+        PDC_wine_version = _wine_version( );
+        if( PDC_wine_version > 0)
+            setbuf( stdout, NULL);
+        }
+    if( setting_mode)
+        {
+        GetConsoleMode( hIn, &old_input_mode);
+        dwMode = ENABLE_VIRTUAL_TERMINAL_INPUT;
+#ifdef PDC_WIDE
+        old_code_page = SetConsoleOutputCP( 65001);
+#else
+        old_code_page = SetConsoleOutputCP( 437);
+#endif
+        }
+    else       /* restoring initial mode */
+        {
+        dwMode = old_input_mode;
+        if( old_code_page)
+            SetConsoleOutputCP( old_code_page);
+        }
+    if( !SetConsoleMode( hIn, dwMode))
+        return GetLastError( );
+        /* Set output mode to handle virtual terminal sequences */
+    hOut = GetStdHandle( STD_OUTPUT_HANDLE);
+    if( hOut == INVALID_HANDLE_VALUE)
+        return GetLastError( );
+
+    if( !GetConsoleMode( hOut, &dwMode))
+        return GetLastError( );
+    if( setting_mode)
+        dwMode |= out_mask;
+    else                    /* clearing VT mode,  not setting it */
+        dwMode &= ~out_mask;
+    if( !SetConsoleMode( hOut, dwMode))
+        return GetLastError( );
+              /* If we've gotten this far,  the terminal has been  */
+              /* set up to process xterm-like sequences : */
+    PDC_is_ansi = FALSE;
+    if( setting_mode)
+        PDC_get_screen_size( &PDC_cols, &PDC_rows);
+    return( 0);
+}
+
+/* It appears that ConPTY doesn't provide any way to be signalled about
+window resizing.  You can't,  say,  set up a callback function,  or have
+an escape sequence omitted upon resizing.  You have to poll.
+
+   This seems so utterly stupid that I suspect I've overlooked something.
+But quite a bit of online searching has failed to find an alternative. */
+
+void PDC_check_for_resize( void)
+{
+   HANDLE hOut = GetStdHandle( STD_OUTPUT_HANDLE);
+   CONSOLE_SCREEN_BUFFER_INFO console_buff_info;
+   static short prev_X, prev_Y;
+
+   if( GetConsoleScreenBufferInfo( hOut, &console_buff_info))
+      if( console_buff_info.dwSize.X != prev_X || console_buff_info.dwSize.Y != prev_Y)
+      {
+         if( prev_X && prev_Y)
+         {
+             PDC_rows = console_buff_info.dwSize.Y;
+             PDC_cols = console_buff_info.dwSize.X;
+             PDC_resize_occurred = TRUE;
+             if (SP)
+                SP->resized = TRUE;
+         }
+         prev_X = console_buff_info.dwSize.X;
+         prev_Y = console_buff_info.dwSize.Y;
+      }
+}
+#endif
+
+static mmask_t _stored_trap_mbe;
+
+/* COLOR_PAIR to attribute encoding table. */
+
+void PDC_reset_prog_mode( void)
+{
+#ifdef USE_TERMIOS
+    struct termios term;
+
+    tcgetattr( fileno( SP->input_fd), &orig_term);
+    memcpy( &term, &orig_term, sizeof( term));
+    term.c_lflag &= ~(ICANON | ECHO);
+    term.c_iflag &= ~ICRNL;
+    term.c_cc[VSUSP] = _POSIX_VDISABLE;   /* disable Ctrl-Z */
+    term.c_cc[VSTOP] = _POSIX_VDISABLE;   /* disable Ctrl-S */
+    term.c_cc[VSTART] = _POSIX_VDISABLE;   /* disable Ctrl-Q */
+    tcsetattr( fileno( SP->input_fd), TCSANOW, &term);
+#endif
+#if !defined( DOS)
+    if( !PDC_is_ansi)
+        PDC_puts_to_stdout( CSI "?1006h");    /* Set SGR mouse tracking,  if available */
+    if( !SP->_preserve)
+       PDC_puts_to_stdout( CSI "?47h");      /* Save screen */
+#endif
+    PDC_puts_to_stdout( "\033" "7");         /* save cursor & attribs (VT100) */
+
+    SP->_trap_mbe = _stored_trap_mbe;
+    PDC_mouse_set( );          /* clear any mouse event captures */
+    PDC_resize_occurred = FALSE;
+}
+
+void PDC_reset_shell_mode( void)
+{
+}
+
+static int initial_PDC_rows, initial_PDC_cols;
+
+int PDC_resize_screen(int nlines, int ncols)
+{
+   if( PDC_rows == -1)     /* initscr( ) hasn't been called;  we're just */
+      {                    /* setting desired size at startup */
+      initial_PDC_rows = nlines;
+      initial_PDC_cols = ncols;
+      }
+   else if( nlines > 1 && ncols > 1 && !PDC_is_ansi)
+      {
+      char tbuff[50];
+
+#ifdef HAVE_SNPRINTF
+      snprintf( tbuff, sizeof( tbuff), CSI "8;%d;%dt", nlines, ncols);
+#else
+      sprintf( tbuff, CSI "8;%d;%dt", nlines, ncols);
+#endif
+      PDC_puts_to_stdout( tbuff);
+      PDC_rows = nlines;
+      PDC_cols = ncols;
+      }
+   return( 0);
+}
+
+void PDC_restore_screen_mode(int i)
+{
+    INTENTIONALLY_UNUSED_PARAMETER( i);
+}
+
+void PDC_save_screen_mode(int i)
+{
+    INTENTIONALLY_UNUSED_PARAMETER( i);
+}
+
+void PDC_scr_close( void)
+{
+#if !defined( DOS)
+   if( !PDC_is_ansi)
+       PDC_puts_to_stdout( CSI "?1006l");    /* Turn off SGR mouse tracking */
+#endif
+   PDC_puts_to_stdout( "\033" "8");         /* restore cursor & attribs (VT100) */
+   PDC_puts_to_stdout( CSI "m");         /* set default screen attributes */
+#if !defined( DOS)
+   PDC_puts_to_stdout( CSI "?47l");      /* restore screen */
+   PDC_curs_set( 2);          /* blinking block cursor */
+#endif
+   PDC_gotoyx( PDC_cols - 1, 0);
+   _stored_trap_mbe = SP->_trap_mbe;
+   SP->_trap_mbe = 0;
+   PDC_mouse_set( );          /* clear any mouse event captures */
+#ifdef _WIN32
+   set_win10_for_vt_codes( FALSE);
+#else
+   #if !defined( DOS)
+      tcsetattr( fileno( SP->input_fd), TCSANOW, &orig_term);
+   #endif
+#endif
+   PDC_doupdate( );
+   PDC_flushinp( );
+   PDC_puts_to_stdout( NULL);      /* free internal cache */
+   return;
+}
+
+void PDC_scr_free( void)
+{
+    PDC_free_palette( );
+#ifdef USING_COMBINING_CHARACTER_SCHEME
+    PDC_expand_combined_characters( 0, NULL);
+#endif
+}
+
+#ifdef USE_TERMIOS
+
+int PDC_get_terminal_fd( void);        /* pdckbd.c */
+
+static void sigwinchHandler( int sig)
+{
+   struct winsize ws;
+
+   INTENTIONALLY_UNUSED_PARAMETER( sig);
+   if( -1 != ioctl( PDC_get_terminal_fd( ), TIOCGWINSZ, &ws))
+      if( PDC_rows != ws.ws_row || PDC_cols != ws.ws_col)
+         {
+         PDC_rows = ws.ws_row;
+         PDC_cols = ws.ws_col;
+         PDC_resize_occurred = TRUE;
+         if (SP)
+            SP->resized = TRUE;
+         }
+}
+
+int PDC_n_ctrl_c = 0;
+
+static void sigintHandler( int sig)
+{
+    INTENTIONALLY_UNUSED_PARAMETER( sig);
+    if( !SP->raw_inp)
+    {
+        PDC_scr_close( );
+        PDC_scr_free( );
+        exit( 0);
+    }
+    else
+        PDC_n_ctrl_c++;
+}
+#endif
+
+#define MAX_LINES 1000
+#define MAX_COLUMNS 1000
+
+bool PDC_has_rgb_color = FALSE;
+
+int PDC_scr_open(void)
+{
+    char *capabilities = getenv( "PDC_VT");
+    char *term_env = getenv( "TERM");
+    const char *colorterm = getenv( "COLORTERM");
+    chtype PDC_capabilities = 0;
+#ifdef USE_TERMIOS
+    struct sigaction sa;
+#endif
+#ifdef _WIN32
+    set_win10_for_vt_codes( TRUE);
+#endif
+
+    PDC_LOG(("PDC_scr_open called\n"));
+    if( term_env && !strcmp( term_env, "linux"))
+       PDC_is_ansi = TRUE;
+    else if( colorterm && !strcmp( colorterm, "truecolor"))
+       PDC_has_rgb_color = TRUE;
+    if( capabilities)      /* these should really come from terminfo! */
+       {
+       if( strstr( capabilities, "RGB"))
+          PDC_has_rgb_color = TRUE;
+       if( strstr( capabilities, "UND"))
+          PDC_capabilities |= A_UNDERLINE;
+       if( strstr( capabilities, "BLI"))
+          PDC_capabilities |= A_BLINK;
+       if( strstr( capabilities, "DIM"))
+          PDC_capabilities |= A_DIM;
+       if( strstr( capabilities, "STA"))
+          PDC_capabilities |= A_STANDOUT;
+       if( strstr( capabilities, "STR"))
+          PDC_capabilities |= A_STRIKEOUT;
+       }
+    COLORS = (PDC_is_ansi ? 16 : 256);
+    if( PDC_has_rgb_color)
+       COLORS = 256 + (256 * 256 * 256);
+    assert( SP);
+    if (!SP || PDC_init_palette( ))
+        return ERR;
+
+    setbuf( SP->input_fd, NULL);
+#ifdef USE_TERMIOS
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+    sa.sa_handler = sigwinchHandler;
+    if (sigaction(SIGWINCH, &sa, NULL) == -1)
+    {
+        fprintf( stderr, "Sigaction failed\n");
+        return( -1);
+    }
+    sigwinchHandler( 0);
+
+    sa.sa_handler = sigintHandler;
+    if (sigaction(SIGINT, &sa, NULL) == -1)
+    {
+        fprintf( stderr, "Sigaction (INT) failed\n");
+        return( -1);
+    }
+#else
+    {
+        const char *env = getenv("PDC_LINES");
+
+        if( env)
+           PDC_rows = atoi( env);
+        if( PDC_rows < 2)
+#ifdef DOS
+           PDC_rows = 25;
+#else
+           PDC_rows = 24;
+#endif
+        env = getenv( "PDC_COLS");
+        if( env)
+           PDC_cols = atoi( env);
+        if( PDC_cols < 2)
+           PDC_cols = 80;
+    }
+#endif
+    SP->mouse_wait = PDC_CLICK_PERIOD;
+    SP->visibility = 0;                /* no cursor,  by default */
+    SP->curscol = SP->cursrow = 0;
+    SP->audible = TRUE;
+    SP->mono = FALSE;
+    SP->orig_attr = TRUE;
+    SP->orig_fore = SP->orig_back = -1;
+    SP->termattrs = PDC_capabilities & ~A_BLINK;
+
+    while( PDC_get_rows( ) < 1 && PDC_get_columns( ) < 1)
+      ;     /* wait for screen to be drawn and size determined */
+    if( initial_PDC_rows > 1 && initial_PDC_cols > 1)
+    {
+        PDC_resize_screen( initial_PDC_rows, initial_PDC_cols);
+        while( PDC_get_rows( ) != initial_PDC_rows
+            && PDC_get_columns( ) != initial_PDC_rows)
+           ;
+    }
+
+    SP->lines = PDC_get_rows();
+    SP->cols = PDC_get_columns();
+
+    if (SP->lines < 2 || SP->lines > MAX_LINES
+       || SP->cols < 2 || SP->cols > MAX_COLUMNS)
+    {
+        fprintf(stderr, "LINES value must be >= 2 and <= %d: got %d\n",
+                MAX_LINES, SP->lines);
+        fprintf(stderr, "COLS value must be >= 2 and <= %d: got %d\n",
+                MAX_COLUMNS, SP->cols);
+
+        return ERR;
+    }
+
+    SP->_preserve = (getenv("PDC_PRESERVE_SCREEN") != NULL);
+    PDC_reset_prog_mode();
+    PDC_LOG(("PDC_scr_open exit\n"));
+    return( 0);
+}
+
+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);
+   return;
+}
+
+
+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( (int32_t)Get_RValue(col) * (int32_t)1000, (int32_t)255);
+    *green = DIVROUND( (int32_t)Get_GValue(col) * (int32_t)1000, (int32_t)255);
+    *blue =  DIVROUND( (int32_t)Get_BValue(col) * (int32_t)1000, (int32_t)255);
+
+    return OK;
+}
+
+int PDC_init_color( int color, int red, int green, int blue)
+{
+    const PACKED_RGB new_rgb = PACK_RGB(DIVROUND((int32_t)red   * (int32_t)255, (int32_t)1000),
+                                        DIVROUND((int32_t)green * (int32_t)255, (int32_t)1000),
+                                        DIVROUND((int32_t)blue  * (int32_t)255, (int32_t)1000));
+
+    if( !PDC_set_palette_entry( color, new_rgb))
+        curscr->_clear = TRUE;
+    return OK;
+}

data/vendor/PDCursesMod/vt/pdcsetsc.c

@@ -0,0 +1,158 @@
+#include <stdio.h>
+#include <curspriv.h>
+#include "pdcvt.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****************************************************************/
+
+    /* #define BLINKING_CURSOR   CSI "?12h"    */
+#define BLINKING_BLOCK      CSI "1 q"
+#define STEADY_BLOCK        CSI "2 q"
+#define BLINKING_UNDERLINE  CSI "3 q"
+#define STEADY_UNDERLINE    CSI "4 q"
+      /* "bar" = "vertical line".  xterm only. */
+#define BLINKING_BAR        CSI "5 q"
+#define STEADY_BAR          CSI "6 q"
+#define CURSOR_ON           CSI "?25h"
+#define CURSOR_OFF          CSI "?25l"
+
+int PDC_curs_set( int visibility)
+{
+    int ret_vis;
+
+    PDC_LOG(("PDC_curs_set() - called: visibility=%d\n", visibility));
+
+    ret_vis = SP->visibility;
+
+#if !defined( LINUX_FRAMEBUFFER_PORT) && !defined( DOS)
+    if( !SP->visibility && visibility)    /* turn cursor back on */
+        PDC_puts_to_stdout( CURSOR_ON);
+    else if( SP->visibility && !visibility)
+        PDC_puts_to_stdout( CURSOR_OFF);
+#endif
+    SP->visibility = visibility;
+#ifdef LINUX_FRAMEBUFFER_PORT
+    PDC_gotoyx( SP->cursrow, SP->curscol);
+#else
+    if( !PDC_is_ansi)
+    {
+        const int vis1 = visibility & 0xff;
+        const int vis2 = (visibility >> 8) & 0xff;
+        const char *command;
+
+        if( vis1 && vis2)      /* show solid */
+            switch( vis1)
+            {
+                case 1:        /* "normal" = underline */
+                case 5:        /* bottom half block;  we don't actually have that */
+                    command = STEADY_UNDERLINE;
+                    break;
+                case 2:        /* full block */
+                    command = STEADY_BLOCK;
+                    break;
+                case 4:       /* caret */
+                    command = STEADY_BAR;
+                    break;
+                default:      /* since we can't do outline, cross, etc. */
+                    command = STEADY_UNDERLINE;
+                    break;
+            }
+        else switch( vis1 ? vis1 : vis2)
+            {
+                case 0:        /* just turning it off */
+                    command = CURSOR_OFF;
+                    break;
+                case 1:        /* "normal" = underline */
+                case 5:        /* bottom half block;  we don't actually have that */
+                    command = BLINKING_UNDERLINE;
+                    break;
+                case 2:        /* full block */
+                    command = BLINKING_BLOCK;
+                    break;
+                case 4:        /* caret */
+                    command = BLINKING_BAR;
+                    break;
+                default:      /* since we can't do outline, cross, etc. */
+                    command = BLINKING_UNDERLINE;
+                    break;
+            }
+
+        PDC_puts_to_stdout( command);
+    }
+#endif
+    return ret_vis;
+}
+
+static int reset_attr( const attr_t attr, const bool attron)
+{
+    attr_t prev_termattrs;
+
+    if (!SP)
+        return ERR;
+    prev_termattrs = SP->termattrs;
+    if( attron)
+        SP->termattrs |= attr;
+    else
+        SP->termattrs &= ~attr;
+    if( prev_termattrs != SP->termattrs)
+       curscr->_clear = TRUE;
+    return OK;
+}
+
+int PDC_set_blink(bool blinkon)
+{
+   return( reset_attr( A_BLINK, blinkon));
+}
+
+int PDC_set_bold(bool boldon)
+{
+   return( reset_attr( A_BOLD, boldon));
+}
+
+void PDC_set_title( const char *title)
+{
+    PDC_LOG(("PDC_set_title() - called:<%s>\n", title));
+
+#if !defined( DOS) && !defined( LINUX_FRAMEBUFFER_PORT)
+    if( !PDC_is_ansi)
+    {
+        PDC_puts_to_stdout( OSC "2;");
+        PDC_puts_to_stdout( title);
+        PDC_puts_to_stdout( "\a");
+    }
+#else
+    INTENTIONALLY_UNUSED_PARAMETER( title);
+#endif
+}