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  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 <stdlib.h>
  27 #include <string.h>
  28
  29 #include "winbase.h"
  30 #include "windef.h"
  31 #include "wingdi.h"
  32 #include "wine/winuser16.h"
  33 #include "gdi.h"
  34 #include "color.h"
  35 #include "palette.h"
  36 #include "wine/debug.h"
  37 #include "winerror.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(palette);
  40
  41 PALETTE_DRIVER *PALETTE_Driver = NULL;
  42
  43 /* Pointers to USER implementation of SelectPalette/RealizePalette */
  44 /* they will be patched by USER on startup */
  45 FARPROC pfnSelectPalette = NULL;
  46 FARPROC pfnRealizePalette = NULL;
  47
  48 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
  49
  50 static HPALETTE16 hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  51 static HPALETTE16 hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  52
  53
  54 /***********************************************************************
  55  *           PALETTE_Init
  56  *
  57  * Create the system palette.
  58  */
  59 HPALETTE16 PALETTE_Init(void)
  60 {
  61     int                 i;
  62     HPALETTE16          hpalette;
  63     LOGPALETTE *        palPtr;
  64     PALETTEOBJ*         palObj;
  65     const PALETTEENTRY* __sysPalTemplate = COLOR_GetSystemPaletteTemplate();
  66
  67     /* create default palette (20 system colors) */
  68
  69     palPtr = HeapAlloc( GetProcessHeap(), 0,
  70              sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY));
  71     if (!palPtr) return FALSE;
  72
  73     palPtr->palVersion = 0x300;
  74     palPtr->palNumEntries = NB_RESERVED_COLORS;
  75     for( i = 0; i < NB_RESERVED_COLORS; i ++ )
  76     {
  77         palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
  78         palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
  79         palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
  80         palPtr->palPalEntry[i].peFlags = 0;
  81     }
  82     hpalette = CreatePalette16( palPtr );
  83     HeapFree( GetProcessHeap(), 0, palPtr );
  84
  85     palObj = (PALETTEOBJ*) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  86     if (palObj)
  87     {
  88         if (!(palObj->mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(int) * 20 )))
  89             ERR("Can not create palette mapping -- out of memory!\n");
  90         GDI_ReleaseObj( hpalette );
  91     }
  92     return hpalette;
  93 }
  94
  95 /***********************************************************************
  96  *           PALETTE_ValidateFlags
  97  */
  98 void PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, int size)
  99 {
 100     int i = 0;
 101     for( ; i<size ; i++ )
 102         lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
 103 }
 104
 105
 106 /***********************************************************************
 107  *           CreatePalette    (GDI.360)
 108  */
 109 HPALETTE16 WINAPI CreatePalette16( const LOGPALETTE* palette )
 110 {
 111     return CreatePalette( palette );
 112 }
 113
 114
 115 /***********************************************************************
 116  * CreatePalette [GDI32.@]  Creates a logical color palette
 117  *
 118  * RETURNS
 119  *    Success: Handle to logical palette
 120  *    Failure: NULL
 121  */
 122 HPALETTE WINAPI CreatePalette(
 123     const LOGPALETTE* palette) /* [in] Pointer to logical color palette */
 124 {
 125     PALETTEOBJ * palettePtr;
 126     HPALETTE hpalette;
 127     int size;
 128
 129     if (!palette) return 0;
 130     TRACE("entries=%i\n", palette->palNumEntries);
 131
 132     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
 133
 134     if (!(palettePtr = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR),
 135                                         PALETTE_MAGIC, &hpalette ))) return 0;
 136     memcpy( &palettePtr->logpalette, palette, size );
 137     PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
 138                           palettePtr->logpalette.palNumEntries);
 139     palettePtr->mapping = NULL;
 140     GDI_ReleaseObj( hpalette );
 141
 142     TRACE("   returning %04x\n", hpalette);
 143     return hpalette;
 144 }
 145
 146
 147 /***********************************************************************
 148  * CreateHalftonePalette [GDI.529]  Creates a halftone palette
 149  *
 150  * RETURNS
 151  *    Success: Handle to logical halftone palette
 152  *    Failure: 0
 153  */
 154 HPALETTE16 WINAPI CreateHalftonePalette16(
 155     HDC16 hdc) /* [in] Handle to device context */
 156 {
 157     return CreateHalftonePalette(hdc);
 158 }
 159
 160
 161 /***********************************************************************
 162  * CreateHalftonePalette [GDI32.@]  Creates a halftone palette
 163  *
 164  * RETURNS
 165  *    Success: Handle to logical halftone palette
 166  *    Failure: 0
 167  *
 168  * FIXME: This simply creates the halftone palette dirived from runing
 169  *        tests on an windows NT machine. this is assuming a color depth
 170  *        of greater that 256 color. On a 256 color device the halftone
 171  *        palette will be differnt and this funtion will be incorrect
 172  */
 173 HPALETTE WINAPI CreateHalftonePalette(
 174     HDC hdc) /* [in] Handle to device context */
 175 {
 176     int i;
 177     struct {
 178         WORD Version;
 179         WORD NumberOfEntries;
 180         PALETTEENTRY aEntries[256];
 181     } Palette;
 182
 183     Palette.Version = 0x300;
 184     Palette.NumberOfEntries = 256;
 185     GetSystemPaletteEntries(hdc, 0, 256, Palette.aEntries);
 186
 187     Palette.NumberOfEntries = 20;
 188
 189     for (i = 0; i < Palette.NumberOfEntries; i++)
 190     {
 191         Palette.aEntries[i].peRed=0xff;
 192         Palette.aEntries[i].peGreen=0xff;
 193         Palette.aEntries[i].peBlue=0xff;
 194         Palette.aEntries[i].peFlags=0x00;
 195     }
 196
 197     Palette.aEntries[0].peRed=0x00;
 198     Palette.aEntries[0].peBlue=0x00;
 199     Palette.aEntries[0].peGreen=0x00;
 200
 201     /* the first 6 */
 202     for (i=1; i <= 6; i++)
 203     {
 204         Palette.aEntries[i].peRed=(i%2)?0x80:0;
 205         Palette.aEntries[i].peGreen=(i==2)?0x80:(i==3)?0x80:(i==6)?0x80:0;
 206         Palette.aEntries[i].peBlue=(i>3)?0x80:0;
 207     }
 208
 209     for (i=7;  i <= 12; i++)
 210     {
 211         switch(i)
 212         {
 213             case 7:
 214                 Palette.aEntries[i].peRed=0xc0;
 215                 Palette.aEntries[i].peBlue=0xc0;
 216                 Palette.aEntries[i].peGreen=0xc0;
 217                 break;
 218             case 8:
 219                 Palette.aEntries[i].peRed=0xc0;
 220                 Palette.aEntries[i].peGreen=0xdc;
 221                 Palette.aEntries[i].peBlue=0xc0;
 222                 break;
 223             case 9:
 224                 Palette.aEntries[i].peRed=0xa6;
 225                 Palette.aEntries[i].peGreen=0xca;
 226                 Palette.aEntries[i].peBlue=0xf0;
 227                 break;
 228             case 10:
 229                 Palette.aEntries[i].peRed=0xff;
 230                 Palette.aEntries[i].peGreen=0xfb;
 231                 Palette.aEntries[i].peBlue=0xf0;
 232                 break;
 233             case 11:
 234                 Palette.aEntries[i].peRed=0xa0;
 235                 Palette.aEntries[i].peGreen=0xa0;
 236                 Palette.aEntries[i].peBlue=0xa4;
 237                 break;
 238             case 12:
 239                 Palette.aEntries[i].peRed=0x80;
 240                 Palette.aEntries[i].peGreen=0x80;
 241                 Palette.aEntries[i].peBlue=0x80;
 242         }
 243     }
 244
 245    for (i=13; i <= 18; i++)
 246     {
 247         Palette.aEntries[i].peRed=(i%2)?0xff:0;
 248         Palette.aEntries[i].peGreen=(i==14)?0xff:(i==15)?0xff:(i==18)?0xff:0;
 249         Palette.aEntries[i].peBlue=(i>15)?0xff:0x00;
 250     }
 251
 252     return CreatePalette((LOGPALETTE *)&Palette);
 253 }
 254
 255
 256 /***********************************************************************
 257  *           GetPaletteEntries    (GDI.363)
 258  */
 259 UINT16 WINAPI GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
 260                                    UINT16 count, LPPALETTEENTRY entries )
 261 {
 262     return GetPaletteEntries( hpalette, start, count, entries );
 263 }
 264
 265
 266 /***********************************************************************
 267  * GetPaletteEntries [GDI32.@]  Retrieves palette entries
 268  *
 269  * RETURNS
 270  *    Success: Number of entries from logical palette
 271  *    Failure: 0
 272  */
 273 UINT WINAPI GetPaletteEntries(
 274     HPALETTE hpalette,    /* [in]  Handle of logical palette */
 275     UINT start,           /* [in]  First entry to receive */
 276     UINT count,           /* [in]  Number of entries to receive */
 277     LPPALETTEENTRY entries) /* [out] Address of array receiving entries */
 278 {
 279     PALETTEOBJ * palPtr;
 280     UINT numEntries;
 281
 282     TRACE("hpal = %04x, count=%i\n", hpalette, count );
 283
 284     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 285     if (!palPtr) return 0;
 286
 287     /* NOTE: not documented but test show this to be the case */
 288     if (count == 0)
 289     {
 290         int rc = palPtr->logpalette.palNumEntries;
 291             GDI_ReleaseObj( hpalette );
 292         return rc;
 293     }
 294
 295     numEntries = palPtr->logpalette.palNumEntries;
 296     if (start+count > numEntries) count = numEntries - start;
 297     if (entries)
 298     {
 299       if (start >= numEntries)
 300       {
 301         GDI_ReleaseObj( hpalette );
 302         return 0;
 303       }
 304       memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 305               count * sizeof(PALETTEENTRY) );
 306       for( numEntries = 0; numEntries < count ; numEntries++ )
 307            if (entries[numEntries].peFlags & 0xF0)
 308                entries[numEntries].peFlags = 0;
 309     }
 310
 311     GDI_ReleaseObj( hpalette );
 312     return count;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           SetPaletteEntries    (GDI.364)
 318  */
 319 UINT16 WINAPI SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start,
 320                                    UINT16 count, LPPALETTEENTRY entries )
 321 {
 322     return SetPaletteEntries( hpalette, start, count, entries );
 323 }
 324
 325
 326 /***********************************************************************
 327  * SetPaletteEntries [GDI32.@]  Sets color values for range in palette
 328  *
 329  * RETURNS
 330  *    Success: Number of entries that were set
 331  *    Failure: 0
 332  */
 333 UINT WINAPI SetPaletteEntries(
 334     HPALETTE hpalette,    /* [in] Handle of logical palette */
 335     UINT start,           /* [in] Index of first entry to set */
 336     UINT count,           /* [in] Number of entries to set */
 337     LPPALETTEENTRY entries) /* [in] Address of array of structures */
 338 {
 339     PALETTEOBJ * palPtr;
 340     UINT numEntries;
 341
 342     TRACE("hpal=%04x,start=%i,count=%i\n",hpalette,start,count );
 343
 344     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 345     if (!palPtr) return 0;
 346
 347     numEntries = palPtr->logpalette.palNumEntries;
 348     if (start >= numEntries)
 349     {
 350       GDI_ReleaseObj( hpalette );
 351       return 0;
 352     }
 353     if (start+count > numEntries) count = numEntries - start;
 354     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 355             count * sizeof(PALETTEENTRY) );
 356     PALETTE_ValidateFlags(palPtr->logpalette.palPalEntry,
 357                           palPtr->logpalette.palNumEntries);
 358     HeapFree( GetProcessHeap(), 0, palPtr->mapping );
 359     palPtr->mapping = NULL;
 360     GDI_ReleaseObj( hpalette );
 361     return count;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           ResizePalette   (GDI.368)
 367  */
 368 BOOL16 WINAPI ResizePalette16( HPALETTE16 hPal, UINT16 cEntries )
 369 {
 370     return ResizePalette( hPal, cEntries );
 371 }
 372
 373
 374 /***********************************************************************
 375  * ResizePalette [GDI32.@]  Resizes logical palette
 376  *
 377  * RETURNS
 378  *    Success: TRUE
 379  *    Failure: FALSE
 380  */
 381 BOOL WINAPI ResizePalette(
 382     HPALETTE hPal, /* [in] Handle of logical palette */
 383     UINT cEntries) /* [in] Number of entries in logical palette */
 384 {
 385     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 386     UINT         cPrevEnt, prevVer;
 387     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 388     int*         mapping = NULL;
 389
 390     TRACE("hpal = %04x, prev = %i, new = %i\n",
 391                     hPal, palPtr ? palPtr->logpalette.palNumEntries : -1,
 392                     cEntries );
 393     if( !palPtr ) return FALSE;
 394     cPrevEnt = palPtr->logpalette.palNumEntries;
 395     prevVer = palPtr->logpalette.palVersion;
 396     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 397                                         sizeof(int*) + sizeof(GDIOBJHDR);
 398     size += sizeof(int*) + sizeof(GDIOBJHDR);
 399     mapping = palPtr->mapping;
 400
 401     if (!(palPtr = GDI_ReallocObject( size, hPal, palPtr ))) return FALSE;
 402
 403     if( mapping )
 404     {
 405         int *newMap = (int*) HeapReAlloc(GetProcessHeap(), 0,
 406                                     mapping, cEntries * sizeof(int) );
 407         if(newMap == NULL)
 408         {
 409             ERR("Can not resize mapping -- out of memory!\n");
 410             GDI_ReleaseObj( hPal );
 411             return FALSE;
 412         }
 413         palPtr->mapping = newMap;
 414     }
 415
 416     if( cEntries > cPrevEnt )
 417     {
 418         if( mapping )
 419             memset(palPtr->mapping + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
 420         memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 421         PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize),
 422                                                      cEntries - cPrevEnt );
 423     }
 424     palPtr->logpalette.palNumEntries = cEntries;
 425     palPtr->logpalette.palVersion = prevVer;
 426     GDI_ReleaseObj( hPal );
 427     return TRUE;
 428 }
 429
 430
 431 /***********************************************************************
 432  *           AnimatePalette   (GDI.367)
 433  */
 434 void WINAPI AnimatePalette16( HPALETTE16 hPal, UINT16 StartIndex,
 435                               UINT16 NumEntries, const PALETTEENTRY* PaletteColors)
 436 {
 437     AnimatePalette( hPal, StartIndex, NumEntries, PaletteColors );
 438 }
 439
 440
 441 /***********************************************************************
 442  * AnimatePalette [GDI32.@]  Replaces entries in logical palette
 443  *
 444  * RETURNS
 445  *    Success: TRUE
 446  *    Failure: FALSE
 447  *
 448  * FIXME
 449  *    Should use existing mapping when animating a primary palette
 450  */
 451 BOOL WINAPI AnimatePalette(
 452     HPALETTE hPal,              /* [in] Handle to logical palette */
 453     UINT StartIndex,            /* [in] First entry in palette */
 454     UINT NumEntries,            /* [in] Count of entries in palette */
 455     const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
 456 {
 457     TRACE("%04x (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
 458
 459     if( hPal != GetStockObject(DEFAULT_PALETTE) )
 460     {
 461         PALETTEOBJ* palPtr = (PALETTEOBJ *)GDI_GetObjPtr(hPal, PALETTE_MAGIC);
 462         if (!palPtr) return FALSE;
 463
 464         if( (StartIndex + NumEntries) <= palPtr->logpalette.palNumEntries )
 465         {
 466             UINT u;
 467             for( u = 0; u < NumEntries; u++ )
 468                 palPtr->logpalette.palPalEntry[u + StartIndex] = PaletteColors[u];
 469             PALETTE_Driver->
 470               pSetMapping(palPtr, StartIndex, NumEntries,
 471                           hPal != hPrimaryPalette );
 472             GDI_ReleaseObj( hPal );
 473             return TRUE;
 474         }
 475         GDI_ReleaseObj( hPal );
 476     }
 477     return FALSE;
 478 }
 479
 480
 481 /***********************************************************************
 482  *           SetSystemPaletteUse   (GDI.373)
 483  */
 484 UINT16 WINAPI SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
 485 {
 486     return SetSystemPaletteUse( hdc, use );
 487 }
 488
 489
 490 /***********************************************************************
 491  * SetSystemPaletteUse [GDI32.@]
 492  *
 493  * RETURNS
 494  *    Success: Previous system palette
 495  *    Failure: SYSPAL_ERROR
 496  */
 497 UINT WINAPI SetSystemPaletteUse(
 498     HDC hdc,  /* [in] Handle of device context */
 499     UINT use) /* [in] Palette-usage flag */
 500 {
 501     UINT old = SystemPaletteUse;
 502     FIXME("(%04x,%04x): stub\n", hdc, use );
 503     SystemPaletteUse = use;
 504     return old;
 505 }
 506
 507
 508 /***********************************************************************
 509  *           GetSystemPaletteUse   (GDI.374)
 510  */
 511 UINT16 WINAPI GetSystemPaletteUse16( HDC16 hdc )
 512 {
 513     return SystemPaletteUse;
 514 }
 515
 516
 517 /***********************************************************************
 518  * GetSystemPaletteUse [GDI32.@]  Gets state of system palette
 519  *
 520  * RETURNS
 521  *    Current state of system palette
 522  */
 523 UINT WINAPI GetSystemPaletteUse(
 524     HDC hdc) /* [in] Handle of device context */
 525 {
 526     return SystemPaletteUse;
 527 }
 528
 529
 530 /***********************************************************************
 531  *           GetSystemPaletteEntries   (GDI.375)
 532  */
 533 UINT16 WINAPI GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
 534                                          LPPALETTEENTRY entries )
 535 {
 536     return GetSystemPaletteEntries( hdc, start, count, entries );
 537 }
 538
 539
 540 /***********************************************************************
 541  * GetSystemPaletteEntries [GDI32.@]  Gets range of palette entries
 542  *
 543  * RETURNS
 544  *    Success: Number of entries retrieved from palette
 545  *    Failure: 0
 546  */
 547 UINT WINAPI GetSystemPaletteEntries(
 548     HDC hdc,              /* [in]  Handle of device context */
 549     UINT start,           /* [in]  Index of first entry to be retrieved */
 550     UINT count,           /* [in]  Number of entries to be retrieved */
 551     LPPALETTEENTRY entries) /* [out] Array receiving system-palette entries */
 552 {
 553     UINT i;
 554     INT sizePalette = GetDeviceCaps( hdc, SIZEPALETTE );
 555
 556     TRACE("hdc=%04x,start=%i,count=%i\n", hdc,start,count);
 557
 558     if (!entries) return sizePalette;
 559     if (start >= sizePalette) return 0;
 560     if (start+count >= sizePalette) count = sizePalette - start;
 561
 562     for (i = 0; i < count; i++)
 563     {
 564         *(COLORREF*)(entries + i) = COLOR_GetSystemPaletteEntry( start + i );
 565
 566         TRACE("\tidx(%02x) -> RGB(%08lx)\n",
 567                          start + i, *(COLORREF*)(entries + i) );
 568     }
 569     return count;
 570 }
 571
 572
 573 /***********************************************************************
 574  *           GetNearestPaletteIndex   (GDI.370)
 575  */
 576 UINT16 WINAPI GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
 577 {
 578     return GetNearestPaletteIndex( hpalette, color );
 579 }
 580
 581
 582 /***********************************************************************
 583  * GetNearestPaletteIndex [GDI32.@]  Gets palette index for color
 584  *
 585  * NOTES
 586  *    Should index be initialized to CLR_INVALID instead of 0?
 587  *
 588  * RETURNS
 589  *    Success: Index of entry in logical palette
 590  *    Failure: CLR_INVALID
 591  */
 592 UINT WINAPI GetNearestPaletteIndex(
 593     HPALETTE hpalette, /* [in] Handle of logical color palette */
 594     COLORREF color)      /* [in] Color to be matched */
 595 {
 596     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 597     UINT index  = 0;
 598
 599     if( palObj )
 600     {
 601       index = COLOR_PaletteLookupPixel(palObj->logpalette.palPalEntry,
 602                                        palObj->logpalette.palNumEntries,
 603                                        NULL, color, FALSE );
 604
 605       GDI_ReleaseObj( hpalette );
 606     }
 607     TRACE("(%04x,%06lx): returning %d\n", hpalette, color, index );
 608     return index;
 609 }
 610
 611
 612 /***********************************************************************
 613  *           GetNearestColor   (GDI.154)
 614  */
 615 COLORREF WINAPI GetNearestColor16( HDC16 hdc, COLORREF color )
 616 {
 617     return GetNearestColor( hdc, color );
 618 }
 619
 620
 621 /***********************************************************************
 622  * GetNearestColor [GDI32.@]  Gets a system color to match
 623  *
 624  * RETURNS
 625  *    Success: Color from system palette that corresponds to given color
 626  *    Failure: CLR_INVALID
 627  */
 628 COLORREF WINAPI GetNearestColor(
 629     HDC hdc,      /* [in] Handle of device context */
 630     COLORREF color) /* [in] Color to be matched */
 631 {
 632     COLORREF     nearest = CLR_INVALID;
 633     DC          *dc;
 634     PALETTEOBJ  *palObj;
 635
 636     if(!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)) {
 637         return color;
 638     }
 639     if ( (dc = DC_GetDCPtr( hdc )) )
 640     {
 641         HPALETTE hpal = (dc->hPalette)? dc->hPalette : GetStockObject( DEFAULT_PALETTE );
 642         palObj = GDI_GetObjPtr( hpal, PALETTE_MAGIC );
 643         if (!palObj) {
 644             GDI_ReleaseObj( hdc );
 645             return nearest;
 646         }
 647
 648         nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
 649                                             palObj->logpalette.palNumEntries, color );
 650         GDI_ReleaseObj( hpal );
 651         GDI_ReleaseObj( hdc );
 652     }
 653
 654     TRACE("(%06lx): returning %06lx\n", color, nearest );
 655     return nearest;
 656 }
 657
 658
 659 /***********************************************************************
 660  *           PALETTE_GetObject
 661  */
 662 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 663 {
 664     if (count > sizeof(WORD)) count = sizeof(WORD);
 665     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 666     return count;
 667 }
 668
 669
 670 /***********************************************************************
 671  *           PALETTE_UnrealizeObject
 672  */
 673 BOOL PALETTE_UnrealizeObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 674 {
 675     if (palette->mapping)
 676     {
 677         HeapFree( GetProcessHeap(), 0, palette->mapping );
 678         palette->mapping = NULL;
 679     }
 680     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 681     return TRUE;
 682 }
 683
 684
 685 /***********************************************************************
 686  *           PALETTE_DeleteObject
 687  */
 688 BOOL PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 689 {
 690     HeapFree( GetProcessHeap(), 0, palette->mapping );
 691     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 692     return GDI_FreeObject( hpalette, palette );
 693 }
 694
 695
 696 /***********************************************************************
 697  *           GDISelectPalette    (GDI.361)
 698  */
 699 HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
 700 {
 701     HPALETTE16 prev;
 702     DC *dc;
 703
 704     TRACE("%04x %04x\n", hdc, hpal );
 705
 706     if (GetObjectType(hpal) != OBJ_PAL)
 707     {
 708       WARN("invalid selected palette %04x\n",hpal);
 709       return 0;
 710     }
 711     if (!(dc = DC_GetDCPtr( hdc ))) return 0;
 712     prev = dc->hPalette;
 713     dc->hPalette = hpal;
 714     GDI_ReleaseObj( hdc );
 715     if (!wBkg) hPrimaryPalette = hpal;
 716     return prev;
 717 }
 718
 719
 720 /***********************************************************************
 721  *           GDIRealizePalette    (GDI.362)
 722  */
 723 UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
 724 {
 725     PALETTEOBJ* palPtr;
 726     int realized = 0;
 727     DC* dc = DC_GetDCPtr( hdc );
 728
 729     if (!dc) return 0;
 730
 731     TRACE("%04x...\n", hdc );
 732
 733     if(dc->hPalette != hLastRealizedPalette )
 734     {
 735         if( dc->hPalette == GetStockObject( DEFAULT_PALETTE )) {
 736             realized = RealizeDefaultPalette16( hdc );
 737             GDI_ReleaseObj( hdc );
 738             return (UINT16)realized;
 739         }
 740
 741
 742         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->hPalette, PALETTE_MAGIC );
 743
 744         if (!palPtr) {
 745             GDI_ReleaseObj( hdc );
 746             FIXME("invalid selected palette %04x\n",dc->hPalette);
 747             return 0;
 748         }
 749
 750         realized = PALETTE_Driver->
 751           pSetMapping(palPtr,0,palPtr->logpalette.palNumEntries,
 752                       (dc->hPalette != hPrimaryPalette) ||
 753                       (dc->hPalette == GetStockObject( DEFAULT_PALETTE )));
 754         hLastRealizedPalette = dc->hPalette;
 755         GDI_ReleaseObj( dc->hPalette );
 756     }
 757     else TRACE("  skipping (hLastRealizedPalette = %04x)\n",
 758                          hLastRealizedPalette);
 759     GDI_ReleaseObj( hdc );
 760
 761     TRACE("   realized %i colors.\n", realized );
 762     return (UINT16)realized;
 763 }
 764
 765
 766 /***********************************************************************
 767  *           RealizeDefaultPalette    (GDI.365)
 768  */
 769 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
 770 {
 771     UINT16 ret = 0;
 772     DC          *dc;
 773     PALETTEOBJ*  palPtr;
 774
 775     TRACE("%04x\n", hdc );
 776
 777     if (!(dc = DC_GetDCPtr( hdc ))) return 0;
 778
 779     if (!(dc->flags & DC_MEMORY))
 780     {
 781         palPtr = (PALETTEOBJ*)GDI_GetObjPtr( GetStockObject(DEFAULT_PALETTE), PALETTE_MAGIC );
 782         if (palPtr)
 783         {
 784             /* lookup is needed to account for SetSystemPaletteUse() stuff */
 785             ret = PALETTE_Driver->pUpdateMapping(palPtr);
 786             GDI_ReleaseObj( GetStockObject(DEFAULT_PALETTE) );
 787         }
 788     }
 789     GDI_ReleaseObj( hdc );
 790     return ret;
 791 }
 792
 793 /***********************************************************************
 794  *           IsDCCurrentPalette   (GDI.412)
 795  */
 796 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
 797 {
 798     DC *dc = DC_GetDCPtr( hDC );
 799     if (dc)
 800     {
 801       BOOL bRet = dc->hPalette == hPrimaryPalette;
 802       GDI_ReleaseObj( hDC );
 803       return bRet;
 804     }
 805     return FALSE;
 806 }
 807
 808
 809 /***********************************************************************
 810  * SelectPalette [GDI32.@]  Selects logical palette into DC
 811  *
 812  * RETURNS
 813  *    Success: Previous logical palette
 814  *    Failure: NULL
 815  */
 816 HPALETTE WINAPI SelectPalette(
 817     HDC hDC,               /* [in] Handle of device context */
 818     HPALETTE hPal,         /* [in] Handle of logical color palette */
 819     BOOL bForceBackground) /* [in] Foreground/background mode */
 820 {
 821     return pfnSelectPalette( hDC, hPal, bForceBackground );
 822 }
 823
 824
 825 /***********************************************************************
 826  * RealizePalette [GDI32.@]  Maps palette entries to system palette
 827  *
 828  * RETURNS
 829  *    Success: Number of entries in logical palette
 830  *    Failure: GDI_ERROR
 831  */
 832 UINT WINAPI RealizePalette(
 833     HDC hDC) /* [in] Handle of device context */
 834 {
 835     return pfnRealizePalette( hDC );
 836 }
 837
 838
 839 typedef HWND (WINAPI *WindowFromDC_funcptr)( HDC );
 840 typedef BOOL (WINAPI *RedrawWindow_funcptr)( HWND, const RECT *, HRGN, UINT );
 841
 842 /**********************************************************************
 843  * UpdateColors [GDI32.@]  Remaps current colors to logical palette
 844  *
 845  * RETURNS
 846  *    Success: TRUE
 847  *    Failure: FALSE
 848  */
 849 BOOL WINAPI UpdateColors(
 850     HDC hDC) /* [in] Handle of device context */
 851 {
 852     HMODULE mod;
 853     int size = GetDeviceCaps( hDC, SIZEPALETTE );
 854
 855     if (!size) return 0;
 856
 857     mod = GetModuleHandleA("user32.dll");
 858     if (mod)
 859     {
 860         WindowFromDC_funcptr pWindowFromDC = (WindowFromDC_funcptr)GetProcAddress(mod,"WindowFromDC");
 861         if (pWindowFromDC)
 862         {
 863             HWND hWnd = pWindowFromDC( hDC );
 864
 865             /* Docs say that we have to remap current drawable pixel by pixel
 866              * but it would take forever given the speed of XGet/PutPixel.
 867              */
 868             if (hWnd && size)
 869             {
 870                 RedrawWindow_funcptr pRedrawWindow = GetProcAddress( mod, "RedrawWindow" );
 871                 if (pRedrawWindow) pRedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
 872             }
 873         }
 874     }
 875     return 0x666;
 876 }
 877
 878
 879 /**********************************************************************
 880  *            UpdateColors   (GDI.366)
 881  */
 882 INT16 WINAPI UpdateColors16( HDC16 hDC )
 883 {
 884     UpdateColors( hDC );
 885     return TRUE;
 886 }
 887
 888
 889 /*********************************************************************
 890  *           SetMagicColors   (GDI.606)
 891  */
 892 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
 893 {
 894     FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
 895
 896 }
 897
 898 /**********************************************************************
 899  * GetICMProfileA [GDI32.@]
 900  *
 901  * Returns the filename of the specified device context's color
 902  * management profile, even if color management is not enabled
 903  * for that DC.
 904  *
 905  * RETURNS
 906  *    TRUE if name copied succesfully OR lpszFilename is NULL
 907  *    FALSE if the buffer length pointed to by lpcbName is too small
 908  *
 909  * NOTE
 910  *    The buffer length pointed to by lpcbName is ALWAYS updated to
 911  *    the length required regardless of other actions this function
 912  *    may take.
 913  *
 914  * FIXME
 915  *    How does Windows assign these?  Some registry key?
 916  */
 917
 918 #define WINEICM "winefake.icm"  /* easy-to-identify fake filename */
 919
 920 /*********************************************************************/
 921
 922 BOOL WINAPI GetICMProfileA(HDC hDC, LPDWORD lpcbName, LPSTR lpszFilename)
 923 {
 924     DWORD callerLen;
 925
 926     FIXME("(%04x, %p, %p): partial stub\n", hDC, lpcbName, lpszFilename);
 927
 928     callerLen = *lpcbName;
 929
 930     /* all 3 behaviors require the required buffer size to be set */
 931     *lpcbName = strlen(WINEICM);
 932
 933     /* behavior 1: if lpszFilename is NULL, return size of string and no error */
 934     if ((DWORD)lpszFilename == (DWORD)0x00000000)
 935         return TRUE;
 936
 937     /* behavior 2: if buffer size too small, return size of string and error */
 938     if (callerLen < strlen(WINEICM))
 939     {
 940         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 941         return FALSE;
 942     }
 943
 944     /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
 945     strcpy(lpszFilename, WINEICM);
 946     return TRUE;
 947 }