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