stick2xyz.h

Go to the documentation of this file.

/***************************************************************************
 *   stick2xyz - Can create and convert stick figure animations for CG.    *
 *   Copyright (C) 2021 by Kevin McBride <dolphindddd@aol.com>             *
 *                                                                         *
 *  This program is free software: you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation, either version 3 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *  GNU General Public License for more details.                           *
 *                                                                         *
 *  You should have received a copy of the GNU General Public License      *
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
 
 
#ifndef     STICK2XYZ_H
#define     STICK2XYZ_H
 
#if   defined(WIN32) | defined(WIN64) | defined(_WIN32) | defined(_WIN64)
#ifndef     __WINDOWS__
#define     __WINDOWS__ (1)
#endif      /* not __WINDOWS__ */
#endif      /* defined(WIN32) | defined(WIN64) | defined(_WIN32) | defined(_WIN64) */
 
#ifdef      UNICODE
#ifdef      T
#undef      T
#endif      /* T */
#define     T(s)  L"s"
#define     STICK2XYZ_LANGPACK_UTF8_16(d, v) \
wchar_t * d; \
if ( v != NULL ) { \
d = (wchar_t *)alloca((strlen(v) + 1) * sizeof(wchar_t)); \
mbstowcs(d, v, strlen(v) + 1); \
} else { d = NULL; }
#else /* not UNICODE */
#ifdef      T
#undef      T
#endif      /* T */
#define     T(s)  "s"
#define STICK2XYZ_LANGPACK_UTF8_16(d, v) \
const char * d; d = v;
#endif      /* not UNICODE */
 
#ifdef      __cplusplus
#ifndef     _cplusplus
#define     _cplusplus  (1)
#endif      /* not _cplusplus */
#endif      /* __cplusplus */
 
/* Make sure we're definitely in ordinary "C" mode. */
#ifdef      _cplusplus
extern "C"
{
#endif      /* _cplusplus */
 
/* Perform the #define sanity checks. */
#ifdef      STICK2XYZ_NO_MODULARIZATION
#ifndef     STICK2XYZ_NO_MODLANGPACKS
#error You can not modularize language packs on static builds.
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
#endif      /* STICK2XYZ_NO_MODULARIZATION */
 
#ifdef      __WINDOWS__
#ifndef     UNICODE
#error Windows builds of stick2xyz program and modules must be compiled in Unicode.
#endif      /* not UNICODE */
 
#ifdef      HAVE_EVENTFD
#error __WINDOWS__ and HAVE_EVENTFD are not compatible with each other.
#endif      /* HAVE_EVENTFD */
#endif      /* __WINDOWS__ */
 
/* First, include the inttypes; this file depends heavily on those. */
#ifdef      HAVE_STDLIB_H
#include <stdlib.h>
#endif      /* HAVE_STDLIB_H */
#ifdef      HAVE_STRING_H
#include <string.h>
#endif      /* HAVE_STRING_H */
#ifdef      HAVE_STDINT_H
#include <stdint.h>
#endif      /* HAVE_STDINT_H */
#ifdef      HAVE_INTTYPES_H
#include <inttypes.h>
#endif      /* HAVE_INTTYPES_H */
 
/* This code is necessary for making sure we can use alloca(). */
#if HAVE_ALLOCA_H
#include <alloca.h>
#elif defined __GNUC__
#ifndef     alloca
#define alloca __builtin_alloca
#endif      /* not alloca */
#elif defined _AIX
#define alloca __alloca
#elif defined _MSC_VER
#include <malloc.h>
#define alloca _alloca
#else
#include <stddef.h>
void *alloca (size_t);
#endif
 
/* Second, include some other system headers that are necessary
   for stick2xyz to compile.
   Include the dlsym linker if the modules will be compiled
   as shared libraries.  Otherwise, define STICK2XYZ_STATIC. */
#ifdef      STICK2XYZ_NO_MODULARIZATION
#define     STICK2XYZ_STATIC  (1)
#ifdef      HAVE_STDLIB_H
#include <stdlib.h>
#endif      /* HAVE_STDLIB_H */
#else /* not STICK2XYZ_NO_MODULARIZATION */
#ifndef     __WINDOWS__
#include <ltdl.h>
#endif      /* not __WINDOWS__ */
#endif      /* not STICK2XYZ_NO_MODULARIZATION */
 
#ifdef      HAVE_ERRNO_H
#include <errno.h>
#endif      /* HAVE_ERRNO_H */
#ifdef      HAVE_THREADS_H
#include <threads.h>
#endif      /* HAVE_THREADS_H */
#ifdef      HAVE_EVENTFD
#include <sys/eventfd.h>
#endif      /* HAVE_EVENTFD */
#ifdef      HAVE_POLL_H
#include <poll.h>
#endif      /* HAVE_POLL_H */
 
#if   !defined(Z_NO_COMPRESSION) & defined(HAVE_ZLIB_H)
#include <zlib.h>
#endif      /* !defined(Z_NO_COMPRESSION) & defined(HAVE_ZLIB_H) */
 
/* Third, include wchar.t and define 'tchar' character as ASCII or UNICODE. */
#ifdef      UNICODE
#include <wchar.h>
 
typedef const wchar_t * stick2xyz_pctchar;
typedef const wchar_t stick2xyz_ctchar;
typedef wchar_t * stick2xyz_ptchar;
typedef wchar_t stick2xyz_tchar;
 
#define     stick2xyz_strlen  wcslen
#define     stick2xyz_strcat  wcscat
#define     stick2xyz_strcpy  wcscpy
#define     stick2xyz_strncpy wcsncpy
#define stick2xyz_strcmp      wcscmp
#define     stick2xyz_strncmp wcsncmp
#define     stick2xyz_strcasecmp    wcscasecmp
 
#define     stick2xyz_fprintf fwprintf
#define     stick2xyz_fputs   fputws
#define     stick2xyz_fputc   fputwc
 
#define     stick2xyz_snprintf      swprintf
#else /* not UNICODE */
 
typedef const char * stick2xyz_pctchar;
typedef const char stick2xyz_ctchar;
typedef char * stick2xyz_ptchar;
typedef char stick2xyz_tchar;
 
#define     stick2xyz_strlen  strlen
#define     stick2xyz_strcat  strcat
#define     stick2xyz_strcpy  strcpy
#define     stick2xyz_strncpy strncpy
#define stick2xyz_strcmp      strcmp
#define     stick2xyz_strncmp strncmp
#define     stick2xyz_strcasecmp    strcasecmp
 
#define     stick2xyz_fprintf fprintf
#define     stick2xyz_fputs   fputs
#define     stick2xyz_fputc   fputc
 
#ifdef      HAVE_SNPRINTF
#define     stick2xyz_snprintf      snprintf
#else /* not HAVE_SNPRINTF */
#define     stick2xyz_snprintf(s,l,f,d)   snprintf(s,f,d)
#endif      /* not HAVE_SNPRINTF */
#endif      /* not UNICODE */
 
/* Fourth, define our custom errno macros and functions. */
#ifdef      __WINDOWS__
#define     stick2xyz_set_errno(err)      _set_errno(err)
#define     stick2xyz_get_errno(retval)   _get_errno(retval)
#else /* not __WINDOWS__ */
#ifndef     HAVE_ERRNO_T
typedef int errno_t;
#endif      /* not HAVE_ERRNO_T */
 
static inline errno_t stick2xyz_set_errno ( int errcode )
{
      /* Set errno to errcode. */
      errno = errcode;
      /* Return success to caller. */
      return 0;
}
 
static inline errno_t stick2xyz_get_errno ( int * errcode )
{
      /* If errcode address is NULL, we can't do anything. */
      if ( errcode == NULL )
            return EINVAL;
 
      /* Set the variable errcode to errno. */
      *errcode = errno;
      /* Return success to caller. */
      return 0;
}
#endif      /* not __WINDOWS__ */
 
#ifndef     STICK2XYZ_HUMAN_LANGUAGE
/* Fifth, create the library type enum. */
 
#define     STICK2XYZ_MODTYPE_NONE                    0x00000000
#define     STICK2XYZ_MODTYPE_PANE2D                  0x00000001
#define     STICK2XYZ_MODTYPE_PANE2D_DEBUG                  0x00000002
#define     STICK2XYZ_MODTYPE_PANE2D_UNICODE          0x00000004
#define     STICK2XYZ_MODTYPE_PANE2D_UNICODE_DEBUG          0x00000008
#define     STICK2XYZ_MODTYPE_OUTPUT2D                0x00000010
#define     STICK2XYZ_MODTYPE_OUTPUT2D_DEBUG          0x00000020
#define     STICK2XYZ_MODTYPE_OUTPUT2D_UNICODE        0x00000040
#define     STICK2XYZ_MODTYPE_OUTPUT2D_UNICODE_DEBUG  0x00000080
#define     STICK2XYZ_MODTYPE_INPUT                   0x00000100
#define     STICK2XYZ_MODTYPE_INPUT_DEBUG             0x00000200
#define     STICK2XYZ_MODTYPE_INPUT_UNICODE                 0x00000400
#define     STICK2XYZ_MODTYPE_INPUT_UNICODE_DEBUG           0x00000800
 
/* This is also a good time to set the '0' compression default. */
#ifndef     DOXYGEN_BUILD
#ifndef STICK2XYZ_COMPRESSION
#define STICK2XYZ_COMPRESSION   Z_NO_COMPRESSION
#endif      /* not STICK2XYZ_COMPRESSION */
#endif      /* not DOXYGEN_BUILD */
 
/* Sixth, we need to define the input type defines. */
#define     STICK2XYZ_MAXBUFLEN     64
#define     STICK2XYZ_MAXBUFPARAMS  16
 
#define     STICK2XYZ_INPUTTYPE_UNKNOWN         0x00000000
#define     STICK2XYZ_INPUTTYPE_IS_PANE2D       0x00000001
#define     STICK2XYZ_INPUTTYPE_IS_PANE3D       0x00000002
 
#define     STICK2XYZ_INPUTTYPE_OUTPUTPANE            0x00000004
#define     STICK2XYZ_INPUTTYPE_CLEARPANE       0x00000008
 
#define     STICK2XYZ_INPUTTYPE_DRAWPIXEL       0x00000010
#define     STICK2XYZ_INPUTTYPE_DRAWLINE        0x00000020
 
#define     STICK2XYZ_INPUTTYPE_DRAWCIRCLE            0x00000100
#define     STICK2XYZ_INPUTTYPE_FILLCIRCLE            0x00000200
#define     STICK2XYZ_INPUTTYPE_DRAWELLIPSE           0x00000400
#define     STICK2XYZ_INPUTTYPE_FILLELLIPSE           0x00000800
 
#define     STICK2XYZ_INPUTTYPE_DRAWRECT        0x00001000
#define     STICK2XYZ_INPUTTYPE_DRAWRECTANGLE   0x00001000
#define     STICK2XYZ_INPUTTYPE_FILLRECT        0x00002000
#define     STICK2XYZ_INPUTTYPE_FILLRECTANGLE   0x00002000
#define     STICK2XYZ_INPUTTYPE_DRAWSQUARE            0x00004000
#define     STICK2XYZ_INPUTTYPE_FILLSQUARE            0x00008000
 
#define STICK2XYZ_INPUTTYPE_DRAWTRIANGLE        0x00010000
#define STICK2XYZ_INPUTTYPE_FILLTRIANGLE        0x00020000
#define     STICK2XYZ_INPUTTYPE_DRAW90TRIANGLE  0x00040000
#define     STICK2XYZ_INPUTTYPE_FILL90TRIANGLE  0x00080000
 
#define     STICK2XYZ_INPUTTYPE_TEXTUREGRAY           0x00100000
#define     STICK2XYZ_INPUTTYPE_TEXTUREGRAY16   0x02100000
#define     STICK2XYZ_INPUTTYPE_TEXTUREGRAYIMAGE      0x00200000
#define     STICK2XYZ_INPUTTYPE_TEXTUREGRAYIMAGE16    0x02200000
#define     STICK2XYZ_INPUTTYPE_TEXTURERGB            0x00400000
#define     STICK2XYZ_INPUTTYPE_TEXTURERGB16    0x02400000
#define     STICK2XYZ_INPUTTYPE_TEXTURERGBIMAGE 0x00800000
#define     STICK2XYZ_INPUTTYPE_TEXTURERGBIMAGE16     0x02800000
 
#define     STICK2XYZ_INPUTTYPE_CLEARTEXTURES   0x01000000
#define     STICK2XYZ_INPUTTYPE_TEXTURE16BIT    0x02000000
 
/* Seventh, we need to define the pane2d vertex options. */
#define     STICK2XYZ_PANE2D_VERTEX_DRAW        0x00000001
#define     STICK2XYZ_PANE2D_VERTEX_STRUCT            0x00000002
#define     STICK2XYZ_PANE2D_VERTEX_NODRAW            0x00000004
#define     STICK2XYZ_PANE2D_VERTEX_DRAWSTRUCT \
      ( STICK2XYZ_PANE2D_VERTEX_DRAW | STICK2XYZ_PANE2D_VERTEX_STRUCT )
 
#define     STICK2XYZ_PANE2D_PIXEL        STICK2XYZ_INPUTTYPE_DRAWPIXEL
#define     STICK2XYZ_PANE2D_LINE         STICK2XYZ_INPUTTYPE_DRAWLINE
#define     STICK2XYZ_PANE2D_CIRCLE       STICK2XYZ_INPUTTYPE_DRAWCIRCLE
#define     STICK2XYZ_PANE2D_CIRCLE_WT    STICK2XYZ_INPUTTYPE_FILLCIRCLE
#define     STICK2XYZ_PANE2D_ELLIPSE      STICK2XYZ_INPUTTYPE_DRAWELLIPSE
#define     STICK2XYZ_PANE2D_ELLIPSE_WT   STICK2XYZ_INPUTTYPE_FILLELLIPSE
#define     STICK2XYZ_PANE2D_RECTANGLE    STICK2XYZ_INPUTTYPE_DRAWRECTANGLE
#define     STICK2XYZ_PANE2D_RECTANGLE_WT STICK2XYZ_INPUTTYPE_FILLRECTANGLE
#define     STICK2XYZ_PANE2D_SQUARE       STICK2XYZ_INPUTTYPE_DRAWSQUARE
#define     STICK2XYZ_PANE2D_SQUARE_WT    STICK2XYZ_INPUTTYPE_FILLSQUARE
#define     STICK2XYZ_PANE2D_TRIANGLE     STICK2XYZ_INPUTTYPE_DRAWTRIANGLE
#define     STICK2XYZ_PANE2D_TRIANGLE_WT  STICK2XYZ_INPUTTYPE_FILLTRIANGLE
#define     STICK2XYZ_PANE2D_90TRIANGLE   STICK2XYZ_INPUTTYPE_DRAW90TRIANGLE
#define     STICK2XYZ_PANE2D_90TRIANGLE_WT      STICK2XYZ_INPUTTYPE_FILL90TRIANGLE
 
 
/* Eighth, create the definitions for event handling. */
 
#ifdef      __WINDOWS__
typedef HANDLE stick2xyz_eventhandle;
 
static inline int stick2xyz_event_occured ( HANDLE src )
{
      /* Check if HANDLE is valid, then if valid, check to see 
         if the event is signaled. */
      if ( ( src != NULL ) && ( src != INVALID_HANDLE_VALUE ) )
            if ( WaitForSingleObject(src, 0) == WAIT_OBJECT_0 )
                  return 1; /* Event is signaled. */
 
      /* Event is not signaled or is invalid. */
      return 0;
}
#else /* not __WINDOWS__ */
typedef int stick2xyz_eventhandle;
 
#ifdef      HAVE_EVENTFD
static inline int stick2xyz_event_occured ( int src )
{
      struct pollfd pfd;
 
      if ( src > -1 )
      {
            /* Set up the polling structure. */
            pfd.fd = src;
            pfd.events = POLLIN;
            pfd.revents = 0;
 
            /* Check if the event is signaled. */
            if ( poll(&pfd, 1, 0) > 0 )
                  return 1; /* Event is signaled. */
      }
 
      /* Event is not signaled or is invalid. */
      return 0;
}
#else /* not HAVE_EVENTFD */
static inline int stick2xyz_event_occured ( int src )
{
      return 0;
}
#endif      /* not HAVE_EVENTFD */
#endif      /* not __WINDOWS__ */
 
 
/* Lastly, create the generic typedefs for each function in the modules.
   After this, the module prototypes, with their structs, will be
   defined. */
 
typedef int (*modid_type)(void);
 
typedef void (*modid_lang)(void *);
 
 
#ifndef     DOXYGEN_BUILD
typedef void * (*stick2xyz_print_ptr)(unsigned int, const void **);
typedef const char * (*stick2xyz_lang_ptr)(void);
typedef unsigned int (*stick2xyz_lang_type)(void);
 
struct langpack_funcptrs
{
      stick2xyz_print_ptr langpack_funcptrs_print;
      unsigned int langpack_funcptrs_type;
      const char * langpack_funcptrs_lang;
};
#endif      /* not DOXYGEN_BUILD */
 
 
/* ----- Drawing Pane (2-D) BEGIN ----- */
 
/* Drawing Pane (2-D) Multithread Alloc Enumeration */
 
#define     STICK2XYZ_PANE2D_ALLOC_NONE   0x00000000
#define     STICK2XYZ_PANE2D_ALLOC_GRAY   0x00000001
#define     STICK2XYZ_PANE2D_ALLOC_GRAY16 0x00000002
#define     STICK2XYZ_PANE2D_ALLOC_RGB    0x00000004
#define     STICK2XYZ_PANE2D_ALLOC_RGB16  0x00000008
#define     STICK2XYZ_PANE2D_ALLOC_ALL    0x0000000F
 
/* Drawing Pane (2-D) Change Owner Enumeration */
 
#define     STICK2XYZ_PANE2D_ACCESSCTRL_NONE          0x00000000
#define     STICK2XYZ_PANE2D_ACCESSCTRL_ADDREF        0x00000001
#define     STICK2XYZ_PANE2D_ACCESSCTRL_NONBLOCK      0x00000002
#define     STICK2XYZ_PANE2D_ACCESSCTRL_CHANGEOWNER   0x00000004
#define     STICK2XYZ_PANE2D_ACCESSCTRL_ACLDRAWSET    0x00000010
 
#define     STICK2XYZ_PANE2D_ACCESSCTRL_READONLY      0
#define     STICK2XYZ_PANE2D_ACCESSCTRL_EVERYONE      -1
 
/* Drawing Pane (2-D) Image Request Enumeration */
 
#define     STICK2XYZ_PANE2D_REQUEST_UNKNOWN    0x0000
#define     STICK2XYZ_PANE2D_REQUEST_UINT8PP    0x0001
#define     STICK2XYZ_PANE2D_REQUEST_UINT8P           0x0002
#define     STICK2XYZ_PANE2D_REQUEST_UINT16PP   0x0004
#define     STICK2XYZ_PANE2D_REQUEST_UINT16P    0x0008
 
/* Drawing Pane (2-D) Texture Enumeration */
 
#define     STICK2XYZ_PANE2D_TEXTURE_INVALID    0x0000
#define     STICK2XYZ_PANE2D_TEXTURE_GRAY       0x0001
#define     STICK2XYZ_PANE2D_TEXTURE_GRAYIMAGE  0x0002
#define     STICK2XYZ_PANE2D_TEXTURE_RGB        0x0004
#define     STICK2XYZ_PANE2D_TEXTURE_RGBIMAGE   0x0008
 
/* Drawing Pane (2-D) Color Type Enumeration */
 
#define     STICK2XYZ_PANE2D_COLORTYPE_GRAY           0x00000001
#define     STICK2XYZ_PANE2D_COLORTYPE_RGB            0x00000002
#define     STICK2XYZ_PANE2D_COLORTYPE_ALPHA    0x00000010
#define     STICK2XYZ_PANE2D_COLORTYPE_16BIT    0x00000020
 
/* Drawing Pane (2-D) Types */
 
typedef void * pane2d_handle;
 
typedef void * pane2d_texture_handle;
 
struct pane2d_dupgen_funcs
{
      uint32_t len;
 
      uint32_t modtype;
 
      void * dupimage;
 
      void * freeimage;
 
      void * dupxy;
 
      void * colorinfo;
 
      void * multithreading;
 
      void * eventreleased;
};
 
struct pane2d_dupgen_funcs_v3
{
      uint32_t len;
 
      uint32_t modtype;
 
      void * dupimage;
 
      void * freeimage;
 
      void * dupxy;
 
      void * colorinfo;
 
      void * multithreading;
};
 
struct pane2d_dupgen_funcs_v2
{
      uint32_t len;
 
      uint32_t modtype;
 
      void * dupimage;
 
      void * freeimage;
 
      void * dupxy;
 
      void * colorinfo;
};
 
struct pane2d_dupgen_funcs_v1
{
      uint32_t len;
 
      uint32_t modtype;
 
      void * dupimage;
 
      void * freeimage;
 
      void * dupxy;
};
 
struct pane2d_vertex_elm
{
      uint32_t vertex_type;
 
      stick2xyz_ptchar vertex_str;
 
      int vertex_params[STICK2XYZ_MAXBUFPARAMS];
};
 
struct pane2d_vertex_elm_v2
{
      uint32_t vertex_type;
 
      stick2xyz_ptchar vertex_str;
 
      int vertex_params[STICK2XYZ_MAXBUFPARAMS];
 
      uint64_t vertex_texture_no;
 
      pane2d_texture_handle vertex_texture;
};
 
#if   defined(DOXYGEN_BUILD) | defined(__WINDOWS__)
struct pane2d_drawacl
{
      SIZE_T drawacl_version;
 
      HANDLE drawacl_heap;
 
      BOOL drawacl_everyone;
 
      BOOL drawacl_readonly;
 
      int drawacl_count;
 
      PDWORD drawacl_threadids;
};
 
struct pane2d_drawacl_withthreadhandles
{
      SIZE_T drawacl_version;
 
      HANDLE drawacl_heap;
 
      BOOL drawacl_everyone;
 
      BOOL drawacl_readonly;
 
      int drawacl_count;
 
      PDWORD drawacl_threadids;
 
      PHANDLE drawacl_handles;
};
#endif /* defined(DOXYGEN_BUILD) | defined(__WINDOWS__) */
 
 
/* Drawing Pane (2-D) Module Identification */
#ifdef      UNICODE
typedef const wchar_t * (*pane2d_modid_name)(void);
typedef const wchar_t * (*pane2d_modid_desc)(void);
#else /* not UNICODE */
typedef const char * (*pane2d_modid_name)(void);
typedef const char * (*pane2d_modid_desc)(void);
#endif      /* not UNICODE */
typedef void (*pane2d_modid_version)(int *);
typedef int (*pane2d_modid_type)(void);
typedef void (*pane2d_modid_lang)(void *);
typedef void (*pane2d_set_tty)(void *,void *);
 
/* Drawing Pane (2-D) Module Initializers/Destructors */
typedef int (*pane2d_init)(int);
typedef int (*pane2d_release)(void);
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
typedef void (*pane2d_sigterm_ready)(int);
typedef int (*pane2d_sigterm)(pane2d_sigterm_ready, int);
#endif      /* !defined(__WINDOWS) | defined(DOXYGEN_BUILD) */
 
/* Drawing Pane (2-D) Multithread Information */
 
typedef int (*pane2d_can_multithread)(void);
typedef int (*pane2d_is_multithreaded)(pane2d_handle);
 
/* Drawing Pane (2-D) Bits Per Pixel Information */
 
typedef int (*pane2d_get_bpp)(void);
 
/* Drawing Pane (2-D) Access Control Functions */
 
typedef void (*pane2d_getref)(pane2d_handle, int *, int *);
typedef int (*pane2d_addref)(pane2d_handle);
typedef int (*pane2d_releaseref)(pane2d_handle, int, int);
typedef int (*pane2d_isowner)(pane2d_handle);
typedef int (*pane2d_candraw)(pane2d_handle);
typedef int (*pane2d_waituntilowner)(pane2d_handle, int);
typedef int (*pane2d_termwaituntilowner)(pane2d_handle);
 
#if   defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
typedef DWORD (*pane2d_getownerinfo_windows)(pane2d_handle, LPHANDLE);
typedef BOOL (*pane2d_getdrawaclinfo_windows)(
      pane2d_handle,
      struct pane2d_drawacl *
);
typedef BOOL (*pane2d_freedrawaclinfo_windows)(
      pane2d_handle,
      struct pane2d_drawacl *
);
typedef int (*pane2d_changeaccesscontrol)(
      pane2d_handle,
      PHANDLE,
      int,
      uint32_t
);
typedef int (*pane2d_changeowningthread)(pane2d_handle, HANDLE, int);
typedef HANDLE (*pane2d_eventreleased)(pane2d_handle);
#else /* not defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
typedef int (*pane2d_eventreleased)(pane2d_handle);
#ifdef      HAVE_THREADS_H
typedef int (*pane2d_changeaccesscontrol)(
      pane2d_handle,
      thrd_t *,
      int,
      uint32_t
);
typedef int (*pane2d_changeowningthread)(pane2d_handle, thrd_t, int);
#else /* not HAVE_THREADS_H */
typedef int (*pane2d_changeaccesscontrol)(
      pane2d_handle,
      void *,
      int,
      uint32_t
);
typedef int (*pane2d_changeowningthread)(pane2d_handle, void *, int);
#endif      /* not HAVE_THREADS_H */
#endif      /* not defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
/* Drawing Pane (2-D) Vertex Functions */
 
typedef uint32_t (*pane2d_vertex_getopts)(pane2d_handle);
typedef void (*pane2d_vertex_setopts)(pane2d_handle, uint32_t);
typedef int (*pane2d_vertex_get)(pane2d_handle, int, struct pane2d_vertex_elm *);
typedef int (*pane2d_vertex_get_v2)(
      pane2d_handle,
      int,
      struct pane2d_vertex_elm_v2 *
);
 
/* Drawing Pane (2-D) Texture Functions */
 
typedef uint64_t (*pane2d_texture_add_gray)(
      pane2d_handle,
      uint8_t,
      uint8_t,
      pane2d_texture_handle *
);
typedef uint64_t (*pane2d_texture_add_gray16)(
      pane2d_handle,
      uint16_t,
      uint16_t,
      pane2d_texture_handle *
);
typedef uint64_t (*pane2d_texture_add_rgb)(
      pane2d_handle,
      uint8_t,
      uint8_t,
      uint8_t,
      uint8_t,
      pane2d_texture_handle *
);
typedef uint64_t (*pane2d_texture_add_rgb16)(
      pane2d_handle,
      uint16_t,
      uint16_t,
      uint16_t,
      uint16_t,
      pane2d_texture_handle *
);
typedef int (*pane2d_texture_enum)(
      pane2d_handle,
      pane2d_texture_handle *,
      uint64_t
);
typedef void (*pane2d_texture_clear)(pane2d_handle);
typedef uint32_t (*pane2d_colortype)(void);
 
/* Drawing Pane (2-D) Allocation Functions */
 
typedef pane2d_handle (*pane2d_alloc)(int, int);
typedef pane2d_handle (*pane2d_alloc_multithread)(
      int,
      int,
      size_t,
      uint32_t
);
typedef void (*pane2d_clear)(pane2d_handle);
typedef void (*pane2d_free)(pane2d_handle);
 
/* Drawing Pane (2-D) Handle Data Access Functions */
 
typedef uint8_t ** (*pane2d_dupdata)(pane2d_handle, int);
typedef uint8_t ** (*pane2d_dupimage)(pane2d_handle, int);
typedef void (*pane2d_freeimage)(pane2d_handle, uint8_t **);
typedef uint16_t ** (*pane2d_dupimage16)(pane2d_handle, int);
typedef void (*pane2d_freeimage16)(pane2d_handle, uint16_t **);
typedef uint8_t * (*pane2d_dupdatap)(pane2d_handle, int);
typedef void (*pane2d_freedatap)(pane2d_handle, uint8_t *);
typedef uint16_t * (*pane2d_dupdata16p)(pane2d_handle, int);
typedef void (*pane2d_freedata16p)(pane2d_handle, uint16_t *);
typedef void (*pane2d_dupxy)(pane2d_handle, int *, int *);
typedef int (*pane2d_dupfunc_getlist)(uint32_t, struct pane2d_dupgen_funcs *);
 
 
/* Drawing Pane (2-D) Debug Functions */
 
typedef void (*pane2d_print_segment)(pane2d_handle, int);
 
 
/* Drawing Pane (2-D) Drawing Functions */
 
typedef void (*pane2d_drawpixel)(pane2d_handle, int , int);
typedef void (*pane2d_drawline)(pane2d_handle, int, int, int, int, int);
 
typedef void (*pane2d_drawcircle)(pane2d_handle, int, int, int, int);
typedef void (*pane2d_fillcircle)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int
);
typedef void (*pane2d_drawellipse)(pane2d_handle, int, int, int, int, int);
typedef void (*pane2d_fillellipse)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int,
      int
);
 
typedef void (*pane2d_drawrect)(pane2d_handle, int, int, int, int, int);
typedef void (*pane2d_fillrect)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int,
      int
);
typedef void (*pane2d_drawsquare)(pane2d_handle, int, int, int, int);
typedef void (*pane2d_fillsquare)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int
);
 
typedef void (*pane2d_drawtriangle)(
      pane2d_handle,
      int,
      int,
      int,
      int,
      int,
      int,
      int
);
typedef void (*pane2d_filltriangle)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int,
      int,
      int,
      int
);
typedef void (*pane2d_drawrighttriangle)(
      pane2d_handle,
      int,
      int,
      int,
      int,
      int,
      int
);
typedef void (*pane2d_fillrighttriangle)(
      pane2d_handle,
      pane2d_texture_handle,
      int,
      int,
      int,
      int,
      int
);
typedef void (*pane2d_drawtworighttriangles)(
      pane2d_handle,
      int,
      int,
      int,
      int,
      int,
      int
);
 
 
/* Drawing Pane (2-D) Static/Shared Function Pointer Loaders. */
struct pane2d_funcptrs
{
      pane2d_modid_name pane2d_funcptrs_name;
      pane2d_modid_desc pane2d_funcptrs_desc;
      pane2d_modid_version pane2d_funcptrs_version;
      pane2d_modid_type pane2d_funcptrs_type;
      pane2d_modid_lang pane2d_funcptrs_lang;
      pane2d_set_tty pane2d_funcptrs_set_tty;
 
      pane2d_init pane2d_funcptrs_init;
      pane2d_release pane2d_funcptrs_release;
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
      pane2d_sigterm pane2d_funcptrs_sigterm;
#endif      /* not defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
      pane2d_can_multithread pane2d_funcptrs_can_multithread;
      pane2d_is_multithreaded pane2d_funcptrs_is_multithreaded;
      pane2d_get_bpp pane2d_funcptrs_get_bpp;
      pane2d_getref pane2d_funcptrs_getref;
      pane2d_addref pane2d_funcptrs_addref;
      pane2d_releaseref pane2d_funcptrs_releaseref;
      pane2d_isowner pane2d_funcptrs_isowner;
      pane2d_candraw pane2d_funcptrs_candraw;
#if   defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
      pane2d_getownerinfo_windows pane2d_funcptrs_getownerinfo_windows;
      pane2d_getdrawaclinfo_windows pane2d_funcptrs_getdrawaclinfo_windows;
      pane2d_freedrawaclinfo_windows pane2d_funcptrs_freedrawaclinfo_windows;
#endif      /* defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
      pane2d_waituntilowner pane2d_funcptrs_waituntilowner;
      pane2d_termwaituntilowner pane2d_funcptrs_termwaituntilowner;
      pane2d_changeaccesscontrol pane2d_funcptrs_changeaccesscontrol;
      pane2d_changeowningthread pane2d_funcptrs_changeowningthread;
      pane2d_eventreleased pane2d_funcptrs_eventreleased;
 
      pane2d_alloc pane2d_funcptrs_alloc;
      pane2d_alloc_multithread pane2d_funcptrs_alloc_multithread;
      pane2d_clear pane2d_funcptrs_clear;
      pane2d_free pane2d_funcptrs_free;
 
      pane2d_vertex_getopts pane2d_funcptrs_getopts;
      pane2d_vertex_setopts pane2d_funcptrs_setopts;
      pane2d_vertex_get pane2d_funcptrs_vertex_get;
      pane2d_vertex_get_v2 pane2d_funcptrs_vertex_get_v2;
 
      pane2d_texture_add_gray pane2d_funcptrs_texture_add_gray;
      pane2d_texture_add_gray16 pane2d_funcptrs_texture_add_gray16;
      pane2d_texture_add_rgb pane2d_funcptrs_texture_add_rgb;
      pane2d_texture_add_rgb16 pane2d_funcptrs_texture_add_rgb16;
      pane2d_texture_enum pane2d_funcptrs_texture_enum;
      pane2d_texture_clear pane2d_funcptrs_texture_clear;
      pane2d_colortype pane2d_funcptrs_colortype;
 
      pane2d_dupdata pane2d_funcptrs_dupdata;
      pane2d_dupimage pane2d_funcptrs_dupimage;
      pane2d_freeimage pane2d_funcptrs_freeimage;
      pane2d_dupimage16 pane2d_funcptrs_dupimage16;
      pane2d_freeimage16 pane2d_funcptrs_freeimage16;
      pane2d_dupdatap pane2d_funcptrs_dupdatap;
      pane2d_freedatap pane2d_funcptrs_freedatap;
      pane2d_dupdata16p pane2d_funcptrs_dupdata16p;
      pane2d_freedata16p pane2d_funcptrs_freedata16p;
      pane2d_dupxy pane2d_funcptrs_dupxy;
      pane2d_dupfunc_getlist pane2d_funcptrs_dupfunc_getlist;
 
      pane2d_drawpixel pane2d_funcptrs_drawpixel;
      pane2d_drawline pane2d_funcptrs_drawline;
 
      pane2d_drawcircle pane2d_funcptrs_drawcircle;
      pane2d_fillcircle pane2d_funcptrs_fillcircle;
      pane2d_drawellipse pane2d_funcptrs_drawellipse;
      pane2d_fillellipse pane2d_funcptrs_fillellipse;
 
      pane2d_drawrect pane2d_funcptrs_drawrect;
      pane2d_fillrect pane2d_funcptrs_fillrect;
      pane2d_drawsquare pane2d_funcptrs_drawsquare;
      pane2d_fillsquare pane2d_funcptrs_fillsquare;
 
      pane2d_drawtriangle pane2d_funcptrs_drawtriangle;
      pane2d_filltriangle pane2d_funcptrs_filltriangle;
      pane2d_drawrighttriangle pane2d_funcptrs_drawrighttriangle;
      pane2d_fillrighttriangle pane2d_funcptrs_fillrighttriangle;
      pane2d_drawtworighttriangles pane2d_funcptrs_drawtworighttriangles;
 
      pane2d_print_segment pane2d_funcptrs_print_segment;
};
 
struct pane2d_image_funcs
{
      uint32_t len;
 
      uint32_t modtype;
 
      pane2d_dupimage dupimage;
 
      pane2d_freeimage freeimage;
 
      pane2d_dupxy dupxy;
 
      pane2d_colortype colorinfo;
 
      pane2d_is_multithreaded multithreading;
 
      pane2d_eventreleased eventreleased;
};
 
struct pane2d_image16_funcs
{
      uint32_t len;
 
      uint32_t modtype;
 
      pane2d_dupimage16 dupimage;
 
      pane2d_freeimage16 freeimage;
 
      pane2d_dupxy dupxy;
 
      pane2d_colortype colorinfo;
 
      pane2d_is_multithreaded multithreading;
 
      pane2d_eventreleased eventreleased;
};
 
struct pane2d_datap_funcs
{
      uint32_t len;
 
      uint32_t modtype;
 
      pane2d_dupdatap dupimage;
 
      pane2d_freedatap freeimage;
 
      pane2d_dupxy dupxy;
 
      pane2d_colortype colorinfo;
 
      pane2d_is_multithreaded multithreading;
 
      pane2d_eventreleased eventreleased;
};
 
struct pane2d_data16p_funcs
{
      uint32_t len;
 
      uint32_t modtype;
 
      pane2d_dupdata16p dupimage;
 
      pane2d_freedata16p freeimage;
 
      pane2d_dupxy dupxy;
 
      pane2d_colortype colorinfo;
 
      pane2d_is_multithreaded multithreading;
 
      pane2d_eventreleased eventreleased;
};
/* ----- Drawing Pane (2-D) END ----- */
 
 
 
/* ----- Output (2-D) BEGIN ----- */
 
/* Output (2-D) Quality Enumeration */
#define     STICK2XYZ_OUTPUT2D_QUALITY_VALID    0x00
#define     STICK2XYZ_OUTPUT2D_QUALITY_INVALID  0x01
#define     STICK2XYZ_OUTPUT2D_QUALITY_TOOLOW   0x03
#define     STICK2XYZ_OUTPUT2D_QUALITY_TOOHIGH  0x05
 
/* Output (2-D) Types */
typedef void * output2d_handle;
 
struct output2d_qualityinfo
{
      uint32_t quality_version;
 
      int quality_min;
 
      int quality_max;
 
      int quality_best;
 
      int quality_fast;
 
      int quality_default;
};
 
/* Output (2-D) Module Identification */
 
#ifdef      UNICODE
typedef const wchar_t * (*output2d_modid_name)(void);
typedef const wchar_t * (*output2d_modid_desc)(void);
#else /* not UNICODE */
typedef const char * (*output2d_modid_name)(void);
typedef const char * (*output2d_modid_desc)(void);
#endif      /* not UNICODE */
typedef void (*output2d_modid_version)(int *);
typedef int (*output2d_modid_type)(void);
typedef void (*output2d_modid_lang)(void *);
typedef int (*output2d_multithread_safe)(void);
typedef void (*output2d_set_tty)(void *,void *);
 
/* Output (2-D) Module Initializers/Destructors */
typedef int (*output2d_init)(int);
typedef int (*output2d_release)(void);
 
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
typedef void (*output2d_sigterm_ready)(int);
typedef int (*output2d_sigterm)(output2d_sigterm_ready, int);
#endif      /* !defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
/* Output (2-D) Quality Functions */
 
typedef int (*output2d_quality_range)(
      struct output2d_qualityinfo *
);
typedef uint32_t (*output2d_quality_valid)(const int);
 
/* Output (2-D) Bits Per Pixel Functions */
 
typedef size_t (*output2d_bpp_list)(int *);
typedef int (*output2d_bpp_supported)(const int);
typedef int (*output2d_bpp_default)(void);
 
/* Output (2-D) Allocation Functions */
 
typedef output2d_handle (*pane_to_output2d)(
      pane2d_handle,
      pane2d_dupdata,
      pane2d_dupxy,
        int
);
typedef output2d_handle (*paneimage_to_output2d)(
      pane2d_handle,
      pane2d_dupimage,
      pane2d_freeimage,
      pane2d_dupxy,
        int
);
typedef output2d_handle (*pane16_to_output2d_bytype)(
      pane2d_handle,
      pane2d_dupfunc_getlist,
      int,
      unsigned int
);
typedef output2d_handle (*pane_to_output2d_bytype)(
      pane2d_handle,
      pane2d_dupfunc_getlist,
      int,
      unsigned int
);
typedef void (*output2d_free_handle)(output2d_handle);
typedef int (*output2d_getnewdata)(output2d_handle, unsigned int);
 
/* Output (2-D) I/O Functions */
 
#ifdef UNICODE
typedef int (*output2d_write_w)(
      output2d_handle,
      const wchar_t*,
      unsigned int,
      int
      );
#endif      /* UNICODE */
typedef int (*output2d_write)(
      output2d_handle,
      const char *,
      unsigned int,
      int
);
 
/* PNG Debug Functions */
 
typedef void (*output2d_read)(const char *);
 
/* Output (2-D) Static/Shared Function Pointer Loaders. */
struct output2d_funcptrs
{
      output2d_modid_name output2d_funcptrs_name;
      output2d_modid_desc output2d_funcptrs_desc;
      output2d_modid_version output2d_funcptrs_version;
      output2d_modid_type output2d_funcptrs_type;
      output2d_modid_lang output2d_funcptrs_lang;
 
      output2d_init output2d_funcptrs_init;
      output2d_release output2d_funcptrs_release;
      output2d_multithread_safe output2d_funcptrs_multithread_safe;
      output2d_set_tty output2d_funcptrs_set_tty;
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
      output2d_sigterm output2d_funcptrs_sigterm;
#endif      /* !defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
      output2d_quality_range output2d_funcptrs_quality_range;
      output2d_quality_valid output2d_funcptrs_quality_valid;
 
      output2d_bpp_list output2d_funcptrs_bpp_list;
      output2d_bpp_supported output2d_funcptrs_bpp_supported;
      output2d_bpp_default output2d_funcptrs_bpp_default;
 
      pane_to_output2d output2d_funcptrs_pane_to_output2d;
      paneimage_to_output2d output2d_funcptrs_paneimage_to_output2d;
      pane16_to_output2d_bytype output2d_funcptrs_pane16_to_output2d_bytype;
      pane_to_output2d_bytype output2d_funcptrs_pane_to_output2d_bytype;
      output2d_getnewdata output2d_funcptrs_getnewdata;
 
      output2d_free_handle output2d_funcptrs_free_handle;
 
#ifdef      UNICODE
      output2d_write_w output2d_funcptrs_write_w;
#endif      /* UNICODE */
      output2d_write output2d_funcptrs_write;
 
      output2d_read output2d_funcptrs_read;
};
 
 
/* ----- Output (2-D) END ----- */
 
 
 
/* ----- Input BEGIN ----- */
 
 
/* Input Types */
typedef void * input_handle;
 
#define     STICK2XYZ_INPUT_OPEN_INVALID  (input_handle)-1
 
#define STICK2XYZ_INPUT_OPEN_ENOENT (input_handle)-2
 
#define     STICK2XYZ_INPUT_OPEN_ERROR    (input_handle)-2
 
#define     STICK2XYZ_INPUT_OPEN_MEMORY   NULL
 
#define     STICK2XYZ_INPUT_TYPE_AUTO     0x00000000
 
#define     STICK2XYZ_INPUT_TYPE_NOTSUPP  0x00000001
 
#define     STICK2XYZ_INPUT_TYPE_PLAIN    0x00000010
 
#define     STICK2XYZ_INPUT_TYPE_BINARY   0x00000020
 
#define     STICK2XYZ_INPUT_TYPE_GZIP     0x00000100
 
#define     STICK2XYZ_INPUT_TYPE_BZIP2    0x00000200
 
#define     STICK2XYZ_INPUT_TYPE_LZMA2    0x00000400
 
#define STICK2XYZ_INPUT_TYPE_IS_UTF8(v) \
      ( ! ( v & 0x0000F000 ) )
 
#define     STICK2XYZ_INPUT_TYPE_UTF8     0x00000000
 
#define     STICK2XYZ_INPUT_TYPE_UTF16BE  0x00001000
 
#define     STICK2XYZ_INPUT_TYPE_UTF16LE  0x00002000
 
#define     STICK2XYZ_INPUT_TYPE_UTF32BE  0x00004000
 
#define     STICK2XYZ_INPUT_TYPE_UTF32LE  0x00008000
 
#define     STICK2XYZ_INPUT_TYPE_SMALL    0x10000000
 
struct input_buf
{
      uint32_t input_buf_type;
 
      stick2xyz_ptchar input_buf_str;
 
      int input_buf_params[STICK2XYZ_MAXBUFPARAMS];
};
 
/* Input Module Identification */
 
#ifdef      UNICODE
typedef const wchar_t * (*input_modid_name)(void);
typedef const wchar_t * (*input_modid_desc)(void);
#else /* not UNICODE */
typedef const char * (*input_modid_name)(void);
typedef const char * (*input_modid_desc)(void);
#endif      /* not UNICODE */
typedef void (*input_modid_version)(int *);
typedef int (*input_modid_type)(void);
typedef void (*input_modid_lang)(void *);
 
/* Input Module Initializers/Destructors */
 
typedef int (*input_init)(int);
typedef int (*input_release)(void);
 
typedef void (*input_set_tty)(void *,void *);
 
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
typedef void (*input_sigterm_ready)(int);
typedef int (*input_sigterm)(input_sigterm_ready, int);
#endif      /* !defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
typedef int (*input_type_supported)(uint32_t);
typedef uint32_t (*input_get_supportedalgorithm)(void);
 
typedef input_handle (*input_open)(void *);
typedef input_handle (*input_open_bt)(void *, uint32_t *);
typedef input_handle (*input_fopen)(const char *);
typedef input_handle (*input_fopen_bt)(const char *, uint32_t *);
typedef input_handle (*input_fdopen)(int);
typedef input_handle (*input_fdopen_bt)(int, uint32_t *);
#ifdef      UNICODE
typedef input_handle (*input_fwopen)(const wchar_t *);
typedef input_handle (*input_fwopen_bt)(const wchar_t *, uint32_t *);
#endif      /* UNICODE */
typedef void (*input_close)(input_handle);
 
typedef uint32_t (*input_get_algorithm)(input_handle);
typedef uint32_t (*input_get_utftype)(input_handle);
typedef uint64_t (*input_get_lineno)(input_handle);
 
typedef int (*input_read)(input_handle, struct input_buf *, size_t, size_t);
 
struct input_funcptrs
{
      input_modid_name input_funcptrs_name;
      input_modid_desc input_funcptrs_desc;
      input_modid_version input_funcptrs_version;
      input_modid_type input_funcptrs_type;
      input_modid_lang input_funcptrs_lang;
      input_set_tty input_funcptrs_set_tty;
 
      input_type_supported input_funcptrs_type_supported;
 
      input_init input_funcptrs_init;
      input_release input_funcptrs_release;
#if   !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
      input_sigterm input_funcptrs_sigterm;
#endif      /* !defined(__WINDOWS__) | defined(DOXYGEN_BUILD)*/
 
      input_open input_funcptrs_open;
      input_open_bt input_funcptrs_open_bt;
      input_fopen input_funcptrs_fopen;
      input_fopen_bt input_funcptrs_fopen_bt;
      input_fdopen input_funcptrs_fdopen;
      input_fdopen_bt input_funcptrs_fdopen_bt;
      input_close input_funcptrs_close;
 
      input_get_algorithm input_funcptrs_get_algorithm;
      input_get_utftype input_funcptrs_get_utftype;
      input_get_supportedalgorithm input_funcptrs_get_supportedalgorithm;
      input_get_lineno input_funcptrs_get_lineno;
 
      input_read input_funcptrs_read;
 
#ifdef      UNICODE
      input_fwopen input_funcptrs_fwopen;
      input_fwopen_bt input_funcptrs_fwopen_bt;
#endif      /* UNICODE */
};
 
 
/* ----- Input END ----- */
 
 
 
#ifdef      STICK2XYZ_STATIC
/* ----- Static Module List BEGIN ----- */
void pane2dgray_funcptrs_setup ( struct pane2d_funcptrs * ptr );
void pane2dgray16_funcptrs_setup ( struct pane2d_funcptrs * ptr );
void pane2drgb_funcptrs_setup ( struct pane2d_funcptrs * ptr );
void pane2drgb16_funcptrs_setup ( struct pane2d_funcptrs * ptr );
void output2djpeg_funcptrs_setup ( struct output2d_funcptrs * ptr );
void output2dpng_funcptrs_setup ( struct output2d_funcptrs * ptr );
void output2dbmp_funcptrs_setup ( struct output2d_funcptrs * ptr );
void inputbasic_funcptrs_setup ( struct input_funcptrs * ptr );
/* ----- Static Module List END ----- */
#endif      /* STICK2XYZ_STATIC */
 
 
/* Make sure we have closed the "human language only" ifdef statement. */
#endif      /* not STICK2XYZ_HUMAN_LANGUAGE */
 
 
/* Exit back to C++ (or other language) if we used extern above. */
#ifdef      _cplusplus
}
#endif      /* _cplusplus */
 
/* Terminate the double-inclusion avoidance ifdef here. */
#endif      /* not STICK2XYZ_H */