/**************************************************************************** * 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 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 #include #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