git.oblomov.eu Git - wine/blob - 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 #include <X11/Xlib.h>
  14
  15 #include "gdi.h"
  16 #include "color.h"
  17 #include "palette.h"
  18 #include "xmalloc.h"
  19 #include "stddebug.h"
  20 /* #define DEBUG_PALETTE */
  21 #include "debug.h"
  22
  23  /* lookup pixel among static entries of the system palette */
  24 extern int COLOR_LookupSystemPixel(COLORREF);
  25
  26 static UINT32 SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  27
  28 static HPALETTE16 hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  29 static HPALETTE16 hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  30
  31
  32 /***********************************************************************
  33  *           PALETTE_Init
  34  *
  35  * Create the system palette.
  36  */
  37 HPALETTE16 PALETTE_Init(void)
  38 {
  39     extern const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(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 = xmalloc( sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY) );
  50     if (!palPtr) return FALSE;
  51
  52     palPtr->palVersion = 0x300;
  53     palPtr->palNumEntries = NB_RESERVED_COLORS;
  54     for( i = 0; i < NB_RESERVED_COLORS; i ++ )
  55     {
  56         palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
  57         palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
  58         palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
  59         palPtr->palPalEntry[i].peFlags = 0;
  60     }
  61     hpalette = CreatePalette16( palPtr );
  62
  63     palObj = (PALETTEOBJ*) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  64
  65     palObj->mapping = xmalloc( sizeof(int) * 20 );
  66
  67     free( palPtr );
  68     return hpalette;
  69 }
  70
  71 /***********************************************************************
  72  *           PALETTE_ValidateFlags
  73  */
  74 void PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, int size)
  75 {
  76     int i = 0;
  77     for( ; i<size ; i++ )
  78         lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
  79 }
  80
  81
  82 /***********************************************************************
  83  *           CreatePalette16    (GDI.360)
  84  */
  85 HPALETTE16 CreatePalette16( const LOGPALETTE* palette )
  86 {
  87     return CreatePalette32( palette );
  88 }
  89
  90
  91 /***********************************************************************
  92  *           CreatePalette32    (GDI32.53)
  93  */
  94 HPALETTE32 CreatePalette32( const LOGPALETTE* palette )
  95 {
  96     PALETTEOBJ * palettePtr;
  97     HPALETTE32 hpalette;
  98     int size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
  99
 100     dprintf_palette(stddeb,"CreatePalette: %i entries, ",
 101                     palette->palNumEntries);
 102
 103     hpalette = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR) , PALETTE_MAGIC );
 104     if (!hpalette) return 0;
 105
 106     palettePtr = (PALETTEOBJ *) GDI_HEAP_LIN_ADDR( hpalette );
 107     memcpy( &palettePtr->logpalette, palette, size );
 108     PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
 109                           palettePtr->logpalette.palNumEntries);
 110     palettePtr->mapping = NULL;
 111
 112     dprintf_palette(stddeb,"returning %04x\n", hpalette);
 113     return hpalette;
 114 }
 115
 116
 117 /***********************************************************************
 118  *           GetPaletteEntries16    (GDI.363)
 119  */
 120 UINT16 GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start, UINT16 count,
 121                             LPPALETTEENTRY entries )
 122 {
 123     return GetPaletteEntries32( hpalette, start, count, entries );
 124 }
 125
 126
 127 /***********************************************************************
 128  *           GetPaletteEntries32    (GDI32.209)
 129  */
 130 UINT32 GetPaletteEntries32( HPALETTE32 hpalette, UINT32 start, UINT32 count,
 131                             LPPALETTEENTRY entries )
 132 {
 133     PALETTEOBJ * palPtr;
 134     INT32 numEntries;
 135
 136     dprintf_palette( stddeb,"GetPaletteEntries: hpal = %04x, %i entries\n",
 137                      hpalette, count );
 138
 139     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 140     if (!palPtr) return 0;
 141
 142     numEntries = palPtr->logpalette.palNumEntries;
 143     if (start >= numEntries) return 0;
 144     if (start+count > numEntries) count = numEntries - start;
 145     memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 146             count * sizeof(PALETTEENTRY) );
 147     for( numEntries = 0; numEntries < count ; numEntries++ )
 148          if (entries[numEntries].peFlags & 0xF0)
 149              entries[numEntries].peFlags = 0;
 150     return count;
 151 }
 152
 153
 154 /***********************************************************************
 155  *           SetPaletteEntries16    (GDI.364)
 156  */
 157 UINT16 SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start, UINT16 count,
 158                             LPPALETTEENTRY entries )
 159 {
 160     return SetPaletteEntries32( hpalette, start, count, entries );
 161 }
 162
 163
 164 /***********************************************************************
 165  *           SetPaletteEntries32    (GDI32.326)
 166  */
 167 UINT32 SetPaletteEntries32( HPALETTE32 hpalette, UINT32 start, UINT32 count,
 168                             LPPALETTEENTRY entries )
 169 {
 170     PALETTEOBJ * palPtr;
 171     INT32 numEntries;
 172
 173     dprintf_palette( stddeb,"SetPaletteEntries: hpal = %04x, %i entries\n",
 174                      hpalette, count );
 175
 176     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 177     if (!palPtr) return 0;
 178
 179     numEntries = palPtr->logpalette.palNumEntries;
 180     if (start >= numEntries) return 0;
 181     if (start+count > numEntries) count = numEntries - start;
 182     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 183             count * sizeof(PALETTEENTRY) );
 184     PALETTE_ValidateFlags(palPtr->logpalette.palPalEntry,
 185                           palPtr->logpalette.palNumEntries);
 186     free(palPtr->mapping);
 187     palPtr->mapping = NULL;
 188
 189     return count;
 190 }
 191
 192
 193 /***********************************************************************
 194  *           ResizePalette16   (GDI.368)
 195  */
 196 BOOL16 ResizePalette16( HPALETTE16 hPal, UINT16 cEntries )
 197 {
 198     return ResizePalette32( hPal, cEntries );
 199 }
 200
 201
 202 /***********************************************************************
 203  *           ResizePalette32   (GDI32.289)
 204  */
 205 BOOL32 ResizePalette32( HPALETTE32 hPal, UINT32 cEntries )
 206 {
 207     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 208     UINT32       cPrevEnt, prevVer;
 209     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 210     int*         mapping = NULL;
 211
 212     dprintf_palette(stddeb,"ResizePalette: hpal = %04x, prev = %i, new = %i\n",
 213                     hPal, palPtr ? palPtr->logpalette.palNumEntries : -1,
 214                     cEntries );
 215     if( !palPtr ) return FALSE;
 216     cPrevEnt = palPtr->logpalette.palNumEntries;
 217     prevVer = palPtr->logpalette.palVersion;
 218     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 219                                         sizeof(int*) + sizeof(GDIOBJHDR);
 220     size += sizeof(int*) + sizeof(GDIOBJHDR);
 221     mapping = palPtr->mapping;
 222
 223     hPal = GDI_HEAP_REALLOC( hPal, size );
 224     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 225     if( !palPtr ) return FALSE;
 226
 227     if( mapping )
 228         palPtr->mapping = (int*) xrealloc( mapping, cEntries * sizeof(int) );
 229     if( cEntries > cPrevEnt )
 230     {
 231         if( mapping )
 232             memset(palPtr->mapping + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
 233         memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 234         PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize),
 235                                                      cEntries - cPrevEnt );
 236     }
 237     palPtr->logpalette.palNumEntries = cEntries;
 238     palPtr->logpalette.palVersion = prevVer;
 239     return TRUE;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           AnimatePalette16   (GDI.367)
 245  */
 246 BOOL16 AnimatePalette16( HPALETTE16 hPal, UINT16 StartIndex, UINT16 NumEntries,
 247                          LPPALETTEENTRY PaletteColors )
 248 {
 249     return AnimatePalette32( hPal, StartIndex, NumEntries, PaletteColors );
 250 }
 251
 252
 253 /***********************************************************************
 254  *           AnimatePalette32   (GDI32.6)
 255  */
 256 BOOL32 AnimatePalette32( HPALETTE32 hPal, UINT32 StartIndex, UINT32 NumEntries,
 257                          LPPALETTEENTRY PaletteColors )
 258 {
 259     fprintf(stdnimp,"AnimatePalette: empty stub! \n");
 260     return TRUE;
 261 }
 262
 263
 264 /***********************************************************************
 265  *           SetSystemPaletteUse16   (GDI.373)
 266  */
 267 UINT16 SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
 268 {
 269     return SetSystemPaletteUse32( hdc, use );
 270 }
 271
 272
 273 /***********************************************************************
 274  *           SetSystemPaletteUse32   (GDI32.335)
 275  */
 276 UINT32 SetSystemPaletteUse32( HDC32 hdc, UINT32 use )
 277 {
 278     UINT32 old = SystemPaletteUse;
 279     fprintf( stdnimp,"SetSystemPaletteUse(%04x,%04x) // empty stub !!!\n",
 280              hdc, use );
 281     SystemPaletteUse = use;
 282     return old;
 283 }
 284
 285
 286 /***********************************************************************
 287  *           GetSystemPaletteUse16   (GDI.374)
 288  */
 289 UINT16 GetSystemPaletteUse16( HDC16 hdc )
 290 {
 291     return SystemPaletteUse;
 292 }
 293
 294
 295 /***********************************************************************
 296  *           GetSystemPaletteUse32   (GDI32.223)
 297  */
 298 UINT32 GetSystemPaletteUse32( HDC32 hdc )
 299 {
 300     return SystemPaletteUse;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           GetSystemPaletteEntries16   (GDI.375)
 306  */
 307 UINT16 GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
 308                                   LPPALETTEENTRY entries )
 309 {
 310     return GetSystemPaletteEntries32( hdc, start, count, entries );
 311 }
 312
 313
 314 /***********************************************************************
 315  *           GetSystemPaletteEntries32   (GDI32.222)
 316  */
 317 UINT32 GetSystemPaletteEntries32( HDC32 hdc, UINT32 start, UINT32 count,
 318                                   LPPALETTEENTRY entries )
 319 {
 320     UINT32 i;
 321     DC *dc;
 322
 323     dprintf_palette(stddeb,"GetSystemPaletteEntries: hdc = %04x, cound = %i", hdc, count );
 324
 325     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 326     if (start >= dc->w.devCaps->sizePalette) return 0;
 327     if (start+count >= dc->w.devCaps->sizePalette)
 328         count = dc->w.devCaps->sizePalette - start;
 329     for (i = 0; i < count; i++)
 330     {
 331         *(COLORREF*)(entries + i) = COLOR_GetSystemPaletteEntry( start + i );
 332
 333         dprintf_palette( stddeb,"\tidx(%02x) -> RGB(%08lx)\n",
 334                          start + i, *(COLORREF*)(entries + i) );
 335     }
 336     return count;
 337 }
 338
 339
 340 /***********************************************************************
 341  *           GetNearestPaletteIndex16   (GDI.370)
 342  */
 343 UINT16 GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
 344 {
 345     return GetNearestPaletteIndex32( hpalette, color );
 346 }
 347
 348
 349 /***********************************************************************
 350  *           GetNearestPaletteIndex32   (GDI32.203)
 351  */
 352 UINT32 GetNearestPaletteIndex32( HPALETTE32 hpalette, COLORREF color )
 353 {
 354     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 355     UINT32 index  = 0;
 356
 357     if( palObj )
 358         index = COLOR_PaletteLookupPixel( palObj->logpalette.palPalEntry,
 359                                           palObj->logpalette.palNumEntries,
 360                                           NULL, color, FALSE );
 361
 362     dprintf_palette(stddeb,"GetNearestPaletteIndex(%04x,%06lx): returning %d\n",
 363                     hpalette, color, index );
 364     return index;
 365 }
 366
 367
 368 /***********************************************************************
 369  *           GetNearestColor16   (GDI.154)
 370  */
 371 COLORREF GetNearestColor16( HDC16 hdc, COLORREF color )
 372 {
 373     return GetNearestColor32( hdc, color );
 374 }
 375
 376
 377 /***********************************************************************
 378  *           GetNearestColor32   (GDI32.202)
 379  */
 380 COLORREF GetNearestColor32( HDC32 hdc, COLORREF color )
 381 {
 382     COLORREF     nearest = 0xFADECAFE;
 383     DC          *dc;
 384     PALETTEOBJ  *palObj;
 385
 386     if ( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
 387     {
 388       palObj = (PALETTEOBJ*)
 389                 GDI_GetObjPtr( (dc->w.hPalette)? dc->w.hPalette
 390                                                : STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 391
 392       nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
 393                                           palObj->logpalette.palNumEntries, color );
 394     }
 395
 396     dprintf_palette(stddeb,"GetNearestColor(%06lx): returning %06lx\n",
 397                     color, nearest );
 398     return nearest;
 399 }
 400
 401
 402 /***********************************************************************
 403  *           PALETTE_GetObject
 404  */
 405 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 406 {
 407     if (count > sizeof(WORD)) count = sizeof(WORD);
 408     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 409     return count;
 410 }
 411
 412
 413 /***********************************************************************
 414  *           PALETTE_UnrealizeObject
 415  */
 416 BOOL32 PALETTE_UnrealizeObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 417 {
 418     if (palette->mapping)
 419     {
 420         free( palette->mapping );
 421         palette->mapping = NULL;
 422     }
 423     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 424     return TRUE;
 425 }
 426
 427
 428 /***********************************************************************
 429  *           PALETTE_DeleteObject
 430  */
 431 BOOL32 PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 432 {
 433     free( palette->mapping );
 434     return GDI_FreeObject( hpalette );
 435 }
 436
 437
 438 /***********************************************************************
 439  *           GDISelectPalette    (GDI.361)
 440  */
 441 HPALETTE16 GDISelectPalette( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
 442 {
 443     HPALETTE16 prev;
 444     DC *dc;
 445
 446     dprintf_palette(stddeb, "GDISelectPalette: %04x %04x\n", hdc, hpal );
 447
 448     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 449     if (!dc)
 450     {
 451         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 452         if (!dc) return 0;
 453     }
 454     prev = dc->w.hPalette;
 455     dc->w.hPalette = hpal;
 456     if (!wBkg) hPrimaryPalette = hpal;
 457     return prev;
 458 }
 459
 460
 461 /***********************************************************************
 462  *           GDIRealizePalette    (GDI.362)
 463  */
 464 UINT16 GDIRealizePalette( HDC16 hdc )
 465 {
 466     PALETTEOBJ* palPtr;
 467     int realized = 0;
 468     DC*         dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 469     if (!dc)
 470     {
 471         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 472         if (!dc) return 0;
 473     }
 474
 475     dprintf_palette(stddeb, "GDIRealizePalette: %04x...", hdc );
 476
 477     if( dc &&  dc->w.hPalette != hLastRealizedPalette )
 478     {
 479         if( dc->w.hPalette == STOCK_DEFAULT_PALETTE )
 480             return RealizeDefaultPalette( hdc );
 481
 482         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
 483
 484         realized = COLOR_SetMapping(palPtr, dc->w.hPalette != hPrimaryPalette
 485                                   || dc->w.hPalette == STOCK_DEFAULT_PALETTE );
 486         hLastRealizedPalette = dc->w.hPalette;
 487     }
 488     else dprintf_palette(stddeb, " skipping ");
 489
 490     dprintf_palette(stdnimp, " realized %i colors\n", realized );
 491     return (UINT16)realized;
 492 }
 493
 494
 495 /***********************************************************************
 496  *           RealizeDefaultPalette    (GDI.365)
 497  */
 498 UINT16 RealizeDefaultPalette( HDC16 hdc )
 499 {
 500     DC          *dc;
 501     PALETTEOBJ*  palPtr;
 502     int          i, index, realized = 0;
 503
 504     dprintf_palette(stddeb,"RealizeDefaultPalette: %04x\n", hdc );
 505
 506     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 507     if (!dc)
 508     {
 509         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 510         if (!dc) return 0;
 511     }
 512
 513     if ( dc->w.flags & DC_MEMORY ) return 0;
 514
 515     hPrimaryPalette = STOCK_DEFAULT_PALETTE;
 516     hLastRealizedPalette = STOCK_DEFAULT_PALETTE;
 517
 518     palPtr = (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 519
 520     /* lookup is needed to account for SetSystemPaletteUse() stuff */
 521
 522     for( i = 0; i < 20; i++ )
 523        {
 524          index = COLOR_LookupSystemPixel(*(COLORREF*)(palPtr->logpalette.palPalEntry + i));
 525
 526          /* mapping is allocated in COLOR_InitPalette() */
 527
 528          if( index != palPtr->mapping[i] ) { palPtr->mapping[i]=index; realized++; }
 529        }
 530     return realized;
 531 }
 532
 533 /***********************************************************************
 534  *           IsDCCurrentPalette   (GDI.412)
 535  */
 536 BOOL16 IsDCCurrentPalette(HDC16 hDC)
 537 {
 538     DC* dc = (DC *)GDI_GetObjPtr( hDC, DC_MAGIC );
 539     return (dc)?(dc->w.hPalette == hPrimaryPalette):FALSE;
 540 }
 541
 542
 543 /***********************************************************************
 544  *           SelectPalette16    (USER.282)
 545  */
 546 HPALETTE16 SelectPalette16( HDC16 hDC, HPALETTE16 hPal,
 547                             BOOL16 bForceBackground )
 548 {
 549     return SelectPalette32( hDC, hPal, bForceBackground );
 550 }
 551
 552
 553 /***********************************************************************
 554  *           SelectPalette32    (GDI32.300)
 555  */
 556 HPALETTE32 SelectPalette32( HDC32 hDC, HPALETTE32 hPal,
 557                             BOOL32 bForceBackground )
 558 {
 559     WORD        wBkgPalette = 1;
 560     PALETTEOBJ* lpt = (PALETTEOBJ*) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 561
 562     dprintf_palette(stddeb,"SelectPalette: dc %04x pal %04x, force=%i ",
 563                             hDC, hPal, bForceBackground);
 564     if( !lpt ) return 0;
 565
 566     dprintf_palette(stddeb," entries = %d\n",
 567                             lpt->logpalette.palNumEntries);
 568
 569     if( hPal != STOCK_DEFAULT_PALETTE )
 570     {
 571         HWND32 hWnd = WindowFromDC32( hDC );
 572         HWND32 hActive = GetActiveWindow32();
 573
 574         /* set primary palette if it's related to current active */
 575
 576         if((!hWnd || (hActive == hWnd || IsChild16(hActive,hWnd))) &&
 577             !bForceBackground )
 578             wBkgPalette = 0;
 579     }
 580     return GDISelectPalette( hDC, hPal, wBkgPalette);
 581 }
 582
 583
 584 /***********************************************************************
 585  *           RealizePalette16    (USER.283)
 586  */
 587 UINT16 RealizePalette16( HDC16 hDC )
 588 {
 589     return RealizePalette32( hDC );
 590 }
 591
 592
 593 /***********************************************************************
 594  *           RealizePalette32    (GDI32.280)
 595  */
 596 UINT32 RealizePalette32( HDC32 hDC )
 597 {
 598     UINT32 realized = GDIRealizePalette( hDC );
 599
 600     /* do not send anything if no colors were changed */
 601
 602     if( IsDCCurrentPalette( hDC ) && realized &&
 603         !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
 604     {
 605         /* Send palette change notification */
 606
 607         HWND32 hWnd;
 608         if( (hWnd = WindowFromDC32( hDC )) )
 609             SendMessage16( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L);
 610     }
 611     return realized;
 612 }
 613
 614
 615 /**********************************************************************
 616  *            UpdateColors16   (GDI.366)
 617  */
 618 INT16 UpdateColors16( HDC16 hDC )
 619 {
 620     HWND32 hWnd = WindowFromDC32( hDC );
 621
 622     /* Docs say that we have to remap current drawable pixel by pixel
 623      * but it would take forever given the speed of XGet/PutPixel.
 624      */
 625     if (hWnd && !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
 626         InvalidateRect32( hWnd, NULL, FALSE );
 627     return 0x666;
 628 }
 629
 630
 631 /**********************************************************************
 632  *            UpdateColors32   (GDI32.359)
 633  */
 634 BOOL32 UpdateColors32( HDC32 hDC )
 635 {
 636     UpdateColors16( hDC );
 637     return TRUE;
 638 }