objects/palette.c

   1 /*
   2  * GDI palette objects
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  * Copyright 1996 Alex Korobka
   6  *
   7  * PALETTEOBJ is documented in the Dr. Dobbs Journal May 1993.
   8  * Information in the "Undocumented Windows" is incorrect.
   9  */
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "gdi.h"
  15 #include "color.h"
  16 #include "palette.h"
  17 #include "xmalloc.h"
  18 #include "debug.h"
  19 #include "wine/winuser16.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(palette)
  22
  23 PALETTE_DRIVER *PALETTE_Driver = NULL;
  24
  25 FARPROC pfnSelectPalette = NULL;
  26 FARPROC pfnRealizePalette = NULL;
  27
  28 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  29
  30 static HPALETTE16 hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  31 static HPALETTE16 hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  32
  33
  34 /***********************************************************************
  35  *           PALETTE_Init
  36  *
  37  * Create the system palette.
  38  */
  39 HPALETTE16 PALETTE_Init(void)
  40 {
  41     int                 i;
  42     HPALETTE16          hpalette;
  43     LOGPALETTE *        palPtr;
  44     PALETTEOBJ*         palObj;
  45     const PALETTEENTRY* __sysPalTemplate = COLOR_GetSystemPaletteTemplate();
  46
  47     /* create default palette (20 system colors) */
  48
  49     palPtr = HeapAlloc( GetProcessHeap(), 0,
  50              sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY));
  51     if (!palPtr) return FALSE;
  52
  53     palPtr->palVersion = 0x300;
  54     palPtr->palNumEntries = NB_RESERVED_COLORS;
  55     for( i = 0; i < NB_RESERVED_COLORS; i ++ )
  56     {
  57         palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
  58         palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
  59         palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
  60         palPtr->palPalEntry[i].peFlags = 0;
  61     }
  62     hpalette = CreatePalette16( palPtr );
  63
  64     palObj = (PALETTEOBJ*) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  65     if (palObj)
  66     {
  67         palObj->mapping = xmalloc( sizeof(int) * 20 );
  68
  69         GDI_HEAP_UNLOCK( hpalette );
  70
  71         HeapFree( GetProcessHeap(), 0, palPtr );
  72     }
  73
  74     return hpalette;
  75 }
  76
  77 /***********************************************************************
  78  *           PALETTE_ValidateFlags
  79  */
  80 void PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, int size)
  81 {
  82     int i = 0;
  83     for( ; i<size ; i++ )
  84         lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
  85 }
  86
  87
  88 /***********************************************************************
  89  *           CreatePalette16    (GDI.360)
  90  */
  91 HPALETTE16 WINAPI CreatePalette16( const LOGPALETTE* palette )
  92 {
  93     return CreatePalette( palette );
  94 }
  95
  96
  97 /***********************************************************************
  98  * CreatePalette32 [GDI32.53]  Creates a logical color palette
  99  *
 100  * RETURNS
 101  *    Success: Handle to logical palette
 102  *    Failure: NULL
 103  */
 104 HPALETTE WINAPI CreatePalette(
 105     const LOGPALETTE* palette) /* [in] Pointer to logical color palette */
 106 {
 107     PALETTEOBJ * palettePtr;
 108     HPALETTE hpalette;
 109     int size;
 110
 111     if (!palette) return 0;
 112     TRACE(palette,"entries=%i\n", palette->palNumEntries);
 113
 114     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
 115
 116     hpalette = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR) , PALETTE_MAGIC );
 117     if (!hpalette) return 0;
 118
 119     palettePtr = (PALETTEOBJ *) GDI_HEAP_LOCK( hpalette );
 120     memcpy( &palettePtr->logpalette, palette, size );
 121     PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
 122                           palettePtr->logpalette.palNumEntries);
 123     palettePtr->mapping = NULL;
 124     GDI_HEAP_UNLOCK( hpalette );
 125
 126     TRACE(palette,"   returning %04x\n", hpalette);
 127     return hpalette;
 128 }
 129
 130
 131 /***********************************************************************
 132  * CreateHalftonePalette16 [GDI.?]  Creates a halftone palette
 133  *
 134  * RETURNS
 135  *    Success: Handle to logical halftone palette
 136  *    Failure: 0
 137  */
 138 HPALETTE16 WINAPI CreateHalftonePalette16(
 139     HDC16 hdc) /* [in] Handle to device context */
 140 {
 141     return CreateHalftonePalette(hdc);
 142 }
 143
 144
 145 /***********************************************************************
 146  * CreateHalftonePalette32 [GDI32.47]  Creates a halftone palette
 147  *
 148  * RETURNS
 149  *    Success: Handle to logical halftone palette
 150  *    Failure: 0
 151  *
 152  * FIXME: not truly tested
 153  */
 154 HPALETTE WINAPI CreateHalftonePalette(
 155     HDC hdc) /* [in] Handle to device context */
 156 {
 157     int i, r, g, b;
 158     struct {
 159         WORD Version;
 160         WORD NumberOfEntries;
 161         PALETTEENTRY aEntries[256];
 162     } Palette = {
 163         0x300, 256
 164     };
 165
 166     GetSystemPaletteEntries(hdc, 0, 256, Palette.aEntries);
 167     return CreatePalette((LOGPALETTE *)&Palette);
 168
 169     for (r = 0; r < 6; r++) {
 170         for (g = 0; g < 6; g++) {
 171             for (b = 0; b < 6; b++) {
 172                 i = r + g*6 + b*36 + 10;
 173                 Palette.aEntries[i].peRed = r * 51;
 174                 Palette.aEntries[i].peGreen = g * 51;
 175                 Palette.aEntries[i].peBlue = b * 51;
 176             }
 177           }
 178         }
 179
 180     for (i = 216; i < 246; i++) {
 181         int v = (i - 216) * 8;
 182         Palette.aEntries[i].peRed = v;
 183         Palette.aEntries[i].peGreen = v;
 184         Palette.aEntries[i].peBlue = v;
 185         }
 186
 187     return CreatePalette((LOGPALETTE *)&Palette);
 188 }
 189
 190
 191 /***********************************************************************
 192  *           GetPaletteEntries16    (GDI.363)
 193  */
 194 UINT16 WINAPI GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
 195                                    UINT16 count, LPPALETTEENTRY entries )
 196 {
 197     return GetPaletteEntries( hpalette, start, count, entries );
 198 }
 199
 200
 201 /***********************************************************************
 202  * GetPaletteEntries32 [GDI32.209]  Retrieves palette entries
 203  *
 204  * RETURNS
 205  *    Success: Number of entries from logical palette
 206  *    Failure: 0
 207  */
 208 UINT WINAPI GetPaletteEntries(
 209     HPALETTE hpalette,    /* [in]  Handle of logical palette */
 210     UINT start,           /* [in]  First entry to receive */
 211     UINT count,           /* [in]  Number of entries to receive */
 212     LPPALETTEENTRY entries) /* [out] Address of array receiving entries */
 213 {
 214     PALETTEOBJ * palPtr;
 215     INT numEntries;
 216
 217     TRACE(palette,"hpal = %04x, count=%i\n", hpalette, count );
 218
 219     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 220     if (!palPtr) return 0;
 221
 222     numEntries = palPtr->logpalette.palNumEntries;
 223     if (start+count > numEntries) count = numEntries - start;
 224     if (entries)
 225     {
 226       if (start >= numEntries)
 227       {
 228         GDI_HEAP_UNLOCK( hpalette );
 229         return 0;
 230       }
 231       memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 232               count * sizeof(PALETTEENTRY) );
 233       for( numEntries = 0; numEntries < count ; numEntries++ )
 234            if (entries[numEntries].peFlags & 0xF0)
 235                entries[numEntries].peFlags = 0;
 236       GDI_HEAP_UNLOCK( hpalette );
 237     }
 238
 239     return count;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           SetPaletteEntries16    (GDI.364)
 245  */
 246 UINT16 WINAPI SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
 247                                    UINT16 count, LPPALETTEENTRY entries )
 248 {
 249     return SetPaletteEntries( hpalette, start, count, entries );
 250 }
 251
 252
 253 /***********************************************************************
 254  * SetPaletteEntries32 [GDI32.326]  Sets color values for range in palette
 255  *
 256  * RETURNS
 257  *    Success: Number of entries that were set
 258  *    Failure: 0
 259  */
 260 UINT WINAPI SetPaletteEntries(
 261     HPALETTE hpalette,    /* [in] Handle of logical palette */
 262     UINT start,           /* [in] Index of first entry to set */
 263     UINT count,           /* [in] Number of entries to set */
 264     LPPALETTEENTRY entries) /* [in] Address of array of structures */
 265 {
 266     PALETTEOBJ * palPtr;
 267     INT numEntries;
 268
 269     TRACE(palette,"hpal=%04x,start=%i,count=%i\n",hpalette,start,count );
 270
 271     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 272     if (!palPtr) return 0;
 273
 274     numEntries = palPtr->logpalette.palNumEntries;
 275     if (start >= numEntries)
 276     {
 277       GDI_HEAP_UNLOCK( hpalette );
 278       return 0;
 279     }
 280     if (start+count > numEntries) count = numEntries - start;
 281     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 282             count * sizeof(PALETTEENTRY) );
 283     PALETTE_ValidateFlags(palPtr->logpalette.palPalEntry,
 284                           palPtr->logpalette.palNumEntries);
 285     free(palPtr->mapping);
 286     palPtr->mapping = NULL;
 287     GDI_HEAP_UNLOCK( hpalette );
 288     return count;
 289 }
 290
 291
 292 /***********************************************************************
 293  *           ResizePalette16   (GDI.368)
 294  */
 295 BOOL16 WINAPI ResizePalette16( HPALETTE16 hPal, UINT16 cEntries )
 296 {
 297     return ResizePalette( hPal, cEntries );
 298 }
 299
 300
 301 /***********************************************************************
 302  * ResizePalette32 [GDI32.289]  Resizes logical palette
 303  *
 304  * RETURNS
 305  *    Success: TRUE
 306  *    Failure: FALSE
 307  */
 308 BOOL WINAPI ResizePalette(
 309     HPALETTE hPal, /* [in] Handle of logical palette */
 310     UINT cEntries) /* [in] Number of entries in logical palette */
 311 {
 312     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 313     UINT         cPrevEnt, prevVer;
 314     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 315     int*         mapping = NULL;
 316
 317     TRACE(palette,"hpal = %04x, prev = %i, new = %i\n",
 318                     hPal, palPtr ? palPtr->logpalette.palNumEntries : -1,
 319                     cEntries );
 320     if( !palPtr ) return FALSE;
 321     cPrevEnt = palPtr->logpalette.palNumEntries;
 322     prevVer = palPtr->logpalette.palVersion;
 323     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 324                                         sizeof(int*) + sizeof(GDIOBJHDR);
 325     size += sizeof(int*) + sizeof(GDIOBJHDR);
 326     mapping = palPtr->mapping;
 327
 328     GDI_HEAP_UNLOCK( hPal );
 329
 330     hPal = GDI_HEAP_REALLOC( hPal, size );
 331     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 332     if( !palPtr ) return FALSE;
 333
 334     if( mapping )
 335         palPtr->mapping = (int*) xrealloc( mapping, cEntries * sizeof(int) );
 336     if( cEntries > cPrevEnt )
 337     {
 338         if( mapping )
 339             memset(palPtr->mapping + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
 340         memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 341         PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize),
 342                                                      cEntries - cPrevEnt );
 343     }
 344     palPtr->logpalette.palNumEntries = cEntries;
 345     palPtr->logpalette.palVersion = prevVer;
 346     GDI_HEAP_UNLOCK( hPal );
 347     return TRUE;
 348 }
 349
 350
 351 /***********************************************************************
 352  *           AnimatePalette16   (GDI.367)
 353  */
 354 void WINAPI AnimatePalette16( HPALETTE16 hPal, UINT16 StartIndex,
 355                               UINT16 NumEntries, const PALETTEENTRY* PaletteColors)
 356 {
 357     AnimatePalette( hPal, StartIndex, NumEntries, PaletteColors );
 358 }
 359
 360
 361 /***********************************************************************
 362  * AnimatePalette32 [GDI32.6]  Replaces entries in logical palette
 363  *
 364  * RETURNS
 365  *    Success: TRUE
 366  *    Failure: FALSE
 367  *
 368  * FIXME
 369  *    Should use existing mapping when animating a primary palette
 370  */
 371 BOOL WINAPI AnimatePalette(
 372     HPALETTE hPal,              /* [in] Handle to logical palette */
 373     UINT StartIndex,            /* [in] First entry in palette */
 374     UINT NumEntries,            /* [in] Count of entries in palette */
 375     const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
 376 {
 377     TRACE(palette, "%04x (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
 378
 379     if( hPal != STOCK_DEFAULT_PALETTE )
 380     {
 381         PALETTEOBJ* palPtr = (PALETTEOBJ *)GDI_GetObjPtr(hPal, PALETTE_MAGIC);
 382         if (!palPtr) return FALSE;
 383
 384         if( (StartIndex + NumEntries) <= palPtr->logpalette.palNumEntries )
 385         {
 386             UINT u;
 387             for( u = 0; u < NumEntries; u++ )
 388                 palPtr->logpalette.palPalEntry[u + StartIndex] = PaletteColors[u];
 389             PALETTE_Driver->
 390               pSetMapping(palPtr, StartIndex, NumEntries,
 391                           hPal != hPrimaryPalette );
 392             GDI_HEAP_UNLOCK( hPal );
 393             return TRUE;
 394         }
 395     }
 396     return FALSE;
 397 }
 398
 399
 400 /***********************************************************************
 401  *           SetSystemPaletteUse16   (GDI.373)
 402  */
 403 UINT16 WINAPI SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
 404 {
 405     return SetSystemPaletteUse( hdc, use );
 406 }
 407
 408
 409 /***********************************************************************
 410  * SetSystemPaletteUse32 [GDI32.335]
 411  *
 412  * RETURNS
 413  *    Success: Previous system palette
 414  *    Failure: SYSPAL_ERROR
 415  */
 416 UINT WINAPI SetSystemPaletteUse(
 417     HDC hdc,  /* [in] Handle of device context */
 418     UINT use) /* [in] Palette-usage flag */
 419 {
 420     UINT old = SystemPaletteUse;
 421     FIXME(palette,"(%04x,%04x): stub\n", hdc, use );
 422     SystemPaletteUse = use;
 423     return old;
 424 }
 425
 426
 427 /***********************************************************************
 428  *           GetSystemPaletteUse16   (GDI.374)
 429  */
 430 UINT16 WINAPI GetSystemPaletteUse16( HDC16 hdc )
 431 {
 432     return SystemPaletteUse;
 433 }
 434
 435
 436 /***********************************************************************
 437  * GetSystemPaletteUse32 [GDI32.223]  Gets state of system palette
 438  *
 439  * RETURNS
 440  *    Current state of system palette
 441  */
 442 UINT WINAPI GetSystemPaletteUse(
 443     HDC hdc) /* [in] Handle of device context */
 444 {
 445     return SystemPaletteUse;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           GetSystemPaletteEntries16   (GDI.375)
 451  */
 452 UINT16 WINAPI GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
 453                                          LPPALETTEENTRY entries )
 454 {
 455     return GetSystemPaletteEntries( hdc, start, count, entries );
 456 }
 457
 458
 459 /***********************************************************************
 460  * GetSystemPaletteEntries32 [GDI32.222]  Gets range of palette entries
 461  *
 462  * RETURNS
 463  *    Success: Number of entries retrieved from palette
 464  *    Failure: 0
 465  */
 466 UINT WINAPI GetSystemPaletteEntries(
 467     HDC hdc,              /* [in]  Handle of device context */
 468     UINT start,           /* [in]  Index of first entry to be retrieved */
 469     UINT count,           /* [in]  Number of entries to be retrieved */
 470     LPPALETTEENTRY entries) /* [out] Array receiving system-palette entries */
 471 {
 472     UINT i;
 473     DC *dc;
 474
 475     TRACE(palette, "hdc=%04x,start=%i,count=%i\n", hdc,start,count);
 476
 477     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 478     if (!entries) return dc->w.devCaps->sizePalette;
 479     if (start >= dc->w.devCaps->sizePalette)
 480       {
 481         GDI_HEAP_UNLOCK( hdc );
 482         return 0;
 483       }
 484     if (start+count >= dc->w.devCaps->sizePalette)
 485         count = dc->w.devCaps->sizePalette - start;
 486     for (i = 0; i < count; i++)
 487     {
 488         *(COLORREF*)(entries + i) = COLOR_GetSystemPaletteEntry( start + i );
 489
 490         TRACE(palette,"\tidx(%02x) -> RGB(%08lx)\n",
 491                          start + i, *(COLORREF*)(entries + i) );
 492     }
 493     GDI_HEAP_UNLOCK( hdc );
 494     return count;
 495 }
 496
 497
 498 /***********************************************************************
 499  *           GetNearestPaletteIndex16   (GDI.370)
 500  */
 501 UINT16 WINAPI GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
 502 {
 503     return GetNearestPaletteIndex( hpalette, color );
 504 }
 505
 506
 507 /***********************************************************************
 508  * GetNearestPaletteIndex32 [GDI32.203]  Gets palette index for color
 509  *
 510  * NOTES
 511  *    Should index be initialized to CLR_INVALID instead of 0?
 512  *
 513  * RETURNS
 514  *    Success: Index of entry in logical palette
 515  *    Failure: CLR_INVALID
 516  */
 517 UINT WINAPI GetNearestPaletteIndex(
 518     HPALETTE hpalette, /* [in] Handle of logical color palette */
 519     COLORREF color)      /* [in] Color to be matched */
 520 {
 521     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 522     UINT index  = 0;
 523
 524     if( palObj )
 525       index = COLOR_PaletteLookupPixel(palObj->logpalette.palPalEntry,
 526                                        palObj->logpalette.palNumEntries,
 527                                        NULL, color, FALSE );
 528
 529     TRACE(palette,"(%04x,%06lx): returning %d\n", hpalette, color, index );
 530     GDI_HEAP_UNLOCK( hpalette );
 531     return index;
 532 }
 533
 534
 535 /***********************************************************************
 536  *           GetNearestColor16   (GDI.154)
 537  */
 538 COLORREF WINAPI GetNearestColor16( HDC16 hdc, COLORREF color )
 539 {
 540     return GetNearestColor( hdc, color );
 541 }
 542
 543
 544 /***********************************************************************
 545  * GetNearestColor32 [GDI32.202]  Gets a system color to match
 546  *
 547  * NOTES
 548  *    Should this return CLR_INVALID instead of FadeCafe?
 549  *
 550  * RETURNS
 551  *    Success: Color from system palette that corresponds to given color
 552  *    Failure: CLR_INVALID
 553  */
 554 COLORREF WINAPI GetNearestColor(
 555     HDC hdc,      /* [in] Handle of device context */
 556     COLORREF color) /* [in] Color to be matched */
 557 {
 558     COLORREF     nearest = 0xFADECAFE;
 559     DC          *dc;
 560     PALETTEOBJ  *palObj;
 561
 562     if ( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
 563     {
 564       palObj = (PALETTEOBJ*)
 565                 GDI_GetObjPtr( (dc->w.hPalette)? dc->w.hPalette
 566                                                : STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 567       if (!palObj) return nearest;
 568
 569       nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
 570                                           palObj->logpalette.palNumEntries, color );
 571       GDI_HEAP_UNLOCK( dc->w.hPalette );
 572     }
 573
 574     TRACE(palette,"(%06lx): returning %06lx\n", color, nearest );
 575     GDI_HEAP_UNLOCK( hdc );
 576     return nearest;
 577 }
 578
 579
 580 /***********************************************************************
 581  *           PALETTE_GetObject
 582  */
 583 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 584 {
 585     if (count > sizeof(WORD)) count = sizeof(WORD);
 586     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 587     return count;
 588 }
 589
 590
 591 /***********************************************************************
 592  *           PALETTE_UnrealizeObject
 593  */
 594 BOOL PALETTE_UnrealizeObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 595 {
 596     if (palette->mapping)
 597     {
 598         free( palette->mapping );
 599         palette->mapping = NULL;
 600     }
 601     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 602     return TRUE;
 603 }
 604
 605
 606 /***********************************************************************
 607  *           PALETTE_DeleteObject
 608  */
 609 BOOL PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 610 {
 611     free( palette->mapping );
 612     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 613     return GDI_FreeObject( hpalette );
 614 }
 615
 616
 617 /***********************************************************************
 618  *           GDISelectPalette    (GDI.361)
 619  */
 620 HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
 621 {
 622     HPALETTE16 prev;
 623     DC *dc;
 624
 625     TRACE(palette, "%04x %04x\n", hdc, hpal );
 626
 627     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 628     if (!dc)
 629     {
 630         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 631         if (!dc) return 0;
 632     }
 633     prev = dc->w.hPalette;
 634     dc->w.hPalette = hpal;
 635     GDI_HEAP_UNLOCK( hdc );
 636     if (!wBkg) hPrimaryPalette = hpal;
 637     return prev;
 638 }
 639
 640
 641 /***********************************************************************
 642  *           GDIRealizePalette    (GDI.362)
 643  */
 644 UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
 645 {
 646     PALETTEOBJ* palPtr;
 647     int realized = 0;
 648     DC*         dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 649     if (!dc)
 650     {
 651         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 652         if (!dc) return 0;
 653     }
 654
 655     TRACE(palette, "%04x...\n", hdc );
 656
 657     if( dc &&  dc->w.hPalette != hLastRealizedPalette )
 658     {
 659         if( dc->w.hPalette == STOCK_DEFAULT_PALETTE )
 660             return RealizeDefaultPalette16( hdc );
 661
 662         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
 663
 664         if (!palPtr) {
 665                 FIXME(palette,"invalid selected palette %04x\n",dc->w.hPalette);
 666                 return 0;
 667         }
 668
 669         realized = PALETTE_Driver->
 670           pSetMapping(palPtr,0,palPtr->logpalette.palNumEntries,
 671                       (dc->w.hPalette != hPrimaryPalette) ||
 672                       (dc->w.hPalette == STOCK_DEFAULT_PALETTE));
 673         GDI_HEAP_UNLOCK( dc->w.hPalette );
 674         hLastRealizedPalette = dc->w.hPalette;
 675     }
 676     else TRACE(palette, "  skipping (hLastRealizedPalette = %04x)\n",
 677                          hLastRealizedPalette);
 678     GDI_HEAP_UNLOCK( hdc );
 679
 680     TRACE(palette, "   realized %i colors.\n", realized );
 681     return (UINT16)realized;
 682 }
 683
 684
 685 /***********************************************************************
 686  *           RealizeDefaultPalette    (GDI.365)
 687  */
 688 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
 689 {
 690     DC          *dc;
 691     PALETTEOBJ*  palPtr;
 692
 693     TRACE(palette,"%04x\n", hdc );
 694
 695     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 696     if (!dc)
 697     {
 698         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 699         if (!dc) return 0;
 700     }
 701
 702     if ( dc->w.flags & DC_MEMORY )
 703       {
 704         GDI_HEAP_UNLOCK( hdc );
 705         return 0;
 706       }
 707
 708     hPrimaryPalette = STOCK_DEFAULT_PALETTE;
 709     hLastRealizedPalette = STOCK_DEFAULT_PALETTE;
 710
 711     palPtr = (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 712     if (!palPtr) return 0;
 713
 714     /* lookup is needed to account for SetSystemPaletteUse() stuff */
 715
 716     return PALETTE_Driver->pUpdateMapping(palPtr);
 717 }
 718
 719 /***********************************************************************
 720  *           IsDCCurrentPalette   (GDI.412)
 721  */
 722 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
 723 {
 724     DC* dc = (DC *)GDI_GetObjPtr( hDC, DC_MAGIC );
 725     if (dc)
 726     {
 727       GDI_HEAP_UNLOCK( hDC );
 728       return dc->w.hPalette == hPrimaryPalette;
 729     }
 730     return FALSE;
 731 }
 732
 733
 734 /***********************************************************************
 735  *           SelectPalette16    (USER.282)
 736  */
 737 HPALETTE16 WINAPI SelectPalette16( HDC16 hDC, HPALETTE16 hPal,
 738                                    BOOL16 bForceBackground )
 739 {
 740     return SelectPalette( hDC, hPal, bForceBackground );
 741 }
 742
 743
 744 /***********************************************************************
 745  * SelectPalette32 [GDI32.300]  Selects logical palette into DC
 746  *
 747  * RETURNS
 748  *    Success: Previous logical palette
 749  *    Failure: NULL
 750  */
 751 HPALETTE WINAPI SelectPalette(
 752     HDC hDC,               /* [in] Handle of device context */
 753     HPALETTE hPal,         /* [in] Handle of logical color palette */
 754     BOOL bForceBackground) /* [in] Foreground/background mode */
 755 {
 756     WORD        wBkgPalette = 1;
 757     PALETTEOBJ* lpt = (PALETTEOBJ*) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 758
 759     TRACE(palette,"dc=%04x,pal=%04x,force=%i\n", hDC, hPal, bForceBackground);
 760     if( !lpt ) return 0;
 761
 762     TRACE(palette," entries = %d\n", lpt->logpalette.palNumEntries);
 763     GDI_HEAP_UNLOCK( hPal );
 764
 765     if( hPal != STOCK_DEFAULT_PALETTE )
 766     {
 767         HWND hWnd = WindowFromDC( hDC );
 768         HWND hActive = GetActiveWindow();
 769
 770         /* set primary palette if it's related to current active */
 771
 772         if((!hWnd || (hActive == hWnd || IsChild16(hActive,hWnd))) &&
 773             !bForceBackground )
 774             wBkgPalette = 0;
 775     }
 776     return GDISelectPalette16( hDC, hPal, wBkgPalette);
 777 }
 778
 779
 780 /***********************************************************************
 781  *           RealizePalette16    (USER.283)
 782  */
 783 UINT16 WINAPI RealizePalette16( HDC16 hDC )
 784 {
 785     return RealizePalette( hDC );
 786 }
 787
 788
 789 /***********************************************************************
 790  * RealizePalette32 [GDI32.280]  Maps palette entries to system palette
 791  *
 792  * RETURNS
 793  *    Success: Number of entries in logical palette
 794  *    Failure: GDI_ERROR
 795  */
 796 UINT WINAPI RealizePalette(
 797     HDC hDC) /* [in] Handle of device context */
 798 {
 799     DC *dc;
 800     UINT realized;
 801
 802     if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return 0;
 803
 804     realized = GDIRealizePalette16( hDC );
 805
 806     /* do not send anything if no colors were changed */
 807
 808     if( IsDCCurrentPalette16( hDC ) && realized &&
 809         dc->w.devCaps->sizePalette )
 810     {
 811         /* Send palette change notification */
 812
 813         HWND hWnd;
 814         if( (hWnd = WindowFromDC( hDC )) )
 815             SendMessage16( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L);
 816     }
 817
 818     GDI_HEAP_UNLOCK( hDC );
 819     return realized;
 820 }
 821
 822
 823 /**********************************************************************
 824  *            UpdateColors16   (GDI.366)
 825  */
 826 INT16 WINAPI UpdateColors16( HDC16 hDC )
 827 {
 828     DC *dc;
 829     HWND hWnd;
 830
 831     if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return 0;
 832
 833     hWnd = WindowFromDC( hDC );
 834
 835     /* Docs say that we have to remap current drawable pixel by pixel
 836      * but it would take forever given the speed of XGet/PutPixel.
 837      */
 838     if (hWnd && dc->w.devCaps->sizePalette )
 839         InvalidateRect( hWnd, NULL, FALSE );
 840
 841     GDI_HEAP_UNLOCK( hDC );
 842
 843     return 0x666;
 844 }
 845
 846
 847 /**********************************************************************
 848  * UpdateColors32 [GDI32.359]  Remaps current colors to logical palette
 849  *
 850  * RETURNS
 851  *    Success: TRUE
 852  *    Failure: FALSE
 853  */
 854 BOOL WINAPI UpdateColors(
 855     HDC hDC) /* [in] Handle of device context */
 856 {
 857     UpdateColors16( hDC );
 858     return TRUE;
 859 }
 860
 861
 862 /*********************************************************************
 863  *           SetMagicColors16   (GDI.606)
 864  */
 865 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
 866 {
 867     FIXME(palette,"(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
 868
 869 }