git.oblomov.eu Git - wine/blob - objects/color.c

   1 /*
   2  * Color functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  * Copyright 1996 Alex Korobka
   6  */
   7
   8 #include <stdlib.h>
   9 #include <X11/Xlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include "windows.h"
  13 #include "options.h"
  14 #include "gdi.h"
  15 #include "color.h"
  16 #include "stddebug.h"
  17 #include "debug.h"
  18 #include "xmalloc.h"
  19
  20 /* Palette indexed mode:
  21
  22  *      logical palette -> mapping -> pixel
  23  *
  24  *
  25  * Windows needs contiguous color space ( from 0 to n ) but
  26  * it is possible only with the private colormap. Otherwise we
  27  * have to map DC palette indices to real pixel values. With
  28  * private colormaps it boils down to the identity mapping. The
  29  * other special case is when we have a fixed color visual with
  30  * the screendepth > 8 - we abandon palette mappings altogether
  31  * because pixel values can be calculated without X server
  32  * assistance.
  33  *
  34  * Windows palette manager is described in the
  35  * http://premium.microsoft.com/msdn/library/techart/f30/f34/f40/d4d/sa942.htm
  36  */
  37
  38 typedef struct
  39 {
  40     Colormap    colorMap;
  41     UINT16      size;
  42     UINT16      flags;
  43     INT32       monoPlane;       /* bit plane different for white and black pixels */
  44
  45     INT32       (*mapColor)( DC*, COLORREF );
  46 } CSPACE;
  47
  48 static CSPACE cSpace = {0, 0, 0};
  49
  50 static int COLOR_Redshift   = 0; /* to handle abortive COLOR_VIRTUAL visuals */
  51 static int COLOR_Redmax     = 0;
  52 static int COLOR_Greenshift = 0;
  53 static int COLOR_Greenmax   = 0;
  54 static int COLOR_Blueshift  = 0;
  55 static int COLOR_Bluemax    = 0;
  56 static int COLOR_Graymax    = 0;
  57
  58 /* System color space.
  59  *
  60  * First 10 and last 10 colors in COLOR_sysPalette are
  61  * "guarded". RealizePalette changes only the rest of colorcells. For
  62  * currently inactive window it changes only DC palette mappings.
  63  */
  64
  65 #define NB_COLORCUBE_START_INDEX        63
  66
  67 Visual*                 visual = NULL;
  68
  69 static PALETTEENTRY* COLOR_sysPal = NULL;    /* current system palette */
  70 static int COLOR_gapStart = 256;
  71 static int COLOR_gapEnd = -1;
  72 static int COLOR_gapFilled = 0;
  73 static int COLOR_max = 256;
  74
  75   /* First free dynamic color cell, 0 = full palette, -1 = fixed palette */
  76 static int            COLOR_firstFree = 0;
  77 static unsigned char  COLOR_freeList[256];
  78
  79   /* Maps entry in the system palette to X pixel value */
  80 int* COLOR_PaletteToPixel = NULL;
  81
  82   /* Maps pixel to the entry in the system palette */
  83 int* COLOR_PixelToPalette = NULL;
  84
  85 static const PALETTEENTRY __sysPalTemplate[NB_RESERVED_COLORS] =
  86 {
  87     /* first 10 entries in the system palette */
  88     /* red  green blue  flags */
  89     { 0x00, 0x00, 0x00, PC_SYS_USED },
  90     { 0x80, 0x00, 0x00, PC_SYS_USED },
  91     { 0x00, 0x80, 0x00, PC_SYS_USED },
  92     { 0x80, 0x80, 0x00, PC_SYS_USED },
  93     { 0x00, 0x00, 0x80, PC_SYS_USED },
  94     { 0x80, 0x00, 0x80, PC_SYS_USED },
  95     { 0x00, 0x80, 0x80, PC_SYS_USED },
  96     { 0xc0, 0xc0, 0xc0, PC_SYS_USED },
  97     { 0xc0, 0xdc, 0xc0, PC_SYS_USED },
  98     { 0xa6, 0xca, 0xf0, PC_SYS_USED },
  99
 100     /* ... c_min/2 dynamic colorcells */
 101
 102     /* ... gap (for sparse palettes) */
 103
 104     /* ... c_min/2 dynamic colorcells */
 105
 106     { 0xff, 0xfb, 0xf0, PC_SYS_USED },
 107     { 0xa0, 0xa0, 0xa4, PC_SYS_USED },
 108     { 0x80, 0x80, 0x80, PC_SYS_USED },
 109     { 0xff, 0x00, 0x00, PC_SYS_USED },
 110     { 0x00, 0xff, 0x00, PC_SYS_USED },
 111     { 0xff, 0xff, 0x00, PC_SYS_USED },
 112     { 0x00, 0x00, 0xff, PC_SYS_USED },
 113     { 0xff, 0x00, 0xff, PC_SYS_USED },
 114     { 0x00, 0xff, 0xff, PC_SYS_USED },
 115     { 0xff, 0xff, 0xff, PC_SYS_USED }     /* last 10 */
 116 };
 117
 118    /* Map an EGA index (0..15) to a pixel value in the system color space.  */
 119
 120 int COLOR_mapEGAPixel[16];
 121
 122 /***********************************************************************
 123  *      Misc auxiliary functions
 124  */
 125 Colormap COLOR_GetColormap(void)
 126 {
 127     return cSpace.colorMap;
 128 }
 129
 130 BOOL32 COLOR_GetMonoPlane(INT32* plane)
 131 {
 132     *plane = cSpace.monoPlane;
 133     return (cSpace.flags & COLOR_WHITESET) ? TRUE : FALSE;
 134 }
 135
 136 UINT16 COLOR_GetSystemPaletteSize(void)
 137 {
 138     return (cSpace.flags & COLOR_PRIVATE) ? cSpace.size : 256;
 139 }
 140
 141 UINT16 COLOR_GetSystemPaletteFlags(void)
 142 {
 143     return cSpace.flags;
 144 }
 145
 146 const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(void)
 147 {
 148     return __sysPalTemplate;
 149 }
 150
 151 COLORREF COLOR_GetSystemPaletteEntry(UINT32 i)
 152 {
 153  return *(COLORREF*)(COLOR_sysPal + i) & 0x00ffffff;
 154 }
 155
 156 void COLOR_FormatSystemPalette(void)
 157 {
 158  /* Build free list so we'd have an easy way to find
 159   * out if there are any available colorcells.
 160   */
 161
 162   int i, j = COLOR_firstFree = NB_RESERVED_COLORS/2;
 163
 164   COLOR_sysPal[j].peFlags = 0;
 165   for( i = NB_RESERVED_COLORS/2 + 1 ; i < 256 - NB_RESERVED_COLORS/2 ; i++ )
 166     if( i < COLOR_gapStart || i > COLOR_gapEnd )
 167       {
 168         COLOR_sysPal[i].peFlags = 0;  /* unused tag */
 169         COLOR_freeList[j] = i;    /* next */
 170         j = i;
 171       }
 172   COLOR_freeList[j] = 0;
 173 }
 174
 175 BOOL32 COLOR_CheckSysColor(COLORREF c)
 176 {
 177   int i;
 178   for( i = 0; i < NB_RESERVED_COLORS; i++ )
 179        if( c == (*(COLORREF*)(__sysPalTemplate + i) & 0x00ffffff) )
 180            return 0;
 181   return 1;
 182 }
 183
 184 /***********************************************************************
 185  *      Colormap Initialization
 186  */
 187 static void COLOR_FillDefaultColors(void)
 188 {
 189  /* initialize unused entries to what Windows uses as a color
 190   * cube - based on Greg Kreider's code.
 191   */
 192
 193   int i = 0, idx = 0;
 194   int red, no_r, inc_r;
 195   int green, no_g, inc_g;
 196   int blue, no_b, inc_b;
 197
 198   if (cSpace.size <= NB_RESERVED_COLORS)
 199         return;
 200   while (i*i*i < (cSpace.size - NB_RESERVED_COLORS)) i++;
 201   no_r = no_g = no_b = --i;
 202   if ((no_r * (no_g+1) * no_b) < (cSpace.size - NB_RESERVED_COLORS)) no_g++;
 203   if ((no_r * no_g * (no_b+1)) < (cSpace.size - NB_RESERVED_COLORS)) no_b++;
 204   inc_r = (255 - NB_COLORCUBE_START_INDEX)/no_r;
 205   inc_g = (255 - NB_COLORCUBE_START_INDEX)/no_g;
 206   inc_b = (255 - NB_COLORCUBE_START_INDEX)/no_b;
 207
 208   idx = COLOR_firstFree;
 209
 210   if( idx != -1 )
 211     for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b )
 212      for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g )
 213       for (red = NB_COLORCUBE_START_INDEX; red < 256 && idx; red += inc_r )
 214       {
 215          /* weird but true */
 216
 217          if( red == NB_COLORCUBE_START_INDEX && green == red && blue == green ) continue;
 218
 219          COLOR_sysPal[idx].peRed = red;
 220          COLOR_sysPal[idx].peGreen = green;
 221          COLOR_sysPal[idx].peBlue = blue;
 222
 223          /* set X color */
 224
 225          if( cSpace.flags & COLOR_VIRTUAL )
 226          {
 227             if (COLOR_Redmax != 255) no_r = (red * COLOR_Redmax) / 255;
 228             if (COLOR_Greenmax != 255) no_g = (green * COLOR_Greenmax) / 255;
 229             if (COLOR_Bluemax != 255) no_b = (blue * COLOR_Bluemax) / 255;
 230
 231             COLOR_PaletteToPixel[idx] = (no_r << COLOR_Redshift) | (no_g << COLOR_Greenshift) | (no_b << COLOR_Blueshift);
 232          }
 233          else if( !(cSpace.flags & COLOR_FIXED) )
 234          {
 235            XColor color = { color.pixel = (COLOR_PaletteToPixel)? COLOR_PaletteToPixel[idx] : idx ,
 236                             COLOR_sysPal[idx].peRed << 8,
 237                             COLOR_sysPal[idx].peGreen << 8,
 238                             COLOR_sysPal[idx].peGreen << 8,
 239                             (DoRed | DoGreen | DoBlue) };
 240            XStoreColor(display, cSpace.colorMap, &color);
 241          }
 242
 243          idx = COLOR_freeList[idx];
 244       }
 245
 246   /* try to fill some entries in the "gap" with
 247    * what's already in the colormap - they will be
 248    * mappable to but not changeable. */
 249
 250   if( COLOR_gapStart < COLOR_gapEnd && COLOR_PixelToPalette )
 251   {
 252     XColor      xc;
 253     int         r, g, b, max;
 254
 255     max = COLOR_max - (256 - (COLOR_gapEnd - COLOR_gapStart));
 256     for ( i = 0, idx = COLOR_gapStart; i < 256 && idx <= COLOR_gapEnd; i++ )
 257       if( COLOR_PixelToPalette[i] == 0 )
 258         {
 259           xc.pixel = i;
 260
 261           XQueryColor(display, cSpace.colorMap, &xc);
 262           r = xc.red>>8; g = xc.green>>8; b = xc.blue>>8;
 263
 264           if( xc.pixel < 256 && COLOR_CheckSysColor(RGB(r, g, b)) &&
 265               XAllocColor(display, cSpace.colorMap, &xc) )
 266           {
 267              COLOR_PixelToPalette[xc.pixel] = idx;
 268              COLOR_PaletteToPixel[idx] = xc.pixel;
 269            *(COLORREF*)(COLOR_sysPal + idx) = RGB(r, g, b);
 270              COLOR_sysPal[idx++].peFlags |= PC_SYS_USED;
 271              if( --max <= 0 ) break;
 272           }
 273         }
 274     COLOR_gapFilled = idx - COLOR_gapStart;
 275   }
 276 }
 277
 278 /***********************************************************************
 279  *           COLOR_BuildPrivateMap/COLOR_BuildSharedMap
 280  *
 281  * Allocate colorcells and initialize mapping tables.
 282  */
 283 static BOOL32 COLOR_BuildPrivateMap(CSPACE* cs)
 284 {
 285     /* Private colormap - identity mapping */
 286
 287     XColor color;
 288     int i;
 289
 290     COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*cs->size);
 291
 292     dprintf_palette(stddeb,"\tbuilding private map - %i palette entries\n", cs->size);
 293
 294       /* Allocate system palette colors */
 295
 296     for( i=0; i < cs->size; i++ )
 297     {
 298        if( i < NB_RESERVED_COLORS/2 )
 299        {
 300          color.red   = __sysPalTemplate[i].peRed * 65535 / 255;
 301          color.green = __sysPalTemplate[i].peGreen * 65535 / 255;
 302          color.blue  = __sysPalTemplate[i].peBlue * 65535 / 255;
 303          COLOR_sysPal[i] = __sysPalTemplate[i];
 304        }
 305        else if( i >= cs->size - NB_RESERVED_COLORS/2 )
 306        {
 307          int j = NB_RESERVED_COLORS + i - cs->size;
 308          color.red   = __sysPalTemplate[j].peRed * 65535 / 255;
 309          color.green = __sysPalTemplate[j].peGreen * 65535 / 255;
 310          color.blue  = __sysPalTemplate[j].peBlue * 65535 / 255;
 311          COLOR_sysPal[i] = __sysPalTemplate[j];
 312        }
 313
 314        color.flags = DoRed | DoGreen | DoBlue;
 315        color.pixel = i;
 316        XStoreColor(display, cs->colorMap, &color);
 317
 318        /* Set EGA mapping if color is from the first or last eight */
 319
 320        if (i < 8)
 321            COLOR_mapEGAPixel[i] = color.pixel;
 322        else if (i >= cs->size - 8 )
 323            COLOR_mapEGAPixel[i - (cs->size - 16)] = color.pixel;
 324     }
 325
 326     COLOR_PixelToPalette = COLOR_PaletteToPixel = NULL;
 327
 328     COLOR_gapStart = 256; COLOR_gapEnd = -1;
 329
 330     COLOR_firstFree = (cs->size > NB_RESERVED_COLORS)?NB_RESERVED_COLORS/2 : -1;
 331     return FALSE;
 332 }
 333
 334 static BOOL32 COLOR_BuildSharedMap(CSPACE* cs)
 335 {
 336    XColor               color;
 337    unsigned long        sysPixel[NB_RESERVED_COLORS];
 338    unsigned long*       pixDynMapping = NULL;
 339    unsigned long        plane_masks[1];
 340    int                  i, j, warn = 0;
 341    int                  diff, r, g, b, max = 256, bp = 0, wp = 1;
 342    int                  step = 1;
 343
 344    /* read "AllocSystemColors" from wine.conf */
 345
 346    COLOR_max = PROFILE_GetWineIniInt( "options", "AllocSystemColors", 256);
 347    if (COLOR_max > 256) COLOR_max = 256;
 348    else if (COLOR_max < 20) COLOR_max = 20;
 349    dprintf_palette(stddeb,"COLOR_Init: %d colors configured.\n", COLOR_max);
 350
 351    dprintf_palette(stddeb,"\tbuilding shared map - %i palette entries\n", cs->size);
 352
 353    /* Be nice and allocate system colors as read-only */
 354
 355    for( i = 0; i < NB_RESERVED_COLORS; i++ )
 356      {
 357         color.red   = __sysPalTemplate[i].peRed * 65535 / 255;
 358         color.green = __sysPalTemplate[i].peGreen * 65535 / 255;
 359         color.blue  = __sysPalTemplate[i].peBlue * 65535 / 255;
 360         color.flags = DoRed | DoGreen | DoBlue;
 361
 362         if (!XAllocColor( display, cSpace.colorMap, &color ))
 363         {
 364              XColor     best, c;
 365
 366              if( !warn++ )
 367              {
 368                   dprintf_palette(stddeb, "Not enough colors for the full system palette.\n");
 369
 370                   bp = BlackPixel(display, DefaultScreen(display));
 371                   wp = WhitePixel(display, DefaultScreen(display));
 372
 373                   max = (0xffffffff)>>(32 - screenDepth);
 374                   if( max > 256 )
 375                   {
 376                       step = max/256;
 377                       max = 256;
 378                   }
 379              }
 380
 381              /* reinit color (XAllocColor() may change it)
 382               * and map to the best shared colorcell */
 383
 384              color.red   = __sysPalTemplate[i].peRed * 65535 / 255;
 385              color.green = __sysPalTemplate[i].peGreen * 65535 / 255;
 386              color.blue  = __sysPalTemplate[i].peBlue * 65535 / 255;
 387
 388              best.pixel = best.red = best.green = best.blue = 0;
 389              for( c.pixel = 0, diff = 0x7fffffff; c.pixel < max; c.pixel += step )
 390              {
 391                 XQueryColor(display, cSpace.colorMap, &c);
 392                 r = (c.red - color.red)>>8;
 393                 g = (c.green - color.green)>>8;
 394                 b = (c.blue - color.blue)>>8;
 395                 r = r*r + g*g + b*b;
 396                 if( r < diff ) { best = c; diff = r; }
 397              }
 398
 399              if( XAllocColor(display, cSpace.colorMap, &best) )
 400                  color.pixel = best.pixel;
 401              else color.pixel = (i < NB_RESERVED_COLORS/2)? bp : wp;
 402         }
 403
 404         sysPixel[i] = color.pixel;
 405
 406         dprintf_palette(stddeb,"\tsyscolor(%lx) -> pixel %i\n",
 407                       *(COLORREF*)(__sysPalTemplate+i), (int)color.pixel);
 408
 409         /* Set EGA mapping if color in the first or last eight */
 410
 411         if (i < 8)
 412             COLOR_mapEGAPixel[i] = color.pixel;
 413         else if (i >= NB_RESERVED_COLORS - 8 )
 414             COLOR_mapEGAPixel[i - (NB_RESERVED_COLORS-16)] = color.pixel;
 415      }
 416
 417    /* now allocate changeable set */
 418
 419    if( !(cSpace.flags & COLOR_FIXED) )
 420      {
 421         int c_min = 0, c_max = cs->size, c_val;
 422
 423         dprintf_palette(stddeb,"\tdynamic colormap... ");
 424
 425         /* comment this out if you want to debug palette init */
 426
 427         XGrabServer(display);
 428
 429         /* let's become the first client that actually follows
 430          * X guidelines and does binary search...
 431          */
 432
 433         pixDynMapping = (unsigned long*)xmalloc(sizeof(long)*cs->size);
 434         while( c_max - c_min > 0 )
 435           {
 436              c_val = (c_max + c_min)/2 + (c_max + c_min)%2;
 437
 438              if( !XAllocColorCells(display, cs->colorMap, False,
 439                                    plane_masks, 0, pixDynMapping, c_val) )
 440                  c_max = c_val - 1;
 441              else
 442                {
 443                  XFreeColors(display, cs->colorMap, pixDynMapping, c_val, 0);
 444                  c_min = c_val;
 445                }
 446           }
 447
 448         if( c_min > COLOR_max - NB_RESERVED_COLORS)
 449             c_min = COLOR_max - NB_RESERVED_COLORS;
 450
 451         c_min = (c_min/2) + (c_min/2);          /* need even set for split palette */
 452
 453         if( c_min > 0 )
 454           if( !XAllocColorCells(display, cs->colorMap, False,
 455                                 plane_masks, 0, pixDynMapping, c_min) )
 456             {
 457               fprintf(stderr,"Inexplicable failure during colorcell allocation.\n");
 458               c_min = 0;
 459             }
 460
 461         cs->size = c_min + NB_RESERVED_COLORS;
 462
 463         XUngrabServer(display);
 464
 465         dprintf_palette(stddeb,"adjusted size %i colorcells\n", cs->size);
 466      }
 467    else if( cSpace.flags & COLOR_VIRTUAL )
 468         {
 469           /* virtual colorspace - ToPhysical takes care of
 470            * color translations but we have to allocate full palette
 471            * to maintain compatibility
 472            */
 473           cs->size = 256;
 474           dprintf_palette(stddeb,"\tvirtual colorspace - screendepth %i\n", screenDepth);
 475         }
 476    else cs->size = NB_RESERVED_COLORS;  /* system palette only - however we can alloc a bunch
 477                                          * of colors and map to them */
 478
 479    dprintf_palette(stddeb,"Shared system palette uses %i colors.\n", cs->size);
 480
 481    /* set gap to account for pixel shortage. It has to be right in the center
 482     * of the system palette because otherwise raster ops get screwed. */
 483
 484    if( cs->size >= 256 )
 485      { COLOR_gapStart = 256; COLOR_gapEnd = -1; }
 486    else
 487      { COLOR_gapStart = cs->size/2; COLOR_gapEnd = 255 - cs->size/2; }
 488
 489    COLOR_firstFree = ( cs->size > NB_RESERVED_COLORS &&
 490                       (cs->flags & COLOR_VIRTUAL || !(cs->flags & COLOR_FIXED)) )
 491                      ? NB_RESERVED_COLORS/2 : -1;
 492
 493    COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*256);
 494
 495    /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */
 496
 497    if( screenDepth <= 8 )
 498      {
 499        COLOR_PixelToPalette = (int*)xmalloc(sizeof(int)*256);
 500        memset( COLOR_PixelToPalette, 0, 256*sizeof(int) );
 501      }
 502
 503    /* for hicolor visuals PaletteToPixel mapping is used to skip
 504     * RGB->pixel calculation in COLOR_ToPhysical().
 505     */
 506
 507    COLOR_PaletteToPixel = (int*)xmalloc(sizeof(int)*256);
 508
 509    for( i = j = 0; i < 256; i++ )
 510    {
 511       if( i >= COLOR_gapStart && i <= COLOR_gapEnd )
 512       {
 513          COLOR_PaletteToPixel[i] = 0;
 514          COLOR_sysPal[i].peFlags = 0;   /* mark as unused */
 515          continue;
 516       }
 517
 518       if( i < NB_RESERVED_COLORS/2 )
 519       {
 520         COLOR_PaletteToPixel[i] = sysPixel[i];
 521         COLOR_sysPal[i] = __sysPalTemplate[i];
 522       }
 523       else if( i >= 256 - NB_RESERVED_COLORS/2 )
 524       {
 525         COLOR_PaletteToPixel[i] = sysPixel[(i + NB_RESERVED_COLORS) - 256];
 526         COLOR_sysPal[i] = __sysPalTemplate[(i + NB_RESERVED_COLORS) - 256];
 527       }
 528       else if( pixDynMapping )
 529              COLOR_PaletteToPixel[i] = pixDynMapping[j++];
 530            else
 531              COLOR_PaletteToPixel[i] = i;
 532
 533       dprintf_palette(stddeb,"\tindex %i -> pixel %i\n", i, COLOR_PaletteToPixel[i]);
 534
 535       if( COLOR_PixelToPalette )
 536           COLOR_PixelToPalette[COLOR_PaletteToPixel[i]] = i;
 537    }
 538
 539    if( pixDynMapping ) free(pixDynMapping);
 540    return TRUE;
 541 }
 542
 543 /***********************************************************************
 544  *           COLOR_Computeshifts
 545  *
 546  * Calculate conversion parameters for direct mapped visuals
 547  */
 548 static void COLOR_Computeshifts(unsigned long maskbits, int *shift, int *max)
 549 {
 550     int i;
 551
 552     if (maskbits==0)
 553     {
 554         *shift=0;
 555         *max=0;
 556         return;
 557     }
 558
 559     for(i=0;!(maskbits&1);i++)
 560         maskbits >>= 1;
 561
 562     *shift = i;
 563     *max = maskbits;
 564 }
 565
 566
 567 /***********************************************************************
 568  *           COLOR_Init
 569  *
 570  * Initialize color management.
 571  */
 572 BOOL32 COLOR_Init(void)
 573 {
 574     int mask, white, black;
 575
 576     visual = DefaultVisual( display, DefaultScreen(display) );
 577
 578     dprintf_palette(stddeb,"COLOR_Init: initializing palette manager...");
 579
 580     white = WhitePixelOfScreen( screen );
 581     black = BlackPixelOfScreen( screen );
 582     cSpace.monoPlane = 1;
 583     for( mask = 1; !((white & mask)^(black & mask)); mask <<= 1 )
 584          cSpace.monoPlane++;
 585     cSpace.flags = (white & mask) ? COLOR_WHITESET : 0;
 586     cSpace.size = visual->map_entries;
 587
 588     switch(visual->class)
 589     {
 590     case DirectColor:
 591         cSpace.flags |= COLOR_VIRTUAL;
 592     case GrayScale:
 593     case PseudoColor:
 594         if (Options.usePrivateMap)
 595         {
 596             XSetWindowAttributes win_attr;
 597
 598             cSpace.colorMap = XCreateColormap( display, rootWindow,
 599                                                  visual, AllocAll );
 600             if (cSpace.colorMap)
 601             {
 602                 cSpace.flags |= (COLOR_PRIVATE | COLOR_WHITESET);
 603
 604                 cSpace.monoPlane = 1;
 605                 for( white = cSpace.size - 1; !(white & 1); white >>= 1 )
 606                      cSpace.monoPlane++;
 607
 608                 if( rootWindow != DefaultRootWindow(display) )
 609                 {
 610                     win_attr.colormap = cSpace.colorMap;
 611                     XChangeWindowAttributes( display, rootWindow,
 612                                          CWColormap, &win_attr );
 613                 }
 614                 break;
 615             }
 616         }
 617         cSpace.colorMap = DefaultColormapOfScreen( screen );
 618         break;
 619
 620     case StaticGray:
 621         cSpace.colorMap = DefaultColormapOfScreen( screen );
 622         cSpace.flags |= COLOR_FIXED;
 623         COLOR_Graymax = (1<<screenDepth)-1;
 624         break;
 625
 626     case TrueColor:
 627         cSpace.flags |= COLOR_VIRTUAL;
 628     case StaticColor: {
 629         int *depths,nrofdepths;
 630         /* FIXME: hack to detect XFree32 XF_VGA16 ... We just have
 631          * depths 1 and 4
 632          */
 633         depths=XListDepths(display,DefaultScreen(display),&nrofdepths);
 634         if ((nrofdepths==2) && ((depths[0]==4) || depths[1]==4)) {
 635             cSpace.monoPlane = 1;
 636             for( white = cSpace.size - 1; !(white & 1); white >>= 1 )
 637                 cSpace.monoPlane++;
 638             cSpace.flags = (white & mask) ? COLOR_WHITESET : 0;
 639             cSpace.colorMap = DefaultColormapOfScreen( screen );
 640             XFree(depths);
 641             break;
 642         }
 643         XFree(depths);
 644         cSpace.colorMap = DefaultColormapOfScreen( screen );
 645         cSpace.flags |= COLOR_FIXED;
 646         COLOR_Computeshifts(visual->red_mask, &COLOR_Redshift, &COLOR_Redmax);
 647         COLOR_Computeshifts(visual->green_mask, &COLOR_Greenshift, &COLOR_Greenmax);
 648         COLOR_Computeshifts(visual->blue_mask, &COLOR_Blueshift, &COLOR_Bluemax);
 649         break;
 650     }
 651     }
 652
 653     dprintf_palette(stddeb," visual class %i (%i)\n",
 654                     visual->class, cSpace.monoPlane);
 655
 656     memset(COLOR_freeList, 0, 256*sizeof(unsigned char));
 657
 658     if (cSpace.flags & COLOR_PRIVATE)
 659         COLOR_BuildPrivateMap( &cSpace );
 660     else
 661         COLOR_BuildSharedMap( &cSpace );
 662
 663     /* Build free list */
 664
 665     if( COLOR_firstFree != -1 )
 666         COLOR_FormatSystemPalette();
 667
 668     COLOR_FillDefaultColors();
 669
 670     return TRUE;
 671 }
 672
 673 /***********************************************************************
 674  *           COLOR_Cleanup
 675  *
 676  * Free external colors we grabbed in the FillDefaultPalette()
 677  */
 678 void COLOR_Cleanup(void)
 679 {
 680   if( COLOR_gapFilled )
 681       XFreeColors(display, cSpace.colorMap,
 682                   (unsigned long*)(COLOR_PaletteToPixel + COLOR_gapStart),
 683                   COLOR_gapFilled, 0);
 684 }
 685
 686 /***********************************************************************
 687  *           COLOR_IsSolid
 688  *
 689  * Check whether 'color' can be represented with a solid color.
 690  */
 691 BOOL32 COLOR_IsSolid( COLORREF color )
 692 {
 693     int i;
 694     const PALETTEENTRY *pEntry = COLOR_sysPal;
 695
 696     if (color & 0xff000000) return TRUE;                /* indexed color */
 697
 698     if (!color || (color == 0xffffff)) return TRUE;     /* black or white */
 699
 700     for (i = 0; i < 256 ; i++, pEntry++)
 701     {
 702       if( i < COLOR_gapStart || i > COLOR_gapEnd )
 703         if ((GetRValue(color) == pEntry->peRed) &&
 704             (GetGValue(color) == pEntry->peGreen) &&
 705             (GetBValue(color) == pEntry->peBlue)) return TRUE;
 706     }
 707     return FALSE;
 708 }
 709
 710
 711 /***********************************************************************
 712  *           COLOR_PaletteLookupPixel
 713  */
 714 int COLOR_PaletteLookupPixel( PALETTEENTRY* palPalEntry, int size,
 715                               int* mapping, COLORREF col, BOOL32 skipReserved )
 716 {
 717     int i, best = 0, diff = 0x7fffffff;
 718     int r,g,b;
 719
 720     for( i = 0; i < size && diff ; i++ )
 721     {
 722         if( !(palPalEntry[i].peFlags & PC_SYS_USED) ||
 723             (skipReserved && palPalEntry[i].peFlags  & PC_SYS_RESERVED) )
 724             continue;
 725
 726         r = palPalEntry[i].peRed - GetRValue(col);
 727         g = palPalEntry[i].peGreen - GetGValue(col);
 728         b = palPalEntry[i].peBlue - GetBValue(col);
 729
 730         r = r*r + g*g + b*b;
 731
 732         if( r < diff ) { best = i; diff = r; }
 733     }
 734     return (mapping) ? mapping[best] : best;
 735 }
 736
 737 /***********************************************************************
 738  *           COLOR_LookupSystemPixel
 739  */
 740 int COLOR_LookupSystemPixel(COLORREF col)
 741 {
 742  int            i, best = 0, diff = 0x7fffffff;
 743  int            size = COLOR_GetSystemPaletteSize();
 744  int            r,g,b;
 745
 746  for( i = 0; i < size && diff ; i++ )
 747     {
 748       if( i == NB_RESERVED_COLORS/2 )
 749       {
 750         int newi = size - NB_RESERVED_COLORS/2;
 751         if (newi>i) i=newi;
 752       }
 753
 754       r = COLOR_sysPal[i].peRed - GetRValue(col);
 755       g = COLOR_sysPal[i].peGreen - GetGValue(col);
 756       b = COLOR_sysPal[i].peBlue - GetBValue(col);
 757
 758       r = r*r + g*g + b*b;
 759
 760       if( r < diff ) { best = i; diff = r; }
 761     }
 762
 763  return (COLOR_PaletteToPixel)? COLOR_PaletteToPixel[best] : best;
 764 }
 765
 766 /***********************************************************************
 767  *           COLOR_PaletteLookupExactIndex
 768  */
 769 int COLOR_PaletteLookupExactIndex( PALETTEENTRY* palPalEntry, int size,
 770                                    COLORREF col )
 771 {
 772     int i;
 773     BYTE r = GetRValue(col), g = GetGValue(col), b = GetBValue(col);
 774     for( i = 0; i < size; i++ )
 775     {
 776         if( palPalEntry[i].peFlags & PC_SYS_USED )      /* skips gap */
 777             if( palPalEntry[i].peRed == r &&
 778                 palPalEntry[i].peGreen == g &&
 779                 palPalEntry[i].peBlue == b )
 780                 return i;
 781     }
 782     return -1;
 783 }
 784
 785 /***********************************************************************
 786  *           COLOR_LookupNearestColor
 787  */
 788 COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color )
 789 {
 790   unsigned char         spec_type = color >> 24;
 791   int                   i;
 792
 793   /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
 794
 795   if( spec_type == 2 ) /* PALETTERGB */
 796     color = *(COLORREF*)
 797              (palPalEntry + COLOR_PaletteLookupPixel(palPalEntry,size,NULL,color,FALSE));
 798
 799   else if( spec_type == 1 ) /* PALETTEINDEX */
 800     if( (i = color & 0x0000ffff) >= size )
 801       {
 802         fprintf(stderr, "\tRGB(%lx) : idx %d is out of bounds, assuming NULL\n", color, i);
 803         color = *(COLORREF*)palPalEntry;
 804       }
 805     else color = *(COLORREF*)(palPalEntry + i);
 806
 807   color &= 0x00ffffff;
 808   return (0x00ffffff & *(COLORREF*)
 809          (COLOR_sysPal + COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, color, FALSE)));
 810 }
 811
 812 /***********************************************************************
 813  *           COLOR_ToLogical
 814  *
 815  * Return RGB color for given X pixel.
 816  */
 817 COLORREF COLOR_ToLogical(int pixel)
 818 {
 819     XColor color;
 820
 821     /* truecolor visual */
 822
 823     if (screenDepth >= 24) return pixel;
 824
 825     /* check for hicolor visuals first */
 826
 827     if ( cSpace.flags & COLOR_FIXED && !COLOR_Graymax )
 828     {
 829          color.red = (pixel >> COLOR_Redshift) & COLOR_Redmax;
 830          color.green = (pixel >> COLOR_Greenshift) & COLOR_Greenmax;
 831          color.blue = (pixel >> COLOR_Blueshift) & COLOR_Bluemax;
 832          return RGB((color.red * 255)/COLOR_Redmax,
 833                     (color.green * 255)/COLOR_Greenmax,
 834                     (color.blue * 255)/COLOR_Bluemax);
 835     }
 836
 837     /* check if we can bypass X */
 838
 839     if ((screenDepth <= 8) && (pixel < 256) &&
 840        !(cSpace.flags & (COLOR_VIRTUAL | COLOR_FIXED)) )
 841          return  ( *(COLORREF*)(COLOR_sysPal +
 842                    ((COLOR_PixelToPalette)?COLOR_PixelToPalette[pixel]:pixel)) ) & 0x00ffffff;
 843
 844     color.pixel = pixel;
 845     XQueryColor(display, cSpace.colorMap, &color);
 846     return RGB(color.red >> 8, color.green >> 8, color.blue >> 8);
 847 }
 848
 849
 850 /***********************************************************************
 851  *           COLOR_ToPhysical
 852  *
 853  * Return the physical color closest to 'color'.
 854  */
 855 int COLOR_ToPhysical( DC *dc, COLORREF color )
 856 {
 857     WORD                 index = 0;
 858     HPALETTE16           hPal = (dc)? dc->w.hPalette: STOCK_DEFAULT_PALETTE;
 859     unsigned char        spec_type = color >> 24;
 860
 861     if ( cSpace.flags & COLOR_FIXED )
 862     {
 863         /* there is no colormap limitation; we are going to have to compute
 864          * the pixel value from the visual information stored earlier
 865          */
 866
 867         unsigned        long red, green, blue;
 868         unsigned        idx = 0;
 869         PALETTEOBJ *    palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 870
 871         switch(spec_type)
 872         {
 873           case 2: /* PALETTERGB - not sure if we really need to search palette */
 874
 875             idx = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry,
 876                                             palPtr->logpalette.palNumEntries,
 877                                             NULL, color, FALSE);
 878
 879             if( palPtr->mapping ) return palPtr->mapping[idx];
 880
 881             color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx);
 882             break;
 883
 884           case 1: /* PALETTEINDEX */
 885
 886             if( (idx = color & 0xffff) >= palPtr->logpalette.palNumEntries)
 887             {
 888                 fprintf(stderr, "\tRGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx);
 889                 return 0;
 890             }
 891
 892             if( palPtr->mapping ) return palPtr->mapping[idx];
 893
 894             color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx);
 895             break;
 896
 897           default:
 898             color &= 0xffffff;
 899             /* fall through to RGB */
 900
 901           case 0: /* RGB */
 902             if( dc && (dc->w.bitsPerPixel == 1) )
 903                 return (((color >> 16) & 0xff) +
 904                         ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
 905         }
 906
 907         red = GetRValue(color); green = GetGValue(color); blue = GetBValue(color);
 908
 909         if (COLOR_Graymax)
 910         {
 911             /* grayscale only; return scaled value */
 912             return ( (red * 30 + green * 69 + blue * 11) * COLOR_Graymax) / 25500;
 913         }
 914         else
 915         {
 916             /* scale each individually and construct the TrueColor pixel value */
 917             if (COLOR_Redmax != 255) red = (red * COLOR_Redmax) / 255;
 918             if (COLOR_Greenmax != 255) green = (green * COLOR_Greenmax) / 255;
 919             if (COLOR_Bluemax != 255) blue = (blue * COLOR_Bluemax) / 255;
 920
 921             return (red << COLOR_Redshift) | (green << COLOR_Greenshift) | (blue << COLOR_Blueshift);
 922         }
 923     }
 924     else
 925     {
 926         PALETTEOBJ* palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC);
 927
 928         /* palPtr can be NULL when DC is being destroyed */
 929
 930         if( !palPtr ) return 0;
 931         else if( !palPtr->mapping )
 932             dprintf_palette(stddeb,"\tpalette %04x is not realized\n", dc->w.hPalette);
 933
 934         switch(spec_type)       /* we have to peruse DC and system palette */
 935         {
 936             default:
 937                 color &= 0xffffff;
 938                 /* fall through to RGB */
 939
 940             case 0:  /* RGB */
 941                 if( dc && (dc->w.bitsPerPixel == 1) )
 942                     return (((color >> 16) & 0xff) +
 943                             ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
 944
 945                 index = COLOR_PaletteLookupPixel( COLOR_sysPal, 256,
 946                                                   COLOR_PaletteToPixel, color, FALSE);
 947
 948                 /* dprintf_palette(stddeb,"\tRGB(%lx) -> pixel %i\n", color, index);
 949                  */
 950                 break;
 951             case 1:  /* PALETTEINDEX */
 952                 index = color & 0xffff;
 953
 954                 if( index >= palPtr->logpalette.palNumEntries )
 955                     fprintf(stderr, "\tRGB(%lx) : index %i is out of bounds\n", color, index);
 956                 else if( palPtr->mapping ) index = palPtr->mapping[index];
 957
 958                 /*  dprintf_palette(stddeb,"\tPALETTEINDEX(%04x) -> pixel %i\n", (WORD)color, index);
 959                  */
 960                 break;
 961             case 2:  /* PALETTERGB */
 962                 index = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry,
 963                                              palPtr->logpalette.palNumEntries,
 964                                              palPtr->mapping, color, FALSE);
 965                 /* dprintf_palette(stddeb,"\tPALETTERGB(%lx) -> pixel %i\n", color, index);
 966                  */
 967                 break;
 968         }
 969     }
 970
 971     return index;
 972 }
 973
 974 /***********************************************************************
 975  *           COLOR_SetMapping
 976  *
 977  * Set the color-mapping table for selected palette.
 978  * Return number of entries which mapping has changed.
 979  */
 980 int COLOR_SetMapping( PALETTEOBJ* palPtr, BOOL32 mapOnly )
 981 {
 982     int  i, index;
 983     char flag;
 984     int  prevMapping = (palPtr->mapping) ? 1 : 0;
 985     int  iRemapped = 0;
 986
 987     /* reset dynamic system palette entries */
 988
 989     if( !mapOnly && COLOR_firstFree != -1)
 990          COLOR_FormatSystemPalette();
 991
 992     /* initialize palette mapping table */
 993
 994     palPtr->mapping = (int*)xrealloc(palPtr->mapping, sizeof(int)*
 995                                      palPtr->logpalette.palNumEntries);
 996
 997     for( i = 0; i < palPtr->logpalette.palNumEntries; i++ )
 998     {
 999         index = -1;
1000         flag = PC_SYS_USED;
1001
1002         switch( palPtr->logpalette.palPalEntry[i].peFlags & 0x07 )
1003         {
1004         case PC_EXPLICIT:   /* palette entries are indices into system palette */
1005             index = *(WORD*)(palPtr->logpalette.palPalEntry + i);
1006             if( index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd) )
1007             {
1008                 fprintf(stderr,"PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index);
1009                 index = 0;
1010             }
1011             break;
1012
1013         case PC_RESERVED:   /* forbid future mappings to this entry */
1014             flag |= PC_SYS_RESERVED;
1015
1016             /* fall through */
1017         default:            /* try to collapse identical colors */
1018             index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256,
1019                              *(COLORREF*)(palPtr->logpalette.palPalEntry + i));
1020             /* fall through */
1021         case PC_NOCOLLAPSE:
1022             if( index < 0 )
1023             {
1024                 if( COLOR_firstFree > 0 && !(cSpace.flags & COLOR_FIXED) )
1025                 {
1026                     XColor color;
1027                     index = COLOR_firstFree;  /* ought to be available */
1028                     COLOR_firstFree = COLOR_freeList[index];
1029
1030                     color.pixel = (COLOR_PaletteToPixel) ? COLOR_PaletteToPixel[index] : index;
1031                     color.red = palPtr->logpalette.palPalEntry[i].peRed << 8;
1032                     color.green = palPtr->logpalette.palPalEntry[i].peGreen << 8;
1033                     color.blue = palPtr->logpalette.palPalEntry[i].peBlue << 8;
1034                     color.flags = DoRed | DoGreen | DoBlue;
1035                     XStoreColor(display, cSpace.colorMap, &color);
1036
1037                     COLOR_sysPal[index] = palPtr->logpalette.palPalEntry[i];
1038                     COLOR_sysPal[index].peFlags = flag;
1039                     COLOR_freeList[index] = 0;
1040
1041                     if( COLOR_PaletteToPixel ) index = COLOR_PaletteToPixel[index];
1042                     break;
1043                 }
1044                 else if ( cSpace.flags & COLOR_VIRTUAL )
1045                 {
1046                     index = COLOR_ToPhysical( NULL, 0x00ffffff &
1047                              *(COLORREF*)(palPtr->logpalette.palPalEntry + i));
1048                     break;
1049                 }
1050
1051                 /* we have to map to existing entry in the system palette */
1052
1053                 index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL,
1054                        *(COLORREF*)(palPtr->logpalette.palPalEntry + i), TRUE);
1055             }
1056             palPtr->logpalette.palPalEntry[i].peFlags |= PC_SYS_USED;
1057
1058             if( COLOR_PaletteToPixel ) index = COLOR_PaletteToPixel[index];
1059             break;
1060         }
1061
1062         if( !prevMapping || palPtr->mapping[i] != index ) iRemapped++;
1063         palPtr->mapping[i] = index;
1064
1065         dprintf_palette(stddeb,"\tentry %i (%lx) -> pixel %i\n", i,
1066                                 *(COLORREF*)(palPtr->logpalette.palPalEntry + i), index);
1067
1068     }
1069     return iRemapped;
1070 }