curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/os2gui/pdcsetsc.c

@@ -0,0 +1,115 @@
+/* Public Domain Curses */
+
+#include <assert.h>
+#include "pdcwin.h"
+#include "../common/pdccolor.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_bold                -       -       -
+    PDC_set_title               -       -       -
+
+**man-end****************************************************************/
+
+                /* Note that the following is a line-for-line   */
+                /* copy of the SDL version of this function.    */
+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));
+
+    WinSetWindowText( PDC_hWnd, (PCSZ)title);
+}
+
+        /* If SP->termattrs & A_BLINK is on, then text with the A_BLINK  */
+        /* attribute will actually blink.  Otherwise,  such text will    */
+        /* be shown with higher color intensity (the R, G, and B values  */
+        /* are averaged with pure white).  See pdcdisp.c for details of  */
+        /* how this is done.                                             */
+        /*     Unlike on other PDCurses platforms,  this doesn't require */
+        /* decreasing the number of colors by half.  Also,  the choice   */
+        /* indicated by 'blinkon' will actually be respected,  so OK is  */
+        /* always returned (most platforms don't actually support        */
+        /* blinking).                                                    */
+        /*      The default behavior is to not show A_BLINK text as      */
+        /* blinking,  i.e., SP->termattrs & A_BLINK = 0.  Blinking text  */
+        /* can be pretty annoying to some people.  You should probably   */
+        /* call PDC_set_blink( TRUE) only if there is something to which */
+        /* the user _must_ pay attention;  say,  "the nuclear reactor    */
+        /* is about to melt down".  Otherwise,  the bolder,  brighter    */
+        /* text should be attention-getting enough.                      */
+        /* Note also that when turning 'blink' On,  we don't have to     */
+        /* mark curscr as needing to be cleared.  Blinking will begin    */
+        /* within half a second anyway.  (This is an exception to the    */
+        /* general rule that changes only take place after refresh().)   */
+
+static int reset_attr( const attr_t attr, const bool attron)
+{
+    attr_t prev_termattrs;
+
+    assert( SP);
+    if (!SP)
+        return ERR;
+    prev_termattrs = SP->termattrs;
+    if( attron)
+        SP->termattrs |= attr;
+    else
+        SP->termattrs &= ~attr;
+    if( prev_termattrs != SP->termattrs)
+        if( !attron || attr == A_BOLD)
+            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));
+}

data/vendor/PDCursesMod/os2gui/pdcutil.c

@@ -0,0 +1,42 @@
+/* Public Domain Curses */
+
+#include "pdcwin.h"
+
+void PDC_beep(void)
+{
+    PDC_LOG(("PDC_beep() - called\n"));
+    DosBeep(440, 500);
+}
+
+void PDC_napms(int ms)     /* 'ms' = milli,  _not_ microseconds! */
+{
+    /* RR: keep GUI window responsive while PDCurses sleeps */
+    HAB hab = WinQueryAnchorBlock( PDC_hWnd);
+    QMSG msg;
+    ULONG curr_ms = WinGetCurrentTime(hab);
+    const ULONG milliseconds_sleep_limit = curr_ms + ms;
+
+    PDC_LOG(("PDC_napms() - called: ms=%d\n", ms));
+
+    /* Pump all pending messages from WIN32 to the window handler */
+    while( !PDC_bDone && curr_ms < milliseconds_sleep_limit )
+    {
+        const ULONG max_sleep_ms = 50;      /* check msgs 20 times/second */
+        ULONG sleep_millisecs;
+
+        while( WinPeekMsg(hab, &msg, NULLHANDLE, 0, 0, PM_REMOVE) )
+           WinDispatchMsg(hab, &msg);
+        curr_ms = WinGetCurrentTime(hab);
+        sleep_millisecs = milliseconds_sleep_limit - curr_ms;
+        if( sleep_millisecs > max_sleep_ms)
+            sleep_millisecs = max_sleep_ms;
+        DosSleep( sleep_millisecs);
+    }
+}
+
+const char *PDC_sysname(void)
+{
+   return "OS2GUI";
+}
+
+enum PDC_port PDC_port_val = PDC_PORT_OS2GUI;

data/vendor/PDCursesMod/os2gui/pdcwin.h

@@ -0,0 +1,106 @@
+/* Public Domain Curses */
+
+/* $Id: pdcwin.h,v 1.6 2008/07/13 06:36:32 wmcbrine Exp $ */
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE 1   /* kill nonsense warnings */
+#endif
+
+#if defined( PDC_FORCE_UTF8) && !defined( PDC_WIDE)
+   #define PDC_WIDE
+#endif
+
+#ifdef PDC_WIDE
+   #if !defined( UNICODE)
+      # define UNICODE
+   #endif
+   #if !defined( _UNICODE)
+      # define _UNICODE
+   #endif
+#endif
+
+#define INCL_PM
+#define INCL_DOS
+#include <os2.h>
+
+#if defined( GS_8BIT_INDICES) && defined( PDC_WIDE)
+     /* We only need the 'fallback font' for the wide-char version, */
+     /* and it'll only work in Win2000 or later (earlier versions   */
+     /* lack the necessary GetFontUnicodeRanges() function.)  Comment */
+     /* out the following line if you're dealing with a really old  */
+     /* system,  or just don't want to use a fallback font.         */
+   #define USE_FALLBACK_FONT
+#endif
+
+/* Windows.h will #define MOUSE_MOVED to 0x1,  which is what the
+Windows API expects.  In Curses,  MOUSE_MOVED is a macro indicating
+whether the mouse has moved,  so we'd get a compiler warning that
+we're re-defining MOUSE_MOVED.  That warning may be a Good Thing in
+your software,  letting you know:  "Be careful;  in a Curses program,
+MOUSE_MOVED won't have the same meaning it does in a 'real' Windows
+program."
+
+   But in building WinGUI itself,  we're expecting the Curses
+meaning for MOUSE_MOVED,  and the compiler warning would just be
+a nuisance.  So we'll #undefine MOUSE_MOVED before getting to the
+Curses definition :                 */
+
+#undef MOUSE_MOVED
+#include <curspriv.h>
+
+extern int PDC_get_buffer_rows(void);
+
+/* The following probably ought to go into 'curses.h' at some point. */
+/* Or at least,  not be here;  this is a temporary place for them.   */
+
+/* WinGUI has some drastically extended cursor possibilities.  The
+following #defines can be used with curs_set().  For all other flavors
+of PDCurses,  only the invisible,  "normal",  and "intense" cursor
+states will be recognized.  In Win32,  caret,  half-block,  central
+block,  cross,  and outlined block cursors are available.
+
+   By default,  all such cursors will blink.  However,  in WinGUI,
+the input value to curs_set() is treated as a two-byte value,  with
+the cursor blinking between those two states.  For example,
+curs_set( 0x0102) would blink between a "normal" (underline) cursor and
+an "intense" (full-block) cursor.  One can see that this behavior is
+backward-compatible;  for example,  curs_set( 1) would blink between a
+"normal" underline cursor and an invisible cursor.  (But curs_set( 0x0101)
+would result in a non-blinking underline cursor.)  Note that one can use
+the PDC_CURSOR macro for this,  as in...
+
+   curs_set( PDC_CURSOR( PDC_CURSOR_OUTLINE, PDC_CURSOR_INTENSE));   */
+
+#define PDC_CURSOR_INVISIBLE                    0x00
+#define PDC_CURSOR_NORMAL                       0x01
+#define PDC_CURSOR_INTENSE                      0x02
+#define PDC_CURSOR_OUTLINE                      0x03
+#define PDC_CURSOR_CARET                        0x04
+#define PDC_CURSOR_HALF_BLOCK                   0x05
+#define PDC_CURSOR_CENTRAL_BLOCK                0x06
+#define PDC_CURSOR_CROSS                        0x07
+#define PDC_CURSOR_OUTLINE_BLOCK                0x08
+
+#define PDC_CURSOR( A, B) ((A)<<8 | (B))
+#define PDC_CURSOR_IS_BLINKING    \
+          ((SP->visibility >> 8) != (SP->visibility & 0xff))
+
+#define KEY_QUEUE_SIZE    30
+
+extern int PDC_key_queue_low, PDC_key_queue_high;
+extern int PDC_key_queue[KEY_QUEUE_SIZE];
+
+extern int PDC_n_rows, PDC_n_cols;
+extern int PDC_cxChar, PDC_cyChar;
+extern HWND PDC_hWnd;
+extern bool PDC_bDone;
+
+extern char PDC_font_name[FACESIZE];
+extern int PDC_font_size;
+
+extern void PDC_set_font_box(HWND hwnd);
+extern void PDC_setup_font(HPS hps);
+extern void PDC_screen_to_pixel(int sx, int sy, RECTL *rect);
+extern void PDC_pixel_to_screen(int px, int py, int *sx, int *sy);
+extern int PDC_choose_a_new_font(char font[FACESIZE], int *fontsize);
+extern int PDC_get_mouse_event_from_queue( void);

data/vendor/PDCursesMod/os2gui/table.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+
+class UnicodeData:
+    """Parser for the UnicodeData.txt file"""
+
+    def __init__(self, path):
+        self.path = path
+
+    def __iter__(self):
+        return UnicodeData.UnicodeDataIterator(self.path)
+
+    class UnicodeDataIterator:
+        def __init__(self, path):
+            self.file = None
+            self.file = open(path, "r")
+            self.rec = None
+            self.first = None
+            self.last = None
+            self.current = None
+
+        def __del__(self):
+            if self.file is not None:
+                self.file.close()
+
+        def __next__(self):
+            if self.current is not None:
+                # Between a "First>" and a "Last>" line
+                tup = (self.current, self.rec)
+                if self.current >= self.last:
+                    # End of range
+                    self.current = None
+                else:
+                    # Go to next
+                    self.current += 1
+            else:
+                line = self.file.readline()
+                if line == '':
+                    raise StopIteration()
+                if line.endswith("\n"):
+                    line = line[:-1]
+                rec = line.split(';')
+                codepoint = int(rec[0], 16)
+                if rec[1].endswith(' First>'):
+                    self.rec = rec
+                    self.first = codepoint
+                elif rec[1].endswith(' Last>'):
+                    self.last = codepoint
+                    rec = self.rec
+                    codepoint = self.first + 1
+                    self.current = self.first + 2
+                    if self.current > self.last:
+                        self.current = None
+                tup = (codepoint, rec)
+            return tup
+
+combining = {}
+decompose = {}
+compose = {}
+exclude = set()
+
+for cp, rec in UnicodeData("UnicodeData.txt"):
+    cclass = int(rec[3])
+    if cclass != 0:
+        combining[cp] = cclass
+
+    if rec[5] != "" and not rec[5].startswith('<'):
+        comp = tuple(map(lambda x: int(x, 16), rec[5].split(' ')))
+        decompose[cp] = comp
+        if len(comp) == 2:
+            compose[comp] = cp
+
+with open('CompositionExclusions.txt', 'r') as file:
+    while True:
+        line = file.readline()
+        if line == '':
+            break
+        sharp = line.find('#')
+        if sharp != -1:
+            line = line[:sharp]
+        line = line.strip()
+        if line != '':
+            exclude.add(int(line, 16))
+
+with open("unitable.h", "w") as file:
+    file.write("/* Generated by table.py from UnicodeData.txt and CompositionExclusions.txt */\n")
+    file.write("static const struct CClassTable cclass_table[] = {\n")
+    c = list(combining.keys())
+    c.sort()
+    for cp in c:
+        file.write("    { 0x%04X, %d },\n" % (cp, combining[cp]))
+    file.write("};\n")
+    file.write("\n")
+
+    file.write("static const struct DecompTable decomp_table[] = {\n")
+    d = list(decompose.keys())
+    d.sort()
+    for cp in d:
+        comp = decompose[cp]
+        comp0 = comp[0]
+        comp1 = comp[1] if len(comp) > 1 else 0
+        file.write("    { 0x%04X, 0x%04X, 0x%04X },\n" % ( cp, comp0, comp1 ))
+    file.write("};\n")
+    file.write("\n")
+
+    file.write("static const struct CompTable comp_table[] = {\n")
+    c = list(compose.keys())
+    c.sort()
+    for comp in c:
+        cp = compose[comp]
+        if not (cp in exclude or cp in combining or comp[0] in combining):
+            file.write("    { 0x%04X, 0x%04X, 0x%04X },\n" % ( comp[0], comp[1], cp ))
+    file.write("};\n")