dlls/gdi32/palette.c

   1 /*
   2  * GDI palette objects
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  * Copyright 1996 Alex Korobka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES:
  22  * PALETTEOBJ is documented in the Dr. Dobbs Journal May 1993.
  23  * Information in the "Undocumented Windows" is incorrect.
  24  */
  25
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "wownt32.h"
  34 #include "wine/winuser16.h"
  35 #include "gdi_private.h"
  36 #include "wine/debug.h"
  37 #include "winerror.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(palette);
  40
  41 typedef struct tagPALETTEOBJ
  42 {
  43     GDIOBJHDR           header;
  44     const DC_FUNCTIONS *funcs;      /* DC function table */
  45     LOGPALETTE          logpalette; /* _MUST_ be the last field */
  46 } PALETTEOBJ;
  47
  48 static INT PALETTE_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
  49 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle, void *obj );
  50 static BOOL PALETTE_DeleteObject( HGDIOBJ handle, void *obj );
  51
  52 static const struct gdi_obj_funcs palette_funcs =
  53 {
  54     NULL,                     /* pSelectObject */
  55     PALETTE_GetObject,        /* pGetObject16 */
  56     PALETTE_GetObject,        /* pGetObjectA */
  57     PALETTE_GetObject,        /* pGetObjectW */
  58     PALETTE_UnrealizeObject,  /* pUnrealizeObject */
  59     PALETTE_DeleteObject      /* pDeleteObject */
  60 };
  61
  62 /* Pointers to USER implementation of SelectPalette/RealizePalette */
  63 /* they will be patched by USER on startup */
  64 HPALETTE (WINAPI *pfnSelectPalette)(HDC hdc, HPALETTE hpal, WORD bkgnd ) = GDISelectPalette;
  65 UINT (WINAPI *pfnRealizePalette)(HDC hdc) = GDIRealizePalette;
  66
  67 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  68
  69 static HPALETTE hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  70 static HPALETTE hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  71
  72 #define NB_RESERVED_COLORS  20   /* number of fixed colors in system palette */
  73
  74 static const PALETTEENTRY sys_pal_template[NB_RESERVED_COLORS] =
  75 {
  76     /* first 10 entries in the system palette */
  77     /* red  green blue  flags */
  78     { 0x00, 0x00, 0x00, 0 },
  79     { 0x80, 0x00, 0x00, 0 },
  80     { 0x00, 0x80, 0x00, 0 },
  81     { 0x80, 0x80, 0x00, 0 },
  82     { 0x00, 0x00, 0x80, 0 },
  83     { 0x80, 0x00, 0x80, 0 },
  84     { 0x00, 0x80, 0x80, 0 },
  85     { 0xc0, 0xc0, 0xc0, 0 },
  86     { 0xc0, 0xdc, 0xc0, 0 },
  87     { 0xa6, 0xca, 0xf0, 0 },
  88
  89     /* ... c_min/2 dynamic colorcells */
  90
  91     /* ... gap (for sparse palettes) */
  92
  93     /* ... c_min/2 dynamic colorcells */
  94
  95     { 0xff, 0xfb, 0xf0, 0 },
  96     { 0xa0, 0xa0, 0xa4, 0 },
  97     { 0x80, 0x80, 0x80, 0 },
  98     { 0xff, 0x00, 0x00, 0 },
  99     { 0x00, 0xff, 0x00, 0 },
 100     { 0xff, 0xff, 0x00, 0 },
 101     { 0x00, 0x00, 0xff, 0 },
 102     { 0xff, 0x00, 0xff, 0 },
 103     { 0x00, 0xff, 0xff, 0 },
 104     { 0xff, 0xff, 0xff, 0 }     /* last 10 */
 105 };
 106
 107 /***********************************************************************
 108  *           PALETTE_Init
 109  *
 110  * Create the system palette.
 111  */
 112 HPALETTE PALETTE_Init(void)
 113 {
 114     HPALETTE          hpalette;
 115     LOGPALETTE *        palPtr;
 116
 117     /* create default palette (20 system colors) */
 118
 119     palPtr = HeapAlloc( GetProcessHeap(), 0,
 120              sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY));
 121     if (!palPtr) return FALSE;
 122
 123     palPtr->palVersion = 0x300;
 124     palPtr->palNumEntries = NB_RESERVED_COLORS;
 125     memcpy( palPtr->palPalEntry, sys_pal_template, sizeof(sys_pal_template) );
 126     hpalette = CreatePalette( palPtr );
 127     HeapFree( GetProcessHeap(), 0, palPtr );
 128     return hpalette;
 129 }
 130
 131
 132 /***********************************************************************
 133  * CreatePalette [GDI32.@]
 134  *
 135  * Creates a logical color palette.
 136  *
 137  * RETURNS
 138  *    Success: Handle to logical palette
 139  *    Failure: NULL
 140  */
 141 HPALETTE WINAPI CreatePalette(
 142     const LOGPALETTE* palette) /* [in] Pointer to logical color palette */
 143 {
 144     PALETTEOBJ * palettePtr;
 145     HPALETTE hpalette;
 146     int size;
 147
 148     if (!palette) return 0;
 149     TRACE("entries=%i\n", palette->palNumEntries);
 150
 151     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
 152
 153     if (!(palettePtr = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR),
 154                                         PALETTE_MAGIC, (HGDIOBJ *)&hpalette,
 155                                         &palette_funcs ))) return 0;
 156     memcpy( &palettePtr->logpalette, palette, size );
 157     palettePtr->funcs = NULL;
 158     GDI_ReleaseObj( hpalette );
 159
 160     TRACE("   returning %p\n", hpalette);
 161     return hpalette;
 162 }
 163
 164
 165 /***********************************************************************
 166  * CreateHalftonePalette [GDI32.@]
 167  *
 168  * Creates a halftone palette.
 169  *
 170  * RETURNS
 171  *    Success: Handle to logical halftone palette
 172  *    Failure: 0
 173  *
 174  * FIXME: This simply creates the halftone palette derived from running
 175  *        tests on a windows NT machine. This is assuming a color depth
 176  *        of greater that 256 color. On a 256 color device the halftone
 177  *        palette will be different and this function will be incorrect
 178  */
 179 HPALETTE WINAPI CreateHalftonePalette(
 180     HDC hdc) /* [in] Handle to device context */
 181 {
 182     int i;
 183     struct {
 184         WORD Version;
 185         WORD NumberOfEntries;
 186         PALETTEENTRY aEntries[256];
 187     } Palette;
 188
 189     Palette.Version = 0x300;
 190     Palette.NumberOfEntries = 256;
 191     GetSystemPaletteEntries(hdc, 0, 256, Palette.aEntries);
 192
 193     Palette.NumberOfEntries = 20;
 194
 195     /*
 196      * CODEWEAVERS HACK - Huw says:
 197      *
 198      * Go back to using a 256 colour halftone palette, which is what my
 199      * version of win2k returns.
 200      *
 201      * This fixes display of word drawings on 8bpp displays.  However it
 202      * reverts a patch by Aric which supposedly fixed some colour issues with
 203      * office 97, so we need to watch out for these again.
 204      */
 205     return CreatePalette((LOGPALETTE *)&Palette);
 206
 207     for (i = 0; i < Palette.NumberOfEntries; i++)
 208     {
 209         Palette.aEntries[i].peRed=0xff;
 210         Palette.aEntries[i].peGreen=0xff;
 211         Palette.aEntries[i].peBlue=0xff;
 212         Palette.aEntries[i].peFlags=0x00;
 213     }
 214
 215     Palette.aEntries[0].peRed=0x00;
 216     Palette.aEntries[0].peBlue=0x00;
 217     Palette.aEntries[0].peGreen=0x00;
 218
 219     /* the first 6 */
 220     for (i=1; i <= 6; i++)
 221     {
 222         Palette.aEntries[i].peRed=(i%2)?0x80:0;
 223         Palette.aEntries[i].peGreen=(i==2)?0x80:(i==3)?0x80:(i==6)?0x80:0;
 224         Palette.aEntries[i].peBlue=(i>3)?0x80:0;
 225     }
 226
 227     for (i=7;  i <= 12; i++)
 228     {
 229         switch(i)
 230         {
 231             case 7:
 232                 Palette.aEntries[i].peRed=0xc0;
 233                 Palette.aEntries[i].peBlue=0xc0;
 234                 Palette.aEntries[i].peGreen=0xc0;
 235                 break;
 236             case 8:
 237                 Palette.aEntries[i].peRed=0xc0;
 238                 Palette.aEntries[i].peGreen=0xdc;
 239                 Palette.aEntries[i].peBlue=0xc0;
 240                 break;
 241             case 9:
 242                 Palette.aEntries[i].peRed=0xa6;
 243                 Palette.aEntries[i].peGreen=0xca;
 244                 Palette.aEntries[i].peBlue=0xf0;
 245                 break;
 246             case 10:
 247                 Palette.aEntries[i].peRed=0xff;
 248                 Palette.aEntries[i].peGreen=0xfb;
 249                 Palette.aEntries[i].peBlue=0xf0;
 250                 break;
 251             case 11:
 252                 Palette.aEntries[i].peRed=0xa0;
 253                 Palette.aEntries[i].peGreen=0xa0;
 254                 Palette.aEntries[i].peBlue=0xa4;
 255                 break;
 256             case 12:
 257                 Palette.aEntries[i].peRed=0x80;
 258                 Palette.aEntries[i].peGreen=0x80;
 259                 Palette.aEntries[i].peBlue=0x80;
 260         }
 261     }
 262
 263    for (i=13; i <= 18; i++)
 264     {
 265         Palette.aEntries[i].peRed=(i%2)?0xff:0;
 266         Palette.aEntries[i].peGreen=(i==14)?0xff:(i==15)?0xff:(i==18)?0xff:0;
 267         Palette.aEntries[i].peBlue=(i>15)?0xff:0x00;
 268     }
 269
 270     return CreatePalette((LOGPALETTE *)&Palette);
 271 }
 272
 273
 274 /***********************************************************************
 275  * GetPaletteEntries [GDI32.@]
 276  *
 277  * Retrieves palette entries.
 278  *
 279  * RETURNS
 280  *    Success: Number of entries from logical palette
 281  *    Failure: 0
 282  */
 283 UINT WINAPI GetPaletteEntries(
 284     HPALETTE hpalette,    /* [in]  Handle of logical palette */
 285     UINT start,           /* [in]  First entry to receive */
 286     UINT count,           /* [in]  Number of entries to receive */
 287     LPPALETTEENTRY entries) /* [out] Address of array receiving entries */
 288 {
 289     PALETTEOBJ * palPtr;
 290     UINT numEntries;
 291
 292     TRACE("hpal = %p, count=%i\n", hpalette, count );
 293
 294     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 295     if (!palPtr) return 0;
 296
 297     /* NOTE: not documented but test show this to be the case */
 298     if (count == 0)
 299     {
 300         int rc = palPtr->logpalette.palNumEntries;
 301             GDI_ReleaseObj( hpalette );
 302         return rc;
 303     }
 304
 305     numEntries = palPtr->logpalette.palNumEntries;
 306     if (start+count > numEntries) count = numEntries - start;
 307     if (entries)
 308     {
 309       if (start >= numEntries)
 310       {
 311         GDI_ReleaseObj( hpalette );
 312         return 0;
 313       }
 314       memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 315               count * sizeof(PALETTEENTRY) );
 316       for( numEntries = 0; numEntries < count ; numEntries++ )
 317            if (entries[numEntries].peFlags & 0xF0)
 318                entries[numEntries].peFlags = 0;
 319     }
 320
 321     GDI_ReleaseObj( hpalette );
 322     return count;
 323 }
 324
 325
 326 /***********************************************************************
 327  * SetPaletteEntries [GDI32.@]
 328  *
 329  * Sets color values for range in palette.
 330  *
 331  * RETURNS
 332  *    Success: Number of entries that were set
 333  *    Failure: 0
 334  */
 335 UINT WINAPI SetPaletteEntries(
 336     HPALETTE hpalette,    /* [in] Handle of logical palette */
 337     UINT start,           /* [in] Index of first entry to set */
 338     UINT count,           /* [in] Number of entries to set */
 339     const PALETTEENTRY *entries) /* [in] Address of array of structures */
 340 {
 341     PALETTEOBJ * palPtr;
 342     UINT numEntries;
 343
 344     TRACE("hpal=%p,start=%i,count=%i\n",hpalette,start,count );
 345
 346     if (hpalette == GetStockObject(DEFAULT_PALETTE)) return 0;
 347     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 348     if (!palPtr) return 0;
 349
 350     numEntries = palPtr->logpalette.palNumEntries;
 351     if (start >= numEntries)
 352     {
 353       GDI_ReleaseObj( hpalette );
 354       return 0;
 355     }
 356     if (start+count > numEntries) count = numEntries - start;
 357     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 358             count * sizeof(PALETTEENTRY) );
 359     UnrealizeObject( hpalette );
 360     GDI_ReleaseObj( hpalette );
 361     return count;
 362 }
 363
 364
 365 /***********************************************************************
 366  * ResizePalette [GDI32.@]
 367  *
 368  * Resizes logical palette.
 369  *
 370  * RETURNS
 371  *    Success: TRUE
 372  *    Failure: FALSE
 373  */
 374 BOOL WINAPI ResizePalette(
 375     HPALETTE hPal, /* [in] Handle of logical palette */
 376     UINT cEntries) /* [in] Number of entries in logical palette */
 377 {
 378     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 379     UINT         cPrevEnt, prevVer;
 380     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 381
 382     TRACE("hpal = %p, prev = %i, new = %i\n",
 383           hPal, palPtr ? palPtr->logpalette.palNumEntries : -1, cEntries );
 384     if( !palPtr ) return FALSE;
 385     cPrevEnt = palPtr->logpalette.palNumEntries;
 386     prevVer = palPtr->logpalette.palVersion;
 387     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 388                                         sizeof(int*) + sizeof(GDIOBJHDR);
 389     size += sizeof(int*) + sizeof(GDIOBJHDR);
 390
 391     if (!(palPtr = GDI_ReallocObject( size, hPal, palPtr ))) return FALSE;
 392
 393     PALETTE_UnrealizeObject( hPal, palPtr );
 394
 395     if( cEntries > cPrevEnt ) memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 396     palPtr->logpalette.palNumEntries = cEntries;
 397     palPtr->logpalette.palVersion = prevVer;
 398     GDI_ReleaseObj( hPal );
 399     return TRUE;
 400 }
 401
 402
 403 /***********************************************************************
 404  * AnimatePalette [GDI32.@]
 405  *
 406  * Replaces entries in logical palette.
 407  *
 408  * RETURNS
 409  *    Success: TRUE
 410  *    Failure: FALSE
 411  *
 412  * FIXME
 413  *    Should use existing mapping when animating a primary palette
 414  */
 415 BOOL WINAPI AnimatePalette(
 416     HPALETTE hPal,              /* [in] Handle to logical palette */
 417     UINT StartIndex,            /* [in] First entry in palette */
 418     UINT NumEntries,            /* [in] Count of entries in palette */
 419     const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
 420 {
 421     TRACE("%p (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
 422
 423     if( hPal != GetStockObject(DEFAULT_PALETTE) )
 424     {
 425         PALETTEOBJ * palPtr;
 426         UINT pal_entries;
 427         const PALETTEENTRY *pptr = PaletteColors;
 428
 429         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 430         if (!palPtr) return 0;
 431
 432         pal_entries = palPtr->logpalette.palNumEntries;
 433         if (StartIndex >= pal_entries)
 434         {
 435           GDI_ReleaseObj( hPal );
 436           return 0;
 437         }
 438         if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
 439
 440         for (NumEntries += StartIndex; StartIndex < NumEntries; StartIndex++, pptr++) {
 441           /* According to MSDN, only animate PC_RESERVED colours */
 442           if (palPtr->logpalette.palPalEntry[StartIndex].peFlags & PC_RESERVED) {
 443             TRACE("Animating colour (%d,%d,%d) to (%d,%d,%d)\n",
 444               palPtr->logpalette.palPalEntry[StartIndex].peRed,
 445               palPtr->logpalette.palPalEntry[StartIndex].peGreen,
 446               palPtr->logpalette.palPalEntry[StartIndex].peBlue,
 447               pptr->peRed, pptr->peGreen, pptr->peBlue);
 448             memcpy( &palPtr->logpalette.palPalEntry[StartIndex], pptr,
 449                     sizeof(PALETTEENTRY) );
 450           } else {
 451             TRACE("Not animating entry %d -- not PC_RESERVED\n", StartIndex);
 452           }
 453         }
 454         if (palPtr->funcs && palPtr->funcs->pRealizePalette)
 455             palPtr->funcs->pRealizePalette( NULL, hPal, hPal == hPrimaryPalette );
 456
 457         GDI_ReleaseObj( hPal );
 458     }
 459     return TRUE;
 460 }
 461
 462
 463 /***********************************************************************
 464  * SetSystemPaletteUse [GDI32.@]
 465  *
 466  * Specify whether the system palette contains 2 or 20 static colors.
 467  *
 468  * RETURNS
 469  *    Success: Previous system palette
 470  *    Failure: SYSPAL_ERROR
 471  */
 472 UINT WINAPI SetSystemPaletteUse(
 473     HDC hdc,  /* [in] Handle of device context */
 474     UINT use) /* [in] Palette-usage flag */
 475 {
 476     UINT old = SystemPaletteUse;
 477
 478     /* Device doesn't support colour palettes */
 479     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)) {
 480         return SYSPAL_ERROR;
 481     }
 482
 483     switch (use) {
 484         case SYSPAL_NOSTATIC:
 485         case SYSPAL_NOSTATIC256:        /* WINVER >= 0x0500 */
 486         case SYSPAL_STATIC:
 487             SystemPaletteUse = use;
 488             return old;
 489         default:
 490             return SYSPAL_ERROR;
 491     }
 492 }
 493
 494
 495 /***********************************************************************
 496  * GetSystemPaletteUse [GDI32.@]
 497  *
 498  * Gets state of system palette.
 499  *
 500  * RETURNS
 501  *    Current state of system palette
 502  */
 503 UINT WINAPI GetSystemPaletteUse(
 504     HDC hdc) /* [in] Handle of device context */
 505 {
 506     return SystemPaletteUse;
 507 }
 508
 509
 510 /***********************************************************************
 511  * GetSystemPaletteEntries [GDI32.@]
 512  *
 513  * Gets range of palette entries.
 514  *
 515  * RETURNS
 516  *    Success: Number of entries retrieved from palette
 517  *    Failure: 0
 518  */
 519 UINT WINAPI GetSystemPaletteEntries(
 520     HDC hdc,              /* [in]  Handle of device context */
 521     UINT start,           /* [in]  Index of first entry to be retrieved */
 522     UINT count,           /* [in]  Number of entries to be retrieved */
 523     LPPALETTEENTRY entries) /* [out] Array receiving system-palette entries */
 524 {
 525     UINT ret = 0;
 526     DC *dc;
 527
 528     TRACE("hdc=%p,start=%i,count=%i\n", hdc,start,count);
 529
 530     if ((dc = DC_GetDCPtr( hdc )))
 531     {
 532         if (dc->funcs->pGetSystemPaletteEntries)
 533             ret = dc->funcs->pGetSystemPaletteEntries( dc->physDev, start, count, entries );
 534         GDI_ReleaseObj( hdc );
 535     }
 536     return ret;
 537 }
 538
 539
 540 /***********************************************************************
 541  * GetNearestPaletteIndex [GDI32.@]
 542  *
 543  * Gets palette index for color.
 544  *
 545  * NOTES
 546  *    Should index be initialized to CLR_INVALID instead of 0?
 547  *
 548  * RETURNS
 549  *    Success: Index of entry in logical palette
 550  *    Failure: CLR_INVALID
 551  */
 552 UINT WINAPI GetNearestPaletteIndex(
 553     HPALETTE hpalette, /* [in] Handle of logical color palette */
 554     COLORREF color)      /* [in] Color to be matched */
 555 {
 556     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 557     UINT index  = 0;
 558
 559     if( palObj )
 560     {
 561         int i, diff = 0x7fffffff;
 562         int r,g,b;
 563         PALETTEENTRY* entry = palObj->logpalette.palPalEntry;
 564
 565         for( i = 0; i < palObj->logpalette.palNumEntries && diff ; i++, entry++)
 566         {
 567             r = entry->peRed - GetRValue(color);
 568             g = entry->peGreen - GetGValue(color);
 569             b = entry->peBlue - GetBValue(color);
 570
 571             r = r*r + g*g + b*b;
 572
 573             if( r < diff ) { index = i; diff = r; }
 574         }
 575         GDI_ReleaseObj( hpalette );
 576     }
 577     TRACE("(%p,%06x): returning %d\n", hpalette, color, index );
 578     return index;
 579 }
 580
 581
 582 /***********************************************************************
 583  * GetNearestColor [GDI32.@]
 584  *
 585  * Gets a system color to match.
 586  *
 587  * RETURNS
 588  *    Success: Color from system palette that corresponds to given color
 589  *    Failure: CLR_INVALID
 590  */
 591 COLORREF WINAPI GetNearestColor(
 592     HDC hdc,      /* [in] Handle of device context */
 593     COLORREF color) /* [in] Color to be matched */
 594 {
 595     unsigned char spec_type;
 596     COLORREF nearest;
 597     DC          *dc;
 598
 599     if (!(dc = DC_GetDCPtr( hdc ))) return CLR_INVALID;
 600
 601     if (dc->funcs->pGetNearestColor)
 602     {
 603         nearest = dc->funcs->pGetNearestColor( dc->physDev, color );
 604         GDI_ReleaseObj( hdc );
 605         return nearest;
 606     }
 607
 608     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
 609     {
 610         GDI_ReleaseObj( hdc );
 611         return color;
 612     }
 613
 614     spec_type = color >> 24;
 615     if (spec_type == 1 || spec_type == 2)
 616     {
 617         /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
 618
 619         UINT index;
 620         PALETTEENTRY entry;
 621         HPALETTE hpal = dc->hPalette ? dc->hPalette : GetStockObject( DEFAULT_PALETTE );
 622
 623         if (spec_type == 2) /* PALETTERGB */
 624             index = GetNearestPaletteIndex( hpal, color );
 625         else  /* PALETTEINDEX */
 626             index = LOWORD(color);
 627
 628         if (!GetPaletteEntries( hpal, index, 1, &entry ))
 629         {
 630             WARN("RGB(%x) : idx %d is out of bounds, assuming NULL\n", color, index );
 631             if (!GetPaletteEntries( hpal, 0, 1, &entry ))
 632             {
 633                 GDI_ReleaseObj( hdc );
 634                 return CLR_INVALID;
 635             }
 636         }
 637         color = RGB( entry.peRed, entry.peGreen, entry.peBlue );
 638     }
 639     nearest = color & 0x00ffffff;
 640     GDI_ReleaseObj( hdc );
 641
 642     TRACE("(%06x): returning %06x\n", color, nearest );
 643     return nearest;
 644 }
 645
 646
 647 /***********************************************************************
 648  *           PALETTE_GetObject
 649  */
 650 static INT PALETTE_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
 651 {
 652     PALETTEOBJ *palette = obj;
 653
 654     if( !buffer )
 655         return sizeof(WORD);
 656
 657     if (count > sizeof(WORD)) count = sizeof(WORD);
 658     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 659     return count;
 660 }
 661
 662
 663 /***********************************************************************
 664  *           PALETTE_UnrealizeObject
 665  */
 666 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle, void *obj )
 667 {
 668     PALETTEOBJ *palette = obj;
 669
 670     if (palette->funcs)
 671     {
 672         if (palette->funcs->pUnrealizePalette)
 673             palette->funcs->pUnrealizePalette( handle );
 674         palette->funcs = NULL;
 675     }
 676
 677     if (hLastRealizedPalette == handle)
 678     {
 679         TRACE("unrealizing palette %p\n", handle);
 680         hLastRealizedPalette = 0;
 681     }
 682     return TRUE;
 683 }
 684
 685
 686 /***********************************************************************
 687  *           PALETTE_DeleteObject
 688  */
 689 static BOOL PALETTE_DeleteObject( HGDIOBJ handle, void *obj )
 690 {
 691     PALETTE_UnrealizeObject( handle, obj );
 692     return GDI_FreeObject( handle, obj );
 693 }
 694
 695
 696 /***********************************************************************
 697  *           GDISelectPalette    (Not a Windows API)
 698  */
 699 HPALETTE WINAPI GDISelectPalette( HDC hdc, HPALETTE hpal, WORD wBkg)
 700 {
 701     HPALETTE ret;
 702     DC *dc;
 703
 704     TRACE("%p %p\n", hdc, hpal );
 705
 706     if (GetObjectType(hpal) != OBJ_PAL)
 707     {
 708       WARN("invalid selected palette %p\n",hpal);
 709       return 0;
 710     }
 711     if (!(dc = DC_GetDCPtr( hdc ))) return 0;
 712     ret = dc->hPalette;
 713     if (dc->funcs->pSelectPalette) hpal = dc->funcs->pSelectPalette( dc->physDev, hpal, FALSE );
 714     if (hpal)
 715     {
 716         dc->hPalette = hpal;
 717         if (!wBkg) hPrimaryPalette = hpal;
 718     }
 719     else ret = 0;
 720     GDI_ReleaseObj( hdc );
 721     return ret;
 722 }
 723
 724
 725 /***********************************************************************
 726  *           GDIRealizePalette    (Not a Windows API)
 727  */
 728 UINT WINAPI GDIRealizePalette( HDC hdc )
 729 {
 730     UINT realized = 0;
 731     DC* dc = DC_GetDCPtr( hdc );
 732
 733     if (!dc) return 0;
 734
 735     TRACE("%p...\n", hdc );
 736
 737     if( dc->hPalette == GetStockObject( DEFAULT_PALETTE ))
 738     {
 739         if (dc->funcs->pRealizeDefaultPalette)
 740             realized = dc->funcs->pRealizeDefaultPalette( dc->physDev );
 741     }
 742     else if(dc->hPalette != hLastRealizedPalette )
 743     {
 744         if (dc->funcs->pRealizePalette)
 745         {
 746             PALETTEOBJ *palPtr = GDI_GetObjPtr( dc->hPalette, PALETTE_MAGIC );
 747             if (palPtr)
 748             {
 749                 realized = dc->funcs->pRealizePalette( dc->physDev, dc->hPalette,
 750                                                        (dc->hPalette == hPrimaryPalette) );
 751                 palPtr->funcs = dc->funcs;
 752                 GDI_ReleaseObj( dc->hPalette );
 753             }
 754         }
 755         hLastRealizedPalette = dc->hPalette;
 756     }
 757     else TRACE("  skipping (hLastRealizedPalette = %p)\n", hLastRealizedPalette);
 758
 759     GDI_ReleaseObj( hdc );
 760     TRACE("   realized %i colors.\n", realized );
 761     return realized;
 762 }
 763
 764
 765 /***********************************************************************
 766  *           RealizeDefaultPalette    (GDI.365)
 767  */
 768 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
 769 {
 770     UINT16 ret = 0;
 771     DC          *dc;
 772
 773     TRACE("%04x\n", hdc );
 774
 775     if (!(dc = DC_GetDCPtr( HDC_32(hdc) ))) return 0;
 776
 777     if (dc->funcs->pRealizeDefaultPalette) ret = dc->funcs->pRealizeDefaultPalette( dc->physDev );
 778     GDI_ReleaseObj( HDC_32(hdc) );
 779     return ret;
 780 }
 781
 782 /***********************************************************************
 783  *           IsDCCurrentPalette   (GDI.412)
 784  */
 785 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
 786 {
 787     DC *dc = DC_GetDCPtr( HDC_32(hDC) );
 788     if (dc)
 789     {
 790       BOOL bRet = dc->hPalette == hPrimaryPalette;
 791       GDI_ReleaseObj( HDC_32(hDC) );
 792       return bRet;
 793     }
 794     return FALSE;
 795 }
 796
 797
 798 /***********************************************************************
 799  * SelectPalette [GDI32.@]
 800  *
 801  * Selects logical palette into DC.
 802  *
 803  * RETURNS
 804  *    Success: Previous logical palette
 805  *    Failure: NULL
 806  */
 807 HPALETTE WINAPI SelectPalette(
 808     HDC hDC,               /* [in] Handle of device context */
 809     HPALETTE hPal,         /* [in] Handle of logical color palette */
 810     BOOL bForceBackground) /* [in] Foreground/background mode */
 811 {
 812     return pfnSelectPalette( hDC, hPal, bForceBackground );
 813 }
 814
 815
 816 /***********************************************************************
 817  * RealizePalette [GDI32.@]
 818  *
 819  * Maps palette entries to system palette.
 820  *
 821  * RETURNS
 822  *    Success: Number of entries in logical palette
 823  *    Failure: GDI_ERROR
 824  */
 825 UINT WINAPI RealizePalette(
 826     HDC hDC) /* [in] Handle of device context */
 827 {
 828     return pfnRealizePalette( hDC );
 829 }
 830
 831
 832 typedef HWND (WINAPI *WindowFromDC_funcptr)( HDC );
 833 typedef BOOL (WINAPI *RedrawWindow_funcptr)( HWND, const RECT *, HRGN, UINT );
 834
 835 /**********************************************************************
 836  * UpdateColors [GDI32.@]
 837  *
 838  * Remaps current colors to logical palette.
 839  *
 840  * RETURNS
 841  *    Success: TRUE
 842  *    Failure: FALSE
 843  */
 844 BOOL WINAPI UpdateColors(
 845     HDC hDC) /* [in] Handle of device context */
 846 {
 847     HMODULE mod;
 848     int size = GetDeviceCaps( hDC, SIZEPALETTE );
 849
 850     if (!size) return 0;
 851
 852     mod = GetModuleHandleA("user32.dll");
 853     if (mod)
 854     {
 855         WindowFromDC_funcptr pWindowFromDC = (WindowFromDC_funcptr)GetProcAddress(mod,"WindowFromDC");
 856         if (pWindowFromDC)
 857         {
 858             HWND hWnd = pWindowFromDC( hDC );
 859
 860             /* Docs say that we have to remap current drawable pixel by pixel
 861              * but it would take forever given the speed of XGet/PutPixel.
 862              */
 863             if (hWnd && size)
 864             {
 865                 RedrawWindow_funcptr pRedrawWindow = GetProcAddress( mod, "RedrawWindow" );
 866                 if (pRedrawWindow) pRedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
 867             }
 868         }
 869     }
 870     return 0x666;
 871 }
 872
 873
 874 /*********************************************************************
 875  *           SetMagicColors   (GDI.606)
 876  */
 877 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
 878 {
 879     FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
 880
 881 }
 882
 883 /*********************************************************************
 884  *           SetMagicColors   (GDI.@)
 885  */
 886 BOOL WINAPI SetMagicColors(HDC hdc, ULONG u1, ULONG u2)
 887 {
 888     FIXME("(%p 0x%08x 0x%08x): stub\n", hdc, u1, u2);
 889     return TRUE;
 890 }
 891
 892 /**********************************************************************
 893  * GetICMProfileA [GDI32.@]
 894  *
 895  * Returns the filename of the specified device context's color
 896  * management profile, even if color management is not enabled
 897  * for that DC.
 898  *
 899  * RETURNS
 900  *    TRUE if name copied successfully OR lpszFilename is NULL
 901  *    FALSE if the buffer length pointed to by lpcbName is too small
 902  *
 903  * NOTE
 904  *    The buffer length pointed to by lpcbName is ALWAYS updated to
 905  *    the length required regardless of other actions this function
 906  *    may take.
 907  *
 908  * FIXME
 909  *    How does Windows assign these?  Some registry key?
 910  */
 911
 912
 913 /*********************************************************************/
 914
 915 BOOL WINAPI GetICMProfileA(HDC hDC, LPDWORD lpcbName, LPSTR lpszFilename)
 916 {
 917     DWORD callerLen;
 918     static const char icm[] = "winefake.icm";
 919
 920     FIXME("(%p, %p, %p): partial stub\n", hDC, lpcbName, lpszFilename);
 921
 922     callerLen = *lpcbName;
 923
 924     /* all 3 behaviors require the required buffer size to be set */
 925     *lpcbName = sizeof(icm);
 926
 927     /* behavior 1: if lpszFilename is NULL, return size of string and no error */
 928     if (!lpszFilename) return TRUE;
 929
 930     /* behavior 2: if buffer size too small, return size of string and error */
 931     if (callerLen < sizeof(icm))
 932     {
 933         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 934         return FALSE;
 935     }
 936
 937     /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
 938     memcpy(lpszFilename, icm, sizeof(icm));
 939     return TRUE;
 940 }
 941
 942 /**********************************************************************
 943  * GetICMProfileW [GDI32.@]
 944  **/
 945 BOOL WINAPI GetICMProfileW(HDC hDC, LPDWORD lpcbName, LPWSTR lpszFilename)
 946 {
 947     DWORD callerLen;
 948     static const WCHAR icm[] = { 'w','i','n','e','f','a','k','e','.','i','c','m', 0 };
 949
 950     FIXME("(%p, %p, %p): partial stub\n", hDC, lpcbName, lpszFilename);
 951
 952     callerLen = *lpcbName;
 953
 954     /* all 3 behaviors require the required buffer size to be set */
 955     *lpcbName = sizeof(icm) / sizeof(WCHAR);
 956
 957     /* behavior 1: if lpszFilename is NULL, return size of string and no error */
 958     if (!lpszFilename) return TRUE;
 959
 960     /* behavior 2: if buffer size too small, return size of string and error */
 961     if (callerLen < sizeof(icm)/sizeof(WCHAR))
 962     {
 963         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 964         return FALSE;
 965     }
 966
 967     /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
 968     memcpy(lpszFilename, icm, sizeof(icm));
 969     return TRUE;
 970 }
 971
 972 /**********************************************************************
 973  * GetLogColorSpaceA [GDI32.@]
 974  *
 975  */
 976 BOOL WINAPI GetLogColorSpaceA(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEA lpBuffer, DWORD nSize)
 977 {
 978     FIXME("%p %p 0x%08x: stub!\n", hColorSpace, lpBuffer, nSize);
 979     return FALSE;
 980 }
 981
 982 /**********************************************************************
 983  * GetLogColorSpaceW [GDI32.@]
 984  *
 985  */
 986 BOOL WINAPI GetLogColorSpaceW(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEW lpBuffer, DWORD nSize)
 987 {
 988     FIXME("%p %p 0x%08x: stub!\n", hColorSpace, lpBuffer, nSize);
 989     return FALSE;
 990 }
 991
 992 /**********************************************************************
 993  * SetICMProfileA [GDI32.@]
 994  *
 995  */
 996 BOOL WINAPI SetICMProfileA(HDC hDC, LPSTR lpszFilename)
 997 {
 998     FIXME("hDC %p filename %s: stub!\n", hDC, debugstr_a(lpszFilename));
 999     return TRUE; /* success */
1000 }
1001
1002 /**********************************************************************
1003  * SetICMProfileA [GDI32.@]
1004  *
1005  */
1006 BOOL WINAPI SetICMProfileW(HDC hDC, LPWSTR lpszFilename)
1007 {
1008     FIXME("hDC %p filename %s: stub!\n", hDC, debugstr_w(lpszFilename));
1009     return TRUE; /* success */
1010 }
1011
1012 /**********************************************************************
1013  * UpdateICMRegKeyA [GDI32.@]
1014  *
1015  */
1016 BOOL WINAPI UpdateICMRegKeyA(DWORD dwReserved, LPSTR lpszCMID, LPSTR lpszFileName, UINT nCommand)
1017 {
1018     FIXME("(0x%08x, %s, %s, 0x%08x): stub!\n", dwReserved, debugstr_a(lpszCMID),
1019           debugstr_a(lpszFileName), nCommand);
1020     return TRUE; /* success */
1021 }
1022
1023 /**********************************************************************
1024  * UpdateICMRegKeyW [GDI32.@]
1025  *
1026  */
1027 BOOL WINAPI UpdateICMRegKeyW(DWORD dwReserved, LPWSTR lpszCMID, LPWSTR lpszFileName, UINT nCommand)
1028 {
1029     FIXME("(0x%08x, %s, %s, 0x%08x): stub!\n", dwReserved, debugstr_w(lpszCMID),
1030           debugstr_w(lpszFileName), nCommand);
1031     return TRUE; /* success */
1032 }