Back to index

plt-scheme  4.2.1
Classes | Defines | Functions | Variables
create.c File Reference
#include "xpmP.h"
#include <ctype.h>
#include <strings.h>

Go to the source code of this file.

Classes

struct  CloseColor

Defines

#define ITERATIONS
#define COLOR_FACTOR   3
#define BRIGHTNESS_FACTOR   1
#define USE_CLOSECOLOR
#define RETURN(status)

Functions

 LFUNC (xpmVisualType, int,(Visual *visual))
 LFUNC (SetCloseColor, int,(Display *display, Colormap colormap, Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel, Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols))
 LFUNC (SetColor, int,(Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel, Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols))
 LFUNC (CreateXImage, int,(Display *display, Visual *visual, unsigned int depth, unsigned int width, unsigned int height, XImage **image_return))
 LFUNC (CreateColors, int,(Display *display, XpmAttributes *attributes, XpmColor *colors, unsigned int ncolors, Pixel *image_pixels, Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels))
 LFUNC (SetImagePixels, void,(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels))
 LFUNC (SetImagePixels32, void,(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels))
 LFUNC (SetImagePixels16, void,(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels))
 LFUNC (SetImagePixels8, void,(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels))
 LFUNC (SetImagePixels1, void,(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels))
static int xpmVisualType (Visual *visual)
static int closeness_cmp (Const void *a, Const void *b)
static int SetCloseColor (Display *display, Colormap colormap, Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel, Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols)
static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel, Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols)
static int CreateColors (Display *display, XpmAttributes *attributes, XpmColor *colors, unsigned int ncolors, Pixel *image_pixels, Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels)
int XpmCreateImageFromXpmImage (Display *display, XpmImage *image, XImage **image_return, XImage **shapeimage_return, XpmAttributes *attributes)
static int CreateXImage (Display *display, Visual *visual, unsigned int depth, unsigned int width, unsigned int height, XImage **image_return)
 LFUNC (_putbits, void,(register char *src, int dstoffset, register int numbits, register char *dst))
 LFUNC (_XReverse_Bytes, int,(register unsigned char *bpt, register int nb))
static int _XReverse_Bytes (unsigned char *bpt, int nb)
void xpm_xynormalizeimagebits (unsigned char *bp, XImage *img)
void xpm_znormalizeimagebits (unsigned char *bp, XImage *img)
static void _putbits (char *src, int dstoffset, int numbits, char *dst)
static void SetImagePixels (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
static void SetImagePixels32 (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
static void SetImagePixels16 (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
static void SetImagePixels8 (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
static void SetImagePixels1 (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
int XpmCreatePixmapFromXpmImage (Display *display, Drawable d, XpmImage *image, Pixmap *pixmap_return, Pixmap *shapemask_return, XpmAttributes *attributes)

Variables

static unsigned char Const _reverse_byte [0x100]
static unsigned char Const _lomask [0x09]
static unsigned char Const _himask [0x09]
static unsigned long RTXpm_byteorderpixel = MSBFirst << 24

Class Documentation

struct CloseColor

Definition at line 164 of file create.c.

Class Members
long closeness
int cols_index

Define Documentation

#define BRIGHTNESS_FACTOR   1
#define COLOR_FACTOR   3
#define ITERATIONS
Value:
2                    /* more than one is almost never
                                    * necessary */
#define RETURN (   status)
Value:
{ \
    if (ximage) XDestroyImage(ximage); \
    if (shapeimage) XDestroyImage(shapeimage); \
    if (image_pixels) XpmFree(image_pixels); \
    if (mask_pixels) XpmFree(mask_pixels); \
    if (nalloc_pixels) \
       XFreeColors(display, colormap, alloc_pixels, nalloc_pixels, 0); \
    if (alloc_pixels) XpmFree(alloc_pixels); \
    if (used_pixels) XpmFree(used_pixels); \
    return (status); \
}

Definition at line 618 of file create.c.

#define USE_CLOSECOLOR
Value:
attributes && \
(((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \
 || ((attributes->valuemask & XpmRGBCloseness) && \
     (attributes->red_closeness != 0 \
      || attributes->green_closeness != 0 \
      || attributes->blue_closeness != 0)))

Definition at line 336 of file create.c.


Function Documentation

static void _putbits ( char *  src,
int  dstoffset,
int  numbits,
char *  dst 
) [static]

Definition at line 981 of file create.c.

{
    register unsigned char chlo, chhi;
    int hibits;

    dst = dst + (dstoffset >> 3);
    dstoffset = dstoffset & 7;
    hibits = 8 - dstoffset;
    chlo = *dst & _lomask[dstoffset];
    for (;;) {
       chhi = (*src << dstoffset) & _himask[dstoffset];
       if (numbits <= hibits) {
           chhi = chhi & _lomask[dstoffset + numbits];
           *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
           break;
       }
       *dst = chhi | chlo;
       dst++;
       numbits = numbits - hibits;
       chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
       src++;
       if (numbits <= dstoffset) {
           chlo = chlo & _lomask[numbits];
           *dst = (*dst & _himask[numbits]) | chlo;
           break;
       }
       numbits = numbits - dstoffset;
    }

Here is the caller graph for this function:

static int _XReverse_Bytes ( unsigned char *  bpt,
int  nb 
) [static]

Definition at line 893 of file create.c.

{
    do {
       *bpt = _reverse_byte[*bpt];
       bpt++;
    } while (--nb > 0);
    return 0;

Here is the caller graph for this function:

static int closeness_cmp ( Const void a,
Const void b 
) [static]

Definition at line 170 of file create.c.

{
    CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;

    /* cast to int as qsort requires */
    return (int) (x->closeness - y->closeness);
}

Here is the caller graph for this function:

static int CreateColors ( Display *  display,
XpmAttributes attributes,
XpmColor colors,
unsigned int  ncolors,
Pixel image_pixels,
Pixel mask_pixels,
unsigned int mask_pixel_index,
Pixel alloc_pixels,
unsigned int nalloc_pixels,
Pixel used_pixels,
unsigned int nused_pixels 
) [static]

Definition at line 404 of file create.c.

{
    /* variables stored in the XpmAttributes structure */
    Visual *visual;
    Colormap colormap;
    XpmColorSymbol *colorsymbols;
    unsigned int numsymbols;

    char *colorname;
    unsigned int color, key;
    Bool pixel_defined;
    XpmColorSymbol *symbol;
    char **defaults;
    int ErrorStatus = XpmSuccess;
    char *s;
    int default_index;

    XColor *cols = NULL;
    unsigned int ncols = 0;

    /*
     * retrieve information from the XpmAttributes
     */
    if (attributes && attributes->valuemask & XpmColorSymbols) {
       colorsymbols = attributes->colorsymbols;
       numsymbols = attributes->numsymbols;
    } else
       numsymbols = 0;

    if (attributes && attributes->valuemask & XpmVisual)
       visual = attributes->visual;
    else
       visual = XDefaultVisual(display, XDefaultScreen(display));

    if (attributes && attributes->valuemask & XpmColormap)
       colormap = attributes->colormap;
    else
       colormap = XDefaultColormap(display, XDefaultScreen(display));

    if (attributes && attributes->valuemask & XpmColorKey)
       key = attributes->color_key;
    else
       key = xpmVisualType(visual);

#ifndef FOR_MSW
    if (USE_CLOSECOLOR) {
       /* originally from SetCloseColor */
#if 0
       if (visual->class == DirectColor) {

           /*
            * TODO: Implement close colors for DirectColor visuals. This is
            * difficult situation. Chances are that we will never get here,
            * because any machine that supports DirectColor will probably
            * also support TrueColor (and probably PseudoColor). Also,
            * DirectColor colormaps can be very large, so looking for close
            * colors may be too slow.
            */
       } else {
#endif
           int i;

           ncols = visual->map_entries;
           cols = (XColor *) XpmCalloc(ncols, sizeof(XColor));
           for (i = 0; i < ncols; ++i)
              cols[i].pixel = i;
           XQueryColors(display, colormap, cols, ncols);
#if 0
       }
#endif
    }
#endif /* ndef FOR_MSW */

    switch (key) {
    case XPM_MONO:
       default_index = 2;
       break;
    case XPM_GRAY4:
       default_index = 3;
       break;
    case XPM_GRAY:
       default_index = 4;
       break;
    case XPM_COLOR:
    default:
       default_index = 5;
       break;
    }

    for (color = 0; color < ncolors; color++, colors++,
                                    image_pixels++, mask_pixels++) {
       colorname = NULL;
       pixel_defined = False;
       defaults = (char **) colors;

       /*
        * look for a defined symbol
        */
       if (numsymbols) {

           unsigned int n;

           s = defaults[1];
           for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) {
              if (symbol->name && s && !strcmp(symbol->name, s))
                  /* override name */
                  break;
              if (!symbol->name && symbol->value) {     /* override value */
                  int def_index = default_index;

                  while (defaults[def_index] == NULL)   /* find defined
                                                  * colorname */
                     --def_index;
                  if (def_index < 2) {/* nothing towards mono, so try
                                    * towards color */
                     def_index = default_index + 1;
                     while (def_index <= 5 && defaults[def_index] == NULL)
                         ++def_index;
                  }
                  if (def_index >= 2 && defaults[def_index] != NULL &&
                     !strcasecmp(symbol->value, defaults[def_index]))
                     break;
              }
           }
           if (n != numsymbols) {
              if (symbol->name && symbol->value)
                  colorname = symbol->value;
              else
                  pixel_defined = True;
           }
       }
       if (!pixel_defined) {              /* pixel not given as symbol value */

           unsigned int k;

           if (colorname) {        /* colorname given as symbol value */
              if (!SetColor(display, colormap, visual, colorname, color,
                           image_pixels, mask_pixels, mask_pixel_index,
                           alloc_pixels, nalloc_pixels, used_pixels,
                           nused_pixels, attributes, cols, ncols))
                  pixel_defined = True;
              else
                  ErrorStatus = XpmColorError;
           }
           k = key;
           while (!pixel_defined && k > 1) {
              if (defaults[k]) {
                  if (!SetColor(display, colormap, visual, defaults[k],
                              color, image_pixels, mask_pixels,
                              mask_pixel_index, alloc_pixels,
                              nalloc_pixels, used_pixels, nused_pixels,
                              attributes, cols, ncols)) {
                     pixel_defined = True;
                     break;
                  } else
                     ErrorStatus = XpmColorError;
              }
              k--;
           }
           k = key + 1;
           while (!pixel_defined && k < NKEYS + 1) {
              if (defaults[k]) {
                  if (!SetColor(display, colormap, visual, defaults[k],
                              color, image_pixels, mask_pixels,
                              mask_pixel_index, alloc_pixels,
                              nalloc_pixels, used_pixels, nused_pixels,
                              attributes, cols, ncols)) {
                     pixel_defined = True;
                     break;
                  } else
                     ErrorStatus = XpmColorError;
              }
              k++;
           }
           if (!pixel_defined) {
              if (cols)
                  XpmFree(cols);
              return (XpmColorFailed);
           }
       } else {
           /* simply use the given pixel */
           *image_pixels = symbol->pixel;
           /* the following makes the mask to be built even if none
              is given a particular pixel */
           if (symbol->value
              && !strcasecmp(symbol->value, TRANSPARENT_COLOR)) {
              *mask_pixels = 0;
              *mask_pixel_index = color;
           } else
              *mask_pixels = 1;
           used_pixels[(*nused_pixels)++] = *image_pixels;
       }
    }
    if (cols)
       XpmFree(cols);
    return (ErrorStatus);

Here is the call graph for this function:

Here is the caller graph for this function:

static int CreateXImage ( Display *  display,
Visual *  visual,
unsigned int  depth,
unsigned int  width,
unsigned int  height,
XImage **  image_return 
) [static]

Definition at line 802 of file create.c.

{
    int bitmap_pad;

    /* first get bitmap_pad */
    if (depth > 16)
       bitmap_pad = 32;
    else if (depth > 8)
       bitmap_pad = 16;
    else
       bitmap_pad = 8;

    /* then create the XImage with data = NULL and bytes_per_line = 0 */
    *image_return = XCreateImage(display, visual, depth, ZPixmap, 0, 0,
                             width, height, bitmap_pad, 0);
    if (!*image_return)
       return (XpmNoMemory);

#ifndef FOR_MSW
    /* now that bytes_per_line must have been set properly alloc data */
    (*image_return)->data =
       (char *) XpmMalloc((*image_return)->bytes_per_line * height);

    if (!(*image_return)->data) {
       XDestroyImage(*image_return);
       *image_return = NULL;
       return (XpmNoMemory);
    }
#else
    /* under FOR_MSW XCreateImage has done it all */
#endif
    return (XpmSuccess);

Here is the caller graph for this function:

LFUNC ( xpmVisualType  ,
int  ,
(Visual *visual)   
)
LFUNC ( SetCloseColor  ,
int  ,
(Display *display, Colormap colormap, Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel, Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols)   
)
LFUNC ( SetColor  ,
int  ,
(Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel, Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols)   
)
LFUNC ( CreateXImage  ,
int  ,
(Display *display, Visual *visual, unsigned int depth, unsigned int width, unsigned int height, XImage **image_return)   
)
LFUNC ( CreateColors  ,
int  ,
(Display *display, XpmAttributes *attributes, XpmColor *colors, unsigned int ncolors, Pixel *image_pixels, Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel *alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels)   
)
LFUNC ( SetImagePixels  ,
void  ,
(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)   
)
LFUNC ( SetImagePixels32  ,
void  ,
(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)   
)
LFUNC ( SetImagePixels16  ,
void  ,
(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)   
)
LFUNC ( SetImagePixels8  ,
void  ,
(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)   
)
LFUNC ( SetImagePixels1  ,
void  ,
(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)   
)
LFUNC ( _putbits  ,
void  ,
(register char *src, int dstoffset, register int numbits, register char *dst)   
)
LFUNC ( _XReverse_Bytes  ,
int  ,
(register unsigned char *bpt, register int nb)   
)
static int SetCloseColor ( Display *  display,
Colormap  colormap,
Visual *  visual,
XColor *  col,
Pixel image_pixel,
Pixel mask_pixel,
Pixel alloc_pixels,
unsigned int nalloc_pixels,
XpmAttributes attributes,
XColor *  cols,
int  ncols 
) [static]

Definition at line 186 of file create.c.

{

    /*
     * Allocation failed, so try close colors. To get here the visual must
     * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor?
     * What about sharing systems like QDSS?). Beware: we have to treat
     * DirectColor differently.
     */


    long int red_closeness, green_closeness, blue_closeness;
    int n;

    if (attributes && (attributes->valuemask & XpmCloseness))
       red_closeness = green_closeness = blue_closeness =
           attributes->closeness;
    else {
       red_closeness = attributes->red_closeness;
       green_closeness = attributes->green_closeness;
       blue_closeness = attributes->blue_closeness;
    }


    /*
     * We sort the colormap by closeness and try to allocate the color
     * closest to the target. If the allocation of this close color fails,
     * which almost never happens, then one of two scenarios is possible.
     * Either the colormap must have changed (since the last close color
     * allocation or possibly while we were sorting the colormap), or the
     * color is allocated as Read/Write by some other client. (Note: X
     * _should_ allow clients to check if a particular color is Read/Write,
     * but it doesn't! :-( ). We cannot determine which of these scenarios
     * occurred, so we try the next closest color, and so on, until no more
     * colors are within closeness of the target. If we knew that the
     * colormap had changed, we could skip this sequence.
     * 
     * If _none_ of the colors within closeness of the target can be allocated,
     * then we can finally be pretty sure that the colormap has actually
     * changed. In this case we try to allocate the original color (again),
     * then try the closecolor stuff (again)...
     * 
     * In theory it would be possible for an infinite loop to occur if another
     * process kept changing the colormap every time we sorted it, so we set
     * a maximum on the number of iterations. After this many tries, we use
     * XGrabServer() to ensure that the colormap remains unchanged.
     * 
     * This approach gives particularly bad worst case performance - as many as
     * <MaximumIterations> colormap reads and sorts may be needed, and as
     * many as <MaximumIterations> * <ColormapSize> attempted allocations
     * may fail. On an 8-bit system, this means as many as 3 colormap reads,
     * 3 sorts and 768 failed allocations per execution of this code!
     * Luckily, my experiments show that in general use in a typical 8-bit
     * color environment only about 1 in every 10000 allocations fails to
     * succeed in the fastest possible time. So virtually every time what
     * actually happens is a single sort followed by a successful allocate.
     * The very first allocation also costs a colormap read, but no further
     * reads are usually necessary.
     */

#define ITERATIONS 2               /* more than one is almost never
                                    * necessary */

    for (n = 0; n <= ITERATIONS; ++n) {
       CloseColor *closenesses =
           (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor));
       int i, c;

       for (i = 0; i < ncols; ++i) {      /* build & sort closenesses table */
#define COLOR_FACTOR       3
#define BRIGHTNESS_FACTOR  1

           closenesses[i].cols_index = i;
           closenesses[i].closeness =
              COLOR_FACTOR * (abs((long) col->red - (long) cols[i].red)
                            + abs((long) col->green - (long) cols[i].green)
                            + abs((long) col->blue - (long) cols[i].blue))
              + BRIGHTNESS_FACTOR * abs(((long) col->red +
                                      (long) col->green +
                                      (long) col->blue)
                                      - ((long) cols[i].red +
                                         (long) cols[i].green +
                                         (long) cols[i].blue));
       }
       qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp);

       i = 0;
       c = closenesses[i].cols_index;
       while ((long) cols[c].red >= (long) col->red - red_closeness &&
              (long) cols[c].red <= (long) col->red + red_closeness &&
              (long) cols[c].green >= (long) col->green - green_closeness &&
              (long) cols[c].green <= (long) col->green + green_closeness &&
              (long) cols[c].blue >= (long) col->blue - blue_closeness &&
              (long) cols[c].blue <= (long) col->blue + blue_closeness) {
           if (XAllocColor(display, colormap, &cols[c])) {
              if (n == ITERATIONS)
                  XUngrabServer(display);
              XpmFree(closenesses);
              *image_pixel = cols[c].pixel;
              *mask_pixel = 1;
              alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel;
              return (0);
           } else {
              ++i;
              if (i == ncols)
                  break;
              c = closenesses[i].cols_index;
           }
       }

       /* Couldn't allocate _any_ of the close colors! */

       if (n == ITERATIONS)
           XUngrabServer(display);
       XpmFree(closenesses);

       if (i == 0 || i == ncols)   /* no color close enough or cannot */
           return (1);                    /* alloc any color (full of r/w's) */

       if (XAllocColor(display, colormap, col)) {
           *image_pixel = col->pixel;
           *mask_pixel = 1;
           alloc_pixels[(*nalloc_pixels)++] = col->pixel;
           return (0);
       } else {                    /* colormap has probably changed, so
                                    * re-read... */
           if (n == ITERATIONS - 1)
              XGrabServer(display);

#if 0
           if (visual->class == DirectColor) {
              /* TODO */
           } else
#endif
              XQueryColors(display, colormap, cols, ncols);
       }
    }
    return (1);

Here is the call graph for this function:

Here is the caller graph for this function:

static int SetColor ( Display *  display,
Colormap  colormap,
Visual *  visual,
char *  colorname,
unsigned int  color_index,
Pixel image_pixel,
Pixel mask_pixel,
unsigned int mask_pixel_index,
Pixel alloc_pixels,
unsigned int nalloc_pixels,
Pixel used_pixels,
unsigned int nused_pixels,
XpmAttributes attributes,
XColor *  cols,
int  ncols 
) [static]

Definition at line 354 of file create.c.

{
    XColor xcolor;

    if (strcasecmp(colorname, TRANSPARENT_COLOR)) {
       if (!XParseColor(display, colormap, colorname, &xcolor))
           return (1);
       if (!XAllocColor(display, colormap, &xcolor)) {
#ifndef FOR_MSW
           if (USE_CLOSECOLOR)
              return (SetCloseColor(display, colormap, visual, &xcolor,
                                  image_pixel, mask_pixel,
                                  alloc_pixels, nalloc_pixels,
                                  attributes, cols, ncols));
           else
#endif /* ndef FOR_MSW */
              return (1);
       } else
           alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel;
       *image_pixel = xcolor.pixel;
       *mask_pixel = 1;
       used_pixels[(*nused_pixels)++] = xcolor.pixel;
    } else {
       *image_pixel = 0;
       *mask_pixel = 0;
       /* store the color table index */
       *mask_pixel_index = color_index;
    }
    return (0);

Here is the call graph for this function:

Here is the caller graph for this function:

static void SetImagePixels ( XImage *  image,
unsigned int  width,
unsigned int  height,
unsigned int pixelindex,
Pixel pixels 
) [static]

Definition at line 1029 of file create.c.

{
    register char *src;
    register char *dst;
    register unsigned int *iptr;
    register int x, y, i;
    register char *data;
    Pixel pixel, px;
    int nbytes, depth, ibu, ibpp;

    data = image->data;
    iptr = pixelindex;
    depth = image->depth;
    if (depth == 1) {
       ibu = image->bitmap_unit;
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              pixel = pixels[*iptr];
              for (i = 0, px = pixel; i < sizeof(unsigned long);
                   i++, px >>= 8)
                  ((unsigned char *) &pixel)[i] = px;
              src = &data[XYINDEX(x, y, image)];
              dst = (char *) &px;
              px = 0;
              nbytes = ibu >> 3;
              for (i = nbytes; --i >= 0;)
                  *dst++ = *src++;
              XYNORMALIZE(&px, image);
              _putbits((char *) &pixel, (x % ibu), 1, (char *) &px);
              XYNORMALIZE(&px, image);
              src = (char *) &px;
              dst = &data[XYINDEX(x, y, image)];
              for (i = nbytes; --i >= 0;)
                  *dst++ = *src++;
           }
    } else {
       ibpp = image->bits_per_pixel;
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              pixel = pixels[*iptr];
              if (depth == 4)
                  pixel &= 0xf;
              for (i = 0, px = pixel; i < sizeof(unsigned long); i++,
                   px >>= 8)
                  ((unsigned char *) &pixel)[i] = px;
              src = &data[ZINDEX(x, y, image)];
              dst = (char *) &px;
              px = 0;
              nbytes = (ibpp + 7) >> 3;
              for (i = nbytes; --i >= 0;)
                  *dst++ = *src++;
              ZNORMALIZE(&px, image);
              _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
              ZNORMALIZE(&px, image);
              src = (char *) &px;
              dst = &data[ZINDEX(x, y, image)];
              for (i = nbytes; --i >= 0;)
                  *dst++ = *src++;
           }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static void SetImagePixels1 ( XImage *  image,
unsigned int  width,
unsigned int  height,
unsigned int pixelindex,
Pixel pixels 
) [static]

Definition at line 1354 of file create.c.

{
    if (image->byte_order != image->bitmap_bit_order)
       SetImagePixels(image, width, height, pixelindex, pixels);
    else {
       unsigned int *iptr;
       int y;
       char *data;

#ifdef WITHOUT_SPEEDUPS

       int x;

       data = image->data;
       iptr = pixelindex;
       if (image->bitmap_bit_order == MSBFirst)
           for (y = 0; y < height; y++)
              for (x = 0; x < width; x++, iptr++) {
                  if (pixels[*iptr] & 1)
                     data[ZINDEX1(x, y, image)] |= 0x80 >> (x & 7);
                  else
                     data[ZINDEX1(x, y, image)] &= ~(0x80 >> (x & 7));
              }
       else
           for (y = 0; y < height; y++)
              for (x = 0; x < width; x++, iptr++) {
                  if (pixels[*iptr] & 1)
                     data[ZINDEX1(x, y, image)] |= 1 << (x & 7);
                  else
                     data[ZINDEX1(x, y, image)] &= ~(1 << (x & 7));
              }

#else  /* WITHOUT_SPEEDUPS */

       char value;
       char *data_ptr, *max_data;
       int bpl = image->bytes_per_line;
       int diff, count;

       data = image->data;
       iptr = pixelindex;

       diff = width & 7;
       width >>= 3;

       if (image->bitmap_bit_order == MSBFirst)
           for (y = 0; y < height; y++) {
              data_ptr = data;
              max_data = data_ptr + width;
              while (data_ptr < max_data) {
                  value = 0;

                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);
                  value = (value << 1) | (pixels[*(iptr++)] & 1);

                  *(data_ptr++) = value;
              }
              if (diff) {
                  value = 0;
                  for (count = 0; count < diff; count++) {
                     if (pixels[*(iptr++)] & 1)
                         value |= (0x80 >> count);
                  }
                  *(data_ptr) = value;
              }
              data += bpl;
           }
       else
           for (y = 0; y < height; y++) {
              data_ptr = data;
              max_data = data_ptr + width;
              while (data_ptr < max_data) {
                  value = 0;
                  iptr += 8;

                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);
                  value = (value << 1) | (pixels[*(--iptr)] & 1);

                  iptr += 8;
                  *(data_ptr++) = value;
              }
              if (diff) {
                  value = 0;
                  for (count = 0; count < diff; count++) {
                     if (pixels[*(iptr++)] & 1)
                         value |= (1 << count);
                  }
                  *(data_ptr) = value;
              }
              data += bpl;
           }

#endif /* WITHOUT_SPEEDUPS */
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static void SetImagePixels16 ( XImage *  image,
unsigned int  width,
unsigned int  height,
unsigned int pixelindex,
Pixel pixels 
) [static]

Definition at line 1226 of file create.c.

{
    unsigned char *data;
    unsigned int *iptr;
    int y;

#ifdef WITHOUT_SPEEDUPS

    int x;
    unsigned char *addr;

    data = (unsigned char *) image->data;
    iptr = pixelindex;
    if (image->byte_order == MSBFirst)
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              addr = &data[ZINDEX16(x, y, image)];
              addr[0] = pixels[*iptr] >> 8;
              addr[1] = pixels[*iptr];
           }
    else
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              addr = &data[ZINDEX16(x, y, image)];
              addr[0] = pixels[*iptr];
              addr[1] = pixels[*iptr] >> 8;
           }

#else  /* WITHOUT_SPEEDUPS */

    Pixel pixel;

    int bpl = image->bytes_per_line;
    unsigned char *data_ptr, *max_data;

    data = (unsigned char *) image->data;
    iptr = pixelindex;
    if (image->byte_order == MSBFirst)
       for (y = 0; y < height; y++) {
           data_ptr = data;
           max_data = data_ptr + (width << 1);

           while (data_ptr < max_data) {
              pixel = pixels[*(iptr++)];

              data_ptr[0] = pixel >> 8;
              data_ptr[1] = pixel;

              data_ptr += (1 << 1);
           }
           data += bpl;
       }
    else
       for (y = 0; y < height; y++) {
           data_ptr = data;
           max_data = data_ptr + (width << 1);

           while (data_ptr < max_data) {
              pixel = pixels[*(iptr++)];

              data_ptr[0] = pixel;
              data_ptr[1] = pixel >> 8;

              data_ptr += (1 << 1);
           }
           data += bpl;
       }

#endif /* WITHOUT_SPEEDUPS */

Here is the call graph for this function:

Here is the caller graph for this function:

static void SetImagePixels32 ( XImage *  image,
unsigned int  width,
unsigned int  height,
unsigned int pixelindex,
Pixel pixels 
) [static]

Definition at line 1116 of file create.c.

{
    unsigned char *data;
    unsigned int *iptr;
    int y;
    Pixel pixel;

#ifdef WITHOUT_SPEEDUPS

    int x;
    unsigned char *addr;

    data = (unsigned char *) image->data;
    iptr = pixelindex;
#if !defined(WORD64) && !defined(LONG64)
    if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) {
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              addr = &data[ZINDEX32(x, y, image)];
              *((unsigned long *) addr) = pixels[*iptr];
           }
    } else
#endif
    if (image->byte_order == MSBFirst)
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              addr = &data[ZINDEX32(x, y, image)];
              pixel = pixels[*iptr];
              addr[0] = pixel >> 24;
              addr[1] = pixel >> 16;
              addr[2] = pixel >> 8;
              addr[3] = pixel;
           }
    else
       for (y = 0; y < height; y++)
           for (x = 0; x < width; x++, iptr++) {
              addr = &data[ZINDEX32(x, y, image)];
              pixel = pixels[*iptr];
              addr[0] = pixel;
              addr[1] = pixel >> 8;
              addr[2] = pixel >> 16;
              addr[3] = pixel >> 24;
           }

#else  /* WITHOUT_SPEEDUPS */

    int bpl = image->bytes_per_line;
    unsigned char *data_ptr, *max_data;

    data = (unsigned char *) image->data;
    iptr = pixelindex;
#if !defined(WORD64) && !defined(LONG64)
    if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) {
       for (y = 0; y < height; y++) {
           data_ptr = data;
           max_data = data_ptr + (width << 2);

           while (data_ptr < max_data) {
              *((unsigned long *) data_ptr) = pixels[*(iptr++)];
              data_ptr += (1 << 2);
           }
           data += bpl;
       }
    } else
#endif
    if (image->byte_order == MSBFirst)
       for (y = 0; y < height; y++) {
           data_ptr = data;
           max_data = data_ptr + (width << 2);

           while (data_ptr < max_data) {
              pixel = pixels[*(iptr++)];

              *data_ptr++ = pixel >> 24;
              *data_ptr++ = pixel >> 16;
              *data_ptr++ = pixel >> 8;
              *data_ptr++ = pixel;

           }
           data += bpl;
       }
    else
       for (y = 0; y < height; y++) {
           data_ptr = data;
           max_data = data_ptr + (width << 2);

           while (data_ptr < max_data) {
              pixel = pixels[*(iptr++)];

              *data_ptr++ = pixel;
              *data_ptr++ = pixel >> 8;
              *data_ptr++ = pixel >> 16;
              *data_ptr++ = pixel >> 24;
           }
           data += bpl;
       }

#endif /* WITHOUT_SPEEDUPS */

Here is the caller graph for this function:

static void SetImagePixels8 ( XImage *  image,
unsigned int  width,
unsigned int  height,
unsigned int pixelindex,
Pixel pixels 
) [static]

Definition at line 1307 of file create.c.

{
    char *data;
    unsigned int *iptr;
    int y;

#ifdef WITHOUT_SPEEDUPS

    int x;

    data = image->data;
    iptr = pixelindex;
    for (y = 0; y < height; y++)
       for (x = 0; x < width; x++, iptr++)
           data[ZINDEX8(x, y, image)] = pixels[*iptr];

#else  /* WITHOUT_SPEEDUPS */

    int bpl = image->bytes_per_line;
    char *data_ptr, *max_data;

    data = image->data;
    iptr = pixelindex;

    for (y = 0; y < height; y++) {
       data_ptr = data;
       max_data = data_ptr + width;

       while (data_ptr < max_data)
           *(data_ptr++) = pixels[*(iptr++)];

       data += bpl;
    }

#endif /* WITHOUT_SPEEDUPS */

Here is the caller graph for this function:

void xpm_xynormalizeimagebits ( unsigned char *  bp,
XImage *  img 
)

Definition at line 906 of file create.c.

{
    register unsigned char c;

    if (img->byte_order != img->bitmap_bit_order) {
       switch (img->bitmap_unit) {

       case 16:
           c = *bp;
           *bp = *(bp + 1);
           *(bp + 1) = c;
           break;

       case 32:
           c = *(bp + 3);
           *(bp + 3) = *bp;
           *bp = c;
           c = *(bp + 2);
           *(bp + 2) = *(bp + 1);
           *(bp + 1) = c;
           break;
       }
    }
    if (img->bitmap_bit_order == MSBFirst)
       _XReverse_Bytes(bp, img->bitmap_unit >> 3);

Here is the call graph for this function:

void xpm_znormalizeimagebits ( unsigned char *  bp,
XImage *  img 
)

Definition at line 936 of file create.c.

{
    register unsigned char c;

    switch (img->bits_per_pixel) {

    case 2:
       _XReverse_Bytes(bp, 1);
       break;

    case 4:
       *bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
       break;

    case 16:
       c = *bp;
       *bp = *(bp + 1);
       *(bp + 1) = c;
       break;

    case 24:
       c = *(bp + 2);
       *(bp + 2) = *bp;
       *bp = c;
       break;

    case 32:
       c = *(bp + 3);
       *(bp + 3) = *bp;
       *bp = c;
       c = *(bp + 2);
       *(bp + 2) = *(bp + 1);
       *(bp + 1) = c;
       break;
    }

Here is the call graph for this function:

int XpmCreateImageFromXpmImage ( Display *  display,
XpmImage image,
XImage **  image_return,
XImage **  shapeimage_return,
XpmAttributes attributes 
)

Definition at line 632 of file create.c.

{
    /* variables stored in the XpmAttributes structure */
    Visual *visual;
    Colormap colormap;
    unsigned int depth;

    /* variables to return */
    XImage *ximage = NULL;
    XImage *shapeimage = NULL;
    unsigned int mask_pixel_index = XpmUndefPixel;
    int ErrorStatus;

    /* calculation variables */
    Pixel *image_pixels = NULL;
    Pixel *mask_pixels = NULL;
    Pixel *alloc_pixels = NULL;
    Pixel *used_pixels = NULL;
    unsigned int nalloc_pixels = 0;
    unsigned int nused_pixels = 0;

    /* initialize return values */
    if (image_return)
       *image_return = NULL;
    if (shapeimage_return)
       *shapeimage_return = NULL;

    /* retrieve information from the XpmAttributes */
    if (attributes && (attributes->valuemask & XpmVisual))
       visual = attributes->visual;
    else
       visual = XDefaultVisual(display, XDefaultScreen(display));

    if (attributes && (attributes->valuemask & XpmColormap))
       colormap = attributes->colormap;
    else
       colormap = XDefaultColormap(display, XDefaultScreen(display));

    if (attributes && (attributes->valuemask & XpmDepth))
       depth = attributes->depth;
    else
       depth = XDefaultDepth(display, XDefaultScreen(display));

    ErrorStatus = XpmSuccess;

    /* malloc pixels index tables */
    image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
    if (!image_pixels)
       return (XpmNoMemory);

    mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
    if (!mask_pixels)
       RETURN(XpmNoMemory);

    /* maximum of allocated pixels will be the number of colors */
    alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
    if (!alloc_pixels)
       RETURN(XpmNoMemory);

    /* maximum of allocated pixels will be the number of colors */
    used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
    if (!used_pixels)
       RETURN(XpmNoMemory);

    /* get pixel colors, store them in index tables */
    ErrorStatus = CreateColors(display, attributes, image->colorTable,
                            image->ncolors, image_pixels, mask_pixels,
                            &mask_pixel_index, alloc_pixels, &nalloc_pixels,
                            used_pixels, &nused_pixels);

    if (ErrorStatus != XpmSuccess
       && (ErrorStatus < 0 || (attributes
                            && (attributes->valuemask & XpmExactColors)
                            && attributes->exactColors)))
       RETURN(ErrorStatus);

    /* create the ximage */
    if (image_return) {
       ErrorStatus = CreateXImage(display, visual, depth,
                               image->width, image->height, &ximage);
       if (ErrorStatus != XpmSuccess)
           RETURN(ErrorStatus);

#ifndef FOR_MSW

       /*
        * set the ximage data
        * 
        * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use
        * optimized functions, otherwise use slower but sure general one.
        * 
        */

       if (ximage->depth == 1)
           SetImagePixels1(ximage, image->width, image->height,
                         image->data, image_pixels);
       else if (ximage->bits_per_pixel == 8)
           SetImagePixels8(ximage, image->width, image->height,
                         image->data, image_pixels);
       else if (ximage->bits_per_pixel == 16)
           SetImagePixels16(ximage, image->width, image->height,
                          image->data, image_pixels);
       else if (ximage->bits_per_pixel == 32)
           SetImagePixels32(ximage, image->width, image->height,
                          image->data, image_pixels);
       else
           SetImagePixels(ximage, image->width, image->height,
                        image->data, image_pixels);
#else  /* FOR_MSW */
       MSWSetImagePixels(display, ximage, image->width, image->height,
                       image->data, image_pixels);
#endif
    }
    /* create the shape mask image */
    if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
       ErrorStatus = CreateXImage(display, visual, 1, image->width,
                               image->height, &shapeimage);
       if (ErrorStatus != XpmSuccess)
           RETURN(ErrorStatus);

#ifndef FOR_MSW
       SetImagePixels1(shapeimage, image->width, image->height,
                     image->data, mask_pixels);
#else
       MSWSetImagePixels(display, shapeimage, image->width, image->height,
                       image->data, mask_pixels);
#endif

    }
    XpmFree(image_pixels);
    XpmFree(mask_pixels);

    /* if requested return used pixels in the XpmAttributes structure */
    if (attributes && (attributes->valuemask & XpmReturnPixels ||
/* 3.2 backward compatibility code */
       attributes->valuemask & XpmReturnInfos)) {
/* end 3.2 bc */
       attributes->pixels = used_pixels;
       attributes->npixels = nused_pixels;
       attributes->mask_pixel = mask_pixel_index;
    } else
       XpmFree(used_pixels);

    /* if requested return alloc'ed pixels in the XpmAttributes structure */
    if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
       attributes->alloc_pixels = alloc_pixels;
       attributes->nalloc_pixels = nalloc_pixels;
    } else
       XpmFree(alloc_pixels);

    /* return created images */
    if (image_return)
       *image_return = ximage;
    if (shapeimage_return)
       *shapeimage_return = shapeimage;

    return (ErrorStatus);

Here is the call graph for this function:

Here is the caller graph for this function:

int XpmCreatePixmapFromXpmImage ( Display *  display,
Drawable  d,
XpmImage image,
Pixmap *  pixmap_return,
Pixmap *  shapemask_return,
XpmAttributes attributes 
)

Definition at line 1468 of file create.c.

{
    XImage *ximage, *shapeimage;
    int ErrorStatus;

    /* initialize return values */
    if (pixmap_return)
       *pixmap_return = 0;
    if (shapemask_return)
       *shapemask_return = 0;

    /* create the ximages */
    ErrorStatus = XpmCreateImageFromXpmImage(display, image,
                                        (pixmap_return ? &ximage : NULL),
                                        (shapemask_return ?
                                         &shapeimage : NULL),
                                        attributes);
    if (ErrorStatus < 0)
       return (ErrorStatus);

    /* create the pixmaps and destroy images */
    if (pixmap_return && ximage) {
       xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
       XDestroyImage(ximage);
    }
    if (shapemask_return && shapeimage) {
       xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
       XDestroyImage(shapeimage);
    }
    return (ErrorStatus);

Here is the call graph for this function:

static int xpmVisualType ( Visual *  visual) [static]

Definition at line 139 of file create.c.

{
#ifndef FOR_MSW
    switch (visual->class) {
    case StaticGray:
    case GrayScale:
       switch (visual->map_entries) {
       case 2:
           return (XPM_MONO);
       case 4:
           return (XPM_GRAY4);
       default:
           return (XPM_GRAY);
       }
    default:
       return (XPM_COLOR);
    }
#else
    /* there should be a similar switch for MSW */
    return (XPM_COLOR);
#endif
}

Here is the caller graph for this function:


Variable Documentation

unsigned char Const _himask[0x09] [static]
Initial value:
 {
0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00}

Definition at line 977 of file create.c.

unsigned char Const _lomask[0x09] [static]
Initial value:
 {
0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff}

Definition at line 975 of file create.c.

unsigned char Const _reverse_byte[0x100] [static]

Definition at line 857 of file create.c.

unsigned long RTXpm_byteorderpixel = MSBFirst << 24 [static]

Definition at line 1106 of file create.c.