/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 */ 

/* 

 * HISTORY

 */ 

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$XConsortium: Mrmicon.c /main/14 1996/11/13 14:01:43 drk $"

#endif

#endif

/* (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/*

 *++

 *  FACILITY:

 *

 *      UIL Resource Manager (URM)

 *

 *  ABSTRACT:

 *

 *	This module contains routines which operate on URM icon images -

 *	RGMIconImage structs.

 *

 *--

 */

/*

 *

 *  INCLUDE FILES

 *

 */

#include <stdio.h>

#include <Mrm/MrmAppl.h>

#include <Mrm/Mrm.h>

#include "MrmMsgI.h"

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine creates and returns an X pixmap from a URM icon

 *	for some widget. It uses the foreground and background obtainable

 *	from the widget as required.

 *

 *  FORMAL PARAMETERS:

 *

 *	icon		URM icon image to be converted to X pixmap

 *	screen		screen to use for pixmap

 *	display		display to use for pixmap

 *	fgpix		foreground color for pixmap

 *	bgpix		background color for pixmap

 *	pixmap		to return resulting X pixmap

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *	URM status

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

UrmCreatePixmap (RGMIconImagePtr	icon,

		 Screen			*screen,

		 Display		*display,

		 Pixel			fgpix,

		 Pixel			bgpix,

		 Pixel			*pixmap,

		 Widget			parent)

{

  /*

   *  Local variables

   */

  Cardinal		result;		/* function results */

  RGMColorTablePtr	ctable;		/* color table in icon */

  unsigned		maxbits;	/* # bits required for X image */

  int			srcpix;		/* # bits per pixel in icon (actual) */

  int			dds ;

  /*

   * Convert the color table colors to pixels.

   */

  ctable = icon->color_table.ctptr;

  result = 

    Urm__RealizeColorTable (screen, display, fgpix, bgpix, ctable, parent);

  if ( result != MrmSUCCESS ) return result;

  /*

   * Use the depth of screen to infer the number of bits required to

   * hold the pixels in X format. The ZPixmap format only supports 1, 8, 16,

   * and 32 bit pixels, so we always map to one of these sizes.

   */

  if (parent) dds = parent->core.depth;

  else dds = DefaultDepthOfScreen(screen) ;

  if (dds == 1) 

    maxbits = 1;

  else if (dds <= 8) 

    maxbits = 8;

  else if (dds <= 16) 

    maxbits = 16;

  else

    maxbits = 32;

  /*

   * See if the icon can be mapped as a bitmap. This will be true if the

   * color table has only FG/BG entries, or uses only those entries.

   */

  if ( ctable->count <= 2 ) maxbits = 1;

  /*

   * Compute the number of bits available in the icon pixmap

   */

  switch ( icon->pixel_size )

    {

    case URMPixelSize1Bit:

      srcpix = 1;

      break;

    case URMPixelSize2Bit:

      srcpix = 2;

      break;

    case URMPixelSize4Bit:

      srcpix = 4;

      break;

    case URMPixelSize8Bit:

      srcpix = 8;

      break;

    default:

      return MrmNOT_VALID;

    }

  /*

   * Map the icon image pixmap from color table indices to Pixel values.

   * There are three cases:

   *	maxbits == 1; a bitmap is possible, so map to a bitmap.

   *	maxbits <= # bits/pixel in pixmap. Map in place. In fact,

   *		only works if maxbits == srcpix == 8.

   *	maxbits > # bits/pixel. Map to allocated pixmap.

   *

   * Each of the three routines which performs these mappings completes

   * the entire process of doing the mapping and creating the X pixmap.

   */

  if ( maxbits == 1 )

    return Urm__MapIconBitmap

      (icon, srcpix, ctable, screen, display, pixmap);

  if ((maxbits == 8) && (srcpix == 8))

    return Urm__MapIconReplace

      (icon, srcpix, ctable, screen, display, pixmap, parent);

  if ( maxbits > srcpix )

    return Urm__MapIconAllocate

      (icon, srcpix, maxbits, ctable, screen, display, pixmap, parent);

  return MrmNOT_VALID;

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine creates and returns an X pixmap of depth 1 from a URM icon

 *	for some widget.

 *

 *  FORMAL PARAMETERS:

 *

 *	icon		URM icon image to be converted to X pixmap

 *	screen		screen to use for pixmap

 *	display		display to use for pixmap

 *	pixmap		to return resulting X pixmap

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *	URM status

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

UrmCreateBitmap (RGMIconImagePtr	icon,

		 Screen			*screen,

		 Display		*display,

		 Pixel			*pixmap)

{

  /*

   *  Local variables

   */

  int			srcpix;		/* # bits per pixel in icon (actual) */

  /*

   * Compute the number of bits available in the icon pixmap

   */

  switch ( icon->pixel_size )

    {

    case URMPixelSize1Bit:

      srcpix = URMPixelSize1Bit;

      break;

    default:

      return MrmNOT_VALID;

    }

  return Urm__MapIconBitmapDepth1 (icon, srcpix, screen, display, pixmap);

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine creates and returns an X pixmap from the X bitmap file

 *	name specified.  It uses the foreground and background as needed.

 *	

 *

 *  FORMAL PARAMETERS:

 *

 *	filename	file containing the bitmap to be converted to X pixmap

 *	screen		screen to use for pixmap

 *	display		display to use for pixmap - not used

 *	fgint		foreground color for pixmap

 *	bgint		background color for pixmap

 *	pixmap		to return resulting X pixmap

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *	URM status

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

Urm__CW_ReadBitmapFile (String			filename,

			Screen			*screen,

			Pixel			fgint,

			Pixel			bgint,

			Pixmap			*pixmap,

			Widget			parent)

{

  int		depth;

  char		err_msg[300];

  /*

  **  Create a pixmap from a X bitmap file specification

  */

  depth = parent ? parent->core.depth : DefaultDepthOfScreen(screen);

  *pixmap = XmGetPixmapByDepth(screen, filename, fgint, bgint, depth);

  if (*pixmap == XmUNSPECIFIED_PIXMAP)

    {

      pixmap = 0;

      sprintf (err_msg, _MrmMMsg_0033, filename);

      return Urm__UT_Error ("UrmReadBitmapFile", err_msg, 

			    NULL, NULL, MrmFAILURE);

    }

  return MrmSUCCESS;

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine maps the pixmap in the icon into a bitmap. The

 *	bitmap is written over pixmap data. The X pixmap is then

 *	constructed as an XYBitmap.

 *

 *  FORMAL PARAMETERS:

 *

 *	icon		the IconImage being converted

 *	srcpix		number of bits/pixel in icon

 *	ctable		the color table for (in) icon

 *	screen		screen for the X pixmap

 *	display		display for the X pixmap

 *	pixmap		to return the result

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

Urm__MapIconBitmap(RGMIconImagePtr		icon,

		   int				srcpix,

		   RGMColorTablePtr		ctable,

		   Screen			*screen,

		   Display			*display,

		   Pixmap			*pixmap)

{

  /*

   *  Local variables

   */

  Pixel			fgpix;		/* foreground pixel value */

  int			iconwid;	/* icon width */

  int			srclinebyt;	/* # bytes per icon line */

  int			dstlinebyt;	/* # bytes per bitmap line */

  char			*srcbytptr;	/* image byte pointer */

  char			*dstbytptr;	/* bitmap pointer */

  int			lin;		/* icon line number */

  int			byt;		/* line byte number */

  int			pix;		/* line pixel number */

  unsigned char		srcbyt;		/* icon image byte */

  unsigned char		dstbyt;		/* mapped image byte */

  int			tndx;		/* color table index */

  XImage		*imagep;	/* X image */

  GC			gc;

  XGCValues		gcValues;

  int			endian;		/* to determine which endian. */

  /*

   * Overwrite the icon data with a bitmap. Use 0 for background, 1 for

   * foreground.

   */

  fgpix = ctable->item[URMColorTableFG].color_pixel;

  iconwid = icon->width;

  srclinebyt = (iconwid*srcpix+7) / 8;

  dstlinebyt = (iconwid+7) / 8;

  srcbytptr = icon->pixel_data.pdptr;

  for ( lin=0 ; lin<icon->height ; lin++ )

    {

      pix = 0;

      dstbytptr = icon->pixel_data.pdptr + lin*dstlinebyt;

      dstbyt = 0;

      for ( byt=0 ; byt

        {

	  srcbyt = *srcbytptr;

	  switch ( icon->pixel_size )

            {

            case URMPixelSize1Bit:

	      *dstbytptr = srcbyt;

	      srcbytptr += 1;

	      dstbytptr += 1;

	      pix += 8;

	      /*

	       *  NOTE: The original algorithm used here cleared any

	       *        unused bits of the last byte.  I don't think

	       *        the protocol requires that...

	       if ( pix > iconwid )

	       */

	      continue;

            case URMPixelSize2Bit:

	      tndx = srcbyt & 0x3;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      srcbyt >>= 2;

	      tndx = srcbyt & 0x3;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      srcbyt >>= 2;

	      tndx = srcbyt & 0x3;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      srcbyt >>= 2;

	      tndx = srcbyt & 0x3;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      break;

            case URMPixelSize4Bit:

	      tndx = srcbyt & 0xF;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      srcbyt >>= 4;

	      tndx = srcbyt & 0xF;

	      if ( pix < iconwid )

		if ( ctable->item[tndx].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      break;

            case URMPixelSize8Bit:

	      if ( pix < iconwid )

		if ( ctable->item[srcbyt].color_pixel == fgpix)

		  dstbyt |= 1<<(pix%8);

	      pix += 1;

	      break;

            }

	  /*

	   *  NOTE:  The "1Bit" case CONTINUEs directly and will never

	   *         reach this point in the loop...

	   */

	  srcbytptr += 1;

	  if ( pix%8 == 0 )

            {

	      *dstbytptr = dstbyt;

	      dstbytptr += 1;

	      dstbyt = 0;

            }

        }

      if ( pix%8 != 0 )

        *dstbytptr = dstbyt;

    }

  imagep = XCreateImage(display,

			DefaultVisualOfScreen(screen),

			1,

			XYBitmap,

			0,

			icon->pixel_data.pdptr,

			(unsigned int)icon->width,

			(unsigned int)icon->height,

			8,

			dstlinebyt);

  if ( imagep == NULL )

    return Urm__UT_Error ("Urm__MapIconBitmap", _MrmMMsg_0034,

			  NULL, NULL, MrmFAILURE);

  /*

   * Well, Uil creates a uid icon in its byteorder, on his side

   * XCreateImage creates an image in the byte_order of the server, so

   * its not correct, we have to adjust the byte_order fields of this

   * image to match those of the icon.

   */

  endian = 1;

  imagep->bitmap_unit = 8 ;

  if (*(char *) &endian) {

    imagep->byte_order = LSBFirst ;

    imagep->bitmap_bit_order = LSBFirst ;

  }

  else {

    imagep->byte_order = MSBFirst;

    imagep->bitmap_bit_order = LSBFirst ;

  }

  *pixmap = XCreatePixmap (display,

			   RootWindowOfScreen(screen),

			   icon->width,

			   icon->height,

			   (unsigned)DefaultDepthOfScreen(screen));

  if ( *pixmap == (Pixmap)0)

    {

      XFree((char*)imagep);

      return Urm__UT_Error ("Urm__MapIconBitmap", _MrmMMsg_0035,

			    NULL, NULL, MrmFAILURE);

    }

  /*

   * Build a gc to use when drawing into the pixmap

   */

  gcValues.foreground = ctable->item[URMColorTableFG].color_pixel;

  gcValues.background = ctable->item[URMColorTableBG].color_pixel;

  gcValues.fill_style = FillTiled;

  gcValues.tile       = *pixmap;

  gc = XCreateGC (display, 

		  RootWindowOfScreen (screen),

		  GCForeground | GCBackground | GCFillStyle | GCTile,

		  &gcValues);

  if ( gc == NULL )

    return Urm__UT_Error ("Urm__MapIconBitmap", _MrmMMsg_0036,

			  NULL, NULL, MrmFAILURE);

  /*

   * Put bits into the pixmap

   */

  XPutImage (display, 

	     *pixmap, 

	     gc, 

	     imagep, 

	     0, 0,				/* source x, y */

	     0, 0, icon->width, icon->height);	/* dest, loc & size */

  XFreeGC (display, gc);

  XFree ((char*)imagep);

  /*

   * Successfully created

   */

  return MrmSUCCESS;

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine maps the pixmap in the icon into a bitmap. The

 *	bitmap is written over pixmap data. The X pixmap is then

 *	constructed as an XYBitmap.

 *

 *  FORMAL PARAMETERS:

 *

 *	icon		the IconImage being converted

 *	srcpix		number of bits/pixel in icon

 *	screen		screen for the X pixmap

 *	display		display for the X pixmap

 *	pixmap		to return the result

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

Urm__MapIconBitmapDepth1 (RGMIconImagePtr	icon,

			  int			srcpix,

			  Screen		*screen,

			  Display		*display,

			  Pixmap		*pixmap)

{

  /*

   *  Local variables

   */

  int			iconwid;	/* icon width */

  int			srclinebyt;	/* # bytes per icon line */

  int			dstlinebyt;	/* # bytes per bitmap line */

  char			*srcbytptr;	/* image byte pointer */

  char			*dstbytptr;	/* bitmap pointer */

  int			lin;		/* icon line number */

  int			byt;		/* line byte number */

  int			pix;		/* line pixel number */

  unsigned char		srcbyt;		/* icon image byte */

  unsigned char		dstbyt;		/* mapped image byte */

  XImage		*imagep;	/* X image */

  GC			gc;

  XGCValues		gcValues;

  int			endian;		/* to determine which endian. */

  /*

   * Overwrite the icon data with a bitmap. Use 0 for background, 1 for

   * foreground.

   */

  iconwid = icon->width;

  srclinebyt = (iconwid*srcpix+7) / 8;

  dstlinebyt = (iconwid+7) / 8;

  srcbytptr = icon->pixel_data.pdptr;

  for ( lin=0 ; lin<icon->height ; lin++ )

    {

      pix = 0;

      dstbytptr = icon->pixel_data.pdptr + lin*dstlinebyt;

      dstbyt = 0;

      for ( byt=0 ; byt

        {

	  srcbyt = *srcbytptr;

	  switch ( icon->pixel_size )

            {

            case URMPixelSize1Bit:

	      *dstbytptr = srcbyt;

	      srcbytptr += 1;

	      dstbytptr += 1;

	      pix += 8;

	      /*

	       *  NOTE: The original algorithm used here cleared any

	       *        unused bits of the last byte.  I don't think

	       *        the protocol requires that...

	       if ( pix > iconwid )

	       */

	      continue;

	    default:

	      return MrmNOT_VALID;

            }

        }

      if ( pix%8 != 0 )

        *dstbytptr = dstbyt;

    }

  imagep = XCreateImage(display,

			DefaultVisualOfScreen(screen),

			1,

			XYBitmap,

			0,

			icon->pixel_data.pdptr,

			(unsigned int)icon->width,

			(unsigned int)icon->height,

			8,

			dstlinebyt);

  if ( imagep == NULL )

    return Urm__UT_Error ("Urm__MapIconBitmapDepth1", _MrmMMsg_0034,

			  NULL, NULL, MrmFAILURE);

  /* Well, Uil creates a uid icon in its byteorder, on his side

     XCreateImage creates an image in the byte_order of the server, so

     its not correct, we have to adjust the byte_order fields of this

     image to match those of the icon. */

  endian = 1;

  imagep->bitmap_unit = 8 ;

  if (*(char *) &endian) {

    imagep->byte_order = LSBFirst ;

    imagep->bitmap_bit_order = LSBFirst ;

  }

  else {

    imagep->byte_order = MSBFirst;

    imagep->bitmap_bit_order = LSBFirst ;

  }

  *pixmap = XCreatePixmap (display,

			   RootWindowOfScreen(screen),

			   icon->width,

			   icon->height,

			   1);

  if ( *pixmap == (Pixmap)0)

    {

      XFree((char*)imagep);

      return Urm__UT_Error ("Urm__MapIconBitmapDepth1", _MrmMMsg_0035,

			    NULL, NULL, MrmFAILURE);

    }

  /*

   * Build a gc to use when drawing into the pixmap

   */

  gcValues.foreground = 1;

  gcValues.background = 0;

  gcValues.fill_style = FillTiled;

  gcValues.tile       = *pixmap;

  gc = XCreateGC (display, 

		  *pixmap,

		  GCForeground | GCBackground | GCFillStyle | GCTile,

		  &gcValues);

  if ( gc == NULL )

    return Urm__UT_Error ("Urm__MapIconBitmapDepth1", _MrmMMsg_0036,

			  NULL, NULL, MrmFAILURE);

  /*

   * Put bits into the pixmap

   */

  XPutImage (display, 

	     *pixmap, 

	     gc, 

	     imagep, 

	     0, 0,				/* source x, y */

	     0, 0, icon->width, icon->height);	/* dest, loc & size */

  XFreeGC (display, gc);

  XFree ((char *)imagep);

  /*

   * Successfully created

   */

  return MrmSUCCESS;

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine maps the pixmap in the icon into a ZPixmap. The

 *	ZPixmap is written over the icon image pixmap data. The X pixmap

 *	is then constructed as a ZPixmap from the overwritten data.

 *

 *	This routine is called only when srcpix == 8.

 *

 *  FORMAL PARAMETERS:

 *

 *	icon		the IconImage being converted

 *	srcpix		number of bits/pixel in icon

 *	ctable		the color table for (in) icon

 *	screen		screen for the X pixmap

 *	display		display for the X pixmap

 *	pixmap		to return the result

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

Urm__MapIconReplace (RGMIconImagePtr		icon,

		     int			srcpix,

		     RGMColorTablePtr		ctable,

		     Screen			*screen,

		     Display			*display,

		     Pixmap			*pixmap,

		     Widget			parent)

{

  /*

   *  Local variables

   */

  int			iconwid;	/* icon width */

  int			linebyt;	/* # bytes per icon line */

  char			*bytptr;	/* image byte pointer */

  int			lin;		/* icon line number */

  int			byt;		/* line byte number */

  int			pix;		/* line pixel number */

  unsigned char		srcbyt;		/* icon image byte */

  XImage		*imagep;	/* X image */

  GC			gc;

  XGCValues		gcValues;

  int			depth;		/* depth of screen  */

  /*

   * Overwrite the pixmap with actual Pixel values. The source and destination

   * bit widths are the same (==8), and the same pointer can be used for

   * both source and destination.

   */

  iconwid = icon->width;

  linebyt = (iconwid*srcpix+7) / 8;

  bytptr = icon->pixel_data.pdptr;

  for ( lin=0 ; lin<icon->height ; lin++ )

    {

      pix = 0;

      for ( byt=0 ; byt

        {

	  srcbyt = *bytptr;

	  if ( pix < iconwid )

	    *bytptr = ctable->item[srcbyt].color_pixel;

	  pix += 1;

	  bytptr += 1;

        }

    }

  depth = parent ? parent->core.depth : DefaultDepthOfScreen(screen);

  imagep = XCreateImage(display,

			DefaultVisualOfScreen(screen),

			depth,

			ZPixmap,

			0,

			icon->pixel_data.pdptr,

			(unsigned int)icon->width,

			(unsigned int)icon->height,

			srcpix,

			linebyt);

  if ( imagep == NULL )

    return Urm__UT_Error ("Urm__MapIconReplace", _MrmMMsg_0034,

			  NULL, NULL, MrmFAILURE);

  *pixmap = XCreatePixmap (display,

			   RootWindowOfScreen(screen),

			   icon->width,

			   icon->height,

			   (unsigned)depth);

  if ( *pixmap == (Pixmap)0)

    {

      XFree((char*)imagep);

      return Urm__UT_Error ("Urm__MapIconReplace", _MrmMMsg_0035,

			    NULL, NULL, MrmFAILURE);

    }

  /*

   * Build a gc to use when drawing into the pixmap

   */

  gcValues.foreground = ctable->item[URMColorTableFG].color_pixel;

  gcValues.background = ctable->item[URMColorTableBG].color_pixel;

  gcValues.fill_style = FillTiled;

  gcValues.tile       = *pixmap;

  gc = XCreateGC (display, 

		  RootWindowOfScreen (screen),

		  GCForeground | GCBackground | GCFillStyle | GCTile,

		  &gcValues);

  if ( gc == NULL )

    return Urm__UT_Error ("Urm__MapIconReplace", _MrmMMsg_0036,

			  NULL, NULL, MrmFAILURE);

  /*

   * Put bits into the pixmap

   */

  XPutImage (display, 

	     *pixmap, 

	     gc, 

	     imagep, 

	     0, 0,				/* source x, y */

	     0, 0, icon->width, icon->height);	/* dest, loc & size */

  XFreeGC (display, gc);

  XFree((char*)imagep);

  /*

   * Successfully created

   */

  return MrmSUCCESS;

}

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine maps the pixmap in the icon into a ZPixmap. The

 *	ZPixmap is allocated 1 byte per pixel, as the icon image pixmap

 *	has too few bits per pixel to be replace in situ. The X pixmap

 *	is created from the allocated ZPixmap.