596 lines
20 KiB
C
596 lines
20 KiB
C
/****************************************************************************
|
|
* NCSA Mosaic for the X Window System *
|
|
* Software Development Group *
|
|
* National Center for Supercomputing Applications *
|
|
* University of Illinois at Urbana-Champaign *
|
|
* 605 E. Springfield, Champaign IL 61820 *
|
|
* mosaic@ncsa.uiuc.edu *
|
|
* *
|
|
* Copyright (C) 1993, Board of Trustees of the University of Illinois *
|
|
* *
|
|
* NCSA Mosaic software, both binary and source (hereafter, Software) is *
|
|
* copyrighted by The Board of Trustees of the University of Illinois *
|
|
* (UI), and ownership remains with the UI. *
|
|
* *
|
|
* The UI grants you (hereafter, Licensee) a license to use the Software *
|
|
* for academic, research and internal business purposes only, without a *
|
|
* fee. Licensee may distribute the binary and source code (if released) *
|
|
* to third parties provided that the copyright notice and this statement *
|
|
* appears on all copies and that no charge is associated with such *
|
|
* copies. *
|
|
* *
|
|
* Licensee may make derivative works. However, if Licensee distributes *
|
|
* any derivative work based on or derived from the Software, then *
|
|
* Licensee will (1) notify NCSA regarding its distribution of the *
|
|
* derivative work, and (2) clearly notify users that such derivative *
|
|
* work is a modified version and not the original NCSA Mosaic *
|
|
* distributed by the UI. *
|
|
* *
|
|
* Any Licensee wishing to make commercial use of the Software should *
|
|
* contact the UI, c/o NCSA, to negotiate an appropriate license for such *
|
|
* commercial use. Commercial use includes (1) integration of all or *
|
|
* part of the source code into a product for sale or license by or on *
|
|
* behalf of Licensee to third parties, or (2) distribution of the binary *
|
|
* code or source code to third parties that need it to utilize a *
|
|
* commercial product sold or licensed by or on behalf of Licensee. *
|
|
* *
|
|
* UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR *
|
|
* ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED *
|
|
* WARRANTY. THE UI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE *
|
|
* USERS OF THIS SOFTWARE. *
|
|
* *
|
|
* By using or copying this Software, Licensee agrees to abide by the *
|
|
* copyright law and all other applicable laws of the U.S. including, but *
|
|
* not limited to, export control laws, and the terms of this license. *
|
|
* UI shall have the right to terminate this license immediately by *
|
|
* written notice upon Licensee's breach of, or non-compliance with, any *
|
|
* of its terms. Licensee may be held legally responsible for any *
|
|
* copyright infringement that is caused or encouraged by Licensee's *
|
|
* failure to abide by the terms of this license. *
|
|
* *
|
|
* Comments and questions are welcome and can be sent to *
|
|
* mosaic-x@ncsa.uiuc.edu. *
|
|
****************************************************************************/
|
|
/*
|
|
* The following XPM header file is based on the libXpm code, which I
|
|
* am free to use as long as I include the following copyright:
|
|
*/
|
|
/*
|
|
* Copyright 1990-93 GROUPE BULL
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software and its
|
|
* documentation for any purpose and without fee is hereby granted, provided
|
|
* that the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of GROUPE BULL not be used in advertising
|
|
* or publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. GROUPE BULL makes no representations about the
|
|
* suitability of this software for any purpose. It is provided "as is"
|
|
* without express or implied warranty.
|
|
*
|
|
* GROUPE BULL disclaims all warranties with regard to this software,
|
|
* including all implied warranties of merchantability and fitness,
|
|
* in no event shall GROUPE BULL be liable for any special,
|
|
* indirect or consequential damages or any damages
|
|
* whatsoever resulting from loss of use, data or profits,
|
|
* whether in an action of contract, negligence or other tortious
|
|
* action, arising out of or in connection with the use
|
|
* or performance of this software.
|
|
*
|
|
*/
|
|
|
|
#ifndef XPM_h
|
|
#define XPM_h
|
|
|
|
#ifdef VMS
|
|
#include "sys$library:stdio.h"
|
|
#else
|
|
#include <stdio.h>
|
|
/* stdio.h doesn't declare popen on a Sequent DYNIX OS */
|
|
#ifdef sequent
|
|
extern FILE *popen();
|
|
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef VMS
|
|
#include "decw$include:Xlib.h"
|
|
#include "decw$include:Xutil.h"
|
|
#else
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
#endif
|
|
|
|
/* let's define Pixel if it is not done yet */
|
|
#ifndef _XtIntrinsic_h
|
|
typedef unsigned long Pixel; /* Index into colormap */
|
|
#endif
|
|
|
|
/* Return ErrorStatus codes:
|
|
* null if full success
|
|
* positive if partial success
|
|
* negative if failure
|
|
*/
|
|
|
|
#define XpmColorError 1
|
|
#define XpmSuccess 0
|
|
#define XpmOpenFailed -1
|
|
#define XpmFileInvalid -2
|
|
#define XpmNoMemory -3
|
|
#define XpmColorFailed -4
|
|
|
|
/* the following should help people wanting to use their own functions */
|
|
#define XpmFree(ptr) free(ptr)
|
|
|
|
typedef struct {
|
|
char *name; /* Symbolic color name */
|
|
char *value; /* Color value */
|
|
Pixel pixel; /* Color pixel */
|
|
} XpmColorSymbol;
|
|
|
|
typedef struct {
|
|
char *name; /* name of the extension */
|
|
unsigned int nlines; /* number of lines in this extension */
|
|
char **lines; /* pointer to the extension array of
|
|
* strings */
|
|
} XpmExtension;
|
|
|
|
typedef struct {
|
|
unsigned long valuemask; /* Specifies which attributes are
|
|
* defined */
|
|
|
|
Visual *visual; /* Specifies the visual to use */
|
|
Colormap colormap; /* Specifies the colormap to use */
|
|
unsigned int depth; /* Specifies the depth */
|
|
unsigned int width; /* Returns the width of the created
|
|
* pixmap */
|
|
unsigned int height; /* Returns the height of the created
|
|
* pixmap */
|
|
unsigned int x_hotspot; /* Returns the x hotspot's
|
|
* coordinate */
|
|
unsigned int y_hotspot; /* Returns the y hotspot's
|
|
* coordinate */
|
|
unsigned int cpp; /* Specifies the number of char per
|
|
* pixel */
|
|
Pixel *pixels; /* List of used color pixels */
|
|
unsigned int npixels; /* Number of pixels */
|
|
XpmColorSymbol *colorsymbols; /* Array of color symbols to
|
|
* override */
|
|
unsigned int numsymbols; /* Number of symbols */
|
|
char *rgb_fname; /* RGB text file name */
|
|
unsigned int nextensions; /* number of extensions */
|
|
XpmExtension *extensions; /* pointer to array of extensions */
|
|
|
|
/* Infos */
|
|
unsigned int ncolors; /* Number of colors */
|
|
char ***colorTable; /* Color table pointer */
|
|
char *hints_cmt; /* Comment of the hints section */
|
|
char *colors_cmt; /* Comment of the colors section */
|
|
char *pixels_cmt; /* Comment of the pixels section */
|
|
unsigned int mask_pixel; /* Transparent pixel's color table
|
|
* index */
|
|
/* Color Allocation Directives */
|
|
unsigned int exactColors; /* Only use exact colors for visual */
|
|
unsigned int closeness; /* Allowable RGB deviation */
|
|
unsigned int red_closeness; /* Allowable red deviation */
|
|
unsigned int green_closeness; /* Allowable green deviation */
|
|
unsigned int blue_closeness; /* Allowable blue deviation */
|
|
int color_key; /* Use colors from this color set */
|
|
|
|
} XpmAttributes;
|
|
|
|
/* Xpm attribute value masks bits */
|
|
#define XpmVisual (1L<<0)
|
|
#define XpmColormap (1L<<1)
|
|
#define XpmDepth (1L<<2)
|
|
#define XpmSize (1L<<3) /* width & height */
|
|
#define XpmHotspot (1L<<4) /* x_hotspot & y_hotspot */
|
|
#define XpmCharsPerPixel (1L<<5)
|
|
#define XpmColorSymbols (1L<<6)
|
|
#define XpmRgbFilename (1L<<7)
|
|
#define XpmInfos (1L<<8) /* all infos members */
|
|
#define XpmExtensions (1L<<10)
|
|
|
|
#define XpmReturnPixels (1L<<9)
|
|
#define XpmReturnInfos XpmInfos
|
|
#define XpmReturnExtensions XpmExtensions
|
|
|
|
#define XpmExactColors (1L<<11)
|
|
#define XpmCloseness (1L<<12)
|
|
#define XpmRGBCloseness (1L<<13)
|
|
#define XpmColorKey (1L<<14)
|
|
|
|
/*
|
|
* color keys for visual type, they must match those defined in xpmP.h
|
|
*/
|
|
#define XPM_MONO 2
|
|
#define XPM_GREY4 3
|
|
#define XPM_GRAY4 3
|
|
#define XPM_GREY 4
|
|
#define XPM_GRAY 4
|
|
#define XPM_COLOR 5
|
|
|
|
/*
|
|
* minimal portability layer between ansi and KR C
|
|
*/
|
|
|
|
/* forward declaration of functions with prototypes */
|
|
|
|
#if __STDC__ || defined(__cplusplus) || defined(c_plusplus)
|
|
/* ANSI || C++ */
|
|
#define FUNC(f, t, p) extern t f p
|
|
#define LFUNC(f, t, p) static t f p
|
|
#else /* K&R */
|
|
#define FUNC(f, t, p) extern t f()
|
|
#define LFUNC(f, t, p) static t f()
|
|
#endif /* end of K&R */
|
|
|
|
|
|
/*
|
|
* functions declarations
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
FUNC(XpmCreatePixmapFromData, int, (Display *display,
|
|
Drawable d,
|
|
char **data,
|
|
Pixmap *pixmap_return,
|
|
Pixmap *shapemask_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateDataFromPixmap, int, (Display *display,
|
|
char ***data_return,
|
|
Pixmap pixmap,
|
|
Pixmap shapemask,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmReadFileToPixmap, int, (Display *display,
|
|
Drawable d,
|
|
char *filename,
|
|
Pixmap *pixmap_return,
|
|
Pixmap *shapemask_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmWriteFileFromPixmap, int, (Display *display,
|
|
char *filename,
|
|
Pixmap pixmap,
|
|
Pixmap shapemask,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateImageFromData, int, (Display *display,
|
|
char **data,
|
|
XImage **image_return,
|
|
XImage **shapemask_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateDataFromImage, int, (Display *display,
|
|
char ***data_return,
|
|
XImage *image,
|
|
XImage *shapeimage,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmReadFileToImage, int, (Display *display,
|
|
char *filename,
|
|
XImage **image_return,
|
|
XImage **shapeimage_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmWriteFileFromImage, int, (Display *display,
|
|
char *filename,
|
|
XImage *image,
|
|
XImage *shapeimage,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateImageFromBuffer, int, (Display *display,
|
|
char *buffer,
|
|
XImage **image_return,
|
|
XImage **shapemask_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreatePixmapFromBuffer, int, (Display *display,
|
|
Drawable d,
|
|
char *buffer,
|
|
Pixmap *pixmap_return,
|
|
Pixmap *shapemask_return,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateBufferFromImage, int, (Display *display,
|
|
char **buffer_return,
|
|
XImage *image,
|
|
XImage *shapeimage,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmCreateBufferFromPixmap, int, (Display *display,
|
|
char **buffer_return,
|
|
Pixmap pixmap,
|
|
Pixmap shapemask,
|
|
XpmAttributes *attributes));
|
|
|
|
FUNC(XpmReadFileToBuffer, int, (char *filename, char **buffer_return));
|
|
FUNC(XpmWriteFileFromBuffer, int, (char *filename, char *buffer));
|
|
|
|
FUNC(XpmReadFileToData, int, (char *filename, char ***data_return));
|
|
FUNC(XpmWriteFileFromData, int, (char *filename, char **data));
|
|
|
|
FUNC(XpmAttributesSize, int, ());
|
|
FUNC(XpmFreeAttributes, void, (XpmAttributes *attributes));
|
|
FUNC(XpmFreeExtensions, void, (XpmExtension *extensions,
|
|
int nextensions));
|
|
|
|
#ifdef __cplusplus
|
|
} /* for C++ V2.0 */
|
|
#endif
|
|
|
|
|
|
/* backward compatibility */
|
|
|
|
/* for version 3.0c */
|
|
#define XpmPixmapColorError XpmColorError
|
|
#define XpmPixmapSuccess XpmSuccess
|
|
#define XpmPixmapOpenFailed XpmOpenFailed
|
|
#define XpmPixmapFileInvalid XpmFileInvalid
|
|
#define XpmPixmapNoMemory XpmNoMemory
|
|
#define XpmPixmapColorFailed XpmColorFailed
|
|
|
|
#define XpmReadPixmapFile(dpy, d, file, pix, mask, att) \
|
|
XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
|
|
#define XpmWritePixmapFile(dpy, file, pix, mask, att) \
|
|
XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
|
|
|
|
/* for version 3.0b */
|
|
#define PixmapColorError XpmColorError
|
|
#define PixmapSuccess XpmSuccess
|
|
#define PixmapOpenFailed XpmOpenFailed
|
|
#define PixmapFileInvalid XpmFileInvalid
|
|
#define PixmapNoMemory XpmNoMemory
|
|
#define PixmapColorFailed XpmColorFailed
|
|
|
|
#define ColorSymbol XpmColorSymbol
|
|
|
|
#define XReadPixmapFile(dpy, d, file, pix, mask, att) \
|
|
XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
|
|
#define XWritePixmapFile(dpy, file, pix, mask, att) \
|
|
XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
|
|
#define XCreatePixmapFromData(dpy, d, data, pix, mask, att) \
|
|
XpmCreatePixmapFromData(dpy, d, data, pix, mask, att)
|
|
#define XCreateDataFromPixmap(dpy, data, pix, mask, att) \
|
|
XpmCreateDataFromPixmap(dpy, data, pix, mask, att)
|
|
|
|
|
|
/* the following should help people wanting to use their own functions */
|
|
#define XpmMalloc(size) malloc((size))
|
|
#define XpmRealloc(ptr, size) realloc((ptr), (size))
|
|
#define XpmCalloc(nelem, elsize) calloc((nelem), (elsize))
|
|
|
|
|
|
typedef struct {
|
|
unsigned int type;
|
|
union {
|
|
FILE *file;
|
|
char **data;
|
|
} stream;
|
|
char *cptr;
|
|
unsigned int line;
|
|
int CommentLength;
|
|
char Comment[BUFSIZ];
|
|
char *Bcmt, *Ecmt, Bos, Eos;
|
|
} xpmData;
|
|
|
|
#define XPMARRAY 0
|
|
#define XPMFILE 1
|
|
#define XPMPIPE 2
|
|
#define XPMBUFFER 3
|
|
|
|
typedef unsigned char byte;
|
|
|
|
#define EOL '\n'
|
|
#define TAB '\t'
|
|
#define SPC ' '
|
|
|
|
typedef struct {
|
|
char *type; /* key word */
|
|
char *Bcmt; /* string beginning comments */
|
|
char *Ecmt; /* string ending comments */
|
|
char Bos; /* character beginning strings */
|
|
char Eos; /* character ending strings */
|
|
char *Strs; /* strings separator */
|
|
char *Dec; /* data declaration string */
|
|
char *Boa; /* string beginning assignment */
|
|
char *Eoa; /* string ending assignment */
|
|
} xpmDataType;
|
|
|
|
extern xpmDataType xpmDataTypes[];
|
|
|
|
/*
|
|
* rgb values and ascii names (from rgb text file) rgb values,
|
|
* range of 0 -> 65535 color mnemonic of rgb value
|
|
*/
|
|
typedef struct {
|
|
int r, g, b;
|
|
char *name;
|
|
} xpmRgbName;
|
|
|
|
/* Maximum number of rgb mnemonics allowed in rgb text file. */
|
|
#define MAX_RGBNAMES 1024
|
|
|
|
extern char *xpmColorKeys[];
|
|
|
|
#define TRANSPARENT_COLOR "None" /* this must be a string! */
|
|
|
|
/* number of xpmColorKeys */
|
|
#define NKEYS 5
|
|
|
|
/*
|
|
* key numbers for visual type, they must fit along with the number key of
|
|
* each corresponding element in xpmColorKeys[] defined in xpm.h
|
|
*/
|
|
#define MONO 2
|
|
#define GRAY4 3
|
|
#define GRAY 4
|
|
#define COLOR 5
|
|
|
|
/* structure containing data related to an Xpm pixmap */
|
|
typedef struct {
|
|
char *name;
|
|
unsigned int width;
|
|
unsigned int height;
|
|
unsigned int cpp;
|
|
unsigned int ncolors;
|
|
char ***colorTable;
|
|
unsigned int *pixelindex;
|
|
XColor *xcolors;
|
|
char **colorStrings;
|
|
unsigned int mask_pixel; /* mask pixel's colorTable index */
|
|
} xpmInternAttrib;
|
|
|
|
#define UNDEF_PIXEL 0x80000000
|
|
|
|
/* XPM private routines */
|
|
|
|
FUNC(xpmWriteData, int, (xpmData * mdata,
|
|
xpmInternAttrib * attrib, XpmAttributes * attributes));
|
|
|
|
FUNC(xpmCreateData, int, (char ***data_return,
|
|
xpmInternAttrib * attrib, XpmAttributes * attributes));
|
|
|
|
FUNC(xpmCreateImage, int, (Display * display,
|
|
xpmInternAttrib * attrib,
|
|
XImage ** image_return,
|
|
XImage ** shapeimage_return,
|
|
XpmAttributes * attributes));
|
|
|
|
FUNC(xpmParseData, int, (xpmData * data,
|
|
xpmInternAttrib * attrib_return,
|
|
XpmAttributes * attributes));
|
|
|
|
FUNC(xpmScanImage, int, (Display * display,
|
|
XImage * image,
|
|
XImage * shapeimage,
|
|
XpmAttributes * attributes,
|
|
xpmInternAttrib * attrib));
|
|
|
|
FUNC(xpmFreeColorTable, void, (char ***colorTable, int ncolors));
|
|
|
|
FUNC(xpmInitInternAttrib, void, (xpmInternAttrib * xmpdata));
|
|
|
|
FUNC(xpmFreeInternAttrib, void, (xpmInternAttrib * xmpdata));
|
|
|
|
FUNC(xpmSetAttributes, void, (xpmInternAttrib * attrib,
|
|
XpmAttributes * attributes));
|
|
|
|
FUNC(xpmInitAttributes, void, (XpmAttributes * attributes));
|
|
|
|
/* I/O utility */
|
|
|
|
FUNC(xpmNextString, int, (xpmData * mdata));
|
|
FUNC(xpmNextUI, int, (xpmData * mdata, unsigned int *ui_return));
|
|
FUNC(xpmGetString, int, (xpmData * mdata, char **sptr, unsigned int *l));
|
|
|
|
#define xpmGetC(mdata) \
|
|
((!mdata->type || mdata->type == XPMBUFFER) ? \
|
|
(*mdata->cptr++) : (getc(mdata->stream.file)))
|
|
|
|
FUNC(xpmNextWord, unsigned int, (xpmData * mdata, char *buf));
|
|
FUNC(xpmGetCmt, int, (xpmData * mdata, char **cmt));
|
|
FUNC(xpmReadFile, int, (char *filename, xpmData * mdata));
|
|
FUNC(xpmWriteFile, int, (char *filename, xpmData * mdata));
|
|
FUNC(xpmOpenArray, void, (char **data, xpmData * mdata));
|
|
FUNC(xpmDataClose, int, (xpmData * mdata));
|
|
FUNC(xpmParseHeader, int, (xpmData * mdata));
|
|
FUNC(xpmOpenBuffer, void, (char *buffer, xpmData * mdata));
|
|
|
|
/* RGB utility */
|
|
|
|
FUNC(xpmReadRgbNames, int, (char *rgb_fname, xpmRgbName * rgbn));
|
|
FUNC(xpmGetRgbName, char *, (xpmRgbName * rgbn, int rgbn_max,
|
|
int red, int green, int blue));
|
|
FUNC(xpmFreeRgbNames, void, (xpmRgbName * rgbn, int rgbn_max));
|
|
|
|
FUNC(xpm_xynormalizeimagebits, void, (register unsigned char *bp,
|
|
register XImage * img));
|
|
FUNC(xpm_znormalizeimagebits, void, (register unsigned char *bp,
|
|
register XImage * img));
|
|
|
|
/*
|
|
* Macros
|
|
*
|
|
* The XYNORMALIZE macro determines whether XY format data requires
|
|
* normalization and calls a routine to do so if needed. The logic in
|
|
* this module is designed for LSBFirst byte and bit order, so
|
|
* normalization is done as required to present the data in this order.
|
|
*
|
|
* The ZNORMALIZE macro performs byte and nibble order normalization if
|
|
* required for Z format data.
|
|
*
|
|
* The XYINDEX macro computes the index to the starting byte (char) boundary
|
|
* for a bitmap_unit containing a pixel with coordinates x and y for image
|
|
* data in XY format.
|
|
*
|
|
* The ZINDEX* macros compute the index to the starting byte (char) boundary
|
|
* for a pixel with coordinates x and y for image data in ZPixmap format.
|
|
*
|
|
*/
|
|
|
|
#define XYNORMALIZE(bp, img) \
|
|
if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \
|
|
xpm_xynormalizeimagebits((unsigned char *)(bp), img)
|
|
|
|
#define ZNORMALIZE(bp, img) \
|
|
if (img->byte_order == MSBFirst) \
|
|
xpm_znormalizeimagebits((unsigned char *)(bp), img)
|
|
|
|
#define XYINDEX(x, y, img) \
|
|
((y) * img->bytes_per_line) + \
|
|
(((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)
|
|
|
|
#define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \
|
|
(((x) * img->bits_per_pixel) >> 3)
|
|
|
|
#define ZINDEX32(x, y, img) ((y) * img->bytes_per_line) + ((x) << 2)
|
|
|
|
#define ZINDEX16(x, y, img) ((y) * img->bytes_per_line) + ((x) << 1)
|
|
|
|
#define ZINDEX8(x, y, img) ((y) * img->bytes_per_line) + (x)
|
|
|
|
#define ZINDEX1(x, y, img) ((y) * img->bytes_per_line) + ((x) >> 3)
|
|
|
|
#if __STDC__
|
|
#define Const const
|
|
#else
|
|
#define Const /**/
|
|
#endif
|
|
|
|
/*
|
|
* there are structures and functions related to hastable code
|
|
*/
|
|
|
|
typedef struct _xpmHashAtom {
|
|
char *name;
|
|
void *data;
|
|
} *xpmHashAtom;
|
|
|
|
typedef struct {
|
|
int size;
|
|
int limit;
|
|
int used;
|
|
xpmHashAtom *atomTable;
|
|
} xpmHashTable;
|
|
|
|
FUNC(xpmHashTableInit, int, (xpmHashTable * table));
|
|
FUNC(xpmHashTableFree, void, (xpmHashTable * table));
|
|
FUNC(xpmHashSlot, xpmHashAtom *, (xpmHashTable * table, char *s));
|
|
FUNC(xpmHashIntern, int, (xpmHashTable * table, char *tag, void *data));
|
|
|
|
#define HashAtomData(i) ((void *)i)
|
|
#define HashColorIndex(slot) ((unsigned int)((*slot)->data))
|
|
#define USE_HASHTABLE (cpp > 2 && ncolors > 4)
|
|
|
|
#ifdef NEED_STRDUP
|
|
FUNC(strdup, char *, (char *s1));
|
|
#endif
|
|
|
|
#endif
|