curses 1.3.0 → 1.4.2

data/vendor/PDCurses/wincon/Makefile.wcc

@@ -0,0 +1,51 @@
+# Watcom WMAKE Makefile for PDCurses library - Windows console Watcom C/C++ 10.6+
+#
+# Usage: wmake -f [wincon\]Makefile.wcc [DEBUG=Y] [WIDE=Y] [UTF8=Y] [target]
+#
+# where target can be any of:
+# [all|demos|pdcurses.lib|testcurs.exe...]
+
+!ifdef %PDCURSES_SRCDIR
+PDCURSES_SRCDIR	= $(%PDCURSES_SRCDIR)
+!else
+PDCURSES_SRCDIR	= ..
+!endif
+
+!include $(PDCURSES_SRCDIR)\version.mif
+
+osdir		= $(PDCURSES_SRCDIR)\wincon
+
+CC		= wcc386
+TARGET		= nt
+
+CFLAGS		= /ei /zq /wx /i=$(PDCURSES_SRCDIR)
+
+!ifeq DEBUG Y
+CFLAGS		+= /d2 /DPDCDEBUG
+LDFLAGS		= D W A op q sys $(TARGET)
+!else
+CFLAGS		+= /oneatx
+LDFLAGS		= op q sys $(TARGET)
+!endif
+
+!ifeq WIDE Y
+CFLAGS		+= /DPDC_WIDE
+!endif
+
+!ifeq UTF8 Y
+CFLAGS		+= /DPDC_FORCE_UTF8
+!endif
+
+LIBEXE		= wlib /q /n /t
+
+!include $(PDCURSES_SRCDIR)\watcom.mif
+
+$(LIBCURSES) : $(LIBOBJS) $(PDCOBJS)
+	$(LIBEXE) $@ $(LIBOBJS) $(PDCOBJS)
+	-copy $(LIBCURSES) panel.lib
+
+PLATFORM1	= Watcom C++ WinCon
+PLATFORM2	= Open Watcom 1.6 for Windows console
+ARCNAME		= pdc$(VER)_wcc_w32
+
+!include $(PDCURSES_SRCDIR)\makedist.mif

data/vendor/PDCurses/wincon/README.md

@@ -0,0 +1,85 @@
+PDCurses for Win32
+==================
+
+This directory contains PDCurses source code files specific to Win32
+console mode (Win95 and all subsequent forks of Windows).
+
+Building
+--------
+
+   (Note that the following is almost identical to the instructions
+   for the Win32a GUI flavor of PDCurses.)
+
+- Choose the appropriate makefile for your compiler:
+
+        Makefile.bcc  - Borland C++ 4.0.2+
+        Makefile.dmc  - Digital Mars
+        Makefile.lcc  - LCC-Win32
+        Makefile.mng  - MinGW, Cygnus GNU Compiler
+        Makefile.vc   - Microsoft Visual C++ 2.0+ or later & Intel(R) compiler
+        Makefile.wcc  - Open Watcom 1.8+
+
+- Optionally, you can build in a different directory than the platform
+  directory by setting PDCURSES_SRCDIR to point to the directory where
+  you unpacked PDCurses, and changing to your target directory:
+
+        set PDCURSES_SRCDIR=c:\pdcurses
+
+  This won't work with the LCC or Digital Mars makefiles, nor will the
+  options described below.
+
+- Build it:
+
+        make -f makefilename
+
+  (For Watcom, use "wmake" instead of "make"; for MSVC, "nmake".) You'll
+  get the libraries (pdcurses.lib or .a, depending on your compiler; and
+  panel.lib or .a), the demos (*.exe), and a lot of object files. Note
+  that the panel library is just a copy of the main library, provided
+  for convenience; both panel and curses functions are in the main
+  library.
+
+  You can also give the optional parameter "WIDE=Y", to build the
+  library with wide-character (Unicode) support:
+
+        make -f Makefile.mng WIDE=Y
+
+  When built this way, the library is not compatible with Windows 9x,
+  unless you also link with the Microsoft Layer for Unicode (not
+  tested).
+
+  For the Intel(R) compiler,  use Makefile.vc and add ICC=Y.
+
+  By default,  Makefile.vc results in 64-bit code for both VC and Intel(R).
+  Add IX86=Y to generate 32-bit code.  (Other builds are 32-bit only.)
+
+  Another option, "UTF8=Y", makes PDCurses ignore the system locale, and
+  treat all narrow-character strings as UTF-8. This option has no effect
+  unless WIDE=Y is also set. Use it to get around the poor support for
+  UTF-8 in the Win32 console:
+
+        make -f Makefile.mng WIDE=Y UTF8=Y
+
+  You can also use the optional parameter "DLL=Y" with Visual C++,
+  MinGW or Cygwin, to build the library as a DLL:
+
+        nmake -f Makefile.vc WIDE=Y DLL=Y
+
+  When you build the library as a Windows DLL, you must always define
+  PDC_DLL_BUILD when linking against it. (Or, if you only want to use
+  the DLL, you could add this definition to your curses.h.)
+
+  If cross-compiling from Linux,  add the parameter `_w64=1` to get
+  64-bit code (default will be 32-bit).
+
+        make -f Makefile.mng _w64=1 [WIDE=Y UTF8=Y DLL=Y]
+
+Distribution Status
+-------------------
+
+The files in this directory are released to the Public Domain.
+
+Acknowledgements
+----------------
+
+Generic Win32 port was provided by Chris Szurgot <szurgot@itribe.net>

data/vendor/PDCurses/wincon/pdcclip.c

@@ -0,0 +1,174 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+
+/*man-start**************************************************************
+
+clipboard
+---------
+
+### Synopsis
+
+    int PDC_getclipboard(char **contents, long *length);
+    int PDC_setclipboard(const char *contents, long length);
+    int PDC_freeclipboard(char *contents);
+    int PDC_clearclipboard(void);
+
+### Description
+
+   PDC_getclipboard() gets the textual contents of the system's
+   clipboard. This function returns the contents of the clipboard
+   in the contents argument. It is the responsibility of the
+   caller to free the memory returned, via PDC_freeclipboard().
+   The length of the clipboard contents is returned in the length
+   argument.
+
+   PDC_setclipboard copies the supplied text into the system's
+   clipboard, emptying the clipboard prior to the copy.
+
+   PDC_clearclipboard() clears the internal clipboard.
+
+### Return Values
+
+   indicator of success/failure of call.
+   PDC_CLIP_SUCCESS        the call was successful
+   PDC_CLIP_MEMORY_ERROR   unable to allocate sufficient memory for
+                           the clipboard contents
+   PDC_CLIP_EMPTY          the clipboard contains no text
+   PDC_CLIP_ACCESS_ERROR   no clipboard support
+
+### Portability
+                             X/Open    BSD    SYS V
+    PDC_getclipboard            -       -       -
+    PDC_setclipboard            -       -       -
+    PDC_freeclipboard           -       -       -
+    PDC_clearclipboard          -       -       -
+
+**man-end****************************************************************/
+
+#ifdef PDC_WIDE
+# define PDC_TEXT CF_UNICODETEXT
+#else
+# define PDC_TEXT CF_OEMTEXT
+#endif
+
+int PDC_getclipboard_handle( HANDLE *handle)
+{
+    PDC_LOG(("PDC_getclipboard() - called\n"));
+
+    if (!OpenClipboard(NULL))
+    {
+        return PDC_CLIP_ACCESS_ERROR;
+    }
+
+    if ((*handle = GetClipboardData(PDC_TEXT)) == NULL)
+    {
+        CloseClipboard();
+        return PDC_CLIP_EMPTY;
+    }
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_getclipboard(char **contents, long *length)
+{
+    HANDLE handle;
+    int rval = PDC_getclipboard_handle( &handle);
+
+    if( rval == PDC_CLIP_SUCCESS)
+    {
+        void *tptr = GlobalLock( handle);
+
+        if( tptr)
+        {
+#ifdef PDC_WIDE
+            size_t len = wcslen((wchar_t *)tptr) * 3;
+#else
+            size_t len = strlen( tptr);
+#endif
+
+            *contents = (char *)GlobalAlloc( GMEM_FIXED, len + 1);
+
+            if( !*contents)
+                rval = PDC_CLIP_MEMORY_ERROR;
+            else
+            {
+#ifdef PDC_WIDE
+                len = PDC_wcstombs( (char *)*contents, tptr, len);
+#else
+                strcpy((char *)*contents, tptr);
+#endif
+            }
+            *length = (long)len;
+            GlobalUnlock( handle);
+        }
+        else
+            rval = PDC_CLIP_MEMORY_ERROR;
+        CloseClipboard();
+    }
+    return rval;
+}
+
+int PDC_setclipboard_raw( const char *contents, long length,
+            const bool translate_multibyte_to_wide_char)
+{
+    HGLOBAL handle;
+    LPTSTR buff;
+
+    PDC_LOG(("PDC_setclipboard() - called\n"));
+
+    if (!OpenClipboard(NULL))
+        return PDC_CLIP_ACCESS_ERROR;
+
+    handle = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,
+        (length + 1) * sizeof(TCHAR));
+
+    if (!handle)
+        return PDC_CLIP_MEMORY_ERROR;
+
+    buff = GlobalLock(handle);
+
+#ifdef PDC_WIDE
+    if( translate_multibyte_to_wide_char)
+       PDC_mbstowcs((wchar_t *)buff, contents, length);
+    else
+       memcpy((char *)buff, contents, (length + 1) * sizeof( wchar_t));
+#else
+    memcpy((char *)buff, contents, length);
+    buff[length] = 0;      /* ensure null termination */
+#endif
+    GlobalUnlock(handle);
+    EmptyClipboard();
+
+    if( !SetClipboardData(PDC_TEXT, handle))
+    {
+        GlobalFree(handle);
+        return PDC_CLIP_ACCESS_ERROR;
+    }
+
+    CloseClipboard();
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_setclipboard(const char *contents, long length)
+{
+   return( PDC_setclipboard_raw( contents, length, TRUE));
+}
+
+int PDC_freeclipboard(char *contents)
+{
+    PDC_LOG(("PDC_freeclipboard() - called\n"));
+
+    GlobalFree(contents);
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_clearclipboard(void)
+{
+    PDC_LOG(("PDC_clearclipboard() - called\n"));
+
+    EmptyClipboard();
+
+    return PDC_CLIP_SUCCESS;
+}

data/vendor/PDCurses/wincon/pdcdisp.c

@@ -0,0 +1,143 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef CHTYPE_LONG
+
+#ifdef PDC_WIDE
+   #define USE_UNICODE_ACS_CHARS 1
+#else
+   #define USE_UNICODE_ACS_CHARS 0
+#endif
+
+#include "acs_defs.h"
+
+#endif
+
+/* position hardware cursor at (y, x) */
+
+void PDC_gotoyx(int row, int col)
+{
+    COORD coord;
+
+    PDC_LOG(("PDC_gotoyx() - called: row %d col %d from row %d col %d\n",
+             row, col, SP->cursrow, SP->curscol));
+
+    coord.X = col;
+    coord.Y = row;
+
+    SetConsoleCursorPosition(pdc_con_out, coord);
+}
+
+/* update the given physical line to look like the corresponding line in
+   curscr */
+
+/* NOTE:  the original indexing into pdc_atrtab[] relied on three or five
+   attribute bits in 'chtype' being adjacent to the color bits.  Such is
+   not the case for 64-bit chtypes (CHTYPE_LONG == 2),  so we have to do
+   additional bit-fiddling for that situation.  Code is similar in Win32
+   and DOS flavors.  (BJG) */
+#define MAX_UNICODE                  0x10ffff
+#define DUMMY_CHAR_NEXT_TO_FULLWIDTH (MAX_UNICODE + 1)
+
+/* see 'addch.c' for an explanation of how combining chars are handled. */
+
+#if defined( CHTYPE_LONG) && CHTYPE_LONG >= 2 && defined( PDC_WIDE)
+   #define USING_COMBINING_CHARACTER_SCHEME
+   int PDC_expand_combined_characters( const cchar_t c, cchar_t *added);  /* addch.c */
+#endif
+
+#define PDC_NEW_WINCON_WORKAROUND 1
+
+void PDC_transform_line(int lineno, int x, int len, const chtype *srcp)
+{
+    CHAR_INFO ci[512];
+    int src, dst;
+    COORD bufSize, bufPos;
+    SMALL_RECT sr;
+
+    PDC_LOG(("PDC_transform_line() - called: lineno=%d\n", lineno));
+
+    bufPos.X = bufPos.Y = 0;
+
+    sr.Top = lineno;
+    sr.Bottom = lineno;
+    sr.Left = x;
+    sr.Right = x + len - 1;
+
+    for (src = dst = 0; src < len; src++)
+        if( (srcp[src] & A_CHARTEXT) != DUMMY_CHAR_NEXT_TO_FULLWIDTH)
+        {
+            const chtype ch = srcp[src];
+            chtype char_out = ch & A_CHARTEXT;
+
+#if defined( CHTYPE_LONG) && (CHTYPE_LONG >= 2)
+            ci[dst].Attributes = pdc_atrtab[((ch >> PDC_ATTR_SHIFT) & 0x1f)
+                     | (((ch >> PDC_COLOR_SHIFT) & 0xff) << 5)];
+#else
+            ci[dst].Attributes = pdc_atrtab[ch >> PDC_ATTR_SHIFT];
+#endif
+
+#ifdef CHTYPE_LONG
+            if (ch & A_ALTCHARSET && !(ch & 0xff80))
+                char_out = acs_map[ch & 0x7f];
+
+#ifdef USING_COMBINING_CHARACTER_SCHEME
+         /* We can't actually display combining characters in cmd.exe.  So
+         show the 'base' character and throw away the modifying marks. */
+            if( char_out > MAX_UNICODE)
+            {
+                cchar_t added;
+                int n_combined = 0;
+
+                while( (char_out = PDC_expand_combined_characters( char_out,
+                                   &added)) > MAX_UNICODE)
+                {
+                    n_combined++;
+                }
+            }
+#endif
+            if( char_out > 0xffff)  /* SMP chars: use surrogates */
+            {
+                ci[dst].Char.UnicodeChar = (WCHAR)( 0xd800 | (char_out>>10));
+                ci[dst + 1] = ci[dst];
+                dst++;
+                char_out = (chtype)( 0xdc00 | (char_out & 0x3ff));
+            }
+#endif
+            ci[dst].Char.UnicodeChar = (WCHAR)char_out;
+
+#ifdef PDC_NEW_WINCON_WORKAROUND
+            sr.Left = x + src;
+            if( src < len - 1 &&
+               (srcp[src + 1] & A_CHARTEXT) == DUMMY_CHAR_NEXT_TO_FULLWIDTH)
+            {
+                 /* necessary to erase garbage */
+                ci[dst + 1].Char.UnicodeChar = (WCHAR)' ';
+                ci[dst + 1].Attributes = ci[dst].Attributes;
+                bufSize.X = 2;
+                bufSize.Y = 1;
+                sr.Right = sr.Left + 2;
+            }
+            else
+            {
+                bufSize.X = 1;
+                bufSize.Y = 1;
+                sr.Right = sr.Left + 1;
+            }
+            WriteConsoleOutput(pdc_con_out, ci, bufSize, bufPos, &sr);
+#else
+            dst++;
+#endif
+        }
+
+#ifndef PDC_NEW_WINCON_WORKAROUND
+    bufSize.X = dst;
+    bufSize.Y = 1;
+
+    WriteConsoleOutput(pdc_con_out, ci, bufSize, bufPos, &sr);
+#endif
+}