//
//  file name : alloc_cl.C
//  This file contains only one function AllocColor().
//  It is from XV source codes with minor changes.
//  AllocColor will allocate the specified colormap
//  from the colors arrays r[], g[], b[], and then
//  put the map from the color arrays index to
//  X pixel values in the array cols[].
//
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>

#define NOPIX 0xffffffff

typedef unsigned char byte;

extern byte r[256], g[256], b[256];	// colormap
extern int nfcols;			// # of colors to free
extern int ncols;			// max # of colors to alloc
extern int numcols;			// # of desired colors
extern unsigned long freecols[256];	// list of pixel values to free
extern unsigned long cols[256];		// maps pic pixels vals to X pixel vals
extern int fc2pcol[256];		// maps freecols into pic pixel vals

void AllocColor(Display *theDisp, Window mainW, Colormap theCmap)
{
  int      i, j, unique, p2alloc, p3alloc;
  Colormap cmap;
  XColor   defs[256];
  XColor   ctab[256];
  int      dc;
 
 
  nfcols = unique = p2alloc = p3alloc = 0;
 
 
  if (ncols == 0) {
    fprintf(stderr,"no colors allocated.  Using black & white.\n");
    return;
  }
 
 
  /* FIRST PASS COLOR ALLOCATION:
     for each color in the 'desired colormap', try to get it via
     XAllocColor().  If for any reason it fails, mark that pixel
     for each color in the 'desired colormap', try to get it via
     XAllocColor().  If for any reason it fails, mark that pixel
     'unallocated' and worry about it later.  Repeat. */
 
  /* attempt to allocate first ncols entries in colormap
     note: On displays with less than 8 bits per RGB gun, it's quite
     possible that different colors in the original picture will be
     mapped to the same color on the screen.  X does this for you
     silently.  However, this is not-desirable for this application,
     because when I say 'allocate me 32 colors' I want it to allocate
     because when I say 'allocate me 32 colors' I want it to allocate
     32 different colors, not 32 instances of the same 4 shades... */
 
  for (i=0; i<numcols; i++) cols[i] = NOPIX;
 
  cmap = theCmap;
  for (i=0; i<numcols && unique<ncols; i++) {
    defs[i].red   = r[i]<<8;
    defs[i].green = g[i]<<8;
    defs[i].blue  = b[i]<<8;
    defs[i].flags = DoRed | DoGreen | DoBlue;
 
    if (XAllocColor(theDisp, cmap, &defs[i])) {
      unsigned long pixel, *fcptr;
 
      pixel = cols[i] = defs[i].pixel;
 
      /* see if the newly allocated color is new and different */
      for (j=0, fcptr=freecols; j<nfcols && *fcptr!=pixel; j++,fcptr++);
      if (j==nfcols) unique++;
 
      fc2pcol[nfcols] = i;
      freecols[nfcols++] = pixel;
    }
 
    else {
      /* the allocation failed.  If we want 'perfect' color, and we haven't
         already created our own colormap, we'll want to do so */
        cols[i] = NOPIX;
    }
  }  /* FIRST PASS */
 
 
/* 
  if (nfcols==numcols) {
    if (numcols != unique)
      fprintf(stderr,"Got all %d desired colors.  (%d unique)\n", numcols,
              unique);
    else
      fprintf(stderr,"Got all %d desired colors.\n", numcols);
 
    return;
  }
*/
  /* SECOND PASS COLOR ALLOCATION:
     Allocating 'exact' colors failed.  Now try to allocate 'closest'
     colors.
 
     Read entire X colormap (or first 256 entries) in from display.
     for each unallocated pixel, find the closest color that actually
     is in the X colormap.  Try to allocate that color (read only).
     If that fails, the THIRD PASS will deal with it */
 
//  fprintf(stderr,"Got %d out of %d colors.  (%d unique)\n",
//          nfcols,numcols,unique);
 
 
  /* read entire colormap (or first 256 entries) into 'ctab' */
  dc = 256;
  for (i=0; i<dc; i++) ctab[i].pixel = (unsigned long) i;
 
  XQueryColors(theDisp, cmap, ctab, dc);
 
  for (i=0; i<numcols && unique<ncols; i++)
    if (cols[i]==NOPIX) {  /* an unallocated pixel */
      int           d, mdist, close;
      unsigned long ri,gi,bi;
 
      mdist = 100000;   close = -1;
      ri = r[i];  gi = g[i];  bi = b[i];
 
      for (j=0; j<dc; j++) {
        d = abs(ri - (ctab[j].red>>8)) +
            abs(gi - (ctab[j].green>>8)) +
            abs(bi - (ctab[j].blue>>8));
        if (d<mdist) { mdist=d; close=j; }
      }
 
      if (close<0) {
         fprintf(stderr,"This Can't Happen! (How reassuring.)");
         exit(-1);
      }
      if (XAllocColor(theDisp, cmap, &ctab[close])) {
        memcpy(&defs[i], &ctab[close], sizeof(XColor));
        cols[i] = ctab[close].pixel;
        fc2pcol[nfcols] = i;
        freecols[nfcols++] = cols[i];
        p2alloc++;
        unique++;
      }
    }
 
 
 
  /* THIRD PASS COLOR ALLOCATION:
     We've alloc'ed all the colors we can.  Now, we have to map any
     remaining unalloced pixels into either A) the colors that we DID get
     (noglob), or B) the colors found in the X colormap */
 
  for (i=0; i<numcols; i++) {
    if (cols[i] == NOPIX) {  /* an unallocated pixel */
      int           d, k, mdist, close;
      unsigned long ri,gi,bi;
 
      mdist = 100000;   close = -1;
      ri = r[i];  gi = g[i];  bi = b[i];
 
      for (j=0; j<dc; j++) {
        d = abs(ri - (ctab[j].red>>8)) +
            abs(gi - (ctab[j].green>>8)) +
            abs(bi - (ctab[j].blue>>8));
        if (d<mdist) { mdist=d; close=j; }
      }
      if (close<0) {
         fprintf(stderr,"This Can't Happen! (How reassuring.)");
         exit(-1);
      }
      memcpy(&defs[i], &ctab[close], sizeof(XColor));
      cols[i] = defs[i].pixel;
      p3alloc++;
 
    }
  }  /* THIRD PASS */
 
 
/*
  if (p2alloc && p3alloc)
    fprintf(stderr,"Got %d 'close' color%s.  'Borrowed' %d color%s.",
            p2alloc, (p2alloc>1) ? "s" : "",
            p3alloc, (p3alloc>1) ? "s" : "");
 
  else if (p2alloc && !p3alloc)
    fprintf(stderr,"Got %d 'close' color%s.",
            p2alloc, (p2alloc>1) ? "s" : "");
 
  else if (!p2alloc && p3alloc)
    fprintf(stderr,"'Borrowed' %d color%s.",
            p3alloc, (p3alloc>1) ? "s" : "");
*/
}