Imported nxcompext-3.1.0-2.tar.gznxcompext/3.1.0-2

Summary: Imported nxcompext-3.1.0-2.tar.gz
Keywords:

Imported nxcompext-3.1.0-2.tar.gz
into Git repository

1 files changed, 904 insertions, 0 deletions

diff --git a/nxcompext/NXlib.h b/nxcompext/NXlib.h
new file mode 100644
index 000000000..d77ff6046
--- /dev/null
+++ b/nxcompext/NXlib.h
@@ -0,0 +1,904 @@
+/**************************************************************************/
+/*                                                                        */
+/* Copyright (c) 2001, 2007 NoMachine, http://www.nomachine.com/.         */
+/*                                                                        */
+/* NXCOMPEXT, NX protocol compression and NX extensions to this software  */
+/* are copyright of NoMachine. Redistribution and use of the present      */
+/* software is allowed according to terms specified in the file LICENSE   */
+/* which comes in the source distribution.                                */
+/*                                                                        */
+/* Check http://www.nomachine.com/licensing.html for applicability.       */
+/*                                                                        */
+/* NX and NoMachine are trademarks of NoMachine S.r.l.                    */
+/*                                                                        */
+/* All rigths reserved.                                                   */
+/*                                                                        */
+/**************************************************************************/
+
+#ifndef NXlib_H
+#define NXlib_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+
+#include "NX.h"
+#include "NXpack.h"
+#include "NXproto.h"
+#include "NXvars.h"
+
+/*
+ * All the NX code should use these.
+ */
+
+#define Xmalloc(size) malloc((size))
+#define Xfree(ptr)    free((ptr))
+ 
+/*
+ * Maximum number of supported pack methods.
+ */
+
+#define NXNumberOfPackMethods  128
+
+/*
+ * Assume this as the limit of resources that
+ * can be provided to the split and unpack
+ * requests.
+ */
+
+#define NXNumberOfResources    256
+
+#define NXNoResource           256 + 1
+#define NXAnyResource          256 + 2
+
+/*
+ * Initialize the internal structures used by
+ * the library. Should be executed again after
+ * having reopened the display.
+ */
+
+extern int NXInitDisplay(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Reset all the internal structures. Should be
+ * executed after closing the display.
+ */
+
+extern int NXResetDisplay(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Set the NX display flush policy. The policy can
+ * be either NXFlushDeferred or NXFlushImmediate.
+ */
+
+extern int NXSetDisplayPolicy(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    int                 /* policy */
+#endif
+);
+
+/*
+ * Set the display output buffer size.
+ */
+
+extern int NXSetDisplayBuffer(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    int                 /* size */
+#endif
+);
+
+/*
+ * If set, the Popen() function in the X server
+ * wil remove the LD_LIBRARY_PATH variable from
+ * the environment before calling the execl()
+ * function on the child process. The function
+ * returns the previous value.
+ */
+
+extern int NXUnsetLibraryPath(
+#if NeedFunctionPrototypes
+    int                 /* value */
+#endif
+);
+
+/*
+ * If the parameter is true, the Xlib I/O error
+ * handler will return, instead of quitting the
+ * program. The function returns the previous
+ * value.
+ */
+
+extern int NXHandleDisplayError(
+#if NeedFunctionPrototypes
+    int                 /* value */
+#endif
+);
+
+/*
+ * Shutdown the display descriptor and force Xlib
+ * to set the I/O error flag.
+ */
+
+extern Bool NXForceDisplayError(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Check the value of the XlibDisplayIOError flag.
+ * If not set, try to call the display error hand-
+ * ler to give to the application a chance to see
+ * whether it needs to close the connection.
+ */
+
+extern int NXDisplayError(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Query the number of bytes readable from the
+ * display connection.
+ */
+
+extern int NXDisplayReadable(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Query the number of the outstanding bytes to
+ * flush to the display connection.
+ */
+
+extern int NXDisplayFlushable(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Return a value between 0 and 9 indicating the
+ * congestion level of the NX transport based on
+ * the tokens remaining. A value of 9 means that
+ * the link is congested and no further data can
+ * be sent.
+ */
+
+extern int NXDisplayCongestion(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+/*
+ * Flush the Xlib display buffer and/or the
+ * outstanding data accumulated by the NX
+ * transport.
+ */
+
+extern int NXFlushDisplay(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    int                 /* what */
+#endif
+);
+
+/*
+ * Public interfaces used to set the handlers.
+ * They all return the previous handler.
+ */
+
+extern NXDisplayErrorPredicate NXSetDisplayErrorPredicate(
+#if NeedFunctionPrototypes
+    NXDisplayErrorPredicate /* predicate */
+#endif
+);
+
+/*
+ * Called when the display blocks waiting to read or
+ * write more data.
+ */
+
+extern NXDisplayBlockHandler NXSetDisplayBlockHandler(
+#if NeedFunctionPrototypes
+    NXDisplayBlockHandler /* handler */
+#endif
+);
+
+/*
+ * Called after more data is written to the display.
+ * When the NX transport is running, data may be queued
+ * until an explicit flush.
+ */
+
+extern NXDisplayWriteHandler NXSetDisplayWriteHandler(
+#if NeedFunctionPrototypes
+    NXDisplayWriteHandler /* handler */
+#endif
+);
+
+/*
+ * Called after more data is sent to the remote proxy.
+ *
+ * Here the display pointer is passed as the second
+ * parameter to make clear that the function does not
+ * tie the callback to the display, but, similarly to
+ * all the Xlib error handlers, to a global variable
+ * shared by all the Xlib functions. The display
+ * pointer will be passed back by nxcomp at the time
+ * it will call the handler. This is because nxcomp
+ * doesn't have access to the display structure.
+ */
+
+extern NXDisplayFlushHandler NXSetDisplayFlushHandler(
+#if NeedFunctionPrototypes
+    NXDisplayFlushHandler      /* handler */,
+    Display*                   /* display */
+#endif
+);
+
+/*
+ * Get an arbitrary null terminated buffer to be added
+ * to the NX statistics.
+ */
+
+extern NXDisplayStatisticsHandler NXSetDisplayStatisticsHandler(
+#if NeedFunctionPrototypes
+    NXDisplayStatisticsHandler /* handler */,
+    char **                    /* buffer */
+#endif
+);
+
+/*
+ * Redefine the function called by Xlib in the case of
+ * an out-of-order sequence number received in the X
+ * protocol stream.
+ */
+ 
+extern NXLostSequenceHandler NXSetLostSequenceHandler(
+#if NeedFunctionPrototypes
+    NXLostSequenceHandler /* handler */
+#endif
+);
+
+/*
+ * The agent should get the NX parameters at startup, just after
+ * having opened the display. If the agent is not able to satisfy
+ * the pack method set by user (because a method is not applica-
+ * ble, it is not supported by the remote or it simply requires a
+ * screen depth greater than the depth available), it should fall
+ * back to the nearest method of the same type.
+ */
+
+extern Status NXGetControlParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int*       /* link_type */,
+    unsigned int*       /* local_major */,
+    unsigned int*       /* local_minor */,
+    unsigned int*       /* local_patch */,
+    unsigned int*       /* remote_major */,
+    unsigned int*       /* remote_minor */,
+    unsigned int*       /* remote_patch */,
+    int*                /* frame_timeout */,
+    int*                /* ping_timeout */,
+    int*                /* split_mode */,
+    int*                /* split_size */,
+    unsigned int*       /* pack_method */,
+    unsigned int*       /* pack_quality */,
+    int*                /* data_level */,
+    int*                /* stream_level */,
+    int*                /* delta_level */,
+    unsigned int*       /* load_cache */,
+    unsigned int*       /* save_cache */,
+    unsigned int*       /* startup_cache */
+#endif
+);
+
+/*
+ * Which unpack methods are supported by the remote proxy?
+ */
+
+extern Status NXGetUnpackParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int*       /* entries */,
+    unsigned char[]     /* supported_methods */
+#endif
+);
+
+/*
+ * Query and enable shared memory support on path agent to X
+ * client proxy and X server proxy to real X server. At the
+ * moment only the path proxy to real X server is implemented.
+ * On return flags will say if support has been successfully
+ * activated. Segments will contain the XID associated to the
+ * shared memory blocks. A MIT-SHM compliant protocol is used
+ * between proxy and the real server, while a simplified
+ * version is used between the agent and the client proxy to
+ * accomodate both packed images and plain X bitmaps.
+ */
+
+extern Status NXGetShmemParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int*       /* enable_client  */,
+    unsigned int*       /* enable_server */,
+    unsigned int*       /* client_segment */,
+    unsigned int*       /* server_segment */,
+    unsigned int*       /* client_size */,
+    unsigned int*       /* server_size */
+#endif
+);
+
+/*
+ * Get the path to the font server that can be used by the X
+ * server to tunnel the font connections across the NX link.
+ * The path actually represents the TCP port where the proxy
+ * on the NX client side is listening. The agent can tempora-
+ * rily enable the tunneling when it needs a font that is not
+ * available on the client, for example when the session is
+ * migrated from a different X server.
+ */
+
+extern Status NXGetFontParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* path_length */,
+    char[]              /* path_data */
+#endif
+);
+
+/*
+ * This set of functions is used to leverage the image stream-
+ * ing capabilities built in nxcomp. An image can be streamed
+ * by sending a start-split message, followed by the X messages
+ * that will have to be split by the proxy, followed by an end-
+ * split closure. Usually, in the middle of a start-split/end-
+ * split sequence there will be a single PutImage() or PutPack-
+ * edImage(), that, in turn, can generate multiple partial
+ * requests, like a SetUnpackColormap() and SetUnpackAlpha()
+ * that will be later used to decompress the image to its ori-
+ * ginal form. Multiple requests may be also generated because
+ * of the maximum size of a X request being exceeded, so that
+ * Xlib has to divide the single image in multiple sub-image re-
+ * quests. The agent doesn't need to take care of these details
+ * but will rather have to track the result of the split opera-
+ * tion. By monitoring the notify events sent by the proxy, the
+ * agent will have to implement its own strategy to deal with
+ * the resources. For example, it will be able to:
+ *
+ * - Mark a drawable as dirty, if the image was not sent
+ *   synchronously, in the main X oputput stream.
+ *
+ * - Choose to commit or discard the original image, at the
+ *   time it will be recomposed at the remote side. This may
+ *   include all the messages that were part of the split
+ *   (the colormap, the alpha channel, etc.)
+ *
+ * - Mark the drawable as clean again, if the image was
+ *   committed and the drawable didn't change in the mean-
+ *   while.
+ *
+ * At the time the proxy receives the end-split, it reports the
+ * result of the operation to the agent. The agent will be able
+ * to identify the original split operation (the one referenced
+ * in the start-split/end-split sequence) by the small integer
+ * number (0-255) named 'resource' sent in the events.
+ *
+ * One of the following cases may be encountered:
+ *
+ *
+ * NXNoSplitNotify      All messages were sent in the main out-
+ *                      put stream, so that no split actually
+ *                      took place.
+ *
+ * NXStartSplitNotify   One or more messages were split, so,
+ *                      at discrection of the agent, the client
+ *                      may be suspended until the transferral
+ *                      is completed.
+ *
+ * NXCommitSplitNotify  One of the requests that made up the
+ *                      split was recomposed. The agent should
+ *                      either commit the given request or tell
+ *                      the proxy to discard it.
+ *
+ * NXEndSplitNotify     The split was duly completed. The agent
+ *                      can restart the client.
+ *
+ * NXEmptySplitNotify   No more split operation are pending.
+ *                      The agent can use this information to
+ *                      implement specific strategies requiring
+ *                      that all messages have been recomposed
+ *                      at the remote end, like updating the
+ *                      drawables that were not synchronized
+ *                      because of the lazy encoding.
+ *
+ * The 'mode' field that is sent by the agent in the start-split
+ * request, determines the strategy that the proxy will adopt to
+ * deal with the image. If set to 'eager', the proxy will only
+ * split the messages whose size exceeds the split threshold (the
+ * current threshold can be found in the NXGetControlParameters()
+ * reply). If the mode is set to lazy, the proxy will split any
+ * image that would have generated an actual transfer of the data
+ * part (in practice all images that are not found in the cache).
+ * This second strategy can be leveraged by an agent to further
+ * reduce the bandwidth requirements. For example, by setting the
+ * mode to lazy and by monitoring the result, an agent can easi-
+ * ly verify if the drawable was successfully updated, mark the
+ * drawable if not, and synchronize it at later time.
+ *
+ * See NXproto.h for the definition of the available modes.
+ */
+
+extern unsigned int NXAllocSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXStartSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* mode */
+#endif
+);
+
+extern int NXEndSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXCommitSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* propagate */,
+    unsigned char       /* request */,
+    unsigned int        /* position */
+#endif
+);
+
+extern int NXAbortSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXFinishSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXFreeSplit(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXSetExposeParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    int                 /* expose */,
+    int                 /* graphics_expose */,
+    int                 /* no_expose */
+#endif
+);
+
+extern int NXSetCacheParameters(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    int                 /* enable_cache */,
+    int                 /* enable_split */,
+    int                 /* enable_save */,
+    int                 /* enable_load */
+#endif
+);
+
+extern unsigned int NXAllocUnpack(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXSetUnpackGeometry(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Visual*             /* visual */
+#endif
+);
+
+extern int NXSetUnpackColormap(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* method */,
+    unsigned int        /* entries */,
+    const char*         /* data */,
+    unsigned int        /* data_length */
+#endif
+);
+
+extern int NXSetUnpackAlpha(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* method */,
+    unsigned int        /* entries */,
+    const char*         /* data */,
+    unsigned int        /* data_length */
+#endif
+);
+
+extern int NXSetUnpackColormapCompat(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* entries */,
+    const char*         /* data */
+#endif
+);
+
+extern int NXSetUnpackAlphaCompat(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    unsigned int        /* entries */,
+    const char*         /* data */
+#endif
+);
+
+extern int NXFreeUnpack(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+/*
+ * A packed image is a XImage but with
+ * offset field containing total amount
+ * of packed image data.
+ */
+
+typedef XImage NXPackedImage;
+
+NXPackedImage *NXCreatePackedImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    Visual*             /* visual */,
+    unsigned int        /* method */,
+    unsigned int        /* depth */,
+    int                 /* format */,
+    char*               /* data */,
+    int                 /* data_length */,
+    unsigned int        /* width */,
+    unsigned int        /* height */,
+    int                 /* bitmap_pad */,
+    int                 /* bytes_per_line */
+#endif
+);
+
+extern int NXDestroyPackedImage(
+#if NeedFunctionPrototypes
+    NXPackedImage*      /* image */
+#endif
+);
+
+NXPackedImage *NXPackImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    XImage*             /* src_image */,
+    unsigned int        /* method */
+#endif
+);
+
+NXPackedImage *NXInPlacePackImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    XImage*             /* src_image */,
+    unsigned int        /* method */
+#endif
+);
+
+/*
+ * GC is declared void * to get rid of mess
+ * with different GC definitions in some X
+ * server code (like in nxagent).
+ */
+
+extern int NXPutPackedImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Drawable            /* drawable */,
+    void*               /* gc */,
+    NXPackedImage*      /* image */,
+    unsigned int        /* method */,
+    unsigned int        /* depth */,
+    int                 /* src_x */,
+    int                 /* src_y */,
+    int                 /* dst_x */,
+    int                 /* dst_y */,
+    unsigned int        /* width */,
+    unsigned int        /* height */
+#endif
+);
+
+/*
+ * Get multiple colors with a single call by
+ * pipelining X_AllocColor requests/replies.
+ */
+
+extern int NXAllocColors(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    Colormap            /* colormap */,
+    unsigned int        /* entries */,
+    XColor[]            /* screens_in_out */,
+    Bool []             /* flags allocation errors */
+#endif
+);
+
+/*
+ * Encode the data in the given format.
+ */
+
+extern char *NXEncodeColormap(
+#if NeedFunctionPrototypes
+    const char*         /* src_data */,
+    unsigned int        /* src_size */,
+    unsigned int*       /* dst_size */
+#endif
+);
+
+extern char *NXEncodeAlpha(
+#if NeedFunctionPrototypes
+    const char*         /* src_data */,
+    unsigned int        /* src_size */,
+    unsigned int*       /* dst_size */
+#endif
+);
+
+extern NXPackedImage *NXEncodeRgb(
+#if NeedFunctionPrototypes
+    XImage*             /* src_image */,
+    unsigned int        /* method */,
+    unsigned int        /* quality */
+#endif
+);
+
+extern NXPackedImage *NXEncodeRle(
+#if NeedFunctionPrototypes
+    XImage*             /* src_image */,
+    unsigned int        /* method */,
+    unsigned int        /* quality */
+#endif
+);
+
+extern NXPackedImage *NXEncodeJpeg(
+#if NeedFunctionPrototypes
+    XImage*             /* src_image */,
+    unsigned int        /* method */,
+    unsigned int        /* quality */
+#endif
+);
+
+typedef struct
+{
+  long pixel;
+  int found;
+
+} NXColorTable;
+
+extern int NXEncodeColors(
+#if NeedFunctionPrototypes
+  XImage*                 /* src_image */,
+  NXColorTable*           /* color_table */,
+  int                     /* nb_max */
+#endif
+);
+
+extern NXPackedImage *NXEncodePng(
+#if NeedFunctionPrototypes
+    XImage*             /* src_image */,
+    unsigned int        /* method */,
+    unsigned int        /* quality */
+#endif
+);
+
+extern NXPackedImage *NXEncodeBitmap(
+#if NeedFunctionPrototypes
+    XImage*             /* src_image */,
+    unsigned int        /* method */,
+    unsigned int        /* quality */
+#endif
+);
+
+extern int NXCleanImage(
+#if NeedFunctionPrototypes
+    XImage*
+#endif
+);
+
+extern void NXMaskImage(
+#if NeedFunctionPrototypes
+    XImage*              /* pointer to image to mask */ ,
+    unsigned int         /* method */
+#endif
+);
+
+extern int NXImageCacheSize;
+
+extern void NXInitCache(
+#if NeedFunctionPrototypes
+    Display*             /* display */,
+    int                  /* entries in image cache */
+#endif
+);
+
+extern void NXFreeCache(
+#if NeedFunctionPrototypes
+    Display*             /* display */
+#endif
+);
+
+extern XImage *NXCacheFindImage(
+#if NeedFunctionPrototypes
+    NXPackedImage*       /* packed image to find */,
+    unsigned int*        /* pointer to the pack method if found */,
+    unsigned char**      /* pointer to the calculated MD5 if found */
+#endif
+);
+
+extern int NXCacheAddImage(
+#if NeedFunctionPrototypes
+    NXPackedImage*       /* packed image to be added to the cache */,
+    unsigned int         /* pack method of the image to add */,
+    unsigned char*       /* pointer to MD5 of the original unpacked image */
+#endif
+);
+
+
+extern int NXGetCollectImageResource(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+extern int NXCollectImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Drawable            /* drawable */,
+    int                 /* src_x */,
+    int                 /* src_y */,
+    unsigned int        /* width */,
+    unsigned int        /* height */,
+    unsigned long       /* plane_mask */,
+    int                 /* format */
+#endif
+);
+
+extern int NXGetCollectedImage(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    XImage**            /* image */
+#endif
+);
+
+extern int NXGetCollectPropertyResource(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+extern int NXCollectProperty(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Window              /* window */,
+    Atom                /* property */,
+    long                /* long_offset */,
+    long                /* long_length */,
+    Bool                /* delete */,
+    Atom                /* req_type */
+#endif
+);
+
+extern int NXGetCollectedProperty(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Atom*               /* actual_type_return */,
+    int*                /* actual_format_return */,
+    unsigned long*      /* nitems_return */,
+    unsigned long*      /* bytes_after_return */,
+    unsigned char**     /* data */
+#endif
+);
+
+extern int NXGetCollectGrabPointerResource(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+extern int NXCollectGrabPointer(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Window              /* grab_window */,
+    Bool                /* owner_events */,
+    unsigned int        /* event_mask */,
+    int                 /* pointer_mode */,
+    int                 /* keyboard_mode */,
+    Window              /* confine_to */,
+    Cursor              /* cursor */,
+    Time                /* time */
+#endif
+);
+
+extern int NXGetCollectedGrabPointer(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    int*                /* status */
+#endif
+);
+
+extern int NXGetCollectInputFocusResource(
+#if NeedFunctionPrototypes
+    Display*            /* display */
+#endif
+);
+
+extern int NXCollectInputFocus(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */
+#endif
+);
+
+extern int NXGetCollectedInputFocus(
+#if NeedFunctionPrototypes
+    Display*            /* display */,
+    unsigned int        /* resource */,
+    Window*             /* focus_return */,
+    int*                /* revert_to_return */
+#endif
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NXlib_H */