home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1715 < prev    next >
Encoding:
Text File  |  1990-12-28  |  82.6 KB  |  2,680 lines
  1. Newsgroups: alt.sources
  2. From: lehors@modja.inria.fr (Arnaud Le Hors)
  3. Subject: [xpert] XPM2 The new XPM version (source files).
  4. Message-ID: <1990Aug25.221607.11150@math.lsa.umich.edu>
  5. Date: Sat, 25 Aug 90 22:16:07 GMT
  6.  
  7. Archive-name: xpm2/25-Aug-90
  8. Original-posting-by: lehors@modja.inria.fr (Arnaud Le Hors)
  9. Original-subject: XPM2 The new XPM version (source files).
  10. Reposted-by: emv@math.lsa.umich.edu (Edward Vielmetti)
  11.  
  12. [Reposted from comp.windows.x.
  13. Comments on this service to emv@math.lsa.umich.edu (Edward Vielmetti).]
  14.  
  15. Here goes the first  distribution of the new version of XPM.
  16.  
  17. XPM (X PixMap) is a format for storing/retrieving X pixmaps to/from ascii 
  18. files. 
  19.  
  20. Here is provided a library containing a set of three functions, similar to the
  21. X bitmap functions as defined in the Xlib: XCreatePixmapFromData,
  22. XReadPixmapFile and XWritePixmapFile for respectively including, reading and
  23. writing this format.
  24.  
  25. This new version provides different types of format: a natural one which will
  26. be preferably used for manual editing (with emacs, vi, ...), a C includable
  27. format and a Lisp includable format. It provides defaults for different types
  28. of display: monochrome/color/grayscale, and symbol names for colors for
  29. overriding default colors when creating the pixmap. Finally it provides a
  30. structure for storing information while reading a file which is re-used while
  31. writing. This way comments, default colors and symbol names aren't lost.
  32.  
  33. Follows the shar file containing all the source files needed for building the 
  34. XPM2 library, the manual (xpm.tex file), and a demo.
  35.  
  36. I hope this will be useful to you. Please let me know your feelings.
  37.  
  38. --
  39.    Arnaud LE HORS
  40.    BULL Research FRANCE -- Koala Project   |    Email : lehors@mirsa.inria.fr
  41.          Inria - Sophia Antipolis          |    Phone : (33) 93 65 77 71
  42.          2004, Route des Lucioles          |    Telex :      97 00 50 F
  43.          06565 Valbonne CEDEX  France      |    Fax   : (33) 93 65 77 66
  44.  
  45. --
  46. #!/bin/sh
  47. # This is a shell archive. To unpack its contents, do "sh <this-file>"
  48. cat > COPYRIGHT << \END_OF_SHAR_FOR_COPYRIGHT
  49. /*
  50.  * Copyright 1990 GROUPE BULL
  51.  *
  52.  * Permission to use, copy, modify, and distribute this software and its
  53.  * documentation for any purpose and without fee is hereby granted, provided
  54.  * that the above copyright notice appear in all copies and that both that
  55.  * copyright notice and this permission notice appear in supporting
  56.  * documentation, and that the name of GROUPE BULL not be used in advertising
  57.  * or publicity pertaining to distribution of the software without specific,
  58.  * written prior permission.  GROUPE BULL makes no representations about the
  59.  * suitability of this software for any purpose.  It is provided "as is"
  60.  * without express or implied warranty.
  61.  *
  62.  * GROUPE BULL disclaims all warranties with regard to this software,
  63.  * including all implied warranties of merchantability and fitness,
  64.  * in no event shall GROUPE BULL be liable for any special,
  65.  * indirect or consequential damages or any damages
  66.  * whatsoever resulting from loss of use, data or profits,
  67.  * whether in an action of contract, negligence or other tortious
  68.  * action, arising out of or in connection with the use 
  69.  * or performance of this software.
  70.  *
  71.  */
  72.  
  73. Arnaud LE HORS      BULL Research FRANCE -- Koala Project 
  74.                     (XPM2 - X PixMap format version 2)
  75.     Internet:       lehors@mirsa.inria.fr
  76. Surface Mail:       Arnaud LE HORS, INRIA - Sophia Antipolis, 
  77.                     2004, route des Lucioles, 06565 Valbonne Cedex -- FRANCE
  78.  Voice phone:       (33) 93.65.77.71, Fax: (33) 93 65 77 66, Telex: 97 00 50 F
  79. END_OF_SHAR_FOR_COPYRIGHT
  80. cat > Makefile << \END_OF_SHAR_FOR_Makefile
  81. # Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT
  82. #
  83. # XPM Makefile - Arnaud LE HORS
  84. # $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  85. #
  86.  
  87. AR = ar r
  88. CC = cc
  89. RANLIB = ranlib
  90. RM = rm -f
  91.  
  92. CFLAGS=
  93.  
  94. LIBDIRS= -L/usr/lib/X11 -L.
  95. LIBS= -lXPM2 -lX11
  96. OBJS= mio.o value.o create.o visual.o free.o XWrPixF.o XRdPixF.o XCrPFData.o
  97.  
  98. all: demo
  99.  
  100. clean: 
  101.     $(RM) *.o demo libXPM2.a
  102.  
  103. demo: libXPM2.a demo.o
  104.     $(CC) $(CFLAGS) demo.o $(LIBDIRS) $(LIBS) -o demo
  105.  
  106. libXPM2.a: $(OBJS)
  107.     $(AR) libXPM2.a $(OBJS)
  108.     $(RANLIB) libXPM2.a
  109. END_OF_SHAR_FOR_Makefile
  110. cat > README << \END_OF_SHAR_FOR_README
  111. $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  112.  
  113.                 XPM Version 2
  114.  
  115. WHAT IS XPM?
  116. ============
  117.  
  118. XPM (X PixMap) is a format for storing/retrieving X pixmaps to/from ascii
  119. files.
  120.  
  121. Here is provided a library containing a set of three functions, similar to the
  122. X bitmap functions as defined in the Xlib: XCreatePixmapFromData,
  123. XReadPixmapFile and XWritePixmapFile for respectively including, reading and
  124. writing this format.
  125.  
  126. This new version provides different types of format: a natural one which will
  127. be preferably used for manual editing (with emacs, vi, ...), a C includable
  128. format and a Lisp includable format. It provides defaults for different types
  129. of display: monochrome/color/grayscale, and symbol names for colors for
  130. overriding default colors when creating the pixmap. Finally it provides a
  131. structure for storing information while reading a file which is re-used while
  132. writing. This way comments, default colors and symbol names aren't lost.
  133.  
  134. See the XPM Manual for more details.
  135.  
  136. INSTALLATION:
  137. ============
  138.  
  139. To obtain the XPM library, first execute the shell archive file in an
  140. approriate directory. Then just do:
  141.  
  142.               make all 
  143.        or          make libxpm.a
  144.  
  145. NOTE:   if you compile  with gcc, use "gcc -traditional", otherwise you will
  146.         have compilation warnings (but the code will work Ok)
  147.  
  148. DEMO:
  149. ====
  150.  
  151. In addition to the library a demo is provided. If you have previously done 
  152. 'make all' you should have it yet, otherwise just do:
  153.  
  154.               make demo
  155.  
  156. This demo shows you all the features of XPM and the three provided functions.
  157.  
  158. By executing 'demo' without any option you will see a demo of the 
  159. XCreatePixmapFromData function. The pixmap is created from the static variable
  160. plaid defined in the demo.c file. Demo will end when you click in the created
  161. window.
  162.  
  163. Executing 'demo -s lines_in_mix blue' will show the feature of color symbols.
  164.  
  165. Then you should try 'demo -o output' to get an output file using the
  166. XWritePixmapFile function. This is a natural type format file, other types can
  167. be obtained by adding the option '-t C' or '-t Lisp'.
  168.  
  169. To end you should try 'demo -i plaid' or 'demo -i plaid_c' or 
  170. 'demo -i plaid_ll' to use the XReadPixmapFile function.
  171.  
  172. Of course, other combinations are allowed and should be tried. Thus, 
  173. 'demo -i plaid -o output -t C' will show you how a natural type format is
  174. translated to a C type format.
  175.  
  176. The XCreatePixmapFromData function is on purpose called without any Xpminfo 
  177. pointer to show the utility of this one. Indeed, compare the color section of
  178. the two files foo and bar obtained from 'demo -o foo' and 
  179. 'demo -i plaid -o bar'.
  180.  
  181. KNOWN BUG:
  182. =========
  183.  
  184. XWritePixmapFile:
  185. Writing out multilines comment to a single line comment is not handled. Thus,
  186. translating a C multilines comment to Lisp will result to an invalid file.
  187.  
  188. DISCUSSION:
  189. ==========
  190.  
  191. Any discussion should be made on the comp.windows.x newsgroup. The subject
  192. line will preferably begin by the word XPM.
  193.  
  194. COPYRIGHT:
  195. ==========
  196.  
  197.   Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT
  198.   See the COPYRIGHT file in the XPM distribution
  199.  
  200. Please mail any bug reports or modifications done, comments, suggestions,
  201. requests for updates or patches to port on another machine to:
  202.  
  203. lehors@mirsa.inria.fr        (INTERNET)
  204.  
  205. 33 (FRANCE) 93.65.77.71        (VOICE PHONE)
  206.  
  207. Arnaud Le Hors            (SURFACE MAIL)
  208. INRIA
  209. 2004, Route des lucioles
  210. Sophia Antipolis
  211. 06565 VALBONNE
  212. FRANCE
  213. END_OF_SHAR_FOR_README
  214. cat > XCrPFData.c << \END_OF_SHAR_FOR_XCrPFData.c
  215. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  216. /* XCrPFData.c:
  217.  *
  218.  *  XPM2
  219.  *  Create from Data utility for XPM2 file format
  220.  *  Developped by Arnaud Le Hors
  221.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  222.  */
  223.  
  224. #include "xpmP.h"
  225.  
  226. int XCreatePixmapFromData(display, visual, d, colormap, data, depth,
  227.               pixmap_return, width_return, height_return, 
  228.               pixels_return, npixels_return,
  229.               colorsymbols, numsymbols, infos)
  230.      Display *display;
  231.      Visual *visual;
  232.      Drawable d;
  233.      Colormap colormap;
  234.      char **data;
  235.      unsigned int depth;
  236.      Pixmap *pixmap_return;
  237.      unsigned int *width_return, *height_return, *npixels_return;
  238.      Pixel **pixels_return;
  239.      ColorSymbol colorsymbols[];
  240.      unsigned int numsymbols;
  241.      XpmInfo *infos;
  242.  
  243. { MData *mdata;
  244.  
  245.   *width_return = *height_return = 0;
  246.   if (! (mdata = (MData *)malloc(sizeof(MData)))) { 
  247.       XpmErrorStatus = PixmapNoMemory;
  248.       return(NULL);
  249.   }
  250.   mdata->type = MARRAY;
  251.   mdata->stream = (void*) data;
  252.   mdata->cptr = *data;
  253.   mdata->line = 0;
  254.   XpmErrorStatus = PixmapSuccess;
  255.   *pixmap_return = CreatePixmap(display, visual, d, colormap, mdata, depth,
  256.                 width_return, height_return, 
  257.                 pixels_return, npixels_return,
  258.                 colorsymbols, numsymbols, infos);
  259.   free(mdata);
  260.   return(XpmErrorStatus);
  261. }
  262. END_OF_SHAR_FOR_XCrPFData.c
  263. cat > XRdPixF.c << \END_OF_SHAR_FOR_XRdPixF.c
  264. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  265. /* XRdPixF.c:
  266.  *
  267.  *  XPM2
  268.  *  Read utility for XPM2 file format
  269.  *  Developped by Arnaud Le Hors
  270.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  271.  */
  272.  
  273. #include "xpmP.h"
  274.  
  275. int XReadPixmapFile(display, visual, d, colormap, filename, depth, 
  276.             pixmap_return, width_return, height_return, 
  277.             pixels_return, npixels_return,
  278.             colorsymbols, numsymbols, infos)
  279.      Display *display;
  280.      Visual *visual;
  281.      Drawable d;
  282.      Colormap colormap;
  283.      char *filename;
  284.      unsigned int depth;
  285.      Pixmap *pixmap_return;
  286.      unsigned int *width_return, *height_return, *npixels_return;
  287.      Pixel **pixels_return;
  288.      ColorSymbol colorsymbols[];
  289.      unsigned int numsymbols;
  290.      XpmInfo *infos;
  291.  
  292. { MData *mdata;
  293.   char buf[BUFSIZ];
  294.   int l, n = 0;
  295.  
  296.   *pixmap_return = NULL;
  297.   *width_return = *height_return = 0;
  298.   XpmErrorStatus = PixmapSuccess;
  299.  
  300.   if (! (mdata = (MData *)malloc(sizeof(MData)))) {
  301.       return(XpmErrorStatus = PixmapNoMemory);
  302.   }
  303.   mdata->type = MFILE;
  304.   if (! (mdata->stream = (void*) fopen(filename, "r"))) {
  305.       free(mdata);
  306.       return(XpmErrorStatus = PixmapOpenFailed);
  307.   }
  308.   mdata->cptr = NULL;
  309.   mdata->line = 0;
  310.  
  311.   /* parse the header file
  312.    */
  313.   BOS = '\0';
  314.   EOS = '\n';
  315.   BCMT = ECMT = NULL;
  316.   l = mnextw(mdata, buf);    /* skip the first word */
  317.   l = mnextw(mdata, buf);    /* then get the second word */
  318.   if (l == 4 && !strncmp("XPM2", buf, 4)) {
  319.       l = mnextw(mdata, buf);    /* get the type key word */
  320.  
  321.      /* get infos about this type
  322.        */
  323.       while (DataTypes[n].type && strncmp(DataTypes[n].type, buf, l)) n++;
  324.       if (DataTypes[n].type) {
  325.       if (infos) {
  326.           infos->type = (char *) malloc(l+1);
  327.           strncpy(infos->type, buf, l);
  328.           infos->type[l] = '\0';
  329.       }
  330.       if (n == 0) {        /* natural type */
  331.           BCMT = DataTypes[n].Bcmt;
  332.           ECMT = DataTypes[n].Ecmt;
  333.           mnextstring(mdata);    /* skip the end of headerline */
  334.           BOS = DataTypes[n].Bos;
  335.       } else {
  336.           mnextstring(mdata);    /* skip the end of headerline */
  337.           BCMT = DataTypes[n].Bcmt;
  338.           ECMT = DataTypes[n].Ecmt;
  339.           BOS = DataTypes[n].Bos;
  340.           mnextstring(mdata);    /* skip the assignment line */
  341.       }
  342.       EOS = DataTypes[n].Eos;
  343.  
  344.       *pixmap_return = CreatePixmap(display, visual, d, colormap, mdata,
  345.                     depth, width_return, height_return,
  346.                     pixels_return, npixels_return,
  347.                     colorsymbols, numsymbols, infos);
  348.       } else {
  349.       XpmErrorStatus = PixmapFileInvalid;
  350.       }
  351.   } else {
  352.       XpmErrorStatus = PixmapFileInvalid;
  353.   }
  354.   fclose((FILE *) mdata->stream);
  355.   free(mdata);
  356.   return(XpmErrorStatus);
  357. }
  358. END_OF_SHAR_FOR_XRdPixF.c
  359. cat > XWrPixF.c << \END_OF_SHAR_FOR_XWrPixF.c
  360. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  361. /*
  362.  *  XPM2
  363.  *  Write utility for XPM2 file format
  364.  *  Developped by Arnaud Le Hors
  365.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  366.  */
  367.  
  368. #include "xpmP.h"
  369. #include <strings.h>
  370.  
  371. #undef RETURN
  372. #define RETURN(status) \
  373.   { if (index) free(index); \
  374.     if (colorStrings) { \
  375.     for (a = 0; a < ncolors; a++) \
  376.         if (*(colorStrings + a)) \
  377.         free(*(colorStrings + a)); \
  378.     free(colorStrings); \
  379.     } \
  380.     fclose(stream); \
  381.     return(XpmErrorStatus = status); }
  382.  
  383. int XWritePixmapFile(display, colormap, filename, pixmap, width, 
  384.              height, type, cppm, infos)
  385.      Display *display;
  386.      Colormap colormap;
  387.      char *filename;
  388.      Pixmap *pixmap;
  389.      unsigned int width, height;
  390.      char *type;
  391.      unsigned int cppm;
  392.      XpmInfo *infos;
  393.  
  394. { FILE *stream;
  395.   XImage *ximage = NULL;
  396.   unsigned int pixlen;        /* length of pixels */
  397.   unsigned int pixgap;        /* length of pixels gap */
  398.   byte *dptr;
  399.   Pixel *index = NULL;        /* index of different pixels */
  400.   unsigned int indexsize = 256;    /* should be enough most of the time */
  401.   XColor *xcolors;        /* used colors */
  402.   char **colorStrings = NULL;    /* character strings associated to colors */
  403.   unsigned int ncolors = 0;    /* number of colors */
  404.   unsigned int cpp;             /* chars per pixel */
  405.   char *name;
  406.   unsigned int a, b, c, x, y, n = 0, key;
  407.   Pixel pixel;
  408.  
  409.   if (! (stream = fopen(filename, "w"))) {
  410.       return(XpmErrorStatus = PixmapOpenFailed);
  411.   }
  412.   XpmErrorStatus = PixmapSuccess;
  413.  
  414.   if (!(name = rindex(filename, '/')))
  415.     name = filename;
  416.   else
  417.     name++;
  418.  
  419.   if (!type)
  420.       if (infos && infos->type)
  421.       type = infos->type;
  422.       else
  423.       n = 0;        /* natural type */
  424.   if (n == 0 && type) {
  425.       while (DataTypes[n].type && strcmp(DataTypes[n].type, type)) n++;
  426.       if (! DataTypes[n].type)
  427.       return(XpmErrorStatus = PixmapFileInvalid);
  428.   }
  429.  
  430.  
  431.   /*
  432.    * read the image data
  433.    */
  434.  
  435.   ximage = XGetImage(display, pixmap, 0, 0, width, height, AllPlanes,
  436. ZPixmap);
  437.   pixlen = (ximage->bits_per_pixel / 8) + (ximage->bits_per_pixel % 8 ? 1 :
  438. 0);
  439.   pixgap = ximage->bytes_per_line - width;
  440.  
  441.   /* index the different pixels
  442.    */
  443.   if (! (index = (Pixel *)malloc(sizeof(Pixel) * indexsize)))
  444.       return(XpmErrorStatus = PixmapNoMemory);
  445.   dptr = (byte *)ximage->data;
  446.   for (y = 0; y < height; y++) {
  447.       for (x = 0; x < width; x++) {
  448.       pixel = memToVal(dptr, pixlen);
  449.       for (a = 0; a < ncolors; a++)
  450.           if (*(index + a) == pixel) break;
  451.       if (a == ncolors) {
  452.           if (ncolors > indexsize) {
  453.           indexsize *= 2;
  454.           if (! (index = (Pixel *)malloc(sizeof(Pixel) * indexsize)))
  455.               RETURN(PixmapNoMemory);
  456.           }
  457.           *(index + ncolors) = pixel;
  458.           ncolors++;
  459.       }
  460.       valToMem((unsigned long)a, dptr, pixlen);
  461.       dptr += pixlen;
  462.       }
  463.       for (b = 0; b < pixgap; b++) dptr += pixlen; /* skip extra pixels */
  464.   }
  465.  
  466.   /* get rgb values and a string of char for each color
  467.    */
  468.   if (! (xcolors = (XColor *) malloc(sizeof(XColor) * ncolors)))
  469.       RETURN(PixmapNoMemory);
  470.   if (! (colorStrings = (char **) calloc(ncolors, sizeof(char *))))
  471.       RETURN(PixmapNoMemory);
  472.  
  473.   for (cpp = 1, c = MAXPRINTABLE; ncolors > c; cpp++) c *= MAXPRINTABLE;
  474.   if (cpp < cppm) cpp = cppm;
  475.  
  476.   for (a = 0; a < ncolors; a++) {
  477.       if (! (*(colorStrings + a) = (char *)malloc(cpp)))
  478.       RETURN(PixmapNoMemory);
  479.       **(colorStrings + a) = printable[c = a % MAXPRINTABLE];
  480.       for (b = 1; b < cpp; b++)
  481.       *(*(colorStrings + a) + b) = 
  482.           printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];
  483.       (xcolors + a)->pixel = *(index + a);
  484.   }
  485.   XQueryColors(display, colormap, xcolors, ncolors);
  486.  
  487.  
  488.   /*
  489.    * print the pixmap file
  490.    */
  491.  
  492.   /* print the header line 
  493.    */
  494.   fprintf(stream, "%s XPM2 %s %s", DataTypes[n].Bcmt, DataTypes[n].type, 
  495.       DataTypes[n].Ecmt);
  496.   if (n != 0)            /* print the assignment line */
  497.       fprintf(stream, "%s %s %s", DataTypes[n].Dec, name, 
  498.           DataTypes[n].Boa);
  499.  
  500.   /* print the hints 
  501.    */
  502.   if (infos && infos->hints_cmt) /* print hints comment line */
  503.       fprintf(stream, "%s%s%s", DataTypes[n].Bcmt, 
  504.           infos->hints_cmt, DataTypes[n].Ecmt);
  505.  
  506.   if (DataTypes[n].Bos) fprintf(stream, "%c", DataTypes[n].Bos);
  507.   fprintf(stream, "%d %d %d %d", width, height, ncolors, cpp);
  508.   if (DataTypes[n].Eos) fprintf(stream, "%c", DataTypes[n].Eos);
  509.   fprintf(stream, DataTypes[n].Strs);
  510.  
  511.   /* print colors 
  512.    */
  513.   if (infos && infos->colors_cmt) /* print colors comment line */
  514.       fprintf(stream, "%s%s%s", DataTypes[n].Bcmt, 
  515.           infos->colors_cmt, DataTypes[n].Ecmt);
  516.  
  517.   for (a = 0; a < ncolors; a++) {
  518.       if (DataTypes[n].Bos) fprintf(stream, "%c", DataTypes[n].Bos);
  519.       for (b = 0; b < cpp; b++)
  520.       fprintf(stream, "%c", *(*(colorStrings + a) + b));
  521.       c = 1;
  522.       if (infos && infos->pixels) {
  523.       for (b = 0; b < infos->ncolors; b++)
  524.           if (*(infos->pixels + b) == (xcolors + a)->pixel)
  525.           break;
  526.       if (b != infos->ncolors) {
  527.           c = 0;
  528.           for (key = 1; key < NKEYS + 1; key++) {
  529.           if (*(*(infos->colorTable + b) + key))
  530.               fprintf(stream, "  %s %s", ColorKeys[key - 1], 
  531.                   *(*(infos->colorTable + b) + key));
  532.           }
  533.       }
  534.       }
  535.       if (c)
  536.           fprintf(stream, " c #%04X%04X%04X", (xcolors + a)->red, 
  537.               (xcolors + a)->green, (xcolors + a)->blue);
  538.       if (DataTypes[n].Eos) fprintf(stream, "%c", DataTypes[n].Eos);
  539.       fprintf(stream, DataTypes[n].Strs);
  540.   }
  541.  
  542.   /* print pixels
  543.    */
  544.   if (infos && infos->pixels_cmt) /* print pixels comment line */
  545.       fprintf(stream,  "%s%s%s", DataTypes[n].Bcmt, 
  546.           infos->pixels_cmt, DataTypes[n].Ecmt);
  547.  
  548.   dptr = (byte *)ximage->data;
  549.   for (y = 0; y < height; y++) {
  550.       if (DataTypes[n].Bos) fprintf(stream, "%c", DataTypes[n].Bos);
  551.       for (x = 0; x < width; x++) {
  552.       for (b = 0; b < cpp; b++) {
  553.           fprintf(stream, "%c", 
  554.               *(*(colorStrings + memToVal(dptr, pixlen)) + b));
  555.       }
  556.       dptr += pixlen;
  557.       }
  558.       if (DataTypes[n].Eos) fprintf(stream, "%c", DataTypes[n].Eos);
  559.       if (y < height - 1) 
  560.       fprintf(stream, DataTypes[n].Strs);
  561.       for (c = 0; c < pixgap; c++) dptr += pixlen; /* skip extra pixels */
  562.   }
  563.   fprintf(stream, DataTypes[n].Eoa);
  564.  
  565.   fclose(stream);
  566.   free(index);
  567.   for (a = 0; a < ncolors; a++)
  568.       free(*(colorStrings + a));
  569.   free(colorStrings);
  570.   free(xcolors);
  571.   return(XpmErrorStatus);
  572. }
  573. END_OF_SHAR_FOR_XWrPixF.c
  574. cat > colas.sty << \END_OF_SHAR_FOR_colas.sty
  575. % my add-on LaTeX macros
  576. % to be used like in:
  577. % \documentstyle[12pt,gwm]{report}
  578.  
  579. % postscript inclusion:
  580. \def\texpsfig#1#2#3
  581. {\vbox{\kern #3pt\hbox{\special{psfile=#1}\kern #2pt}}\typeout{(#1)}}
  582.  
  583. % RCS version stripping
  584. \def\RCSRevNum#1Revision: #2 ${#2}
  585. \def\RCSRevVersion#1Version: #2 ${#2}
  586.  
  587. \newlength{\colaslength}
  588. \newlength{\colaslengthh}
  589. \newlength{\colasmargin}
  590.  
  591. \def\exemplefont{\footnotesize}
  592. \def\usagefont{\large}
  593. \def\usageupspace{\vspace{0.1mm}}
  594. \newcommand{\Description}
  595.     {\list{}{\leftmargin 4cm \labelsep 0.1cm \labelwidth 3.9cm}}
  596.  
  597. \def\descriptionlabel#1{\bf #1\hspace\labelsep\hfil}
  598. \def\description
  599.     {\list{}{\leftmargin 2.4cm \labelsep 0.1cm \labelwidth 2.3cm
  600.     \let\makelabel\descriptionlabel}}
  601.  
  602. \def\upspace{\vspace{-2mm}}
  603. \def\undertablespace{\vspace{-3mm}}
  604.  
  605. \def\Item#1#2{\upspace\pagebreak[1]\section*{\hspace{-7pt}
  606.     {\large\tt#1}{\normalsize\sf\quad ---\quad #2}}\vspace{-0.3cm}}
  607.  
  608. \def\ITEMa#1#2{
  609.  \Item{#1}{#2}\markright{#1}
  610.  \label{#1}}
  611. \def\ITEMb#1#2#3{
  612.  \Item{\vbox{\hbox{#1}\hbox{#2}}}{#3}\markright{#1}
  613.  \label{#1} \label{#2}}
  614. \def\ITEMbi#1#2#3{
  615.  \Item{\vbox{\hbox{#1}\hbox{#2}}}{#3}\markright{#1}
  616.  \label{#2}}
  617. \def\ITEMc#1#2#3#4{
  618.  \Item{\vbox{\hbox{#1}\hbox{#2}\hbox{#3}}}{#4}\markright{#1}
  619.  \label{#1}\label{#2} \label{#3}}
  620. \def\ITEMci#1#2#3#4{
  621.  \Item{\vbox{\hbox{#1}\hbox{#2}\hbox{#3}}}{#4}\markright{#1}
  622.  \label{#2}\label{#3}}
  623. \def\ITEMd#1#2#3#4#5{
  624.  \Item{\vbox{\hbox{#1}\hbox{#2}\hbox{#3}\hbox{#4}}}{#5}\markright{#1}
  625.  \label{#1}\label{#2}\label{#3}\label{#4}}
  626. \def\ITEMe#1#2#3#4#5#6{
  627.  \Item{
  628.   \vbox{\hbox{#1}\hbox{#2}\hbox{#3}\hbox{#4}\hbox{#5}}}{#6}\markright{#1}
  629.  \label{#1}\label{#2}\label{#3}\label{#4}\label{#5}}
  630. \def\ITEMf#1#2#3#4#5#6#7{
  631.  \Item{
  632.     \vbox{\hbox{#1}\hbox{#2}\hbox{#3}\hbox{#4}\hbox{#5}\hbox{#6}}}{#7}
  633.     \markright{#1}
  634.  \label{#1}\label{#2}\label{#3}\label{#4}\label{#5}\label{#6}}
  635.  
  636. \newcommand{\context}[1]{
  637.   Context used:
  638.     \begin{center}\begin{tabular}{@{\tt}l@{\hspace{1cm}}@{\rm}p{7cm}}
  639.     \multicolumn{1}{c}{\bf Variable}&\multicolumn{1}{c}{\bf used for}\\ 
  640.     \hline \multicolumn{2}{l}{\undertablespace}\\
  641.     #1
  642.     \end{tabular}\end{center}}
  643.  
  644. \newcommand{\contextdim}[2]{
  645.   \setlength{\colaslength}{7cm}
  646.   \addtolength{\colaslength}{#1}
  647.   Context used:
  648.     \begin{center}\begin{tabular}{@{\tt}l@{\hspace{1cm}}@{\rm}p{\colaslength}}
  649.     \multicolumn{1}{c}{\bf Variable}&\multicolumn{1}{c}{\bf used for}\\ 
  650.     \hline  \multicolumn{2}{l}{\undertablespace}\\
  651.     #2
  652.     \end{tabular}\end{center}}
  653.  
  654. \newcommand{\desctable}[3]{
  655.     \begin{center}\begin{tabular}{@{\bf}l@{\hspace{1cm}}@{\rm}p{7cm}}
  656.     \multicolumn{1}{c}{\bf #1}&\multicolumn{1}{c}{\bf #2}\\ 
  657.     \hline \multicolumn{2}{l}{\undertablespace}\\
  658.     #3
  659.     \end{tabular}\end{center}}
  660.  
  661. \newcommand{\desctabledim}[4]{
  662.   \setlength{\colaslength}{7cm}
  663.   \addtolength{\colaslength}{#1}
  664.     \begin{center}\begin{tabular}{@{\bf}l@{\hspace{1cm}}@{\rm}p{\colaslength}}
  665.     \multicolumn{1}{c}{\bf #2}&\multicolumn{1}{c}{\bf #3}\\ 
  666.     \hline  \multicolumn{2}{l}{\undertablespace}\\
  667.     #4
  668.     \end{tabular}\end{center}}
  669.  
  670. \newcommand{\exemples}[2]{
  671.   #1{\exemplefont 
  672.     \begin{center}\begin{tabular}{@{\tt}l@{\hspace{1cm}}@{\rm}p{5cm}}
  673.     #2
  674.     \end{tabular}\end{center}}}
  675.  
  676. \newcommand{\exemplesdim}[3]{
  677.   \setlength{\colaslength}{5cm}
  678.   \addtolength{\colaslength}{#1}
  679.   #2{\exemplefont 
  680.     \begin{center}\begin{tabular}{@{\tt}l@{\hspace{1cm}}@{\rm}p{\colaslength}}
  681.     #3
  682.     \end{tabular}\end{center}}}
  683.  
  684. \newcommand{\usagetype}[1]{{\sl #1}\vspace{0.2cm}}
  685. \newcommand{\usagetyped}[2]{{\sl #1}\quad{\it (#2)}\vspace{0.2cm}}
  686. \newcommand{\see}[1]{{\tt #1}}
  687. \newcommand{\seep}[1]{{\tt #1}, p~\pageref{#1}}
  688. \newcommand{\seensp}[1]{{\tt #1} (see p~\pageref{#1})}
  689. \newcommand{\seesnp}[1]{(see {\tt #1}, p~\pageref{#1})}
  690. \newcommand{\seeref}[1]{{\tt #1} (see \ref{#1}, p~\pageref{#1})}
  691. \newcommand{\seesp}[1]{(see \ref{#1}, p~\pageref{#1})}
  692.  
  693. \def\smalldesc#1#2#3{#1\\}
  694. \newcommand{\bigdesc}[2]{
  695.   \setlength{\colaslength}{300pt}
  696.   \settowidth{\colaslengthh}{{\tt #1}}
  697.   \addtolength{\colaslength}{-\colaslengthh}
  698.     \begin{center}\begin{tabular}
  699.     {@{\tt}l@{\hspace{0.5cm}}@{\sf}p{\colaslength}@{\hspace{0.4cm}}@{\bf}r}
  700.    \multicolumn{1}{c}{\bf Object}&\multicolumn{1}{c}{\bf Description}&{\bf
  701. p}\\
  702.     \hline \multicolumn{3}{l}{\undertablespace}\\
  703.     #2
  704.     \end{tabular}\end{center}}
  705.  
  706. \newcommand{\desc}[4]{
  707.   \setlength{\colaslength}{250pt}
  708.   \settowidth{\colaslengthh}{{\tt #1}}
  709.   \addtolength{\colaslength}{-\colaslengthh}
  710.     \begin{center}\begin{tabular}
  711. {@{\tt}l@{\hspace{0.5cm}}@{\sf}p{\colaslength}}
  712.     \multicolumn{1}{c}{\bf #2}&\multicolumn{1}{c}{\bf #3}\\
  713.     \hline \multicolumn{2}{l}{\undertablespace}\\
  714.     #4
  715.     \end{tabular}\end{center}}
  716.  
  717. \newcommand{\contextdimtt}[2]{
  718.   \setlength{\colaslength}{250pt}
  719.   \settowidth{\colaslengthh}{{\tt #1}}
  720.   \addtolength{\colaslength}{-\colaslengthh}
  721.   Context used:
  722.     \begin{center}\begin{tabular}{@{\tt}l@{\hspace{1cm}}@{\rm}p{\colaslength}}
  723.     \multicolumn{1}{c}{\bf Variable}&\multicolumn{1}{c}{\bf used for}\\ 
  724.     \hline \multicolumn{2}{l}{\undertablespace}\\
  725.     #2
  726.     \end{tabular}\end{center}}
  727.  
  728. \def\itemtt#1{\item[{\tt #1}]}
  729. \def\itemit#1{\item[{\it #1}]}
  730.  
  731.  
  732. % SIZE of page
  733. %=============
  734.  
  735. \def\fullpage{\if@twoside \oddsidemargin 35pt \evensidemargin -8pt 
  736. \marginparsep 10pt \marginparpush 10pt \marginparwidth 10pt
  737. \else \oddsidemargin 0pt \evensidemargin 0pt 
  738. \marginparwidth 30pt\fi
  739. \textwidth 450pt \setlength{\colasmargin}{0pt}
  740. \def\colaspm{\hspace{0pt}}\def\colasmm{\hspace{0pt}}
  741. \def\colassmm{\hspace{0pt}}\def\colastitledisp{\hspace{0pt}}
  742. }
  743. \def\mediumpage{\if@twoside \oddsidemargin 75pt \evensidemargin 32pt 
  744. \marginparsep 10pt \marginparpush 10pt \marginparwidth 40pt
  745. \else \oddsidemargin 43pt \evensidemargin 63pt 
  746. \marginparwidth 30pt\fi
  747. \textwidth 410pt \setlength{\colasmargin}{0pt}
  748. \def\colaspm{\hspace{40pt}}\def\colasmm{\hspace{-40pt}}
  749. \def\colassmm{\hspace{-20pt}}\def\colastitledisp{\hspace{-45pt}}
  750. }
  751. \def\smallpage{\if@twoside \oddsidemargin 135pt \evensidemargin 92pt 
  752. \marginparsep 10pt \marginparpush 10pt \marginparwidth 80pt
  753. \else \oddsidemargin 123pt \evensidemargin 123pt
  754. \marginparwidth 30pt \fi
  755. \textwidth 350pt 
  756. \setlength{\colasmargin}{100pt}
  757. \def\colaspm{\hspace{100pt}}\def\colasmm{\hspace{-100pt}}
  758. \def\colassmm{\hspace{-60pt}}\def\colastitledisp{\hspace{-75pt}}
  759. }
  760.  
  761. \smallpage
  762. \topmargin -30pt \headheight 12pt \headsep 25pt \footheight 12pt \footskip
  763. 30pt 
  764. \textheight 680pt \columnsep 10pt \columnseprule 0pt 
  765. \footnotesep 12pt \skip\footins 6pt plus 2pt minus 2pt 
  766. \floatsep 12pt plus 2pt minus 2pt \textfloatsep 20pt plus 2pt minus 4pt
  767. \intextsep 12pt plus 2pt minus 2pt \@maxsep 20pt \dblfloatsep 12pt plus 2pt
  768. minus 2pt \dbltextfloatsep 20pt plus 2pt minus 4pt \@dblmaxsep 20pt 
  769. \@fptop 0pt plus 1fil \@fpsep 8pt plus 2fil \@fpbot 0pt plus 1fil 
  770. \@dblfptop 0pt plus 1fil \@dblfpsep 8pt plus 2fil \@dblfpbot 0pt plus 1fil
  771.  
  772. \parskip 5pt plus 1pt \parindent 0pt \topsep 2pt plus 1pt minus 1pt
  773. \partopsep 0pt plus 1pt minus 1pt \itemsep 2pt plus 1pt minus 1pt 
  774.  
  775. \reversemarginpar
  776. \@mparswitchfalse
  777.  
  778. %% abbrevs
  779.  
  780. \def\GWM{\sc Gwm}
  781. \def\WOOL{\sc Wool}
  782.  
  783. %% fonts
  784. \def\Huge{\@setsize\Huge{30pt}\xxvpt\@xxvpt}
  785.  
  786. %% chapter
  787.  
  788. \def\@makechapterhead#1{ \vspace*{1pt} { \parindent 0pt \raggedright 
  789.  \Huge\bf \colasmm
  790.  \ifnum \c@secnumdepth >\m@ne \thechapter \quad \fi
  791.  #1\par 
  792.  \nobreak \vskip 20pt
  793.  \colasmm{\vbox{\hbox{\vrule height 5pt width450pt depth -3pt}
  794.              \vspace*{-1.1cm}
  795.                 \hbox{\vrule height 0.0pt width450pt depth 0.4pt}}}
  796.  \nobreak \vskip 50pt \nobreak } }
  797.  
  798. \def\@makeschapterhead#1{ \vspace*{1pt} { \parindent 0pt \raggedright 
  799.  \Huge \bf \colasmm #1\par 
  800.  \nobreak \vskip 80pt } }
  801.  
  802. \def\chapter{\clearpage \thispagestyle{pagenum} \global\@topnum\z@
  803. \@afterindentfalse \secdef\@chapter\@schapter} 
  804. \def\@chapter[#1]#2{\ifnum \c@secnumdepth >\m@ne
  805.  \refstepcounter{chapter}
  806.  \typeout{\@chapapp\space\thechapter.}
  807.  \addcontentsline{toc}{chapter}{\protect
  808.  \numberline{\thechapter}#1}\else
  809.  \addcontentsline{toc}{chapter}{#1}\fi
  810.  \chaptermark{#1}
  811.  \addtocontents{lof}{\protect\addvspace{10pt}}
  812. \addtocontents{lot}{\protect\addvspace{10pt}} \if@twocolumn
  813. \@topnewpage[\@makechapterhead{#2}] 
  814.  \else \@makechapterhead{#2}
  815.  \@afterheading \fi} 
  816. \def\@schapter#1{\if@twocolumn \@topnewpage[\@makeschapterhead{#1}]
  817.  \else \@makeschapterhead{#1} 
  818.  \@afterheading\fi}
  819.  
  820. %% sections
  821.  
  822. \def\section{\@startsection {section}{1}{\z@}{-3.5ex plus -1ex minus 
  823.  -.2ex}{2.3ex plus .2ex}{\Large\bf\colasmm}}
  824. \def\subsection{\@startsection{subsection}{2}{\z@}{-3.25ex plus -1ex minus 
  825.  -.2ex}{1.5ex plus .2ex}{\large\bf\colassmm}}
  826. \def\subsubsection{\@startsection{subsubsection}{3}{\z@}{-3.25ex plus
  827. -1ex minus -.2ex}{1.5ex plus .2ex}{\normalsize\bf}}
  828. \def\paragraph{\@startsection
  829.  {paragraph}{4}{\z@}{3.25ex plus 1ex minus .2ex}{-1em}{\normalsize\bf}}
  830. \def\subparagraph{\@startsection
  831.  {subparagraph}{4}{\parindent}{3.25ex plus 1ex minus 
  832.  .2ex}{-1em}{\normalsize\bf}}
  833.  
  834. %% headings
  835.  
  836. \if@twoside \def\ps@headings{\def\@oddfoot{}
  837. \def\@evenfoot{}\def\@evenhead{
  838. \colasmm\makebox[0pt][l]{\vrule height-4pt width450pt depth4.3pt}
  839. \bf\thepage\hfill \sl \leftmark}
  840. \def\@oddhead{
  841. \colasmm\makebox[0pt][l]{\vrule height-4pt width450pt depth4.3pt}
  842. \sl \rightmark \hfill\bf\thepage}
  843. \def\chaptermark##1{\markboth {\uppercase{\ifnum \c@secnumdepth
  844. >\m@ne
  845.  \@chapapp\ \thechapter. \ \fi ##1}}{}}\def\sectionmark##1{\markright
  846. {\uppercase{\ifnum \c@secnumdepth >\z@
  847.  \thesection. \ \fi ##1}}}}
  848. \else \def\ps@headings{\def\@oddfoot{}\def\@evenfoot{}\def\@oddhead{\hbox
  849. {}\sl \rightmark \hfill \rm\thepage}\def\chaptermark##1{\markright
  850. {\uppercase{\ifnum \c@secnumdepth >\m@ne
  851.  \@chapapp\ \thechapter. \ \fi ##1}}}}
  852. \fi
  853.  
  854. \if@twoside \def\ps@pagenum{\def\@oddfoot{}
  855. \def\@evenfoot{}\def\@evenhead{
  856. \colasmm\bf\thepage\hfill}
  857. \def\@oddhead{
  858. \colasmm\hfill\bf\thepage}
  859. \def\chaptermark##1{\markboth {\uppercase{\ifnum \c@secnumdepth
  860. >\m@ne
  861.  \@chapapp\ \thechapter. \ \fi ##1}}{}}\def\sectionmark##1{\markright
  862. {\uppercase{\ifnum \c@secnumdepth >\z@
  863.  \thesection. \ \fi ##1}}}}
  864. \else \def\ps@pagenum{\def\@oddfoot{}\def\@evenfoot{}\def\@oddhead{\hbox
  865. {}\hfil \bf\thepage}\def\chaptermark##1{\markright
  866. {\uppercase{\ifnum \c@secnumdepth >\m@ne
  867.  \@chapapp\ \thechapter. \ \fi ##1}}}}
  868. \fi
  869.  
  870. END_OF_SHAR_FOR_colas.sty
  871. cat > create.c << \END_OF_SHAR_FOR_create.c
  872. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  873. /* create.c:
  874.  *
  875.  *  XPM2
  876.  *  Create utility for XPM2 file format
  877.  *  Developped by Arnaud Le Hors
  878.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  879.  */
  880.  
  881. #include "xpmP.h"
  882.  
  883. #define RETURN(status) \
  884.   { freeColorTable(colorTable, ncolors); \
  885.     XpmErrorStatus = status; \
  886.     return(NULL); }
  887.  
  888. Pixmap CreatePixmap(display, visual, d, colormap, data, depth, 
  889.             width_return, height_return, 
  890.             pixels_return, npixels_return,
  891.             colorsymbols, numsymbols, infos)
  892.      Display *display;
  893.      Visual *visual;
  894.      Drawable d;
  895.      Colormap colormap;
  896.      MData *data;
  897.      unsigned int depth;
  898.      unsigned int *width_return, *height_return, *npixels_return;
  899.      Pixel **pixels_return;
  900.      ColorSymbol colorsymbols[];
  901.      unsigned int numsymbols;
  902.      XpmInfo *infos;
  903.  
  904. { Pixmap       pixmap;
  905.   unsigned int cpp;             /* chars per pixel */
  906.   unsigned int ncolors;         /* number of colors */
  907.   char       ***colorTable;     /* color table */
  908.   unsigned int key;        /* color key */
  909.   unsigned int pixlen;        /* length of pixels */
  910.   Pixel        *pixels;        /* pixels colors */
  911.   unsigned int width, height;
  912.   char         *chars, buf[BUFSIZ], *colorname;
  913.   byte         *dptr, *bptr;
  914.   XColor       xcolor;
  915.   XGCValues    gcv;
  916.   GC           gc;
  917.   XImage       *ximage;
  918.   unsigned int a, b, x, y, l = 0;
  919.  
  920.   /* Initialize return values
  921.    */
  922.   *width_return = *height_return = *npixels_return = 0;
  923.   *pixels_return = NULL;
  924.  
  925.   /*
  926.    * parse the data
  927.    */
  928.  
  929.   /* read hints: width, height, ncolors, chars_per_pixel
  930.    */
  931.   if (! ((width = mnextui(data)) && (height = mnextui(data))
  932.      && (ncolors = mnextui(data)) && (cpp =  mnextui(data)))) {
  933.       XpmErrorStatus = PixmapFileInvalid;
  934.       return(NULL);
  935.   }
  936.  
  937.   /* store the hints comment line
  938.    */
  939.   if (infos) mgetcmt(data, &infos->hints_cmt);
  940.  
  941.   for (a = 1, b = 2; b < ncolors; b <<= 1, a++);
  942.   pixlen = (a / 8) + (a % 8 ? 1 : 0);
  943.  
  944.   /* read colors
  945.    */
  946.   if (! (colorTable = (char ***)calloc(ncolors, sizeof(char **)))) {
  947.       XpmErrorStatus = PixmapNoMemory;
  948.       return(NULL);
  949.   }
  950.   for(a = 0; a < ncolors; a++) {
  951.       mnextstring(data);        /* skip the line */
  952.       if (! (*(colorTable + a) = (char **)calloc((NKEYS + 1), sizeof(char
  953. *))))
  954.       RETURN(PixmapNoMemory);
  955.       /* read pixel value
  956.        */
  957.       if (! (**(colorTable + a) = (char *)malloc(cpp)))
  958.       RETURN(PixmapNoMemory);
  959.       for (b = 0; b < cpp; b++)
  960.       *(**(colorTable + a) + b)= mgetc(data);
  961.  
  962.       /* read color keys and values
  963.        */
  964.       while (l = mnextw(data, buf)) {
  965.       for (key = 1; key < NKEYS + 1; key++)
  966.           if (! strncmp(ColorKeys[key - 1], buf, l))
  967.           break;
  968.       if (l = mnextw(data, buf)) {
  969.           if (! (*(*(colorTable + a) + key) = (char *)malloc(l + 1)))
  970.           RETURN(PixmapNoMemory);
  971.           strncpy(*(*(colorTable + a) + key), buf, l);
  972.           *(*(*(colorTable + a) + key) + l) = '\0';
  973.       } else {
  974.           RETURN(PixmapFileInvalid); /* key without value */
  975.       }
  976.       }      
  977.   }
  978.  
  979.   /* store the colors comment line
  980.    */
  981.   if (infos) mgetcmt(data, &infos->colors_cmt);
  982.  
  983.   /* read pixels and index them on color number
  984.    */
  985.   if (! (dptr = bptr = (unsigned char *)
  986.      malloc(width * height * pixlen)))
  987.       RETURN(PixmapNoMemory);
  988.   if (! (chars = (char *)malloc(cpp)))
  989.       RETURN(PixmapNoMemory);
  990.   for (y = 0; y < height; y++) {
  991.       mnextstring(data);
  992.       for (x = 0; x < width; x++) {
  993.       for (a = 0; a < cpp; a++) {
  994.           chars[a] = mgetc(data);
  995.       }
  996.       for (a = 0; a < ncolors; a++)
  997.           if (!strncmp(**(colorTable + a), chars, cpp))
  998.           break;
  999.       if (a == ncolors) {    /* no color matches */
  1000.           RETURN(PixmapFileInvalid);
  1001.       }
  1002.       valToMem((unsigned long)a, dptr, pixlen);
  1003.       dptr += pixlen;
  1004.       }
  1005.   }
  1006.  
  1007.   /* store the pixels comment line
  1008.    */
  1009.   if (infos) mgetcmt(data, &infos->pixels_cmt);
  1010.  
  1011.   /* 
  1012.    * build the image data
  1013.    */
  1014.  
  1015.   key = visualType(visual);
  1016.  
  1017.   if (! (pixels = (Pixel *)malloc(sizeof(Pixel) * ncolors)))
  1018.       RETURN(PixmapNoMemory);
  1019.  
  1020.   /* get pixel colors and index them
  1021.    */
  1022.   for (a = 0; a < ncolors; a++) {
  1023.       colorname = NULL;
  1024.  
  1025.       /* look for a defined symbol
  1026.        */
  1027.       if (numsymbols && *(*(colorTable + a) + 1)) {
  1028.       for (l = 0; l < numsymbols; l++)
  1029.           if (!strcmp(colorsymbols[l].name, *(*(colorTable + a) + 1)))
  1030.           break;
  1031.       if (l != numsymbols && colorsymbols[l].value)
  1032.           colorname = colorsymbols[l].value;
  1033.       }
  1034.       if (! colorname) {
  1035.       if (*(*(colorTable + a) + key)) {
  1036.           b = key;
  1037.       } else {
  1038.           for (b = key - 1; b > 1; b--)
  1039.           if (*(*(colorTable + a) + b))
  1040.               break;
  1041.           if (b == 1) {
  1042.           for (b = key + 1; b < NKEYS + 1; b++)
  1043.               if (*(*(colorTable + a) + b))
  1044.               break;
  1045.           if (b == NKEYS + 1)
  1046.               RETURN(PixmapFileInvalid);
  1047.           }
  1048.       }
  1049.       colorname = *(*(colorTable + a) + b);
  1050.       }
  1051.       if (! XParseColor(display, colormap, colorname, &xcolor))
  1052.       RETURN(PixmapParseColorFailed);
  1053.       if (XAllocColor(display, colormap, &xcolor)) {
  1054.       if (infos) {
  1055.           for (b = 0; b < a; b++)
  1056.           if (*(pixels + b) == xcolor.pixel)
  1057.               break;
  1058.           if (b != a) {
  1059.           if (! XAllocColorCells(display, colormap, False, NULL, 0,
  1060.                      pixels + a, 1))
  1061.               RETURN(PixmapAllocColorFailed);
  1062.           XFreeColors(display, colormap, &(xcolor.pixel), 1, 0);
  1063.           xcolor.pixel = *(pixels + a);
  1064.           XStoreColor(display, colormap, &xcolor);
  1065.           }
  1066.       }
  1067.       } else
  1068.       RETURN(PixmapAllocColorFailed);
  1069.  
  1070.       *(pixels + a) = xcolor.pixel;
  1071.   }
  1072.  
  1073.   /* set data pixels to the indexed color pixel
  1074.    */
  1075.   dptr = bptr;
  1076.   for (y = 0; y < height; y++) {
  1077.       for (x = 0; x < width; x++) {
  1078.       valToMem(*(pixels + memToVal(dptr, pixlen)), dptr, pixlen);
  1079.       dptr += pixlen;
  1080.       }
  1081.   }
  1082.  
  1083.   /*
  1084.    * send the image to the server
  1085.    */
  1086.  
  1087.   pixmap = XCreatePixmap(display, d, width, 
  1088.              height, depth);
  1089.   gcv.function= GXcopy;
  1090.   gc = XCreateGC(display, pixmap, GCFunction, &gcv);
  1091.   ximage = XCreateImage(display, visual, depth, ZPixmap, 0, (char *)bptr, 
  1092.             width, height, 8, 0);
  1093.   ximage->byte_order= MSBFirst; /* trust him, Jim Frost knows what he's */
  1094.                 /* talking about */
  1095.   XPutImage(display, pixmap, gc, ximage, 0, 0, 0, 0, 
  1096.         width, height);
  1097.  
  1098.   ximage->data = NULL;
  1099.   XDestroyImage(ximage);    /* waste not want not */
  1100.   XFreeGC(display, gc);
  1101.   free(dptr);
  1102.   free(chars);
  1103.  
  1104.   *width_return = width;
  1105.   *height_return = height;
  1106.   *pixels_return = pixels;
  1107.   *npixels_return = ncolors;
  1108.  
  1109.   /* store color table infos
  1110.    */
  1111.   if (infos) {
  1112.       infos->ncolors = ncolors;
  1113.       infos->colorTable = colorTable;
  1114.       infos->pixels = pixels;
  1115.   } else {
  1116.       freeColorTable(colorTable, ncolors);
  1117.   }
  1118.  
  1119.   return(pixmap);
  1120. }
  1121. END_OF_SHAR_FOR_create.c
  1122. cat > demo.c << \END_OF_SHAR_FOR_demo.c
  1123. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1124. /* demo.c:
  1125.  *
  1126.  *  XPM2
  1127.  *  Demo File
  1128.  *  Developped by Arnaud Le Hors
  1129.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1130.  */
  1131.  
  1132. #include "xpm.h"
  1133.  
  1134. /* XPM2 C */
  1135. /* plaid pixmap */
  1136. static char * plaid[] = {
  1137. /* width height ncolors chars_per_pixel */ 
  1138. "22 22 4 2",
  1139. /* colors */
  1140. "   c red     m white  s light_color",
  1141. "Y  c yellow    m black  s lines_in_mix",
  1142. "+  c yellow    m white  s lines_in_dark",
  1143. "x         m black  s dark_color",
  1144. /* pixels */
  1145. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1146. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1147. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1148. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1149. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1150. "Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + ", 
  1151. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1152. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1153. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1154. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1155. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1156. "          x           x   x   x Y x   x   x ", 
  1157. "          x             x   x   Y   x   x   ",
  1158. "          x           x   x   x Y x   x   x ", 
  1159. "          x             x   x   Y   x   x   ", 
  1160. "          x           x   x   x Y x   x   x ", 
  1161. "x x x x x x x x x x x x x x x x x x x x x x ", 
  1162. "          x           x   x   x Y x   x   x ", 
  1163. "          x             x   x   Y   x   x   ", 
  1164. "          x           x   x   x Y x   x   x ", 
  1165. "          x             x   x   Y   x   x   ", 
  1166. "          x           x   x   x Y x   x   x "
  1167. } ;
  1168.  
  1169. static Display *dpy;
  1170. static XEvent e ;
  1171. static Window root, win ;
  1172. static int depth,screen ;
  1173. static XSetWindowAttributes xswa;
  1174. static char **command ;
  1175. static Pixmap pix ;
  1176. static Colormap cmp;
  1177. static unsigned long *pixels;
  1178. static unsigned int npixels;
  1179. static XpmInfo infos;
  1180. static Visual *v;
  1181.  
  1182. main(argc, argv)
  1183. int    argc;
  1184. char    *argv[];
  1185. {
  1186.  
  1187.     unsigned int w, h;
  1188.     int winx, winy, winw, winh;
  1189.     char *display = NULL ;
  1190.     char *geom = NULL;
  1191.     char *type = NULL;
  1192.     char *input = NULL;
  1193.     char *output = NULL;
  1194.     int numsymbols = 0;
  1195.     ColorSymbol symbols[4];
  1196.     int ErrorStatus, notend = 1;
  1197.  
  1198.     command = argv ;
  1199.     while (*++argv) {
  1200.     if (index(*argv,':')) display = *argv ; else
  1201.     if (!strcmp(*argv,"-d")) 
  1202.         if (*++argv)  display = *argv ; else Usage(); else
  1203.     if (!strcmp(*argv,"-display")) 
  1204.         if (*++argv)  display = *argv ; else Usage(); else
  1205.     if (index(*argv,'=')) geom = *argv ; else
  1206.     if (!strcmp(*argv,"-g")) 
  1207.         if (*++argv)  geom = *argv ; else Usage(); else
  1208.     if (!strcmp(*argv,"-geometry")) 
  1209.         if (*++argv)  geom = *argv ; else Usage(); else
  1210.     if (!strcmp(*argv,"-geom")) 
  1211.         if (*++argv)  geom = *argv ; else Usage(); else
  1212.     if (!strcmp(*argv,"-t")) 
  1213.         if (*++argv)  type = *argv ; else Usage(); else
  1214.     if (!strcmp(*argv,"-i")) 
  1215.         if (*++argv)  input = *argv ; else Usage(); else
  1216.     if (!strcmp(*argv,"-o")) 
  1217.         if (*++argv)  output = *argv ; else Usage(); else
  1218.     if (!strcmp(*argv,"-s")) {
  1219.         if (numsymbols < 4) {
  1220.         if (*++argv) symbols[numsymbols].name = *argv ; else Usage();
  1221.         if (*++argv) symbols[numsymbols++].value = *argv ; else Usage();
  1222.         }
  1223.     } else
  1224.          Usage() ;
  1225.     }
  1226.  
  1227.  
  1228.     if ((dpy = XOpenDisplay(display)) == NULL) {
  1229.     fprintf(stderr,"Cannot open display : %s\n",
  1230.             XDisplayName(display));
  1231.     exit(0);
  1232.     }
  1233.  
  1234.     winx = 100;        winy = 100;
  1235.     winw = 100;        winh = 100;
  1236.     if (geom)  {
  1237.        XParseGeometry(geom, &winx, &winy, &winw, &winh) ;
  1238.     }
  1239.      
  1240.     root = DefaultRootWindow(dpy);
  1241.     screen = DefaultScreen(dpy) ;
  1242.     depth = DefaultDepth(dpy,screen) ;
  1243.     cmp = DefaultColormap(dpy, screen);
  1244.     v = DefaultVisual(dpy, screen);
  1245.  
  1246.     xswa.background_pixel = WhitePixel(dpy,DefaultScreen(dpy)) ;
  1247.     xswa.event_mask = ButtonPressMask;
  1248.     xswa.save_under = True ;
  1249.     xswa.override_redirect = True ;
  1250.     win = XCreateWindow(dpy,root,
  1251.             winx, winy, winw, winh, 1, 
  1252.             depth, InputOutput,CopyFromParent,
  1253.             CWEventMask|CWBackPixel|
  1254.             CWOverrideRedirect|CWSaveUnder, &xswa);
  1255.  
  1256.     if (input) {
  1257.     if ((ErrorStatus = XReadPixmapFile(dpy, v, win, cmp, input, depth,
  1258.                        &pix, &w, &h, &pixels, &npixels,
  1259.                        symbols, numsymbols, &infos))
  1260.         != PixmapSuccess) {
  1261.         printf("Pixmap Error %d\n", ErrorStatus);
  1262.         exit(1);
  1263.     }
  1264.     } else {
  1265.     if ((ErrorStatus = XCreatePixmapFromData(dpy, v, win, cmp, plaid, depth,
  1266.                         &pix, &w, &h, &pixels, &npixels,
  1267.                          symbols, numsymbols, NULL))
  1268.         != PixmapSuccess) {
  1269.         printf("Pixmap Error %d\n", ErrorStatus);
  1270.         exit(1);
  1271.     }
  1272.     }
  1273.     XSetWindowBackgroundPixmap(dpy, win, pix);
  1274.     XMapWindow(dpy, win);
  1275.  
  1276.     if (output)
  1277.     if ((ErrorStatus = XWritePixmapFile(dpy, cmp, output, pix, w, h, type, 
  1278.                         2, &infos))
  1279.         != PixmapSuccess) {
  1280.         printf("Pixmap Error %d\n", ErrorStatus);
  1281.         exit(1);
  1282.     }
  1283.  
  1284.     do {
  1285.       XNextEvent(dpy, &e) ;
  1286.       if (e.type == ButtonPress)
  1287.        notend = 0;
  1288.     } while (notend) ;
  1289.  
  1290.     XFreePixmap(dpy, pix);
  1291.     XFreeColors(dpy, cmp, pixels, npixels, 0);
  1292.     XFreeXpmInfo(&infos);
  1293. }
  1294.  
  1295.  
  1296. Usage()
  1297. {
  1298.     fprintf(stderr,"%s %s %s%s", command[0],
  1299.         "[-g wxh+x+y] [-d host:display.screen]",
  1300.         "[-s symbol_name symbol_value]\n", 
  1301.         "\t[-t type] [-i inputfile] [-o outputfile]\n");
  1302.     exit(0);
  1303. }
  1304. END_OF_SHAR_FOR_demo.c
  1305. cat > free.c << \END_OF_SHAR_FOR_free.c
  1306. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1307. /* free.c:
  1308.  *
  1309.  *  XPM2
  1310.  *  Free utility for XPM2 file format
  1311.  *  Developped by Arnaud Le Hors
  1312.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1313.  */
  1314.  
  1315. #include "xpmP.h"
  1316.  
  1317. freeColorTable(colorTable, ncolors)
  1318. char ***colorTable;
  1319. int ncolors;
  1320. { int a, b;
  1321.     if (colorTable) {
  1322.     for (a = 0; a < ncolors; a++)
  1323.         if (*(colorTable +a)) {
  1324.         for (b = 0; b < (NKEYS + 1); b++)
  1325.             if (*(*(colorTable +a) + b))
  1326.             free(*(*(colorTable +a) + b));
  1327.         free(*(colorTable +a));
  1328.         }
  1329.     free(colorTable);
  1330.     }
  1331. }
  1332.  
  1333. XFreeXpmInfo(infos)
  1334. XpmInfo *infos;
  1335. {
  1336.     if (infos) {
  1337.     if (infos->type) free(infos->type);
  1338.     freeColorTable(infos->colorTable, infos->ncolors);
  1339.     if (infos->hints_cmt) free(infos->hints_cmt);
  1340.     if (infos->colors_cmt) free(infos->colors_cmt);
  1341.     if (infos->pixels_cmt) free(infos->pixels_cmt);
  1342.     }
  1343. }
  1344. END_OF_SHAR_FOR_free.c
  1345. cat > mio.c << \END_OF_SHAR_FOR_mio.c
  1346. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1347. /* mio.c:
  1348.  *
  1349.  *  XPM2
  1350.  *  I/O utility for XPM2 file format
  1351.  *  Developped by Arnaud Le Hors
  1352.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1353.  */
  1354.  
  1355. #include "xpmP.h"
  1356.  
  1357. static int CommentLength = 0;
  1358. static char Comment[BUFSIZ];
  1359. LFUNC(atoui, unsigned int, (char *p));
  1360.  
  1361. static unsigned int atoui(p)
  1362. char *p;
  1363. {
  1364.         register int n;
  1365.  
  1366.         n = 0;
  1367.         while(*p >= '0' && *p <= '9')
  1368.                 n = n*10 + *p++ - '0';
  1369.         return(n);
  1370. }
  1371.  
  1372. mnextstring(mdata)        /* skip to the end of the current string */
  1373. MData *mdata;            /* and the beginning of the next one */
  1374. { char  c;
  1375.     switch(mdata->type) {
  1376.     case MARRAY:
  1377.     mdata->cptr = ((char **)mdata->stream)[++mdata->line];
  1378.     break;
  1379.     case MFILE:
  1380.     while ((c = mgetc(mdata)) != EOS && c != EOF);
  1381.     if (BOS)
  1382.         while ((c = mgetc(mdata)) != BOS && c != EOF);
  1383.     break;
  1384.     }
  1385. }
  1386.  
  1387. unsigned int mnextui(mdata)    /* skip whitespace and return the following */
  1388. MData *mdata;            /* unsigned int                 */
  1389. { char buf[BUFSIZ];
  1390.  
  1391.   mnextw(mdata, buf);
  1392.   return(atoui(buf));
  1393. }
  1394.  
  1395. char mgetc(mdata)        /* return the current character */
  1396. MData *mdata;
  1397. { char c;
  1398.   register unsigned int n = 1, a;
  1399.   unsigned int notend;
  1400.  
  1401.     switch(mdata->type) {
  1402.     case MARRAY:
  1403.     return(*mdata->cptr++);
  1404.     case MFILE:
  1405.     c = getc((FILE *)mdata->stream);
  1406.     if (BCMT && c == BCMT[0]) {
  1407.         Comment[0] = c;
  1408.         /* skip the string begining comment
  1409.          */
  1410.         while ((Comment[n] = getc((FILE *)mdata->stream)) == BCMT[n]
  1411.            && BCMT[n] != '\0' && Comment[n] != EOF) n++;
  1412.         if (BCMT[n] != '\0') { /* this wasn't the begining of a comment */
  1413.         for (a = 1; a < n; a++)
  1414.             mungetc(Comment[a], mdata);
  1415.         return(c);
  1416.         }
  1417.         /* store comment 
  1418.          */
  1419.         Comment[0] = Comment[n];
  1420.         n = notend = 1;
  1421.         while (notend) {
  1422.         while ((Comment[n] = getc((FILE *)mdata->stream)) != ECMT[0] 
  1423.                && Comment[n] != EOF) n++;
  1424.         CommentLength = n++;
  1425.         a = 1;
  1426.         while ((Comment[n] = getc((FILE *)mdata->stream)) == ECMT[a]
  1427.                && ECMT[a] != '\0' && Comment[n] != EOF) { a++; n++; }
  1428.         if (ECMT[a] == '\0') { /* this is the end of the comment */
  1429.             notend = 0;
  1430.             mungetc(Comment[n], mdata);
  1431.         } else {
  1432.             n++;
  1433.         }
  1434.         }
  1435.         c = mgetc(mdata);
  1436.     }
  1437.     return(c);
  1438.     }
  1439. }
  1440.  
  1441.  
  1442. char mungetc(c, mdata)        /* push the given character back */
  1443. int c;
  1444. MData *mdata;
  1445. { 
  1446.     switch(mdata->type) {
  1447.     case MARRAY:
  1448.     return(*--mdata->cptr = c);
  1449.     case MFILE:
  1450.     return(ungetc(c, (FILE *)mdata->stream));
  1451.     }
  1452. }
  1453.  
  1454.  
  1455. mskipwhite(mdata)        /* skip whitespace */
  1456. MData *mdata;
  1457. { char c;
  1458.  
  1459.     switch(mdata->type) {
  1460.     case MARRAY:
  1461.     while (*mdata->cptr == SPC || *mdata->cptr == TAB) 
  1462.         mdata->cptr++;
  1463.     break;
  1464.     case MFILE:
  1465.     while ((c = mgetc(mdata)) == SPC || c == TAB);
  1466.     mungetc(c, mdata);
  1467.     break;
  1468.     }
  1469. }
  1470.  
  1471.  
  1472. unsigned int mnextw(mdata, buf)    /* skip whitespace and return the following */
  1473. MData *mdata;            /* word                        */
  1474. char *buf;
  1475. { register unsigned int n = 0;
  1476.  
  1477.     mskipwhite(mdata);
  1478.     switch(mdata->type) {
  1479.     case MARRAY:
  1480.     while ((buf[n] = *mdata->cptr++) != SPC 
  1481.            && buf[n] != TAB && buf[n] != EOS && buf[n] != EOF) n++;
  1482.     mdata->cptr--;
  1483.     break;
  1484.     case MFILE:
  1485.     while ((buf[n] = mgetc(mdata)) != SPC 
  1486.            && buf[n] != TAB && buf[n] != EOS && buf[n] != EOF) n++;
  1487.     ungetc(buf[n],(FILE *)mdata->stream); 
  1488.     break;
  1489.     }
  1490.   return(n);
  1491. }
  1492.  
  1493. mgetcmt(mdata, cmt)        /* get the current comment line */
  1494. MData *mdata;
  1495. char **cmt;
  1496. {
  1497.     switch(mdata->type) {
  1498.     case MARRAY:
  1499.     break;
  1500.     case MFILE:
  1501.     *cmt = (char *) malloc(CommentLength + 1);
  1502.     strncpy(*cmt, Comment, CommentLength);
  1503.     (*cmt)[CommentLength] = '\0';
  1504.     CommentLength = 0;
  1505.     break;
  1506.     }
  1507. }
  1508. END_OF_SHAR_FOR_mio.c
  1509. cat > plaid << \END_OF_SHAR_FOR_plaid
  1510. ! XPM2
  1511. ! width height ncolors chars_per_pixel
  1512. 22 22 4 2
  1513. ! colors
  1514.    c red     m white  s light_color
  1515. Y  c yellow    m black  s lines_in_mix
  1516. +  c yellow    m white  s lines_in_dark
  1517. x         m black  s dark_color
  1518. ! pixels
  1519. x   x   x x x   x   x x x x x x + x x x x x 
  1520.   x   x   x   x   x   x x x x x x x x x x x 
  1521. x   x   x x x   x   x x x x x x + x x x x x 
  1522.   x   x   x   x   x   x x x x x x x x x x x 
  1523. x   x   x x x   x   x x x x x x + x x x x x 
  1524. Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + 
  1525. x   x   x x x   x   x x x x x x + x x x x x 
  1526.   x   x   x   x   x   x x x x x x x x x x x 
  1527. x   x   x x x   x   x x x x x x + x x x x x 
  1528.   x   x   x   x   x   x x x x x x x x x x x 
  1529. x   x   x x x   x   x x x x x x + x x x x x 
  1530.           x           x   x   x Y x   x   x 
  1531.           x             x   x   Y   x   x   
  1532.           x           x   x   x Y x   x   x 
  1533.           x             x   x   Y   x   x   
  1534.           x           x   x   x Y x   x   x 
  1535. x x x x x x x x x x x x x x x x x x x x x x 
  1536.           x           x   x   x Y x   x   x 
  1537.           x             x   x   Y   x   x   
  1538.           x           x   x   x Y x   x   x 
  1539.           x             x   x   Y   x   x   
  1540.           x           x   x   x Y x   x   x 
  1541. END_OF_SHAR_FOR_plaid
  1542. cat > plaid_c << \END_OF_SHAR_FOR_plaid_c
  1543. /* XPM2 C */
  1544. static char * plaid[] = {
  1545. /* plaid pixmap 
  1546.  * width height ncolors chars_per_pixel */
  1547. "22 22 4 2 ",
  1548. /* colors 
  1549.  */
  1550. "   c red     m white  s light_color ",
  1551. "Y  c yellow    m black  s lines_in_mix ",
  1552. "+  c yellow    m white  s lines_in_dark ",
  1553. "x         m black  s dark_color ",
  1554. /* pixels */
  1555. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1556. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1557. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1558. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1559. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1560. "Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + ", 
  1561. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1562. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1563. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1564. "  x   x   x   x   x   x x x x x x x x x x x ", 
  1565. "x   x   x x x   x   x x x x x x + x x x x x ", 
  1566. "          x           x   x   x Y x   x   x ", 
  1567. "          x             x   x   Y   x   x   ",
  1568. "          x           x   x   x Y x   x   x ", 
  1569. "          x             x   x   Y   x   x   ", 
  1570. "          x           x   x   x Y x   x   x ", 
  1571. "x x x x x x x x x x x x x x x x x x x x x x ", 
  1572. "          x           x   x   x Y x   x   x ", 
  1573. "          x             x   x   Y   x   x   ", 
  1574. "          x           x   x   x Y x   x   x ", 
  1575. "          x             x   x   Y   x   x   ", 
  1576. "          x           x   x   x Y x   x   x "
  1577. } ;
  1578. END_OF_SHAR_FOR_plaid_c
  1579. cat > plaid_ll << \END_OF_SHAR_FOR_plaid_ll
  1580. ; XPM2 Lisp 
  1581. (setq plaid '(
  1582. ; width height ncolors chars_per_pixel  
  1583. "22 22 4 2"
  1584. ; colors 
  1585. "   c red     m white  s light_color"
  1586. "Y  c yellow    m black  s lines_in_mix"
  1587. "+  c yellow    m white  s lines_in_dark"
  1588. "x         m black  s dark_color"
  1589. ; pixels 
  1590. "x   x   x x x   x   x x x x x x + x x x x x " 
  1591. "  x   x   x   x   x   x x x x x x x x x x x " 
  1592. "x   x   x x x   x   x x x x x x + x x x x x " 
  1593. "  x   x   x   x   x   x x x x x x x x x x x " 
  1594. "x   x   x x x   x   x x x x x x + x x x x x " 
  1595. "Y Y Y Y Y x Y Y Y Y Y + x + x + x + x + x + " 
  1596. "x   x   x x x   x   x x x x x x + x x x x x " 
  1597. "  x   x   x   x   x   x x x x x x x x x x x " 
  1598. "x   x   x x x   x   x x x x x x + x x x x x " 
  1599. "  x   x   x   x   x   x x x x x x x x x x x " 
  1600. "x   x   x x x   x   x x x x x x + x x x x x " 
  1601. "          x           x   x   x Y x   x   x " 
  1602. "          x             x   x   Y   x   x   "
  1603. "          x           x   x   x Y x   x   x " 
  1604. "          x             x   x   Y   x   x   " 
  1605. "          x           x   x   x Y x   x   x " 
  1606. "x x x x x x x x x x x x x x x x x x x x x x " 
  1607. "          x           x   x   x Y x   x   x " 
  1608. "          x             x   x   Y   x   x   " 
  1609. "          x           x   x   x Y x   x   x " 
  1610. "          x             x   x   Y   x   x   " 
  1611. "          x           x   x   x Y x   x   x "
  1612. ))
  1613. END_OF_SHAR_FOR_plaid_ll
  1614. cat > rep10.sty << \END_OF_SHAR_FOR_rep10.sty
  1615. % rep10.sty 23 Sep 85
  1616. \lineskip 1pt \normallineskip 1pt
  1617. \def\baselinestretch{1}
  1618.  
  1619. \def\@normalsize{\@setsize\normalsize{12pt}\xpt\@xpt
  1620. \abovedisplayskip 10pt plus2pt minus5pt\belowdisplayskip \abovedisplayskip
  1621. \abovedisplayshortskip \z@ plus3pt\belowdisplayshortskip 6pt plus3pt minus3pt}
  1622. \def\small{\@setsize\small{11pt}\ixpt\@ixpt
  1623. \abovedisplayskip 8.5pt plus 3pt minus 4pt\belowdisplayskip \abovedisplayskip
  1624. \abovedisplayshortskip \z@ plus2pt\belowdisplayshortskip 4pt plus2pt minus 2pt
  1625. \def\@listi{\topsep 4pt plus 2pt minus 2pt\parsep 2pt plus 1pt minus 1pt
  1626. \itemsep \parsep}}
  1627. \def\footnotesize{\@setsize\footnotesize{9.5pt}\viiipt\@viiipt
  1628. \abovedisplayskip 6pt plus 2pt minus 4pt\belowdisplayskip \abovedisplayskip
  1629. \abovedisplayshortskip \z@ plus 1pt\belowdisplayshortskip 3pt plus 1pt minus
  1630. 2pt
  1631. \def\@listi{\topsep 3pt plus 1pt minus 1pt\parsep 2pt plus 1pt minus 1pt
  1632. \itemsep \parsep}}
  1633. \def\scriptsize{\@setsize\scriptsize{8pt}\viipt\@viipt}
  1634. \def\tiny{\@setsize\tiny{6pt}\vpt\@vpt}
  1635. \def\large{\@setsize\large{14pt}\xiipt\@xiipt}
  1636. \def\Large{\@setsize\Large{18pt}\xivpt\@xivpt}
  1637. \def\LARGE{\@setsize\LARGE{22pt}\xviipt\@xviipt}
  1638. \def\huge{\@setsize\huge{25pt}\xxpt\@xxpt}
  1639. \def\Huge{\@setsize\Huge{30pt}\xxvpt\@xxvpt}
  1640. \normalsize 
  1641.  
  1642. \if@twoside \oddsidemargin 44pt \evensidemargin 82pt \marginparwidth 107pt
  1643. \else \oddsidemargin 63pt \evensidemargin 63pt
  1644.  \marginparwidth 90pt 
  1645. \fi
  1646. \marginparsep 11pt 
  1647.  \topmargin 27pt \headheight 12pt \headsep 25pt \footheight 12pt \footskip
  1648. 30pt 
  1649.  
  1650. \textheight 528pt \textwidth 345pt \columnsep 10pt \columnseprule 0pt 
  1651.  
  1652. \footnotesep 6.65pt 
  1653. \skip\footins 9pt plus 4pt minus 2pt 
  1654. \floatsep 12pt plus 2pt minus 2pt \textfloatsep 20pt plus 2pt minus 4pt
  1655. \intextsep 12pt plus 2pt minus 2pt \@maxsep 20pt \dblfloatsep 12pt plus 2pt
  1656. minus 2pt \dbltextfloatsep 20pt plus 2pt minus 4pt \@dblmaxsep 20pt 
  1657. \@fptop 0pt plus 1fil \@fpsep 8pt plus 2fil \@fpbot 0pt plus 1fil 
  1658. \@dblfptop 0pt plus 1fil \@dblfpsep 8pt plus 2fil \@dblfpbot 0pt plus 1fil
  1659. \marginparpush 5pt 
  1660.  
  1661. \parskip 0pt plus 1pt \parindent 15pt \topsep 8pt plus 2pt minus 4pt
  1662. \partopsep 2pt plus 1pt minus 1pt \itemsep 4pt plus 2pt minus 1pt 
  1663. \@lowpenalty 51 \@medpenalty 151 \@highpenalty 301 
  1664. \@beginparpenalty -\@lowpenalty \@endparpenalty -\@lowpenalty \@itempenalty
  1665. -\@lowpenalty 
  1666.  
  1667. \def\part{\cleardoublepage \thispagestyle{plain} \if@twocolumn \onecolumn
  1668. \@tempswatrue \else \@tempswafalse \fi \hbox{}\vfil \bgroup \centering
  1669. \secdef\@part\@spart} 
  1670.  
  1671. \def\@part[#1]#2{\ifnum \c@secnumdepth >-2\relax \refstepcounter{part}
  1672. \addcontentsline{toc}{part}{\thepart \hspace{1em}#1}\else
  1673. \addcontentsline{toc}{part}{#1}\fi \markboth{}{}
  1674.  \ifnum \c@secnumdepth >-2\relax \huge\bf Part \thepart \par \vskip 20pt \fi
  1675. \Huge \bf #1\@endpart} 
  1676. \def\@endpart{\par\egroup \vfil\newpage \if@twoside \hbox{}
  1677. \thispagestyle{empty} 
  1678.  \newpage 
  1679.  \fi \if@tempswa \twocolumn \fi} 
  1680. \def\@spart#1{\Huge \bf #1\@endpart}
  1681.  
  1682.  
  1683. \def\@makechapterhead#1{ \vspace*{50pt} { \parindent 0pt \raggedright 
  1684.  \ifnum \c@secnumdepth >\m@ne \huge\bf \@chapapp{} \thechapter \par 
  1685.  \vskip 20pt \fi \Huge \bf #1\par 
  1686.  \nobreak \vskip 40pt } }
  1687.  
  1688. \def\@makeschapterhead#1{ \vspace*{50pt} { \parindent 0pt \raggedright 
  1689.  \Huge \bf #1\par 
  1690.  \nobreak \vskip 40pt } }
  1691.  
  1692. \def\chapter{\clearpage \thispagestyle{plain} \global\@topnum\z@
  1693. \@afterindentfalse \secdef\@chapter\@schapter} 
  1694. \def\@chapter[#1]#2{\ifnum \c@secnumdepth >\m@ne
  1695.  \refstepcounter{chapter}
  1696.  \typeout{\@chapapp\space\thechapter.}
  1697.  \addcontentsline{toc}{chapter}{\protect
  1698.  \numberline{\thechapter}#1}\else
  1699.  \addcontentsline{toc}{chapter}{#1}\fi
  1700.  \chaptermark{#1}
  1701.  \addtocontents{lof}{\protect\addvspace{10pt}}
  1702. \addtocontents{lot}{\protect\addvspace{10pt}} \if@twocolumn
  1703. \@topnewpage[\@makechapterhead{#2}] 
  1704.  \else \@makechapterhead{#2}
  1705.  \@afterheading \fi} 
  1706. \def\@schapter#1{\if@twocolumn \@topnewpage[\@makeschapterhead{#1}]
  1707.  \else \@makeschapterhead{#1} 
  1708.  \@afterheading\fi}
  1709.  
  1710. \def\section{\@startsection {section}{1}{\z@}{-3.5ex plus -1ex minus 
  1711.  -.2ex}{2.3ex plus .2ex}{\Large\bf}}
  1712. \def\subsection{\@startsection{subsection}{2}{\z@}{-3.25ex plus -1ex minus 
  1713.  -.2ex}{1.5ex plus .2ex}{\large\bf}}
  1714. \def\subsubsection{\@startsection{subsubsection}{3}{\z@}{-3.25ex plus
  1715. -1ex minus -.2ex}{1.5ex plus .2ex}{\normalsize\bf}}
  1716. \def\paragraph{\@startsection
  1717.  {paragraph}{4}{\z@}{3.25ex plus 1ex minus .2ex}{-1em}{\normalsize\bf}}
  1718. \def\subparagraph{\@startsection
  1719.  {subparagraph}{4}{\parindent}{3.25ex plus 1ex minus 
  1720.  .2ex}{-1em}{\normalsize\bf}}
  1721.  
  1722. \def\chaptermark#1{}
  1723.  
  1724. \setcounter{secnumdepth}{2}
  1725.  
  1726. \def\appendix{\par
  1727.  \setcounter{chapter}{0}
  1728.  \setcounter{section}{0}
  1729.  \def\@chapapp{Appendix}
  1730.  \def\thechapter{\Alph{chapter}}}
  1731.  
  1732.  
  1733. \leftmargini 25pt
  1734. \leftmarginii 22pt \leftmarginiii 18.7pt \leftmarginiv 17pt \leftmarginv 10pt
  1735. \leftmarginvi 10pt
  1736. \leftmargin\leftmargini
  1737. \labelwidth\leftmargini\advance\labelwidth-\labelsep
  1738. \labelsep 5pt
  1739. \parsep 4pt plus 2pt minus 1pt
  1740. \def\@listi{\leftmargin\leftmargini}
  1741. \def\@listii{\leftmargin\leftmarginii
  1742.  \labelwidth\leftmarginii\advance\labelwidth-\labelsep
  1743.  \topsep 4pt plus 2pt minus 1pt
  1744.  \parsep 2pt plus 1pt minus 1pt
  1745.  \itemsep \parsep}
  1746. \def\@listiii{\leftmargin\leftmarginiii
  1747.  \labelwidth\leftmarginiii\advance\labelwidth-\labelsep
  1748.  \topsep 2pt plus 1pt minus 1pt 
  1749.  \parsep \z@ \partopsep 1pt plus 0pt minus 1pt
  1750.  \itemsep \topsep}
  1751. \def\@listiv{\leftmargin\leftmarginiv
  1752.  \labelwidth\leftmarginiv\advance\labelwidth-\labelsep}
  1753. \def\@listv{\leftmargin\leftmarginv
  1754.  \labelwidth\leftmarginv\advance\labelwidth-\labelsep}
  1755. \def\@listvi{\leftmargin\leftmarginvi
  1756.  \labelwidth\leftmarginvi\advance\labelwidth-\labelsep}
  1757. END_OF_SHAR_FOR_rep10.sty
  1758. cat > value.c << \END_OF_SHAR_FOR_value.c
  1759. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1760. /* value.c:
  1761.  *
  1762.  * routines for converting byte values to long values.  these are pretty
  1763.  * portable although they are not necessarily the fastest things in the
  1764.  * world.
  1765.  *
  1766.  * jim frost 10.02.89
  1767.  * Copyright 1989, 1990 Jim Frost
  1768.  *
  1769.  * Permission to use, copy, modify, distribute, and sell this software
  1770.  * and its documentation for any purpose is hereby granted without fee,
  1771.  * provided that the above copyright notice appear in all copies and
  1772.  * that both that copyright notice and this permission notice appear
  1773.  * in supporting documentation.  The author makes no representations
  1774.  * about the suitability of this software for any purpose.  It is
  1775.  * provided "as is" without express or implied warranty.
  1776.  *
  1777.  * THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  1778.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  1779.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  1780.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  1781.  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  1782.  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
  1783.  * USE OR PERFORMANCE OF THIS SOFTWARE.
  1784.  *
  1785.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1786.  */
  1787.  
  1788. typedef unsigned char  byte;      /* byte type */
  1789.  
  1790. unsigned long memToVal(p, len)
  1791.      byte         *p;
  1792.      unsigned int  len;
  1793. { unsigned int  a;
  1794.   unsigned long i;
  1795.  
  1796.   i= 0;
  1797.   for (a= 0; a < len; a++)
  1798.     i= (i << 8) + *(p++);
  1799.   return(i);
  1800. }
  1801.  
  1802. void valToMem(val, p, len)
  1803.      unsigned long  val;
  1804.      byte          *p;
  1805.      unsigned int   len;
  1806. { int a;
  1807.  
  1808.   for (a= len - 1; a >= 0; a--) {
  1809.     *(p + a)= val & 0xff;
  1810.     val >>= 8;
  1811.   }
  1812. }
  1813. END_OF_SHAR_FOR_value.c
  1814. cat > visual.c << \END_OF_SHAR_FOR_visual.c
  1815. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1816. /* visual.c:
  1817.  *
  1818.  *  XPM2
  1819.  *  Visual utility for XPM2 file format
  1820.  *  Developped by Arnaud Le Hors
  1821.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1822.  */
  1823.  
  1824. #include "xpmP.h"
  1825.  
  1826. visualType(visual)
  1827. Visual *visual;
  1828. {
  1829.   if (visual->class == GrayScale)
  1830.       switch(visual->map_entries) {
  1831.       case 2:
  1832.       return(MONO);
  1833.       break;
  1834.       case 4:
  1835.       return(GRAY4);
  1836.       break;
  1837.       default:
  1838.       return(GRAY);
  1839.       }
  1840.   else
  1841.       return(COLOR);
  1842. }
  1843.  
  1844. END_OF_SHAR_FOR_visual.c
  1845. cat > xpm.h << \END_OF_SHAR_FOR_xpm.h
  1846. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  1847. /* xpm.h:
  1848.  *
  1849.  *  XPM2
  1850.  *  Include file
  1851.  *  Developped by Arnaud Le Hors
  1852.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  1853.  */
  1854.  
  1855. #ifndef XPM_h
  1856. #define XPM_h
  1857.  
  1858. #define XPM_FORMAT 2
  1859.  
  1860. #include <X11/Xlib.h>
  1861. #include <stdio.h>
  1862.  
  1863. /* we keep the same codes as for Bitmap management */
  1864. #ifndef _XUTIL_H_
  1865. #ifdef VMS
  1866. #include "decw$include:Xutil.h"
  1867. #else
  1868. #include <X11/Xutil.h>
  1869. #endif
  1870. #endif
  1871.  
  1872. #define PixmapSuccess          0
  1873. #define PixmapOpenFailed       1
  1874. #define PixmapFileInvalid      2
  1875. #define PixmapNoMemory         3
  1876. #define PixmapParseColorFailed 4
  1877. #define PixmapAllocColorFailed 5
  1878.  
  1879.  
  1880. /* Global variables
  1881.  */
  1882.  
  1883. int XpmErrorStatus;
  1884. char *BCMT, *ECMT, BOS, EOS;
  1885.  
  1886. #define EOL '\n'
  1887. #define TAB '\t'
  1888. #define SPC ' '
  1889.  
  1890. typedef unsigned char  byte;      /* byte type */
  1891. typedef unsigned long  Pixel;     /* what X thinks a pixel is */
  1892.  
  1893. struct {
  1894.     char *type;            /* key word */
  1895.     char *Bcmt;            /* string begining comments */
  1896.     char *Ecmt;            /* string ending comments */
  1897.     char  Bos;            /* character begining strings */
  1898.     char  Eos;            /* character ending strings */
  1899.     char *Strs;            /* strings separator */
  1900.     char *Dec;            /* data declaration string */
  1901.     char *Boa;            /* string begining assignment */
  1902.     char *Eoa;            /* string ending assignment */
  1903. } DataTypes[] = {
  1904.     "", "!", "\n", '\0', '\n', "", "", "", "", /* Natural type */
  1905.     "C", "/*", "*/\n", '"', '"', ",\n", "static char **", " = {\n", "};\n",
  1906.     "Lisp", ";", "\n", '"', '"', "\n", "(setq ", " '(\n", "))\n",
  1907.     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  1908. };
  1909.  
  1910. char *ColorKeys[] = {
  1911.     "s",            /* key #1: symbol */
  1912.     "m",            /* key #2: mono visual */
  1913.     "g4",            /* key #3: 4 grays visual */
  1914.     "g",            /* key #4: gray visual */
  1915.     "c",            /* key #5: color visual */
  1916. };
  1917. #define NKEYS 5            /* total number of Colorkeys */
  1918.  
  1919.  
  1920. typedef struct {
  1921.     char *name;
  1922.     char *value;
  1923. } ColorSymbol;
  1924.  
  1925. typedef struct {
  1926.     char *type;
  1927.     int ncolors;
  1928.     char ***colorTable;
  1929.     Pixel *pixels;
  1930.     char *hints_cmt;
  1931.     char *colors_cmt;
  1932.     char *pixels_cmt;
  1933. } XpmInfo;
  1934.  
  1935. #define MAXPRINTABLE 93             /* number of printable ascii chars 
  1936.                        minus \ and " for string compat. */
  1937.  
  1938. char *printable = 
  1939. " .XoO+@#$%&*=-;:?>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\
  1940. ASDFGHJKLPIUYTREWQ!~^/()_`'][{}|" ;
  1941.            /* printable begin with a space, so in most case, due to
  1942.           my algorythm, when the number of different colors is
  1943.           less than MAXPRINTABLE, it will give a char follow by 
  1944.           "nothing" (a space) in the readable xpm file */
  1945.  
  1946.  
  1947. /* minimal portability layer between ansi and KR C 
  1948.  */
  1949.  
  1950. /* forward declaration of functions with prototypes */
  1951.  
  1952. #if __STDC__                /* ANSI */
  1953. #define FUNC(f, t, p) extern t f p
  1954. #define LFUNC(f, t, p) static t f p
  1955. #else                    /* K&R */
  1956. #define FUNC(f, t, p) extern t f()
  1957. #define LFUNC(f, t, p) static t f()
  1958. #endif                    /* end of K&R */
  1959.  
  1960. /* functions declarations
  1961.  */
  1962.  
  1963. FUNC(XCreatePixmapFromData, int, (Display *display,
  1964.                   Visual *visual,
  1965.                   Drawable d,
  1966.                   Colormap colormap,
  1967.                   char **data,
  1968.                   unsigned int depth,
  1969.                   Pixmap *pixmap_return,
  1970.                   unsigned int *width_return, 
  1971.                   unsigned int *height_return, 
  1972.                   Pixel **pixels_return,
  1973.                   unsigned int *npixels_return,
  1974.                   ColorSymbol colorsymbols[],
  1975.                   unsigned int numsymbols,
  1976.                   XpmInfo *infos));
  1977.  
  1978. FUNC(XReadPixmapFile, int, (Display *display,
  1979.                 Visual *visual,
  1980.                 Drawable d,
  1981.                 Colormap colormap,
  1982.                 char *filename,
  1983.                 unsigned int depth,
  1984.                 Pixmap *pixmap_return,
  1985.                 unsigned int *width_return, 
  1986.                 unsigned int *height_return, 
  1987.                 Pixel **pixels_return,
  1988.                 unsigned int *npixels_return,
  1989.                 ColorSymbol colorsymbols[],
  1990.                 unsigned int numsymbols,
  1991.                 XpmInfo *infos));
  1992.  
  1993. FUNC(XWritePixmapFile, int, (Display *display,
  1994.                  Colormap colormap,
  1995.                  char *filename,
  1996.                  Pixmap *pixmap,
  1997.                  unsigned int width,
  1998.                  unsigned int height,
  1999.                  char *type,
  2000.                  unsigned int cppm,
  2001.                  XpmInfo *infos));
  2002.  
  2003. FUNC(XFreeXpmInfo, int, (XpmInfo *infos));
  2004.  
  2005. #endif
  2006. END_OF_SHAR_FOR_xpm.h
  2007. cat > xpm.tex << \END_OF_SHAR_FOR_xpm.tex
  2008. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2009. %                              XPM MANUAL                                    %
  2010. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2011.  
  2012. % $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  2013. %
  2014. % adjust these for centering on the page:
  2015. % upper-left corner of frame in title page must be at 60mm,60mm from 
  2016. % upper-left corner of the page
  2017.  
  2018. % normal (A4) on our Apple Laserwriter with dvi2ps
  2019. %\hoffset 0cm
  2020. %\voffset 0cm
  2021. % normal (A4 & Letter) on our Apple Laserwriter with dvips v5.0
  2022. \hoffset -5.5mm
  2023. \voffset 0cm
  2024. % our imagen
  2025. %\hoffset -0.9cm
  2026. %\voffset -2.2cm
  2027.            
  2028. % NOTE: the following line MUST be commented out!
  2029. %\includeonly{standard}
  2030.  
  2031. \makeindex
  2032.  
  2033. \documentstyle[twoside,colas]{article}
  2034.  
  2035. % IF YOUR DVI PRINTER CHOKES ON INCLUDED POSTSCRIPT FILES
  2036. % by the \special command, uncomment the following line:
  2037. % \def\texpsfig#1#2#3{\fbox{Figure ``#1''}}
  2038.  
  2039.  
  2040. \pagestyle{headings}
  2041. \begin{document} 
  2042.  
  2043. \thispagestyle{empty}
  2044. \ 
  2045. \hbox{\colastitledisp
  2046. \vbox{
  2047. \vspace{3cm}
  2048. \begin{center}
  2049. \fboxrule 0.4pt \fboxsep 1pt
  2050. \fbox{\fboxrule 3pt \fboxsep 30pt \fbox{\Huge\bf XPM Manual}}
  2051. \end{center}
  2052. \vspace{2cm}
  2053. \begin{center}
  2054. \huge
  2055. The {\bf X} {\bf P}ix{\bf M}ap Format
  2056. \end{center}
  2057. \vspace{2cm}
  2058. \begin{center} 
  2059. \Large Version \RCSRevVersion$Version: 2.1 $\\
  2060. \end{center}
  2061. \vspace{2cm}
  2062. \begin{center}
  2063. \LARGE\sf Arnaud Le Hors\\
  2064. \large\tt lehors@mirsa.inria.fr
  2065. \end{center}
  2066. \vspace{1cm}
  2067. \vspace{1cm}
  2068. \begin{center}
  2069. \copyright BULL 1990
  2070. \end{center}
  2071. }}
  2072.  
  2073. \newpage
  2074.  
  2075. \section*{Copyright restrictions}
  2076. {\bf\begin{flushleft} 
  2077. Copyright 1990 GROUPE BULL\\
  2078. \end{flushleft}}
  2079.  
  2080. {\sf
  2081. Permission to use, copy, modify, and distribute this software and its
  2082. documentation for any purpose and without fee is hereby granted, provided
  2083. that the above copyright notice appear in all copies and that both that
  2084. copyright notice and this permission notice appear in supporting
  2085. documentation, and that the name of GROUPE BULL not be used in advertising
  2086. or publicity pertaining to distribution of the software without specific,
  2087. written prior permission.  GROUPE BULL makes no representations about the
  2088. suitability of this software for any purpose.  It is provided ``as is''
  2089. without express or implied warranty.
  2090.  
  2091. GROUPE BULL disclaims all warranties with regard to this software,
  2092. including all implied warranties of merchantability and fitness,
  2093. in no event shall GROUPE BULL be liable for any special,
  2094. indirect or consequential damages or any damages
  2095. whatsoever resulting from loss of use, data or profits,
  2096. whether in an action of contract, negligence or other tortious
  2097. action, arising out of or in connection with the use 
  2098. or performance of this software.
  2099. }
  2100.  
  2101. \section*{Acknowledgements}
  2102.  
  2103. I want to thank my team partner and friend Colas Nahaboo who proposed me this
  2104. project, and who actively participated to its design.
  2105.  
  2106. \begin{flushright}
  2107. {\Large Arnaud Le Hors.\quad}
  2108. {\small
  2109. KOALA Project -- BULL Research c/o INRIA\\
  2110. 2004 route des Lucioles -- 06565 Valbonne Cedex -- FRANCE\\
  2111. }
  2112. \end{flushright}
  2113.  
  2114. \section*{Support}
  2115.  
  2116. \sloppy 
  2117. You can mail any question or suggestion relative to {\bf XPM} by electronic
  2118. mail to {\tt lehors@mirsa.inria.fr}, and you can find the latest release by
  2119. anonymous ftp on avahi.inria.fr (192.5.60.47) or expo.lcs.mit.edu
  2120. (18.30.0.212).
  2121.  
  2122. \newpage
  2123. \section{Introduction}
  2124. First, Why another image format?  We (Koala team at Bull Research, France)
  2125. felt that most images bundled with X applications will be small "icons", and
  2126. that since many applications are color-customizable, existing image formats
  2127. such as gif, tiff, iff, etc... were intended for big images with well-defined
  2128. colors and so weren't adapted to the task.  So {\bf XPM} was designed with
  2129. these criterions in mind:
  2130. \begin{itemize}
  2131. \item be editable by hand (under emacs, vi...). Color pixmap editors aren't
  2132. available everywhere.
  2133. \item be includable in code either C, Lisp, ... It is unreasonable to load
  2134. 1000 pixmap files on each start of an application.
  2135. \item be a portable, mailable ascii format.
  2136. \item provide defaults for monochrome/color/grayscale renderings.
  2137. \item provide overriding of colors. This way if the user wants your
  2138. application
  2139. to be bluish instead of greenish, you can use the SAME icon files.
  2140. \item allow comments to be included in the file.
  2141. \end{itemize}
  2142.  
  2143. \newpage
  2144. \section{The {\bf XPM2} Format}
  2145.  
  2146. The {\bf XPM2} format presents different types of syntax, in order to provide
  2147. the ability to include {\bf XPM2} files in different languages. But the
  2148. different types are much alike if we consider the following type dependent
  2149. tokens: beginning and end of line, beginning and end of string, string
  2150. separator, beginning and end of comment, declaration string, beginning and end
  2151. of assignment. Depending on the type they may or may not exist.
  2152.  
  2153. The {\bf XPM2} format is conceptually an array of string. The Natural type
  2154. which is designed for manual editing is a syntax derived from the {\bf X}
  2155. resource file format, where strings are just lines ending with a newline
  2156. character and where comments start at an exclamation mark and end at the end
  2157. of the line.
  2158.  
  2159. The {\bf XPM2} format is composed of six different sections as follows:
  2160. {\tt
  2161. \begin{flushleft}
  2162. \hspace{1cm}<Header line>\\
  2163. \hspace{1cm}<Declaration and Beginning of Assignment line>\\
  2164. \hspace{1cm}<Hints>\\
  2165. \hspace{1cm}<Colors>\\
  2166. \hspace{1cm}<Pixels>\\
  2167. \hspace{1cm}<End of Assignment>
  2168. \end{flushleft}
  2169. }
  2170. The {\tt Header line} is composed as follows: 
  2171.  
  2172. {\tt <AnyWord>} XPM2 {\tt <Type>} {\tt <AnyWord>}
  2173.  
  2174. The words are separated by a white space which can be composed of space and
  2175. tabulation characters.  The {\tt AnyWord} can be anyone as it will just be
  2176. skipped, this is to allow any kind of language dependent comment string. The
  2177. {\tt Type} word defines the type of {\bf XPM2} format and thus the syntax of
  2178. the file being read. For now, this may be nothing for Natural type, C, or
  2179. Lisp.  The line must end by a newline character. From there, the different
  2180. type dependent syntax tokens are determined.
  2181.  
  2182. In case of Natural type, there is no {\tt Declaration and Beginning of
  2183. Assignment line}; otherwise it must end by a newline character and is composed
  2184. as follows: 
  2185.  
  2186. {\tt <Declaration string> <variable name> <Beginning of assignment>}
  2187.  
  2188. The {\tt Hints} section is composed of one line containing the four integers
  2189. in base 10, corresponding to the pixmap width and height, the number of colors
  2190. and the number of characters per pixel as follows:
  2191.  
  2192. {\tt <width> <height> <ncolors> <chars\_per\_pixel>}
  2193.  
  2194. The {\tt Colors} section is composed of as many lines as there are colors, and
  2195. each line is composed as follows: 
  2196.  
  2197. {\tt <chars> [[<key> <color>] ... ]}
  2198.  
  2199. Where {\tt chars} is the {\tt chars\_per\_pixel} length string (not surrounded
  2200. anything) representing the pixels, {\tt color} is the specified color, and
  2201. {\tt key} is a keyword describing in which context this color should be used.
  2202. For now these keys may have the following values:
  2203.  
  2204. \begin{tabbing}
  2205. \hspace{1cm}\= g4 \= for 4-level grayscale\kill
  2206. \> m  \>for mono visual\\
  2207. \> s  \> for symbolic name\\
  2208. \> g4 \> for 4-level grayscale\\
  2209. \> g  \> for grayscale with more than 4 levels\\
  2210. \> c  \> for color visual
  2211. \end{tabbing}
  2212.  
  2213. Colors can be specified by giving colorname, the RGB code following the \#
  2214. character, or the HSV code following the \% character (not implemented yet).
  2215. The symbolic name provides the ability of specifying the colors at load
  2216. time, and not to hard-code them in the file.
  2217.  
  2218. The {\tt Pixels} section is composed by {\tt height} strings of {\tt width} *
  2219. {\tt chars\_per\_pixel} characters, where every {\tt chars\_per\_pixel} length
  2220. string must be one of the previously defined in the {\tt Colors} section.
  2221.  
  2222. Finally the {\tt End of Assignment} section ends the format.
  2223.  
  2224.  
  2225. \newpage
  2226. \section{The {\bf XPM2} Library}
  2227.  
  2228. The {\bf XPM2} library provides three functions that you can use to read and
  2229. write a pixmap from and to a {\bf XPM2} format file, and to create a pixmap.
  2230. This section describes these functions.
  2231.  
  2232. \vspace{.5cm}
  2233. To provide a way to rewrite an {\bf XPM2} file without loosing information
  2234. such as comments, color defaults and symbols which may exist in the read file,
  2235. the {\bf XPM2} library defines the {\bf XpmInfo} structure to stores them.
  2236. This structure contains:
  2237.  
  2238. \begin{tabbing}
  2239.  
  2240. \hspace{1cm}\= Unsigned long *pixels; \= /* List of color pixels. */ \kill
  2241. typedef struct \{ \\
  2242. \> char *type; \> /* Type of {\bf XPM2} format: Natural, C, Lisp, ... */ \\
  2243. \> int ncolors; \> /* Number of colors. */ \\
  2244. \> char ***colorTable; \> /* Color table pointer. */ \\
  2245. \> Unsigned long *pixels; \> /* List of color pixels. */ \\
  2246. \> char *hints\_cmt; \> /* Comment of the hints section. */ \\
  2247. \> char *colors\_cmt; \> /* Comment of the colors section. */ \\
  2248. \> char *pixels\_cmt; \> /* Comment of the pixels section. */ \\
  2249. \} XpmInfo;
  2250.  
  2251. \end{tabbing}
  2252.  
  2253. The colorTable is a two dimensional array of strings, organized as follows:
  2254. \begin{flushleft}
  2255. \hspace{.5cm}colorTable[color\#][0] points to the character string associated
  2256. to the color.\\
  2257. \hspace{.5cm}colorTable[color\#][1] points to the symbolic name of the
  2258. color.\\
  2259. \hspace{.5cm}colorTable[color\#][2] points to the default color for monochrome
  2260. visuals.\\
  2261. \hspace{.5cm}colorTable[color\#][3] points to the default color for 4-level
  2262. grayscale visuals.\\
  2263. \hspace{.5cm}colorTable[color\#][4] points to the default color for other
  2264. grayscale visuals.\\
  2265. \hspace{.5cm}colorTable[color\#][5] points to the default color for color
  2266. visuals. 
  2267. \end{flushleft}
  2268.  
  2269. Comments are limited to a single comment string by section. If more exist in
  2270. the read file, then only the last comment of each section will be stored.
  2271.  
  2272. To get informations back while writting out to a file, you just have to pass a
  2273. pointer to an {\bf XpmInfo} structure to the {\bf XReadPixmapFile} {\bf XPM2}
  2274. function while reading the file, and then give it back to the {\bf
  2275. XWritePixmapFile} {\bf XPM2} function while writting.
  2276.  
  2277. \vspace{.5cm}
  2278. To allow overriding of colors at load time the {\bf XPM2} library defines the
  2279. {\bf ColorSymbol} structure which contains:
  2280.  
  2281. \begin{tabbing}
  2282. \hspace{1cm}\= char *value; \hspace{1.5cm}\= /* Color value */\kill
  2283. typedef struct \{\\
  2284. \> char *name; \> /* Symbolic color name */\\
  2285. \> char *value;\> /* Color value */\\
  2286. \} ColorSymbol;
  2287. \end{tabbing}
  2288.  
  2289. To override colors at load time, you just have to pass to the {\bf
  2290. XReadPixmapFile} or {\bf XCreatePixmapFromData} {\bf XPM2} functions a pointer
  2291. to a list of {\bf ColorSymbol} elements containing the desired colors.
  2292.  
  2293. \vspace{.5cm}
  2294. To read a pixmap from a file, use {\bf XReadPixmapFile}.
  2295.  
  2296. \begin{flushleft} 
  2297.  
  2298. int XReadPixmapFile({\it display, visual, d, colormap, filename, depth, \\
  2299. \hspace{3cm}pixmap\_return, width\_return, height\_return, \\
  2300. \hspace{3cm}pixels\_return, npixels\_return, \\
  2301. \hspace{3cm}colorsymbols, numsymbols, infos})\\
  2302.  
  2303. \hspace{1cm}Display {\it *display;}\\
  2304. \hspace{1cm}Visual {\it *visual;}\\
  2305. \hspace{1cm}Drawable {\it d;}\\
  2306. \hspace{1cm}Colormap {\it colormap;}\\
  2307. \hspace{1cm}char {\it *filename;}\\
  2308. \hspace{1cm}unsigned int {\it depth;}\\
  2309. \hspace{1cm}Pixmap {\it *pixmap\_return;}\\
  2310. \hspace{1cm}unsigned int {\it *width\_return, *height\_return;}\\
  2311. \hspace{1cm}unsigned long {\it **pixels\_return;}\\
  2312. \hspace{1cm}unsigned int {\it *npixels\_return;}\\
  2313. \hspace{1cm}ColorSymbol {\it colorsymbols[];}\\
  2314. \hspace{1cm}unsigned int {\it numsymbols;}\\
  2315. \hspace{1cm}XpmInfo {\it *infos;}
  2316.  
  2317. \end{flushleft}
  2318.  
  2319. \begin{description}
  2320.  
  2321. \itemit{display} Specifies the connection to the X server.
  2322. \itemit{visual} Specifies a pointer to the visual.
  2323. \itemit{d} Specifies the drawable that indicates the screen.
  2324. \itemit{colormap} Specifies the colormap to use.
  2325. \itemit{filename} Specifies the file name to use.
  2326. \itemit{depth} Specifies the depth.
  2327. \itemit{pixmap\_return} Returns the pixmap which is created.
  2328. \itemit{width\_return}
  2329. \itemit{height\_return} Return the width and height values of the read pixmap
  2330. file.
  2331. \itemit{pixels\_return} Returns the list of color pixels which have been
  2332. allocated.
  2333. \itemit{npixels\_return} Returns the length of the returned color pixels list.
  2334. \itemit{colorsymbols} Specifies an array of color symbols for overriding.
  2335. \itemit{numsymbols} Specifies the number of symbols.
  2336. \itemit{infos} Specifies the location of an {\bf XpmInfo} structure to store
  2337. informations. 
  2338.  
  2339. \end{description} 
  2340.  
  2341. The {\bf XReadPixmapFile} function reads in a file containing a pixmap in the
  2342. {\bf XPM2} format. If the file cannot be opened, {\bf XReadPixmapFile} returns
  2343. {\bf PixmapOpenFailed}. If the file can be opened but does not contain valid
  2344. {\bf XPM2} pixmap data, it returns {\bf PixmapFileInvalid}. If insufficient
  2345. working storage is allocated, it returns {\bf PixmapNoMemory}. If parsing a
  2346. color fails, it returns {\bf PixmapParseColorFailed}. If allocating a color
  2347. cell fails, it returns {\bf PixmapAllocColorFailed}. Finally if no error
  2348. occurs, it returns {\bf PixmapSuccess}.
  2349.  
  2350. {\bf XReadPixmapFile} returns the pixmap's height and width, as read from the
  2351. file, to width\_return and height\_return. It reads the colors and pixels data
  2352. from the file. It allocates colors, as read from the file or possibly
  2353. overridden as specified in the given colorsymbols array.  The colors are
  2354. allocated dependently on the type of visual and on the default colors. If no
  2355. default value exits for the specified visual, it first looks for other
  2356. defaults nearer to the monochrome visual type and secondly nearer to the color
  2357. visual type. Then it creates a pixmap of the appropriate size, which is
  2358. returned to pixmap\_return.  If a pointer to an {\bf XpmInfo} structure, other
  2359. than {\bf NULL}, is passed {\bf XReadPixmapFile} stores in it possible
  2360. comments, color defaults and symbols, and color pixels.  The caller must free
  2361. the pixmap using {\bf XFreePixmap}, the colors using {\bf XFreeColors} with
  2362. the returned pixels list, and finally the {\bf XpmInfo} if any using {\bf
  2363. XFreeXpmInfo} when finished.
  2364.  
  2365. \vspace{.5cm}
  2366. To write out a pixmap to a file, use {\bf XWritePixmapFile}.
  2367.  
  2368. \begin{flushleft} 
  2369.  
  2370. int XWritePixmapFile({\it display, colormap, filename, pixmap, width,
  2371. height,\\
  2372. \hspace{3cm}type, cppm, infos})\\
  2373.  
  2374. \hspace{1cm}Display {\it *display;}\\
  2375. \hspace{1cm}Colormap {\it colormap;}\\
  2376. \hspace{1cm}char {\it *filename;}\\
  2377. \hspace{1cm}Pixmap {\it *pixmap;}\\
  2378. \hspace{1cm}unsigned int {\it width, height;}\\
  2379. \hspace{1cm}char {\it *type;}\\
  2380. \hspace{1cm}unsigned int {\it cppm;}\\
  2381. \hspace{1cm}XpmInfo {\it *infos;}
  2382.  
  2383. \end{flushleft}
  2384.  
  2385. \begin{description}
  2386.  
  2387. \itemit{display} Specifies the connection to the X server.
  2388. \itemit{colormap} Specifies the colormap.
  2389. \itemit{filename} Specifies the file name to use.
  2390. \itemit{pixmap} Specifies the pixmap which is created.
  2391. \itemit{width}
  2392. \itemit{height} Specifies the width and height of the pixmap.
  2393. file.
  2394. \itemit{type} Specifies the type of {\bf XPM2} format.
  2395. \itemit{cppm} Specifies a minimum number of characters per pixels.
  2396. \itemit{infos} Specifies the location of an {\bf XpmInfo} structure containing
  2397. informations. 
  2398.  
  2399. \end{description} 
  2400.  
  2401. The {\bf XWritePixmapFile} function writes a pixmap out to a file in the {\bf
  2402. XPM2} format. If the file cannot be opened, it returns {\bf PixmapOpenFailed}.
  2403. If the specified type is not valid, it returns {\bf PixmapFileInvalid}. If
  2404. insufficient working storage is allocated, it returns {\bf PixmapNoMemory}. If
  2405. no error occurs then it returns {\bf PixmapSuccess}.
  2406.  
  2407. {\bf XWritePixmapFile} writes out in the type format specified in argument,
  2408. stored in the {\bf XpmInfo} structure if any is given, or in Natural type by
  2409. default.  If a {\bf XpmInfo} structure is passed, it will writes out possible
  2410. stored informations such as comments, and color defaults and symbols.
  2411.  
  2412. \vspace{.5cm}
  2413. To create a pixmap from file written out by {\bf XWritePixmapFile} and
  2414. directly include in a program, use {\bf XCreatePixmapFromData}.
  2415.  
  2416. \begin{flushleft} 
  2417.  
  2418. int XCreatePixmapFromData({\it display, visual, d, colormap, data, depth, \\
  2419. \hspace{3cm}pixmap\_return, width\_return, height\_return, \\
  2420. \hspace{3cm}pixels\_return, npixels\_return, \\
  2421. \hspace{3cm}colorsymbols, numsymbols, infos})\\
  2422.  
  2423. \hspace{1cm}Display {\it *display;}\\
  2424. \hspace{1cm}Visual {\it *visual;}\\
  2425. \hspace{1cm}Drawable {\it d;}\\
  2426. \hspace{1cm}Colormap {\it colormap;}\\
  2427. \hspace{1cm}char {\it **data;}\\
  2428. \hspace{1cm}unsigned int {\it depth;}\\
  2429. \hspace{1cm}Pixmap {\it *pixmap\_return;}\\
  2430. \hspace{1cm}unsigned int {\it *width\_return, *height\_return;}\\
  2431. \hspace{1cm}unsigned long {\it **pixels\_return;}\\
  2432. \hspace{1cm}unsigned int {\it *npixels\_return;}\\
  2433. \hspace{1cm}ColorSymbol {\it colorsymbols[];}\\
  2434. \hspace{1cm}unsigned int {\it numsymbols;}\\
  2435. \hspace{1cm}XpmInfo {\it *infos;}
  2436.  
  2437. \end{flushleft}
  2438.  
  2439. \begin{description}
  2440.  
  2441. \itemit{display} Specifies the connection to the X server.
  2442. \itemit{visual} Specifies a pointer to the visual.
  2443. \itemit{d} Specifies the drawable that indicates the screen.
  2444. \itemit{colormap} Specifies the colormap to use.
  2445. \itemit{data} Specifies the location of the pixmap data.
  2446. \itemit{depth} Specifies the depth.
  2447. \itemit{pixmap\_return} Returns the pixmap which is created.
  2448. \itemit{width\_return}
  2449. \itemit{height\_return} Return the width and height values of the read pixmap
  2450. data.
  2451. \itemit{pixels\_return} Returns the list of color pixels which have been
  2452. allocated.
  2453. \itemit{npixels\_return} Returns the length of the returned color pixels list.
  2454. \itemit{colorsymbols} Specifies an array of color symbols which for
  2455. overriding.
  2456. \itemit{numsymbols} Specifies the number of symbols.
  2457. \itemit{infos} Specifies the location of an {\bf XpmInfo} structure to store
  2458. informations. 
  2459.  
  2460. \end{description} 
  2461.  
  2462. The {\bf XCreatePixmapFromData} function allows you to include in your program
  2463. a pixmap file of the corresponding type (C, Lisp, ...) which was written out
  2464. by {\bf XWritePixmapFile} ({\bf XPM2} format only) without reading in the
  2465. pixmap file.
  2466.  
  2467. {\bf XCreatePixmapFromData} exactly works as {\bf XReadPixmapFile} does and
  2468. returns the same way. It just reads data instead of a file. Here again, it is
  2469. the caller's responsibility to free the pixmap, the colors, and possibly the
  2470. {\bf XpmInfo} structure.
  2471.  
  2472. \vspace{.5cm}
  2473. To free an {\bf XpmInfo} structure use {\bf XFreeXpmInfo}.
  2474.  
  2475. \begin{flushleft} 
  2476.  
  2477. int XFreeXpmInfo({\it infos})\\
  2478.  
  2479. \hspace{1cm}XpmInfo {\it *infos;}
  2480.  
  2481. \end{flushleft}
  2482.  
  2483. \begin{description}
  2484.  
  2485. \itemit{infos} Specifies the structure to free.
  2486.  
  2487. \end{description}
  2488.  
  2489. The {\bf XFreeXpmInfo} frees all the different members of the structure: the
  2490. character strings and the ColorTable. 
  2491.  
  2492. \end{document} 
  2493. END_OF_SHAR_FOR_xpm.tex
  2494. cat > xpmP.h << \END_OF_SHAR_FOR_xpmP.h
  2495. /* Copyright 1990 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  2496. /* xpmP.h:
  2497.  *
  2498.  *  XPM2
  2499.  *  Private Include file
  2500.  *  Developped by Arnaud Le Hors
  2501.  *  $Id: xpm.shar,v 2.1 90/08/24 19:07:31 lehors Exp $
  2502.  */
  2503.  
  2504. #ifndef XPMP_h
  2505. #define XPMP_h
  2506.  
  2507. #include <X11/Xlib.h>
  2508. #include<stdio.h>
  2509.  
  2510. /* we keep the same codes as for Bitmap management */
  2511. #ifndef _XUTIL_H_
  2512. #ifdef VMS
  2513. #include "decw$include:Xutil.h"
  2514. #else
  2515. #include <X11/Xutil.h>
  2516. #endif
  2517. #endif
  2518.  
  2519. typedef struct {
  2520.     unsigned int type;
  2521.     void         *stream;
  2522.     char         *cptr;
  2523.     unsigned int line;
  2524. } MData;
  2525.  
  2526. #define PixmapSuccess          0
  2527. #define PixmapOpenFailed       1
  2528. #define PixmapFileInvalid      2
  2529. #define PixmapNoMemory         3
  2530. #define PixmapParseColorFailed 4
  2531. #define PixmapAllocColorFailed 5
  2532.  
  2533.  
  2534. #define MARRAY 0
  2535. #define MFILE  1
  2536.  
  2537. extern int XpmErrorStatus;
  2538.  
  2539. typedef unsigned char  byte;      /* byte type */
  2540. typedef unsigned long  Pixel;     /* what X thinks a pixel is */
  2541.  
  2542. extern char *BCMT, *ECMT, BOS, EOS;
  2543.  
  2544. #define EOL '\n'
  2545. #define TAB '\t'
  2546. #define SPC ' '
  2547.  
  2548. extern struct {
  2549.     char *type;            /* key word */
  2550.     char *Bcmt;            /* string begining comments */
  2551.     char *Ecmt;            /* string ending comments */
  2552.     char  Bos;            /* character begining strings */
  2553.     char  Eos;            /* character ending strings */
  2554.     char *Strs;            /* strings separator */
  2555.     char *Dec;            /* data declaration string */
  2556.     char *Boa;            /* string begining assignment */
  2557.     char *Eoa;            /* string ending assignment */
  2558. } DataTypes[];
  2559.  
  2560. typedef struct {
  2561.     char *name;
  2562.     char *value;
  2563. } ColorSymbol;
  2564.  
  2565. typedef struct {
  2566.     char *type;
  2567.     int ncolors;
  2568.     char ***colorTable;
  2569.     Pixel *pixels;
  2570.     char *hints_cmt;
  2571.     char *colors_cmt;
  2572.     char *pixels_cmt;
  2573. } XpmInfo;
  2574.  
  2575. extern char *ColorKeys[];
  2576. #define NKEYS 5            /* number of ColorKeys */
  2577.  
  2578. #define MONO    2        /* key numbers for visual type, they must */
  2579. #define GRAY4    3        /* fit along with the number key of each */
  2580. #define GRAY     4        /* corresponding element in ColorKeys[] */
  2581. #define COLOR    5        /* defined in xpm.h */
  2582.  
  2583.  
  2584. #define MAXPRINTABLE 93             /* number of printable ascii chars 
  2585.                        minus \ and " for string compat. */
  2586. extern char *printable;
  2587.  
  2588. /* minimal portability layer between ansi and KR C 
  2589.  */
  2590.  
  2591. /* forward declaration of functions with prototypes */
  2592.  
  2593. #if __STDC__                /* ANSI */
  2594. #define FUNC(f, t, p) extern t f p
  2595. #define LFUNC(f, t, p) static t f p
  2596. #else                    /* K&R */
  2597. #define FUNC(f, t, p) extern t f()
  2598. #define LFUNC(f, t, p) static t f()
  2599. #endif                    /* end of K&R */
  2600.  
  2601. /* functions declarations
  2602.  */
  2603.  
  2604. FUNC(XCreatePixmapFromData, int, (Display *display,
  2605.                   Visual *visual,
  2606.                   Drawable d,
  2607.                   Colormap colormap,
  2608.                   char **data,
  2609.                   unsigned int depth,
  2610.                   Pixmap *pixmap_return,
  2611.                   unsigned int *width_return, 
  2612.                   unsigned int *height_return, 
  2613.                   Pixel **pixels_return,
  2614.                   unsigned int *npixels_return,
  2615.                   ColorSymbol colorsymbols[],
  2616.                   unsigned int numsymbols,
  2617.                   XpmInfo *infos));
  2618.  
  2619. FUNC(XReadPixmapFile, int, (Display *display,
  2620.                 Visual *visual,
  2621.                 Drawable d,
  2622.                 Colormap colormap,
  2623.                 char *filename,
  2624.                 unsigned int depth,
  2625.                 Pixmap *pixmap_return,
  2626.                 unsigned int *width_return, 
  2627.                 unsigned int *height_return, 
  2628.                 Pixel **pixels_return,
  2629.                 unsigned int *npixels_return,
  2630.                 ColorSymbol colorsymbols[],
  2631.                 unsigned int numsymbols,
  2632.                 XpmInfo *infos));
  2633.  
  2634. FUNC(XWritePixmapFile, int, (Display *display,
  2635.                  Colormap colormap,
  2636.                  char *filename,
  2637.                  Pixmap *pixmap,
  2638.                  unsigned int width,
  2639.                  unsigned int height,
  2640.                  char *type,
  2641.                  unsigned int cppm,
  2642.                  XpmInfo *infos));
  2643.  
  2644. FUNC(XFreeXpmInfo, int, (XpmInfo *infos));
  2645.  
  2646. /* XPM private routines */
  2647. FUNC(CreatePixmap, Pixmap, (Display *display,
  2648.                 Visual *visual,
  2649.                 Drawable d,
  2650.                 Colormap colormap,
  2651.                 MData *data,
  2652.                 unsigned int depth,
  2653.                 unsigned int *width_return, 
  2654.                 unsigned int *height_return, 
  2655.                 Pixel **pixels_return,
  2656.                 unsigned int *npixels_return,
  2657.                 ColorSymbol colorsymbols[],
  2658.                 unsigned int numsymbols,
  2659.                 XpmInfo *infos));
  2660.  
  2661. FUNC(visualType, int, (Visual *visual));
  2662. FUNC(freeColorTable, int, (char ***colorTable, int ncolors));
  2663.  
  2664. /* I/O utility */
  2665. FUNC(mnextstring, int, (MData *mdata));
  2666. FUNC(mnextui, unsigned int, (MData *mdata));
  2667. FUNC(mgetc, char, (MData *mdata));
  2668. FUNC(mungetc, char, (int c, MData *mdata));
  2669. FUNC(mnextc, char, (MData *mdata));
  2670. FUNC(mnextw, unsigned int, (MData *mdata, char *buf));
  2671. FUNC(mgetcmt, int, (MData *mdata, char **cmt));
  2672.  
  2673. /* Values routines */
  2674. FUNC(valToMem, void, (unsigned long val, byte *p, unsigned int len));
  2675. FUNC(memToVal, unsigned long, (byte *p, unsigned int len));
  2676.  
  2677.  
  2678. #endif
  2679. END_OF_SHAR_FOR_xpmP.h
  2680.