dlls/win32u/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 #if 0
  27 #pragma makedep unix
  28 #endif
  29
  30 #include "ntgdi_private.h"
  31 #include "ntuser_private.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(palette);
  35
  36 typedef BOOL (CDECL *unrealize_function)(HPALETTE);
  37
  38 typedef struct tagPALETTEOBJ
  39 {
  40     struct gdi_obj_header obj;
  41     unrealize_function    unrealize;
  42     WORD                  version;    /* palette version */
  43     WORD                  count;      /* count of palette entries */
  44     PALETTEENTRY         *entries;
  45 } PALETTEOBJ;
  46
  47 static INT PALETTE_GetObject( HGDIOBJ handle, INT count, LPVOID buffer );
  48 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle );
  49 static BOOL PALETTE_DeleteObject( HGDIOBJ handle );
  50
  51 static const struct gdi_obj_funcs palette_funcs =
  52 {
  53     PALETTE_GetObject,        /* pGetObjectW */
  54     PALETTE_UnrealizeObject,  /* pUnrealizeObject */
  55     PALETTE_DeleteObject      /* pDeleteObject */
  56 };
  57
  58 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  59
  60 static HPALETTE hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  61 static HPALETTE hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  62
  63
  64 /***********************************************************************
  65  *           PALETTE_Init
  66  *
  67  * Create the system palette.
  68  */
  69 HPALETTE PALETTE_Init(void)
  70 {
  71     const RGBQUAD *entries = get_default_color_table( 8 );
  72     char buffer[FIELD_OFFSET( LOGPALETTE, palPalEntry[20] )];
  73     LOGPALETTE *palPtr = (LOGPALETTE *)buffer;
  74     int i;
  75
  76     /* create default palette (20 system colors) */
  77
  78     palPtr->palVersion = 0x300;
  79     palPtr->palNumEntries = 20;
  80     for (i = 0; i < 20; i++)
  81     {
  82         palPtr->palPalEntry[i].peRed   = entries[i < 10 ? i : 236 + i].rgbRed;
  83         palPtr->palPalEntry[i].peGreen = entries[i < 10 ? i : 236 + i].rgbGreen;
  84         palPtr->palPalEntry[i].peBlue  = entries[i < 10 ? i : 236 + i].rgbBlue;
  85         palPtr->palPalEntry[i].peFlags = 0;
  86     }
  87     return NtGdiCreatePaletteInternal( palPtr, palPtr->palNumEntries );
  88 }
  89
  90
  91 /***********************************************************************
  92  *           NtGdiCreatePaletteInternal    (win32u.@)
  93  *
  94  * Creates a logical color palette.
  95  */
  96 HPALETTE WINAPI NtGdiCreatePaletteInternal( const LOGPALETTE *palette, UINT count )
  97 {
  98     PALETTEOBJ * palettePtr;
  99     HPALETTE hpalette;
 100     int size;
 101
 102     if (!palette) return 0;
 103     TRACE( "entries=%u\n", count );
 104
 105     if (!(palettePtr = malloc( sizeof(*palettePtr) ))) return 0;
 106     palettePtr->unrealize = NULL;
 107     palettePtr->version = palette->palVersion;
 108     palettePtr->count   = count;
 109     size = palettePtr->count * sizeof(*palettePtr->entries);
 110     if (!(palettePtr->entries = malloc( size )))
 111     {
 112         free( palettePtr );
 113         return 0;
 114     }
 115     memcpy( palettePtr->entries, palette->palPalEntry, size );
 116     if (!(hpalette = alloc_gdi_handle( &palettePtr->obj, NTGDI_OBJ_PAL, &palette_funcs )))
 117     {
 118         free( palettePtr->entries );
 119         free( palettePtr );
 120     }
 121     TRACE("   returning %p\n", hpalette);
 122     return hpalette;
 123 }
 124
 125
 126 /***********************************************************************
 127  *           NtGdiCreateHalftonePalette    (win32u.@)
 128  *
 129  * Creates a halftone palette.
 130  *
 131  * RETURNS
 132  *    Success: Handle to logical halftone palette
 133  *    Failure: 0
 134  *
 135  * FIXME: This simply creates the halftone palette derived from running
 136  *        tests on a windows NT machine. This is assuming a color depth
 137  *        of greater that 256 color. On a 256 color device the halftone
 138  *        palette will be different and this function will be incorrect
 139  */
 140 HPALETTE WINAPI NtGdiCreateHalftonePalette( HDC hdc )
 141 {
 142     const RGBQUAD *entries = get_default_color_table( 8 );
 143     char buffer[FIELD_OFFSET( LOGPALETTE, palPalEntry[256] )];
 144     LOGPALETTE *pal = (LOGPALETTE *)buffer;
 145     int i;
 146
 147     pal->palVersion = 0x300;
 148     pal->palNumEntries = 256;
 149     for (i = 0; i < 256; i++)
 150     {
 151         pal->palPalEntry[i].peRed   = entries[i].rgbRed;
 152         pal->palPalEntry[i].peGreen = entries[i].rgbGreen;
 153         pal->palPalEntry[i].peBlue  = entries[i].rgbBlue;
 154         pal->palPalEntry[i].peFlags = 0;
 155     }
 156     return NtGdiCreatePaletteInternal( pal, pal->palNumEntries );
 157 }
 158
 159
 160 UINT get_palette_entries( HPALETTE hpalette, UINT start, UINT count, PALETTEENTRY *entries )
 161 {
 162     PALETTEOBJ * palPtr;
 163     UINT numEntries;
 164
 165     TRACE("hpal = %p, count=%i\n", hpalette, count );
 166
 167     palPtr = GDI_GetObjPtr( hpalette, NTGDI_OBJ_PAL );
 168     if (!palPtr) return 0;
 169
 170     /* NOTE: not documented but test show this to be the case */
 171     if (count == 0)
 172     {
 173         count = palPtr->count;
 174     }
 175     else
 176     {
 177         numEntries = palPtr->count;
 178         if (start+count > numEntries) count = numEntries - start;
 179         if (entries)
 180         {
 181             if (start >= numEntries) count = 0;
 182             else memcpy( entries, &palPtr->entries[start], count * sizeof(PALETTEENTRY) );
 183         }
 184     }
 185
 186     GDI_ReleaseObj( hpalette );
 187     return count;
 188 }
 189
 190
 191 static UINT set_palette_entries( HPALETTE hpalette, UINT start, UINT count,
 192                                  const PALETTEENTRY *entries )
 193 {
 194     PALETTEOBJ * palPtr;
 195     UINT numEntries;
 196
 197     TRACE("hpal=%p,start=%i,count=%i\n",hpalette,start,count );
 198
 199     if (hpalette == GetStockObject(DEFAULT_PALETTE)) return 0;
 200     palPtr = GDI_GetObjPtr( hpalette, NTGDI_OBJ_PAL );
 201     if (!palPtr) return 0;
 202
 203     numEntries = palPtr->count;
 204     if (start >= numEntries)
 205     {
 206       GDI_ReleaseObj( hpalette );
 207       return 0;
 208     }
 209     if (start+count > numEntries) count = numEntries - start;
 210     memcpy( &palPtr->entries[start], entries, count * sizeof(PALETTEENTRY) );
 211     GDI_ReleaseObj( hpalette );
 212     NtGdiUnrealizeObject( hpalette );
 213     return count;
 214 }
 215
 216
 217 /***********************************************************************
 218  *           NtGdiResizePalette    (win32u.@)
 219  *
 220  * Resizes logical palette.
 221  */
 222 BOOL WINAPI NtGdiResizePalette( HPALETTE hPal, UINT count )
 223 {
 224     PALETTEOBJ * palPtr = GDI_GetObjPtr( hPal, NTGDI_OBJ_PAL );
 225     PALETTEENTRY *entries;
 226
 227     if( !palPtr ) return FALSE;
 228     TRACE("hpal = %p, prev = %i, new = %i\n", hPal, palPtr->count, count );
 229
 230     if (!(entries = realloc( palPtr->entries, count * sizeof(*palPtr->entries) )))
 231     {
 232         GDI_ReleaseObj( hPal );
 233         return FALSE;
 234     }
 235     if (count > palPtr->count)
 236         memset( entries + palPtr->count, 0, (count - palPtr->count) * sizeof(*palPtr->entries) );
 237     palPtr->entries = entries;
 238     palPtr->count = count;
 239
 240     GDI_ReleaseObj( hPal );
 241     PALETTE_UnrealizeObject( hPal );
 242     return TRUE;
 243 }
 244
 245
 246 /* Replaces entries in logical palette. */
 247 static BOOL animate_palette( HPALETTE hPal, UINT StartIndex, UINT NumEntries,
 248                              const PALETTEENTRY *PaletteColors )
 249 {
 250     TRACE("%p (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
 251
 252     if( hPal != GetStockObject(DEFAULT_PALETTE) )
 253     {
 254         PALETTEOBJ * palPtr;
 255         UINT pal_entries;
 256         const PALETTEENTRY *pptr = PaletteColors;
 257
 258         palPtr = GDI_GetObjPtr( hPal, NTGDI_OBJ_PAL );
 259         if (!palPtr) return FALSE;
 260
 261         pal_entries = palPtr->count;
 262         if (StartIndex >= pal_entries)
 263         {
 264           GDI_ReleaseObj( hPal );
 265           return FALSE;
 266         }
 267         if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
 268
 269         for (NumEntries += StartIndex; StartIndex < NumEntries; StartIndex++, pptr++) {
 270           /* According to MSDN, only animate PC_RESERVED colours */
 271           if (palPtr->entries[StartIndex].peFlags & PC_RESERVED) {
 272             TRACE("Animating colour (%d,%d,%d) to (%d,%d,%d)\n",
 273               palPtr->entries[StartIndex].peRed,
 274               palPtr->entries[StartIndex].peGreen,
 275               palPtr->entries[StartIndex].peBlue,
 276               pptr->peRed, pptr->peGreen, pptr->peBlue);
 277             palPtr->entries[StartIndex] = *pptr;
 278           } else {
 279             TRACE("Not animating entry %d -- not PC_RESERVED\n", StartIndex);
 280           }
 281         }
 282         GDI_ReleaseObj( hPal );
 283         /* FIXME: check for palette selected in active window */
 284     }
 285     return TRUE;
 286 }
 287
 288
 289 /***********************************************************************
 290  *           SetSystemPaletteUse    (win32u.@)
 291  *
 292  * Specify whether the system palette contains 2 or 20 static colors.
 293  *
 294  * RETURNS
 295  *    Success: Previous system palette
 296  *    Failure: SYSPAL_ERROR
 297  */
 298 UINT WINAPI NtGdiSetSystemPaletteUse( HDC hdc, UINT use )
 299 {
 300     UINT old = SystemPaletteUse;
 301
 302     /* Device doesn't support colour palettes */
 303     if (!(NtGdiGetDeviceCaps( hdc, RASTERCAPS ) & RC_PALETTE))
 304         return SYSPAL_ERROR;
 305
 306     switch (use) {
 307         case SYSPAL_NOSTATIC:
 308         case SYSPAL_NOSTATIC256:        /* WINVER >= 0x0500 */
 309         case SYSPAL_STATIC:
 310             SystemPaletteUse = use;
 311             return old;
 312         default:
 313             return SYSPAL_ERROR;
 314     }
 315 }
 316
 317
 318 /***********************************************************************
 319  *           NtGdiGetSystemPaletteUse    (win32u.@)
 320  *
 321  * Gets state of system palette.
 322  */
 323 UINT WINAPI NtGdiGetSystemPaletteUse( HDC hdc )
 324 {
 325     return SystemPaletteUse;
 326 }
 327
 328
 329 static UINT get_system_palette_entries( HDC hdc, UINT start, UINT count, PALETTEENTRY *entries )
 330 {
 331     UINT ret = 0;
 332     DC *dc;
 333
 334     TRACE( "hdc=%p,start=%i,count=%i\n", hdc, start, count );
 335
 336     if ((dc = get_dc_ptr( hdc )))
 337     {
 338         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetSystemPaletteEntries );
 339         ret = physdev->funcs->pGetSystemPaletteEntries( physdev, start, count, entries );
 340         release_dc_ptr( dc );
 341     }
 342     return ret;
 343 }
 344
 345
 346 /* null driver fallback implementation for GetSystemPaletteEntries */
 347 UINT CDECL nulldrv_GetSystemPaletteEntries( PHYSDEV dev, UINT start, UINT count, PALETTEENTRY *entries )
 348 {
 349     return 0;
 350 }
 351
 352 /***********************************************************************
 353  *           NtGdiGetNearestPaletteIndex    (win32u.@)
 354  *
 355  * Gets palette index for color.
 356  *
 357  * NOTES
 358  *    Should index be initialized to CLR_INVALID instead of 0?
 359  *
 360  * RETURNS
 361  *    Success: Index of entry in logical palette
 362  *    Failure: CLR_INVALID
 363  */
 364 UINT WINAPI NtGdiGetNearestPaletteIndex( HPALETTE hpalette, COLORREF color )
 365 {
 366     PALETTEOBJ* palObj = GDI_GetObjPtr( hpalette, NTGDI_OBJ_PAL );
 367     UINT index  = 0;
 368
 369     if( palObj )
 370     {
 371         int i, diff = 0x7fffffff;
 372         int r,g,b;
 373         PALETTEENTRY* entry = palObj->entries;
 374
 375         for( i = 0; i < palObj->count && diff ; i++, entry++)
 376         {
 377             r = entry->peRed - GetRValue(color);
 378             g = entry->peGreen - GetGValue(color);
 379             b = entry->peBlue - GetBValue(color);
 380
 381             r = r*r + g*g + b*b;
 382
 383             if( r < diff ) { index = i; diff = r; }
 384         }
 385         GDI_ReleaseObj( hpalette );
 386     }
 387     TRACE("(%p,%s): returning %d\n", hpalette, debugstr_color(color), index );
 388     return index;
 389 }
 390
 391
 392 /* null driver fallback implementation for GetNearestColor */
 393 COLORREF CDECL nulldrv_GetNearestColor( PHYSDEV dev, COLORREF color )
 394 {
 395     unsigned char spec_type;
 396     DC *dc = get_nulldrv_dc( dev );
 397
 398     if (!(NtGdiGetDeviceCaps( dev->hdc, RASTERCAPS ) & RC_PALETTE)) return color;
 399
 400     spec_type = color >> 24;
 401     if (spec_type == 1 || spec_type == 2)
 402     {
 403         /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
 404         UINT index;
 405         PALETTEENTRY entry;
 406         HPALETTE hpal = dc->hPalette;
 407
 408         if (!hpal) hpal = GetStockObject( DEFAULT_PALETTE );
 409         if (spec_type == 2) /* PALETTERGB */
 410             index = NtGdiGetNearestPaletteIndex( hpal, color );
 411         else  /* PALETTEINDEX */
 412             index = LOWORD(color);
 413
 414         if (!get_palette_entries( hpal, index, 1, &entry ))
 415         {
 416             WARN("%s: idx %d is out of bounds, assuming NULL\n", debugstr_color(color), index );
 417             if (!get_palette_entries( hpal, 0, 1, &entry )) return CLR_INVALID;
 418         }
 419         color = RGB( entry.peRed, entry.peGreen, entry.peBlue );
 420     }
 421     return color & 0x00ffffff;
 422 }
 423
 424
 425 /***********************************************************************
 426  *           NtGdiGetNearestColor    (win32u.@)
 427  *
 428  * Gets a system color to match.
 429  *
 430  * RETURNS
 431  *    Success: Color from system palette that corresponds to given color
 432  *    Failure: CLR_INVALID
 433  */
 434 COLORREF WINAPI NtGdiGetNearestColor( HDC hdc, COLORREF color )
 435 {
 436     COLORREF nearest = CLR_INVALID;
 437     DC *dc;
 438
 439     if ((dc = get_dc_ptr( hdc )))
 440     {
 441         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetNearestColor );
 442         nearest = physdev->funcs->pGetNearestColor( physdev, color );
 443         release_dc_ptr( dc );
 444     }
 445     return nearest;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           PALETTE_GetObject
 451  */
 452 static INT PALETTE_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
 453 {
 454     PALETTEOBJ *palette = GDI_GetObjPtr( handle, NTGDI_OBJ_PAL );
 455
 456     if (!palette) return 0;
 457
 458     if (buffer)
 459     {
 460         if (count > sizeof(WORD)) count = sizeof(WORD);
 461         memcpy( buffer, &palette->count, count );
 462     }
 463     else count = sizeof(WORD);
 464     GDI_ReleaseObj( handle );
 465     return count;
 466 }
 467
 468
 469 /***********************************************************************
 470  *           PALETTE_UnrealizeObject
 471  */
 472 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle )
 473 {
 474     PALETTEOBJ *palette = GDI_GetObjPtr( handle, NTGDI_OBJ_PAL );
 475
 476     if (palette)
 477     {
 478         unrealize_function unrealize = palette->unrealize;
 479         palette->unrealize = NULL;
 480         GDI_ReleaseObj( handle );
 481         if (unrealize) unrealize( handle );
 482     }
 483
 484     if (InterlockedCompareExchangePointer( (void **)&hLastRealizedPalette, 0, handle ) == handle)
 485         TRACE("unrealizing palette %p\n", handle);
 486
 487     return TRUE;
 488 }
 489
 490
 491 /***********************************************************************
 492  *           PALETTE_DeleteObject
 493  */
 494 static BOOL PALETTE_DeleteObject( HGDIOBJ handle )
 495 {
 496     PALETTEOBJ *obj;
 497
 498     PALETTE_UnrealizeObject( handle );
 499     if (!(obj = free_gdi_handle( handle ))) return FALSE;
 500     free( obj->entries );
 501     free( obj );
 502     return TRUE;
 503 }
 504
 505
 506 /***********************************************************************
 507  *           NtUserSelectPalette    (win32u.@)
 508  */
 509 HPALETTE WINAPI NtUserSelectPalette( HDC hdc, HPALETTE hpal, WORD bkg )
 510 {
 511     BOOL is_primary = FALSE;
 512     HPALETTE ret = 0;
 513     DC *dc;
 514
 515     TRACE("%p %p\n", hdc, hpal );
 516
 517     if (!bkg && hpal != GetStockObject( DEFAULT_PALETTE ))
 518     {
 519         HWND hwnd = NtUserWindowFromDC( hdc );
 520         if (hwnd)
 521         {
 522             /* set primary palette if it's related to current active */
 523             HWND foreground = NtUserGetForegroundWindow();
 524             is_primary = foreground == hwnd || is_child( foreground, hwnd );
 525         }
 526     }
 527
 528     if (get_gdi_object_type(hpal) != NTGDI_OBJ_PAL)
 529     {
 530       WARN("invalid selected palette %p\n",hpal);
 531       return 0;
 532     }
 533     if ((dc = get_dc_ptr( hdc )))
 534     {
 535         ret = dc->hPalette;
 536         dc->hPalette = hpal;
 537         if (is_primary) hPrimaryPalette = hpal;
 538         release_dc_ptr( dc );
 539     }
 540     return ret;
 541 }
 542
 543
 544 /***********************************************************************
 545  *           realize_palette
 546  */
 547 UINT realize_palette( HDC hdc )
 548 {
 549     BOOL is_primary = FALSE;
 550     UINT realized = 0;
 551     DC* dc = get_dc_ptr( hdc );
 552
 553     TRACE( "%p\n", hdc );
 554     if (!dc) return 0;
 555
 556     /* FIXME: move primary palette handling from user32 */
 557
 558     if( dc->hPalette == GetStockObject( DEFAULT_PALETTE ))
 559     {
 560         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizeDefaultPalette );
 561         realized = physdev->funcs->pRealizeDefaultPalette( physdev );
 562     }
 563     else if (InterlockedExchangePointer( (void **)&hLastRealizedPalette, dc->hPalette ) != dc->hPalette)
 564     {
 565         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizePalette );
 566         PALETTEOBJ *palPtr = GDI_GetObjPtr( dc->hPalette, NTGDI_OBJ_PAL );
 567         if (palPtr)
 568         {
 569             realized = physdev->funcs->pRealizePalette( physdev, dc->hPalette,
 570                                                         (dc->hPalette == hPrimaryPalette) );
 571             palPtr->unrealize = physdev->funcs->pUnrealizePalette;
 572             GDI_ReleaseObj( dc->hPalette );
 573             is_primary = dc->hPalette == hPrimaryPalette;
 574         }
 575     }
 576     else TRACE("  skipping (hLastRealizedPalette = %p)\n", hLastRealizedPalette);
 577
 578     release_dc_ptr( dc );
 579     TRACE("   realized %i colors.\n", realized );
 580
 581     /* do not send anything if no colors were changed */
 582     if (realized && is_primary)
 583     {
 584         /* send palette change notification */
 585         HWND hwnd = NtUserWindowFromDC( hdc );
 586         if (hwnd) send_message_timeout( HWND_BROADCAST, WM_PALETTECHANGED, HandleToUlong(hwnd), 0,
 587                                         SMTO_ABORTIFHUNG, 2000, FALSE );
 588     }
 589     return realized;
 590 }
 591
 592
 593 /**********************************************************************
 594  *           NtGdiUpdateColors    (win32u.@)
 595  *
 596  * Remaps current colors to logical palette.
 597  */
 598 BOOL WINAPI NtGdiUpdateColors( HDC hDC )
 599 {
 600     int size = NtGdiGetDeviceCaps( hDC, SIZEPALETTE );
 601     HWND hwnd;
 602
 603     if (!size) return FALSE;
 604
 605     hwnd = NtUserWindowFromDC( hDC );
 606
 607     /* Docs say that we have to remap current drawable pixel by pixel
 608      * but it would take forever given the speed of XGet/PutPixel.
 609      */
 610     if (hwnd && size) NtUserRedrawWindow( hwnd, NULL, 0, RDW_INVALIDATE );
 611     return TRUE;
 612 }
 613
 614 /*********************************************************************
 615  *           NtGdiSetMagicColors   (win32u.@)
 616  */
 617 BOOL WINAPI NtGdiSetMagicColors( HDC hdc, DWORD magic, ULONG index )
 618 {
 619     FIXME( "(%p 0x%08x 0x%08x): stub\n", hdc, (int)magic, (int)index );
 620     return TRUE;
 621 }
 622
 623 /*********************************************************************
 624  *           NtGdiDoPalette   (win32u.@)
 625  */
 626 LONG WINAPI NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries,
 627                             DWORD func, BOOL inbound )
 628 {
 629     switch (func)
 630     {
 631     case NtGdiAnimatePalette:
 632         return animate_palette( handle, start, count, entries );
 633     case NtGdiSetPaletteEntries:
 634         return set_palette_entries( handle, start, count, entries );
 635     case NtGdiGetPaletteEntries:
 636         return get_palette_entries( handle, start, count, entries );
 637     case NtGdiGetSystemPaletteEntries:
 638         return get_system_palette_entries( handle, start, count, entries );
 639     case NtGdiSetDIBColorTable:
 640         return set_dib_dc_color_table( handle, start, count, entries );
 641     case NtGdiGetDIBColorTable:
 642         return get_dib_dc_color_table( handle, start, count, entries );
 643     default:
 644         WARN( "invalid func %u\n", (int)func );
 645         return 0;
 646     }
 647 }