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