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