curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/common/mouse.c

@@ -0,0 +1,293 @@
+/* Platform-independent parts of mouse handling.  This is surprisingly
+hard to get right.
+
+   The idea here is that the various platforms detect "raw" mouse
+events.  The actual methods are,  of course,  platform-dependent,
+but the "raw" events will consist of
+
+- button N pressed
+- button N released
+- mouse moved
+- wheel up/down/left/right
+
+   The actual events returned by the PDCursesMod library,  however,
+will be the above plus "cooked" events made from presses and releases :
+
+- button N clicked
+- button N double-clicked
+- button N triple-clicked
+
+   Some of these will be filtered,  according to the bits set in
+SP->_trap_mbe.  This code contains the (platform-independent) logic
+used to turn "raw" mouse events from the platform into "cooked"
+events returned by the library,  with unwanted events filtered out.
+
+   Presses and releases will be combined into clicks _if_ we're actually
+looking for clicks from that button.  (If not,  PDCursesMod may return a
+press and a release... if,  again,  corresponding bits are turned on.)
+Two clicks will be combined into a double-click, _if_ we're actually
+looking for double-clicks.  And so on.
+
+   In some cases,  the raw event may leave us in an "incomplete" state.
+Let's say a mouse button is pressed, and we're looking for clicks on that
+button (i.e.,  the BUTTONn_CLICKED bit is set in SP->_trap_mbe).  If so,
+we need to wait up to SP->mouse_wait milliseconds for a release of that
+button.  If that happens,  the button is clicked.  If not,  the button is
+pressed (and presumably held,  and sometime later,  we should get a
+'release' event for that button... should note that there's not actually
+any guarantee that we won't get two presses or two releases in a row from
+the same button.  In theory,  presses and releases alternate;  in practice,
+they sometimes don't.)
+
+   If we're looking for double-clicks on that button,  we need to wait
+yet another SP->mouse_wait milliseconds for another button press.  If we
+get one,  we have to wait again to see if there's a button release.  So
+a double-click could be returned as
+
+press,  release,  press,  release (if we aren't looking for clicks,
+   _or_ if SP->mouse_wait == 0)
+click,  click (if we're looking for single-clicks but not double-clicks)
+double-click (if we're looking for both)
+
+   And while these events may get generated,  they may also never be
+returned by the PDCursesMod library if corresponding bits in SP->_trap_mbe
+are not set.
+
+   From the viewpoint of the platform code,  the logic is :
+
+While a "raw" event is pending and _add_raw_mouse_event() == TRUE,  we're
+   in an incomplete state.  Wait for up to SP->mouse_wait milliseconds
+   for another mouse event.
+Filter out unwanted events.
+If we have "cooked" mouse events left after this,  queue them.
+Each time a mouse event is returned,  call _get_mouse_event() to retrieve
+   that event,  put it into SP->mouse_status,  and remove it.
+
+   Only button presses and releases get "cooked" (and,  as described above,
+even they are not always cooked).  The _add_raw_mouse_event() will collect
+the raw events and synthesize them into cooked ones.  It returns TRUE
+if the platform should wait SP->mouse_wait milliseconds,  or FALSE if
+there is no need to wait (i.e.,  the event cannot be combined with a
+later event to make a click,  double-click,  or triple-click).  The logic
+it uses is :
+
+Add the event to the queue.
+If it's a mouse movement or wheel event,  return FALSE to tell the
+   platform that it doesn't have to wait SP->mouse_wait milliseconds
+   for more mouse input.
+(If we get this far,  the event must be a press or release.)
+If SP->mouse_wait == 0,  or if BUTTONn_CLICKED isn't set in SP->_trap_mbe,
+   we can again return FALSE.  In such cases,  we're just returning
+   presses and releases without trying to combine them into clicks.
+   Pretty much the same as if it were a wheel event or a move event.
+If it's a button-pressed event :
+   return TRUE (because we need to wait for a possible button release
+   to make a click,  double-click,  or triple)
+Else,  it's a button-release event :
+  If there's a preceding press event for that button,  combine and
+      make it a click.  (If not,  it can't be combined with anything;
+      return FALSE.)
+  If, preceding the click,  there's another click for that button,  combine
+      them into a double-click.  If BUTTONn_TRIPLE_CLICKED is set in
+      SP->_trap_mbe,  return TRUE to indicate that we need to wait to see
+      if a third click happens.
+  If it's preceded by a double-click,  combine them into a triple-click.
+      We don't look for BUTTONn_QUADRUPLE_CLICKED in SP->_trap_mbe,
+      because PDCursesMod doesn't handle quad-clicks.  We return FALSE.
+  If the click can't be combined with previous events,  then our new
+      single-click might be followed by another click.  Check the
+      BUTTONn_DOUBLE_CLICKED flag in SP->_trap_mbe;  if it's set,  return
+      TRUE.
+  The current mouse state cannot be combined with further events to make
+      new "cooked" events,  so there's no point in waiting for them.
+      Return FALSE.
+
+   A few notes :
+
+   (1) In the above,  if we're in an incomplete state, we "wait up to
+SP->mouse_wait milliseconds".  Most of the code has traditionally waited
+that long,  even if the completing click or release came immediately.  It's
+better to take small naps over the SP->mouse_wait milliseconds,  checking
+to see if the completing event has come in.  For example :
+
+while( the platform has a new mouse event && TRUE == _add_raw_mouse_event( ))
+   {
+   const long t_end = PDC_millisecs( ) + SP->mouse_wait;
+   long ms_remaining;
+
+   while( (ms_remaining = t_end - PDC_millisecs())  > 0)
+      {
+      napms( ms_remaining > 20 ? 20 : ms_remaining);
+      if( there's a new mouse event pending)
+         break;
+      }
+   }
+
+   (Strictly speaking,  the naps are unnecessary.  Without them,  you
+simply go to 100% CPU usage looking for the next mouse event during those
+SP->mouse_wait milliseconds.  With enough clicking,  those cycles would
+start to add up.)
+
+   (2) In the above logic,  you can't get double-clicks without also getting
+single-clicks,  and you can't get triple-clicks without getting doubles and
+singles.  This may be changed eventually,  though it seems like an unlikely
+use case.
+
+   (3) One _can_ use the PDCurses*-specific BUTTONn_MOVED masks,  and
+thereby get motion events only if the corresponding button(s) are held.
+But for the sake of portability,  you probably should instead use
+REPORT_MOUSE_POSITION to get _all_ mouse events.  Then keep track of which
+buttons are held and filter out the events you aren't interested in.  */
+
+/* I don't think we can ever have more than three events in the list.
+(For example,  button 2 clicked,  button 2 pressed,  mouse moved.)  But
+some platforms (framebuffer/DRM) can have a temporary fourth event if an
+extra move event hasn't been merged.  And a larger queue paves the way for
+a working ungetmouse() function.                 */
+
+#define MLIST_SIZE 8
+
+static MOUSE_STATUS mouse_list[MLIST_SIZE];
+static int _mlist_count = 0;
+
+static short _button_change_flag( const int button)
+{
+   return( (button < 3 ? 1 : 64) << button);
+}
+
+#define TRAPPING_EVENT( event, button) (SP->_trap_mbe & PDC_SHIFTED_BUTTON( event, (button) + 1))
+
+bool _add_raw_mouse_event( int button, int event_type, const int modifiers,
+                  const int x, const int y)
+{
+   bool wait_for_next_event = FALSE;
+   MOUSE_STATUS *mptr = mouse_list + _mlist_count;
+   static int held_buttons = 0;
+   int i;
+
+   assert( _mlist_count >= 0 && _mlist_count < MLIST_SIZE);
+   assert( button >= 0 && button < PDC_MAX_MOUSE_BUTTONS);
+   mptr->x = x;
+   mptr->y = y;
+   if( SP->ncurses_mouse)
+      {
+      if( event_type == PDC_MOUSE_WHEEL_RIGHT
+               || event_type == PDC_MOUSE_WHEEL_LEFT)
+         return( FALSE);      /* 'real' ncurses interface doesn't know about tilt mice */
+      if( event_type == PDC_MOUSE_WHEEL_UP)
+         {
+         button = 3;
+         event_type = BUTTON_PRESSED;
+         }
+      if( event_type == PDC_MOUSE_WHEEL_DOWN)
+         {
+         button = 4;
+         event_type = BUTTON_PRESSED;
+         }
+      }
+   for( i = 0; i < PDC_MAX_MOUSE_BUTTONS; i++)
+      mptr->button[i] = (short)modifiers;
+   switch( event_type)
+      {
+      case BUTTON_MOVED:
+         {
+         MOUSE_STATUS *prev = (_mlist_count ? mptr - 1 : &SP->mouse_status);
+
+         if( x != prev->x || y != prev->y)
+            {
+            mptr->changes = 0;
+            if( SP->_trap_mbe & REPORT_MOUSE_POSITION)
+               mptr->changes = PDC_MOUSE_MOVED;
+            for( i = 0; i < PDC_MAX_MOUSE_BUTTONS; i++)
+               if( TRAPPING_EVENT( BUTTON1_MOVED, i)
+                                 && ((held_buttons >> i) & 1))
+                  {
+                  mptr->button[i] |= BUTTON_MOVED;
+                  mptr->changes |= PDC_MOUSE_MOVED | (1 << i);
+                  }
+            if( mptr->changes)
+               {
+               if( _mlist_count && prev->changes == mptr->changes)
+                  {   /* already got a mouse move event;  just update that one */
+                  _mlist_count--;
+                  mptr--;
+                  }
+               mptr->x = x;
+               mptr->y = y;
+               _mlist_count++;
+               }
+            }
+         }
+         break;
+      case PDC_MOUSE_WHEEL_UP:
+      case PDC_MOUSE_WHEEL_DOWN:
+      case PDC_MOUSE_WHEEL_LEFT:
+      case PDC_MOUSE_WHEEL_RIGHT:
+         if( SP->_trap_mbe & MOUSE_WHEEL_SCROLL)
+            {
+            _mlist_count++;
+            mptr->changes = event_type;
+            }
+         break;
+      case BUTTON_PRESSED:
+         mptr->button[button] = BUTTON_PRESSED | (short)modifiers;
+         mptr->changes = _button_change_flag( button);
+         held_buttons |= (1 << button);
+         _mlist_count++;
+         if( SP->mouse_wait && TRAPPING_EVENT( BUTTON1_CLICKED, button))
+            wait_for_next_event = TRUE;   /* may need to synthesize a click */
+         if( SP->ncurses_mouse && button >= 3)
+            wait_for_next_event = FALSE;  /* is really mouse wheel event */
+         break;
+      case BUTTON_RELEASED:
+         mptr->button[button] = BUTTON_RELEASED | (short)modifiers;
+         mptr->changes = _button_change_flag( button);
+         held_buttons &= ~(1 << button);
+         mptr->changes = _button_change_flag( button);
+         if( _mlist_count && mptr[-1].changes == mptr->changes
+                     && mptr[-1].button[button] == (BUTTON_PRESSED | modifiers))
+            {        /* can combine press with release to make a click */
+            mptr[-1].button[button] = BUTTON_CLICKED | (short)modifiers;
+            if( _mlist_count > 1 && mptr[-2].changes == mptr->changes)
+               {
+               if( mptr[-2].button[button] == (BUTTON_DOUBLE_CLICKED | modifiers))
+                  {
+                  mptr[-2].button[button] = BUTTON_TRIPLE_CLICKED | (short)modifiers;
+                  _mlist_count--;
+                  }
+               if( mptr[-2].button[button] == (BUTTON_CLICKED | modifiers))
+                  {
+                  mptr[-2].button[button] = BUTTON_DOUBLE_CLICKED | (short)modifiers;
+                  _mlist_count--;
+                  if( TRAPPING_EVENT( BUTTON1_TRIPLE_CLICKED, button))
+                      wait_for_next_event = TRUE;
+                  }                     /* wait to see if we get a triple-click */
+               }
+            else if( TRAPPING_EVENT( BUTTON1_DOUBLE_CLICKED, button))
+               wait_for_next_event = TRUE;
+            }
+         else if( TRAPPING_EVENT( BUTTON1_RELEASED, button))
+            _mlist_count++;   /* just returning an uncooked release event */
+         break;
+      default:
+         fprintf( stderr, "Got event %d,  button %d\n", event_type, button);
+         assert( 0);
+         break;
+      }
+   return( wait_for_next_event);
+}
+
+bool _get_mouse_event( MOUSE_STATUS *mstatus)
+{
+   if( !mstatus)                    /* just checking to see if events are queued up */
+      return( _mlist_count ? TRUE : FALSE);
+   if( _mlist_count)                /* should filter untrapped press/releases */
+      {
+      *mstatus = mouse_list[0];
+      _mlist_count--;
+      memmove( mouse_list, mouse_list + 1, _mlist_count * sizeof( MOUSE_STATUS));
+      return( TRUE);
+      }
+   else
+      return FALSE;
+}

data/vendor/PDCursesMod/common/pdcclip.c

@@ -0,0 +1,135 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <string.h>
+
+#include <stdlib.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  ncurses  NetBSD
+    PDC_getclipboard            -       -       -
+    PDC_setclipboard            -       -       -
+    PDC_freeclipboard           -       -       -
+    PDC_clearclipboard          -       -       -
+
+**man-end****************************************************************/
+
+/* This version is used (at present) in the VT,  framebuffer,  DOS,
+and DOSVGA ports,  and could be used for the Plan9 one as well.  These
+platforms lack system clipboards,  so we just store the clipboard text
+in a malloced buffer.   */
+
+/* global clipboard contents, should be NULL if none set */
+
+static char *pdc_clipboard = NULL;
+
+int PDC_getclipboard(char **contents, long *length)
+{
+    int len;
+
+    PDC_LOG(("PDC_getclipboard() - called\n"));
+
+    if (!pdc_clipboard)
+        return PDC_CLIP_EMPTY;
+
+    len = (int)strlen(pdc_clipboard);
+    *contents = (char *)malloc(len + 1);
+    if (!*contents)
+        return PDC_CLIP_MEMORY_ERROR;
+
+    strcpy(*contents, pdc_clipboard);
+    *length = len;
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_setclipboard(const char *contents, long length)
+{
+    PDC_LOG(("PDC_setclipboard() - called\n"));
+
+    PDC_clearclipboard( );
+
+    if (contents)
+    {
+        pdc_clipboard = (char *)malloc(length + 1);
+        if (!pdc_clipboard)
+            return PDC_CLIP_MEMORY_ERROR;
+
+        strcpy(pdc_clipboard, contents);
+    }
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_freeclipboard(char *contents)
+{
+    PDC_LOG(("PDC_freeclipboard() - called\n"));
+
+    /* should we also free empty the system clipboard? probably not */
+
+    if (contents)
+    {
+        /* NOTE: We free the memory, but we can not set caller's pointer
+           to NULL, so if caller calls again then will try to access
+           free'd memory.  We 1st overwrite memory with a string so if
+           caller tries to use free memory they won't get what they
+           expect & hopefully notice. */
+        const char *refreed = "!Freed buffer PDC clipboard!";
+        const char *tptr = refreed;
+        char *tptr2 = contents;
+
+        while( *tptr2 && *tptr)
+            *tptr2++ = *tptr++;
+
+        free(contents);
+    }
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_clearclipboard(void)
+{
+    PDC_LOG(("PDC_clearclipboard() - called\n"));
+
+    if (pdc_clipboard)
+    {
+        free(pdc_clipboard);
+        pdc_clipboard = NULL;
+    }
+
+    return PDC_CLIP_SUCCESS;
+}

data/vendor/PDCursesMod/common/pdccolor.c

@@ -0,0 +1,223 @@
+/* PDCurses */
+
+/* Palette management code used by VT,  WinGUI,  SDL1/2,  and X11 for
+'full color' (24-bit).  It may eventually be used by DOSVGA,  WinCon,
+and/or the Plan9 platform,  all of which have full color capability.
+It will presumably never be useful for the DOS or OS/2 platforms.
+See 'pdccolor.txt' for a rationale of how this works. */
+
+   #include <stdlib.h>
+   #include <assert.h>
+
+#define PACKED_RGB uint32_t
+
+#ifndef PACK_RGB
+   #define PACK_RGB( red, green, blue) ((PACKED_RGB)(red) | ((PACKED_RGB)(green)<<8) | ((PACKED_RGB)(blue) << 16))
+#endif
+
+#include <curspriv.h>
+#include "pdccolor.h"
+
+static PACKED_RGB *rgbs;   /* the 'standard' 256-color palette,  plus any allocated */
+static int _palette_size;
+
+PACKED_RGB PDC_default_color( int idx)
+{
+    PACKED_RGB rval;
+
+    assert( idx >= 0);
+    if( idx < 16)
+    {
+        if( idx == 8)
+            rval = PACK_RGB( 0x80, 0x80, 0x80);
+        else
+        {
+            const int intensity = ((idx & 8) ? 0xff : 0xc0);
+
+            rval = PACK_RGB( ((idx & COLOR_RED) ? intensity : 0),
+                             ((idx & COLOR_GREEN) ? intensity : 0),
+                             ((idx & COLOR_BLUE) ? intensity : 0));
+        }
+    }
+    else if( idx < 216 + 16)
+    {                    /* colors 16-231 are a 6x6x6 color cube */
+        int r, g, b;
+
+        idx -= 16;
+        r = idx / 36;
+        g = (idx / 6) % 6;
+        b = idx % 6;
+        rval = PACK_RGB( r ? r * 40 + 55 : 0,
+                         g ? g * 40 + 55 : 0,
+                         b ? b * 40 + 55 : 0);
+    }
+    else if( idx < 256)    /* colors 232-255 are 24 shades of gray */
+    {
+        const int intensity = (idx - 232) * 10 + 8;
+
+        rval = PACK_RGB( intensity, intensity, intensity);
+    }
+    else             /* colors 256 to 256+2^24 are RGB values */
+        rval = idx - 256;
+    return( rval);
+}
+
+int PDC_init_palette( void)
+{
+    return( 0);
+}
+
+void PDC_free_palette( void)
+{
+   if( rgbs)
+      free( rgbs);
+   rgbs = NULL;
+}
+
+PACKED_RGB PDC_get_palette_entry( const int idx)
+{
+   PACKED_RGB rval;
+
+   if( idx < _palette_size)
+   {
+      assert( idx >= 0);
+      rval = rgbs[idx];
+   }
+   else
+      rval = PDC_default_color( idx);
+   return( rval);
+}
+
+/* Return value is -1 if no palette could be allocated,  0 if the color
+didn't change (new RGB matched the old one),  and 1 if the color changed. */
+
+int PDC_set_palette_entry( const int idx, const PACKED_RGB rgb)
+{
+   int rval;
+
+   if( idx >= _palette_size)
+      {
+      int i, new_size = _palette_size;
+      const int initial_palette_size = 8;
+
+      if( !new_size)
+         new_size = initial_palette_size;
+      while( new_size <= idx)
+         new_size *= 2;
+      rgbs = (PACKED_RGB *)PDC_realloc_array( rgbs, new_size, sizeof( PACKED_RGB));
+      assert( rgbs);
+      if( !rgbs)
+         return( -1);
+      for( i = _palette_size; i < new_size; i++)
+         rgbs[i] = PDC_default_color( i);
+      _palette_size = new_size;
+      }
+   rval = (rgbs[idx] == rgb ? 1 : 0);
+   rgbs[idx] = rgb;
+   return( rval);
+}
+
+    /* This function 'intensifies' a color by shifting it toward white. */
+    /* It used to average the input color with white.  Then it did a    */
+    /* weighted average:  2/3 of the input color,  1/3 white,   for a   */
+    /* lower "intensification" level.                                   */
+    /*    Then Mark Hessling suggested that the output level should     */
+    /* remap zero to 85 (= 255 / 3, so one-third intensity),  and input */
+    /* of 192 or greater should be remapped to 255 (full intensity).    */
+    /* Assuming we want a linear response between zero and 192,  that   */
+    /* leads to output = 85 + input * (255-85)/192.                     */
+    /*    This should lead to proper handling of bold text in legacy    */
+    /* apps,  where "bold" means "high intensity".                      */
+
+static PACKED_RGB intensified_color( PACKED_RGB ival)
+{
+    int i;
+    PACKED_RGB oval = 0;
+
+    for( i = 0; i < 3; i++, ival >>= 8)
+    {
+        int rgb = (int)( ival & 0xff);
+
+        if( rgb >= 192)
+            rgb = 255;
+        else
+            rgb = 85 + rgb * (255 - 85) / 192;
+        oval |= ((PACKED_RGB)rgb << (i * 8));
+    }
+    return( oval);
+}
+
+   /* For use in adjusting colors for A_DIMmed characters.  Just */
+   /* knocks down the intensity of R, G, and B by 1/3.           */
+
+static PACKED_RGB dimmed_color( PACKED_RGB ival)
+{
+    unsigned i;
+    PACKED_RGB oval = 0;
+
+    for( i = 0; i < 3; i++, ival >>= 8)
+    {
+        unsigned rgb = (unsigned)( ival & 0xff);
+
+        rgb -= (rgb / 3);
+        oval |= ((PACKED_RGB)rgb << (i * 8));
+    }
+    return( oval);
+}
+
+
+void PDC_get_rgb_values( const chtype srcp,
+            PACKED_RGB *foreground_rgb, PACKED_RGB *background_rgb)
+{
+    const int color = (int)(( srcp & A_COLOR) >> PDC_COLOR_SHIFT);
+    bool reverse_colors = ((srcp & A_REVERSE) ? TRUE : FALSE);
+    bool blinking = FALSE;
+    bool intensify_backgnd = FALSE;
+    bool default_foreground = FALSE, default_background = FALSE;
+    int foreground_index, background_index;
+
+    extended_pair_content( color, &foreground_index, &background_index);
+    if( foreground_index < 0 && SP->orig_attr)
+        default_foreground = TRUE;
+    else
+        *foreground_rgb = PDC_get_palette_entry( foreground_index);
+    if( background_index < 0 && SP->orig_attr)
+        default_background = TRUE;
+    else
+        *background_rgb = PDC_get_palette_entry( background_index);
+
+    if( srcp & A_STANDOUT)
+        intensify_backgnd = TRUE;
+    if( srcp & A_BLINK)
+    {
+        if( !(SP->termattrs & A_BLINK))   /* convert 'blinking' to 'bold' */
+            intensify_backgnd = TRUE;
+        else if( SP->blink_state & 1)
+            blinking = TRUE;
+    }
+    if( default_foreground)
+        *foreground_rgb = (PACKED_RGB)-1;
+    else if( srcp & A_BOLD & ~SP->termattrs)
+        *foreground_rgb = intensified_color( *foreground_rgb);
+
+    if( default_background)
+        *background_rgb = (PACKED_RGB)-1;
+    else if( intensify_backgnd)
+        *background_rgb = intensified_color( *background_rgb);
+    if( srcp & A_DIM)
+    {
+        if( !default_foreground)
+           *foreground_rgb = dimmed_color( *foreground_rgb);
+        if( !default_background)
+           *background_rgb = dimmed_color( *background_rgb);
+    }
+    if( reverse_colors)
+    {
+        const PACKED_RGB temp = *foreground_rgb;
+
+        *foreground_rgb = *background_rgb;
+        *background_rgb = temp;
+    }
+    if( blinking)
+        *foreground_rgb = *background_rgb;
+}

data/vendor/PDCursesMod/common/pdccolor.h

@@ -0,0 +1,17 @@
+#ifndef PDCCOLOR_H
+
+#define PDCCOLOR_H
+
+typedef uint32_t PACKED_RGB;
+
+#define Get_BValue( rgb) ((int)( (rgb) >> 16))
+#define Get_GValue( rgb) ((int)( (rgb) >> 8) & 0xff)
+#define Get_RValue( rgb) ((int)((rgb) & 0xff))
+
+int PDC_init_palette( void);
+void PDC_get_rgb_values( const chtype srcp,
+            PACKED_RGB *foreground_rgb, PACKED_RGB *background_rgb);
+int PDC_set_palette_entry( const int idx, const PACKED_RGB rgb);
+PACKED_RGB PDC_get_palette_entry( const int idx);
+void PDC_free_palette( void);
+#endif