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, INT count, LPVOID buffer );
  49 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle );
  50 static BOOL PALETTE_DeleteObject( HGDIOBJ handle );
  51
  52 static const struct gdi_obj_funcs palette_funcs =
  53 {
  54     NULL,                     /* pSelectObject */
  55     PALETTE_GetObject,        /* pGetObjectA */
  56     PALETTE_GetObject,        /* pGetObjectW */
  57     PALETTE_UnrealizeObject,  /* pUnrealizeObject */
  58     PALETTE_DeleteObject      /* pDeleteObject */
  59 };
  60
  61 /* Pointers to USER implementation of SelectPalette/RealizePalette */
  62 /* they will be patched by USER on startup */
  63 HPALETTE (WINAPI *pfnSelectPalette)(HDC hdc, HPALETTE hpal, WORD bkgnd ) = GDISelectPalette;
  64 UINT (WINAPI *pfnRealizePalette)(HDC hdc) = GDIRealizePalette;
  65
  66 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  67
  68 static HPALETTE hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  69 static HPALETTE hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  70
  71 #define NB_RESERVED_COLORS  20   /* number of fixed colors in system palette */
  72
  73 static const PALETTEENTRY sys_pal_template[NB_RESERVED_COLORS] =
  74 {
  75     /* first 10 entries in the system palette */
  76     /* red  green blue  flags */
  77     { 0x00, 0x00, 0x00, 0 },
  78     { 0x80, 0x00, 0x00, 0 },
  79     { 0x00, 0x80, 0x00, 0 },
  80     { 0x80, 0x80, 0x00, 0 },
  81     { 0x00, 0x00, 0x80, 0 },
  82     { 0x80, 0x00, 0x80, 0 },
  83     { 0x00, 0x80, 0x80, 0 },
  84     { 0xc0, 0xc0, 0xc0, 0 },
  85     { 0xc0, 0xdc, 0xc0, 0 },
  86     { 0xa6, 0xca, 0xf0, 0 },
  87
  88     /* ... c_min/2 dynamic colorcells */
  89
  90     /* ... gap (for sparse palettes) */
  91
  92     /* ... c_min/2 dynamic colorcells */
  93
  94     { 0xff, 0xfb, 0xf0, 0 },
  95     { 0xa0, 0xa0, 0xa4, 0 },
  96     { 0x80, 0x80, 0x80, 0 },
  97     { 0xff, 0x00, 0x00, 0 },
  98     { 0x00, 0xff, 0x00, 0 },
  99     { 0xff, 0xff, 0x00, 0 },
 100     { 0x00, 0x00, 0xff, 0 },
 101     { 0xff, 0x00, 0xff, 0 },
 102     { 0x00, 0xff, 0xff, 0 },
 103     { 0xff, 0xff, 0xff, 0 }     /* last 10 */
 104 };
 105
 106 /***********************************************************************
 107  *           PALETTE_Init
 108  *
 109  * Create the system palette.
 110  */
 111 HPALETTE PALETTE_Init(void)
 112 {
 113     HPALETTE          hpalette;
 114     LOGPALETTE *        palPtr;
 115
 116     /* create default palette (20 system colors) */
 117
 118     palPtr = HeapAlloc( GetProcessHeap(), 0,
 119              sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY));
 120     if (!palPtr) return FALSE;
 121
 122     palPtr->palVersion = 0x300;
 123     palPtr->palNumEntries = NB_RESERVED_COLORS;
 124     memcpy( palPtr->palPalEntry, sys_pal_template, sizeof(sys_pal_template) );
 125     hpalette = CreatePalette( palPtr );
 126     HeapFree( GetProcessHeap(), 0, palPtr );
 127     return hpalette;
 128 }
 129
 130
 131 /***********************************************************************
 132  * CreatePalette [GDI32.@]
 133  *
 134  * Creates a logical color palette.
 135  *
 136  * RETURNS
 137  *    Success: Handle to logical palette
 138  *    Failure: NULL
 139  */
 140 HPALETTE WINAPI CreatePalette(
 141     const LOGPALETTE* palette) /* [in] Pointer to logical color palette */
 142 {
 143     PALETTEOBJ * palettePtr;
 144     HPALETTE hpalette;
 145     int size;
 146
 147     if (!palette) return 0;
 148     TRACE("entries=%i\n", palette->palNumEntries);
 149
 150     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
 151
 152     if (!(palettePtr = HeapAlloc( GetProcessHeap(), 0,
 153                         FIELD_OFFSET( PALETTEOBJ, logpalette.palPalEntry[palette->palNumEntries] ))))
 154         return 0;
 155
 156     memcpy( &palettePtr->logpalette, palette, size );
 157     palettePtr->funcs = NULL;
 158     if (!(hpalette = alloc_gdi_handle( &palettePtr->header, OBJ_PAL, &palette_funcs )))
 159         HeapFree( GetProcessHeap(), 0, palettePtr );
 160
 161     TRACE("   returning %p\n", hpalette);
 162     return hpalette;
 163 }
 164
 165
 166 /***********************************************************************
 167  * CreateHalftonePalette [GDI32.@]
 168  *
 169  * Creates a halftone palette.
 170  *
 171  * RETURNS
 172  *    Success: Handle to logical halftone palette
 173  *    Failure: 0
 174  *
 175  * FIXME: This simply creates the halftone palette derived from running
 176  *        tests on a windows NT machine. This is assuming a color depth
 177  *        of greater that 256 color. On a 256 color device the halftone
 178  *        palette will be different and this function will be incorrect
 179  */
 180 HPALETTE WINAPI CreateHalftonePalette(
 181     HDC hdc) /* [in] Handle to device context */
 182 {
 183     int i;
 184     struct {
 185         WORD Version;
 186         WORD NumberOfEntries;
 187         PALETTEENTRY aEntries[256];
 188     } Palette;
 189
 190     Palette.Version = 0x300;
 191     Palette.NumberOfEntries = 256;
 192     GetSystemPaletteEntries(hdc, 0, 256, Palette.aEntries);
 193
 194     Palette.NumberOfEntries = 20;
 195
 196     for (i = 0; i < Palette.NumberOfEntries; i++)
 197     {
 198         Palette.aEntries[i].peRed=0xff;
 199         Palette.aEntries[i].peGreen=0xff;
 200         Palette.aEntries[i].peBlue=0xff;
 201         Palette.aEntries[i].peFlags=0x00;
 202     }
 203
 204     Palette.aEntries[0].peRed=0x00;
 205     Palette.aEntries[0].peBlue=0x00;
 206     Palette.aEntries[0].peGreen=0x00;
 207
 208     /* the first 6 */
 209     for (i=1; i <= 6; i++)
 210     {
 211         Palette.aEntries[i].peRed=(i%2)?0x80:0;
 212         Palette.aEntries[i].peGreen=(i==2)?0x80:(i==3)?0x80:(i==6)?0x80:0;
 213         Palette.aEntries[i].peBlue=(i>3)?0x80:0;
 214     }
 215
 216     for (i=7;  i <= 12; i++)
 217     {
 218         switch(i)
 219         {
 220             case 7:
 221                 Palette.aEntries[i].peRed=0xc0;
 222                 Palette.aEntries[i].peBlue=0xc0;
 223                 Palette.aEntries[i].peGreen=0xc0;
 224                 break;
 225             case 8:
 226                 Palette.aEntries[i].peRed=0xc0;
 227                 Palette.aEntries[i].peGreen=0xdc;
 228                 Palette.aEntries[i].peBlue=0xc0;
 229                 break;
 230             case 9:
 231                 Palette.aEntries[i].peRed=0xa6;
 232                 Palette.aEntries[i].peGreen=0xca;
 233                 Palette.aEntries[i].peBlue=0xf0;
 234                 break;
 235             case 10:
 236                 Palette.aEntries[i].peRed=0xff;
 237                 Palette.aEntries[i].peGreen=0xfb;
 238                 Palette.aEntries[i].peBlue=0xf0;
 239                 break;
 240             case 11:
 241                 Palette.aEntries[i].peRed=0xa0;
 242                 Palette.aEntries[i].peGreen=0xa0;
 243                 Palette.aEntries[i].peBlue=0xa4;
 244                 break;
 245             case 12:
 246                 Palette.aEntries[i].peRed=0x80;
 247                 Palette.aEntries[i].peGreen=0x80;
 248                 Palette.aEntries[i].peBlue=0x80;
 249         }
 250     }
 251
 252    for (i=13; i <= 18; i++)
 253     {
 254         Palette.aEntries[i].peRed=(i%2)?0xff:0;
 255         Palette.aEntries[i].peGreen=(i==14)?0xff:(i==15)?0xff:(i==18)?0xff:0;
 256         Palette.aEntries[i].peBlue=(i>15)?0xff:0x00;
 257     }
 258
 259     return CreatePalette((LOGPALETTE *)&Palette);
 260 }
 261
 262
 263 /***********************************************************************
 264  * GetPaletteEntries [GDI32.@]
 265  *
 266  * Retrieves palette entries.
 267  *
 268  * RETURNS
 269  *    Success: Number of entries from logical palette
 270  *    Failure: 0
 271  */
 272 UINT WINAPI GetPaletteEntries(
 273     HPALETTE hpalette,    /* [in]  Handle of logical palette */
 274     UINT start,           /* [in]  First entry to receive */
 275     UINT count,           /* [in]  Number of entries to receive */
 276     LPPALETTEENTRY entries) /* [out] Address of array receiving entries */
 277 {
 278     PALETTEOBJ * palPtr;
 279     UINT numEntries;
 280
 281     TRACE("hpal = %p, count=%i\n", hpalette, count );
 282
 283     palPtr = GDI_GetObjPtr( hpalette, OBJ_PAL );
 284     if (!palPtr) return 0;
 285
 286     /* NOTE: not documented but test show this to be the case */
 287     if (count == 0)
 288     {
 289         int rc = palPtr->logpalette.palNumEntries;
 290             GDI_ReleaseObj( hpalette );
 291         return rc;
 292     }
 293
 294     numEntries = palPtr->logpalette.palNumEntries;
 295     if (start+count > numEntries) count = numEntries - start;
 296     if (entries)
 297     {
 298       if (start >= numEntries)
 299       {
 300         GDI_ReleaseObj( hpalette );
 301         return 0;
 302       }
 303       memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 304               count * sizeof(PALETTEENTRY) );
 305     }
 306
 307     GDI_ReleaseObj( hpalette );
 308     return count;
 309 }
 310
 311
 312 /***********************************************************************
 313  * SetPaletteEntries [GDI32.@]
 314  *
 315  * Sets color values for range in palette.
 316  *
 317  * RETURNS
 318  *    Success: Number of entries that were set
 319  *    Failure: 0
 320  */
 321 UINT WINAPI SetPaletteEntries(
 322     HPALETTE hpalette,    /* [in] Handle of logical palette */
 323     UINT start,           /* [in] Index of first entry to set */
 324     UINT count,           /* [in] Number of entries to set */
 325     const PALETTEENTRY *entries) /* [in] Address of array of structures */
 326 {
 327     PALETTEOBJ * palPtr;
 328     UINT numEntries;
 329
 330     TRACE("hpal=%p,start=%i,count=%i\n",hpalette,start,count );
 331
 332     if (hpalette == GetStockObject(DEFAULT_PALETTE)) return 0;
 333     palPtr = GDI_GetObjPtr( hpalette, OBJ_PAL );
 334     if (!palPtr) return 0;
 335
 336     numEntries = palPtr->logpalette.palNumEntries;
 337     if (start >= numEntries)
 338     {
 339       GDI_ReleaseObj( hpalette );
 340       return 0;
 341     }
 342     if (start+count > numEntries) count = numEntries - start;
 343     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 344             count * sizeof(PALETTEENTRY) );
 345     UnrealizeObject( hpalette );
 346     GDI_ReleaseObj( hpalette );
 347     return count;
 348 }
 349
 350
 351 /***********************************************************************
 352  * ResizePalette [GDI32.@]
 353  *
 354  * Resizes logical palette.
 355  *
 356  * RETURNS
 357  *    Success: TRUE
 358  *    Failure: FALSE
 359  */
 360 BOOL WINAPI ResizePalette(
 361     HPALETTE hPal, /* [in] Handle of logical palette */
 362     UINT cEntries) /* [in] Number of entries in logical palette */
 363 {
 364     PALETTEOBJ * palPtr = GDI_GetObjPtr( hPal, OBJ_PAL );
 365     UINT         cPrevEnt, prevVer;
 366     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 367
 368     TRACE("hpal = %p, prev = %i, new = %i\n",
 369           hPal, palPtr ? palPtr->logpalette.palNumEntries : -1, cEntries );
 370     if( !palPtr ) return FALSE;
 371     cPrevEnt = palPtr->logpalette.palNumEntries;
 372     prevVer = palPtr->logpalette.palVersion;
 373     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 374                                         sizeof(int*) + sizeof(GDIOBJHDR);
 375     size += sizeof(int*) + sizeof(GDIOBJHDR);
 376
 377     if (!(palPtr = GDI_ReallocObject( size, hPal, palPtr ))) return FALSE;
 378
 379     if( cEntries > cPrevEnt ) memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 380     palPtr->logpalette.palNumEntries = cEntries;
 381     palPtr->logpalette.palVersion = prevVer;
 382     GDI_ReleaseObj( hPal );
 383     PALETTE_UnrealizeObject( hPal );
 384     return TRUE;
 385 }
 386
 387
 388 /***********************************************************************
 389  * AnimatePalette [GDI32.@]
 390  *
 391  * Replaces entries in logical palette.
 392  *
 393  * RETURNS
 394  *    Success: TRUE
 395  *    Failure: FALSE
 396  *
 397  * FIXME
 398  *    Should use existing mapping when animating a primary palette
 399  */
 400 BOOL WINAPI AnimatePalette(
 401     HPALETTE hPal,              /* [in] Handle to logical palette */
 402     UINT StartIndex,            /* [in] First entry in palette */
 403     UINT NumEntries,            /* [in] Count of entries in palette */
 404     const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
 405 {
 406     TRACE("%p (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
 407
 408     if( hPal != GetStockObject(DEFAULT_PALETTE) )
 409     {
 410         PALETTEOBJ * palPtr;
 411         UINT pal_entries;
 412         const PALETTEENTRY *pptr = PaletteColors;
 413
 414         palPtr = GDI_GetObjPtr( hPal, OBJ_PAL );
 415         if (!palPtr) return 0;
 416
 417         pal_entries = palPtr->logpalette.palNumEntries;
 418         if (StartIndex >= pal_entries)
 419         {
 420           GDI_ReleaseObj( hPal );
 421           return 0;
 422         }
 423         if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
 424
 425         for (NumEntries += StartIndex; StartIndex < NumEntries; StartIndex++, pptr++) {
 426           /* According to MSDN, only animate PC_RESERVED colours */
 427           if (palPtr->logpalette.palPalEntry[StartIndex].peFlags & PC_RESERVED) {
 428             TRACE("Animating colour (%d,%d,%d) to (%d,%d,%d)\n",
 429               palPtr->logpalette.palPalEntry[StartIndex].peRed,
 430               palPtr->logpalette.palPalEntry[StartIndex].peGreen,
 431               palPtr->logpalette.palPalEntry[StartIndex].peBlue,
 432               pptr->peRed, pptr->peGreen, pptr->peBlue);
 433             memcpy( &palPtr->logpalette.palPalEntry[StartIndex], pptr,
 434                     sizeof(PALETTEENTRY) );
 435           } else {
 436             TRACE("Not animating entry %d -- not PC_RESERVED\n", StartIndex);
 437           }
 438         }
 439         if (palPtr->funcs && palPtr->funcs->pRealizePalette)
 440             palPtr->funcs->pRealizePalette( NULL, hPal, hPal == hPrimaryPalette );
 441
 442         GDI_ReleaseObj( hPal );
 443     }
 444     return TRUE;
 445 }
 446
 447
 448 /***********************************************************************
 449  * SetSystemPaletteUse [GDI32.@]
 450  *
 451  * Specify whether the system palette contains 2 or 20 static colors.
 452  *
 453  * RETURNS
 454  *    Success: Previous system palette
 455  *    Failure: SYSPAL_ERROR
 456  */
 457 UINT WINAPI SetSystemPaletteUse(
 458     HDC hdc,  /* [in] Handle of device context */
 459     UINT use) /* [in] Palette-usage flag */
 460 {
 461     UINT old = SystemPaletteUse;
 462
 463     /* Device doesn't support colour palettes */
 464     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)) {
 465         return SYSPAL_ERROR;
 466     }
 467
 468     switch (use) {
 469         case SYSPAL_NOSTATIC:
 470         case SYSPAL_NOSTATIC256:        /* WINVER >= 0x0500 */
 471         case SYSPAL_STATIC:
 472             SystemPaletteUse = use;
 473             return old;
 474         default:
 475             return SYSPAL_ERROR;
 476     }
 477 }
 478
 479
 480 /***********************************************************************
 481  * GetSystemPaletteUse [GDI32.@]
 482  *
 483  * Gets state of system palette.
 484  *
 485  * RETURNS
 486  *    Current state of system palette
 487  */
 488 UINT WINAPI GetSystemPaletteUse(
 489     HDC hdc) /* [in] Handle of device context */
 490 {
 491     return SystemPaletteUse;
 492 }
 493
 494
 495 /***********************************************************************
 496  * GetSystemPaletteEntries [GDI32.@]
 497  *
 498  * Gets range of palette entries.
 499  *
 500  * RETURNS
 501  *    Success: Number of entries retrieved from palette
 502  *    Failure: 0
 503  */
 504 UINT WINAPI GetSystemPaletteEntries(
 505     HDC hdc,              /* [in]  Handle of device context */
 506     UINT start,           /* [in]  Index of first entry to be retrieved */
 507     UINT count,           /* [in]  Number of entries to be retrieved */
 508     LPPALETTEENTRY entries) /* [out] Array receiving system-palette entries */
 509 {
 510     UINT ret = 0;
 511     DC *dc;
 512
 513     TRACE("hdc=%p,start=%i,count=%i\n", hdc,start,count);
 514
 515     if ((dc = get_dc_ptr( hdc )))
 516     {
 517         if (dc->funcs->pGetSystemPaletteEntries)
 518             ret = dc->funcs->pGetSystemPaletteEntries( dc->physDev, start, count, entries );
 519         release_dc_ptr( dc );
 520     }
 521     return ret;
 522 }
 523
 524
 525 /***********************************************************************
 526  * GetNearestPaletteIndex [GDI32.@]
 527  *
 528  * Gets palette index for color.
 529  *
 530  * NOTES
 531  *    Should index be initialized to CLR_INVALID instead of 0?
 532  *
 533  * RETURNS
 534  *    Success: Index of entry in logical palette
 535  *    Failure: CLR_INVALID
 536  */
 537 UINT WINAPI GetNearestPaletteIndex(
 538     HPALETTE hpalette, /* [in] Handle of logical color palette */
 539     COLORREF color)      /* [in] Color to be matched */
 540 {
 541     PALETTEOBJ* palObj = GDI_GetObjPtr( hpalette, OBJ_PAL );
 542     UINT index  = 0;
 543
 544     if( palObj )
 545     {
 546         int i, diff = 0x7fffffff;
 547         int r,g,b;
 548         PALETTEENTRY* entry = palObj->logpalette.palPalEntry;
 549
 550         for( i = 0; i < palObj->logpalette.palNumEntries && diff ; i++, entry++)
 551         {
 552             r = entry->peRed - GetRValue(color);
 553             g = entry->peGreen - GetGValue(color);
 554             b = entry->peBlue - GetBValue(color);
 555
 556             r = r*r + g*g + b*b;
 557
 558             if( r < diff ) { index = i; diff = r; }
 559         }
 560         GDI_ReleaseObj( hpalette );
 561     }
 562     TRACE("(%p,%06x): returning %d\n", hpalette, color, index );
 563     return index;
 564 }
 565
 566
 567 /***********************************************************************
 568  * GetNearestColor [GDI32.@]
 569  *
 570  * Gets a system color to match.
 571  *
 572  * RETURNS
 573  *    Success: Color from system palette that corresponds to given color
 574  *    Failure: CLR_INVALID
 575  */
 576 COLORREF WINAPI GetNearestColor(
 577     HDC hdc,      /* [in] Handle of device context */
 578     COLORREF color) /* [in] Color to be matched */
 579 {
 580     unsigned char spec_type;
 581     COLORREF nearest;
 582     DC          *dc;
 583
 584     if (!(dc = get_dc_ptr( hdc ))) return CLR_INVALID;
 585
 586     if (dc->funcs->pGetNearestColor)
 587     {
 588         nearest = dc->funcs->pGetNearestColor( dc->physDev, color );
 589         release_dc_ptr( dc );
 590         return nearest;
 591     }
 592
 593     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
 594     {
 595         release_dc_ptr( dc );
 596         return color;
 597     }
 598
 599     spec_type = color >> 24;
 600     if (spec_type == 1 || spec_type == 2)
 601     {
 602         /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
 603
 604         UINT index;
 605         PALETTEENTRY entry;
 606         HPALETTE hpal = dc->hPalette ? dc->hPalette : GetStockObject( DEFAULT_PALETTE );
 607
 608         if (spec_type == 2) /* PALETTERGB */
 609             index = GetNearestPaletteIndex( hpal, color );
 610         else  /* PALETTEINDEX */
 611             index = LOWORD(color);
 612
 613         if (!GetPaletteEntries( hpal, index, 1, &entry ))
 614         {
 615             WARN("RGB(%x) : idx %d is out of bounds, assuming NULL\n", color, index );
 616             if (!GetPaletteEntries( hpal, 0, 1, &entry ))
 617             {
 618                 release_dc_ptr( dc );
 619                 return CLR_INVALID;
 620             }
 621         }
 622         color = RGB( entry.peRed, entry.peGreen, entry.peBlue );
 623     }
 624     nearest = color & 0x00ffffff;
 625     release_dc_ptr( dc );
 626
 627     TRACE("(%06x): returning %06x\n", color, nearest );
 628     return nearest;
 629 }
 630
 631
 632 /***********************************************************************
 633  *           PALETTE_GetObject
 634  */
 635 static INT PALETTE_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
 636 {
 637     PALETTEOBJ *palette = GDI_GetObjPtr( handle, OBJ_PAL );
 638
 639     if (!palette) return 0;
 640
 641     if (buffer)
 642     {
 643         if (count > sizeof(WORD)) count = sizeof(WORD);
 644         memcpy( buffer, &palette->logpalette.palNumEntries, count );
 645     }
 646     else count = sizeof(WORD);
 647     GDI_ReleaseObj( handle );
 648     return count;
 649 }
 650
 651
 652 /***********************************************************************
 653  *           PALETTE_UnrealizeObject
 654  */
 655 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle )
 656 {
 657     PALETTEOBJ *palette = GDI_GetObjPtr( handle, OBJ_PAL );
 658
 659     if (palette)
 660     {
 661         const DC_FUNCTIONS *funcs = palette->funcs;
 662         palette->funcs = NULL;
 663         GDI_ReleaseObj( handle );
 664         if (funcs && funcs->pUnrealizePalette) funcs->pUnrealizePalette( handle );
 665     }
 666
 667     if (InterlockedCompareExchangePointer( (void **)&hLastRealizedPalette, 0, handle ) == handle)
 668         TRACE("unrealizing palette %p\n", handle);
 669
 670     return TRUE;
 671 }
 672
 673
 674 /***********************************************************************
 675  *           PALETTE_DeleteObject
 676  */
 677 static BOOL PALETTE_DeleteObject( HGDIOBJ handle )
 678 {
 679     PALETTEOBJ *obj;
 680
 681     PALETTE_UnrealizeObject( handle );
 682     if (!(obj = free_gdi_handle( handle ))) return FALSE;
 683     return HeapFree( GetProcessHeap(), 0, obj );
 684 }
 685
 686
 687 /***********************************************************************
 688  *           GDISelectPalette    (Not a Windows API)
 689  */
 690 HPALETTE WINAPI GDISelectPalette( HDC hdc, HPALETTE hpal, WORD wBkg)
 691 {
 692     HPALETTE ret;
 693     DC *dc;
 694
 695     TRACE("%p %p\n", hdc, hpal );
 696
 697     if (GetObjectType(hpal) != OBJ_PAL)
 698     {
 699       WARN("invalid selected palette %p\n",hpal);
 700       return 0;
 701     }
 702     if (!(dc = get_dc_ptr( hdc ))) return 0;
 703     ret = dc->hPalette;
 704     if (dc->funcs->pSelectPalette) hpal = dc->funcs->pSelectPalette( dc->physDev, hpal, FALSE );
 705     if (hpal)
 706     {
 707         dc->hPalette = hpal;
 708         if (!wBkg) hPrimaryPalette = hpal;
 709     }
 710     else ret = 0;
 711     release_dc_ptr( dc );
 712     return ret;
 713 }
 714
 715
 716 /***********************************************************************
 717  *           GDIRealizePalette    (Not a Windows API)
 718  */
 719 UINT WINAPI GDIRealizePalette( HDC hdc )
 720 {
 721     UINT realized = 0;
 722     DC* dc = get_dc_ptr( hdc );
 723
 724     if (!dc) return 0;
 725
 726     TRACE("%p...\n", hdc );
 727
 728     if( dc->hPalette == GetStockObject( DEFAULT_PALETTE ))
 729     {
 730         if (dc->funcs->pRealizeDefaultPalette)
 731             realized = dc->funcs->pRealizeDefaultPalette( dc->physDev );
 732     }
 733     else if (InterlockedExchangePointer( (void **)&hLastRealizedPalette, dc->hPalette ) != dc->hPalette)
 734     {
 735         if (dc->funcs->pRealizePalette)
 736         {
 737             PALETTEOBJ *palPtr = GDI_GetObjPtr( dc->hPalette, OBJ_PAL );
 738             if (palPtr)
 739             {
 740                 realized = dc->funcs->pRealizePalette( dc->physDev, dc->hPalette,
 741                                                        (dc->hPalette == hPrimaryPalette) );
 742                 palPtr->funcs = dc->funcs;
 743                 GDI_ReleaseObj( dc->hPalette );
 744             }
 745         }
 746     }
 747     else TRACE("  skipping (hLastRealizedPalette = %p)\n", hLastRealizedPalette);
 748
 749     release_dc_ptr( dc );
 750     TRACE("   realized %i colors.\n", realized );
 751     return realized;
 752 }
 753
 754
 755 /***********************************************************************
 756  *           RealizeDefaultPalette    (GDI.365)
 757  */
 758 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
 759 {
 760     UINT16 ret = 0;
 761     DC          *dc;
 762
 763     TRACE("%04x\n", hdc );
 764
 765     if (!(dc = get_dc_ptr( HDC_32(hdc) ))) return 0;
 766
 767     if (dc->funcs->pRealizeDefaultPalette) ret = dc->funcs->pRealizeDefaultPalette( dc->physDev );
 768     release_dc_ptr( dc );
 769     return ret;
 770 }
 771
 772 /***********************************************************************
 773  *           IsDCCurrentPalette   (GDI.412)
 774  */
 775 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
 776 {
 777     DC *dc = get_dc_ptr( HDC_32(hDC) );
 778     if (dc)
 779     {
 780       BOOL bRet = dc->hPalette == hPrimaryPalette;
 781       release_dc_ptr( dc );
 782       return bRet;
 783     }
 784     return FALSE;
 785 }
 786
 787
 788 /***********************************************************************
 789  * SelectPalette [GDI32.@]
 790  *
 791  * Selects logical palette into DC.
 792  *
 793  * RETURNS
 794  *    Success: Previous logical palette
 795  *    Failure: NULL
 796  */
 797 HPALETTE WINAPI SelectPalette(
 798     HDC hDC,               /* [in] Handle of device context */
 799     HPALETTE hPal,         /* [in] Handle of logical color palette */
 800     BOOL bForceBackground) /* [in] Foreground/background mode */
 801 {
 802     return pfnSelectPalette( hDC, hPal, bForceBackground );
 803 }
 804
 805
 806 /***********************************************************************
 807  * RealizePalette [GDI32.@]
 808  *
 809  * Maps palette entries to system palette.
 810  *
 811  * RETURNS
 812  *    Success: Number of entries in logical palette
 813  *    Failure: GDI_ERROR
 814  */
 815 UINT WINAPI RealizePalette(
 816     HDC hDC) /* [in] Handle of device context */
 817 {
 818     return pfnRealizePalette( hDC );
 819 }
 820
 821
 822 typedef HWND (WINAPI *WindowFromDC_funcptr)( HDC );
 823 typedef BOOL (WINAPI *RedrawWindow_funcptr)( HWND, const RECT *, HRGN, UINT );
 824
 825 /**********************************************************************
 826  * UpdateColors [GDI32.@]
 827  *
 828  * Remaps current colors to logical palette.
 829  *
 830  * RETURNS
 831  *    Success: TRUE
 832  *    Failure: FALSE
 833  */
 834 BOOL WINAPI UpdateColors(
 835     HDC hDC) /* [in] Handle of device context */
 836 {
 837     HMODULE mod;
 838     int size = GetDeviceCaps( hDC, SIZEPALETTE );
 839
 840     if (!size) return 0;
 841
 842     mod = GetModuleHandleA("user32.dll");
 843     if (mod)
 844     {
 845         WindowFromDC_funcptr pWindowFromDC = (WindowFromDC_funcptr)GetProcAddress(mod,"WindowFromDC");
 846         if (pWindowFromDC)
 847         {
 848             HWND hWnd = pWindowFromDC( hDC );
 849
 850             /* Docs say that we have to remap current drawable pixel by pixel
 851              * but it would take forever given the speed of XGet/PutPixel.
 852              */
 853             if (hWnd && size)
 854             {
 855                 RedrawWindow_funcptr pRedrawWindow = (void *)GetProcAddress( mod, "RedrawWindow" );
 856                 if (pRedrawWindow) pRedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
 857             }
 858         }
 859     }
 860     return 0x666;
 861 }
 862
 863
 864 /*********************************************************************
 865  *           SetMagicColors   (GDI.606)
 866  */
 867 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
 868 {
 869     FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
 870
 871 }
 872
 873 /*********************************************************************
 874  *           SetMagicColors   (GDI32.@)
 875  */
 876 BOOL WINAPI SetMagicColors(HDC hdc, ULONG u1, ULONG u2)
 877 {
 878     FIXME("(%p 0x%08x 0x%08x): stub\n", hdc, u1, u2);
 879     return TRUE;
 880 }