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