msvcrt: Replace inline static with static inline.
[wine] / dlls / gdi32 / palette.c
1 /*
2  * GDI palette objects
3  *
4  * Copyright 1993,1994 Alexandre Julliard
5  * Copyright 1996 Alex Korobka
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  *
21  * NOTES:
22  * PALETTEOBJ is documented in the Dr. Dobbs Journal May 1993.
23  * Information in the "Undocumented Windows" is incorrect.
24  */
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "wownt32.h"
34 #include "wine/winuser16.h"
35 #include "gdi_private.h"
36 #include "wine/debug.h"
37 #include "winerror.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(palette);
40
41 typedef struct tagPALETTEOBJ
42 {
43     GDIOBJHDR           header;
44     const DC_FUNCTIONS *funcs;      /* DC function table */
45     LOGPALETTE          logpalette; /* _MUST_ be the last field */
46 } PALETTEOBJ;
47
48 static INT PALETTE_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
49 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle, void *obj );
50 static BOOL PALETTE_DeleteObject( HGDIOBJ handle, void *obj );
51
52 static const struct gdi_obj_funcs palette_funcs =
53 {
54     NULL,                     /* pSelectObject */
55     PALETTE_GetObject,        /* pGetObject16 */
56     PALETTE_GetObject,        /* pGetObjectA */
57     PALETTE_GetObject,        /* pGetObjectW */
58     PALETTE_UnrealizeObject,  /* pUnrealizeObject */
59     PALETTE_DeleteObject      /* pDeleteObject */
60 };
61
62 /* Pointers to USER implementation of SelectPalette/RealizePalette */
63 /* they will be patched by USER on startup */
64 HPALETTE (WINAPI *pfnSelectPalette)(HDC hdc, HPALETTE hpal, WORD bkgnd ) = GDISelectPalette;
65 UINT (WINAPI *pfnRealizePalette)(HDC hdc) = GDIRealizePalette;
66
67 static UINT SystemPaletteUse = SYSPAL_STATIC;  /* currently not considered */
68
69 static HPALETTE hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
70 static HPALETTE hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
71
72 #define NB_RESERVED_COLORS  20   /* number of fixed colors in system palette */
73
74 static const PALETTEENTRY sys_pal_template[NB_RESERVED_COLORS] =
75 {
76     /* first 10 entries in the system palette */
77     /* red  green blue  flags */
78     { 0x00, 0x00, 0x00, 0 },
79     { 0x80, 0x00, 0x00, 0 },
80     { 0x00, 0x80, 0x00, 0 },
81     { 0x80, 0x80, 0x00, 0 },
82     { 0x00, 0x00, 0x80, 0 },
83     { 0x80, 0x00, 0x80, 0 },
84     { 0x00, 0x80, 0x80, 0 },
85     { 0xc0, 0xc0, 0xc0, 0 },
86     { 0xc0, 0xdc, 0xc0, 0 },
87     { 0xa6, 0xca, 0xf0, 0 },
88
89     /* ... c_min/2 dynamic colorcells */
90
91     /* ... gap (for sparse palettes) */
92
93     /* ... c_min/2 dynamic colorcells */
94
95     { 0xff, 0xfb, 0xf0, 0 },
96     { 0xa0, 0xa0, 0xa4, 0 },
97     { 0x80, 0x80, 0x80, 0 },
98     { 0xff, 0x00, 0x00, 0 },
99     { 0x00, 0xff, 0x00, 0 },
100     { 0xff, 0xff, 0x00, 0 },
101     { 0x00, 0x00, 0xff, 0 },
102     { 0xff, 0x00, 0xff, 0 },
103     { 0x00, 0xff, 0xff, 0 },
104     { 0xff, 0xff, 0xff, 0 }     /* last 10 */
105 };
106
107 /***********************************************************************
108  *           PALETTE_Init
109  *
110  * Create the system palette.
111  */
112 HPALETTE PALETTE_Init(void)
113 {
114     HPALETTE          hpalette;
115     LOGPALETTE *        palPtr;
116
117     /* create default palette (20 system colors) */
118
119     palPtr = HeapAlloc( GetProcessHeap(), 0,
120              sizeof(LOGPALETTE) + (NB_RESERVED_COLORS-1)*sizeof(PALETTEENTRY));
121     if (!palPtr) return FALSE;
122
123     palPtr->palVersion = 0x300;
124     palPtr->palNumEntries = NB_RESERVED_COLORS;
125     memcpy( palPtr->palPalEntry, sys_pal_template, sizeof(sys_pal_template) );
126     hpalette = CreatePalette( palPtr );
127     HeapFree( GetProcessHeap(), 0, palPtr );
128     return hpalette;
129 }
130
131
132 /***********************************************************************
133  * CreatePalette [GDI32.@]
134  *
135  * Creates a logical color palette.
136  *
137  * RETURNS
138  *    Success: Handle to logical palette
139  *    Failure: NULL
140  */
141 HPALETTE WINAPI CreatePalette(
142     const LOGPALETTE* palette) /* [in] Pointer to logical color palette */
143 {
144     PALETTEOBJ * palettePtr;
145     HPALETTE hpalette;
146     int size;
147
148     if (!palette) return 0;
149     TRACE("entries=%i\n", palette->palNumEntries);
150
151     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
152
153     if (!(palettePtr = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR),
154                                         PALETTE_MAGIC, (HGDIOBJ *)&hpalette,
155                                         &palette_funcs ))) return 0;
156     memcpy( &palettePtr->logpalette, palette, size );
157     palettePtr->funcs = NULL;
158     GDI_ReleaseObj( hpalette );
159
160     TRACE("   returning %p\n", hpalette);
161     return hpalette;
162 }
163
164
165 /***********************************************************************
166  * CreateHalftonePalette [GDI32.@]
167  *
168  * Creates a halftone palette.
169  *
170  * RETURNS
171  *    Success: Handle to logical halftone palette
172  *    Failure: 0
173  *
174  * FIXME: This simply creates the halftone palette derived from running
175  *        tests on a windows NT machine. This is assuming a color depth
176  *        of greater that 256 color. On a 256 color device the halftone
177  *        palette will be different and this function will be incorrect
178  */
179 HPALETTE WINAPI CreateHalftonePalette(
180     HDC hdc) /* [in] Handle to device context */
181 {
182     int i;
183     struct {
184         WORD Version;
185         WORD NumberOfEntries;
186         PALETTEENTRY aEntries[256];
187     } Palette;
188
189     Palette.Version = 0x300;
190     Palette.NumberOfEntries = 256;
191     GetSystemPaletteEntries(hdc, 0, 256, Palette.aEntries);
192
193     Palette.NumberOfEntries = 20;
194
195     for (i = 0; i < Palette.NumberOfEntries; i++)
196     {
197         Palette.aEntries[i].peRed=0xff;
198         Palette.aEntries[i].peGreen=0xff;
199         Palette.aEntries[i].peBlue=0xff;
200         Palette.aEntries[i].peFlags=0x00;
201     }
202
203     Palette.aEntries[0].peRed=0x00;
204     Palette.aEntries[0].peBlue=0x00;
205     Palette.aEntries[0].peGreen=0x00;
206
207     /* the first 6 */
208     for (i=1; i <= 6; i++)
209     {
210         Palette.aEntries[i].peRed=(i%2)?0x80:0;
211         Palette.aEntries[i].peGreen=(i==2)?0x80:(i==3)?0x80:(i==6)?0x80:0;
212         Palette.aEntries[i].peBlue=(i>3)?0x80:0;
213     }
214
215     for (i=7;  i <= 12; i++)
216     {
217         switch(i)
218         {
219             case 7:
220                 Palette.aEntries[i].peRed=0xc0;
221                 Palette.aEntries[i].peBlue=0xc0;
222                 Palette.aEntries[i].peGreen=0xc0;
223                 break;
224             case 8:
225                 Palette.aEntries[i].peRed=0xc0;
226                 Palette.aEntries[i].peGreen=0xdc;
227                 Palette.aEntries[i].peBlue=0xc0;
228                 break;
229             case 9:
230                 Palette.aEntries[i].peRed=0xa6;
231                 Palette.aEntries[i].peGreen=0xca;
232                 Palette.aEntries[i].peBlue=0xf0;
233                 break;
234             case 10:
235                 Palette.aEntries[i].peRed=0xff;
236                 Palette.aEntries[i].peGreen=0xfb;
237                 Palette.aEntries[i].peBlue=0xf0;
238                 break;
239             case 11:
240                 Palette.aEntries[i].peRed=0xa0;
241                 Palette.aEntries[i].peGreen=0xa0;
242                 Palette.aEntries[i].peBlue=0xa4;
243                 break;
244             case 12:
245                 Palette.aEntries[i].peRed=0x80;
246                 Palette.aEntries[i].peGreen=0x80;
247                 Palette.aEntries[i].peBlue=0x80;
248         }
249     }
250
251    for (i=13; i <= 18; i++)
252     {
253         Palette.aEntries[i].peRed=(i%2)?0xff:0;
254         Palette.aEntries[i].peGreen=(i==14)?0xff:(i==15)?0xff:(i==18)?0xff:0;
255         Palette.aEntries[i].peBlue=(i>15)?0xff:0x00;
256     }
257
258     return CreatePalette((LOGPALETTE *)&Palette);
259 }
260
261
262 /***********************************************************************
263  * GetPaletteEntries [GDI32.@]
264  *
265  * Retrieves palette entries.
266  *
267  * RETURNS
268  *    Success: Number of entries from logical palette
269  *    Failure: 0
270  */
271 UINT WINAPI GetPaletteEntries(
272     HPALETTE hpalette,    /* [in]  Handle of logical palette */
273     UINT start,           /* [in]  First entry to receive */
274     UINT count,           /* [in]  Number of entries to receive */
275     LPPALETTEENTRY entries) /* [out] Address of array receiving entries */
276 {
277     PALETTEOBJ * palPtr;
278     UINT numEntries;
279
280     TRACE("hpal = %p, count=%i\n", hpalette, count );
281
282     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
283     if (!palPtr) return 0;
284
285     /* NOTE: not documented but test show this to be the case */
286     if (count == 0)
287     {
288         int rc = palPtr->logpalette.palNumEntries;
289             GDI_ReleaseObj( hpalette );
290         return rc;
291     }
292
293     numEntries = palPtr->logpalette.palNumEntries;
294     if (start+count > numEntries) count = numEntries - start;
295     if (entries)
296     {
297       if (start >= numEntries)
298       {
299         GDI_ReleaseObj( hpalette );
300         return 0;
301       }
302       memcpy( entries, &palPtr->logpalette.palPalEntry[start],
303               count * sizeof(PALETTEENTRY) );
304       for( numEntries = 0; numEntries < count ; numEntries++ )
305            if (entries[numEntries].peFlags & 0xF0)
306                entries[numEntries].peFlags = 0;
307     }
308
309     GDI_ReleaseObj( hpalette );
310     return count;
311 }
312
313
314 /***********************************************************************
315  * SetPaletteEntries [GDI32.@]
316  *
317  * Sets color values for range in palette.
318  *
319  * RETURNS
320  *    Success: Number of entries that were set
321  *    Failure: 0
322  */
323 UINT WINAPI SetPaletteEntries(
324     HPALETTE hpalette,    /* [in] Handle of logical palette */
325     UINT start,           /* [in] Index of first entry to set */
326     UINT count,           /* [in] Number of entries to set */
327     const PALETTEENTRY *entries) /* [in] Address of array of structures */
328 {
329     PALETTEOBJ * palPtr;
330     UINT numEntries;
331
332     TRACE("hpal=%p,start=%i,count=%i\n",hpalette,start,count );
333
334     if (hpalette == GetStockObject(DEFAULT_PALETTE)) return 0;
335     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
336     if (!palPtr) return 0;
337
338     numEntries = palPtr->logpalette.palNumEntries;
339     if (start >= numEntries)
340     {
341       GDI_ReleaseObj( hpalette );
342       return 0;
343     }
344     if (start+count > numEntries) count = numEntries - start;
345     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
346             count * sizeof(PALETTEENTRY) );
347     UnrealizeObject( hpalette );
348     GDI_ReleaseObj( hpalette );
349     return count;
350 }
351
352
353 /***********************************************************************
354  * ResizePalette [GDI32.@]
355  *
356  * Resizes logical palette.
357  *
358  * RETURNS
359  *    Success: TRUE
360  *    Failure: FALSE
361  */
362 BOOL WINAPI ResizePalette(
363     HPALETTE hPal, /* [in] Handle of logical palette */
364     UINT cEntries) /* [in] Number of entries in logical palette */
365 {
366     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
367     UINT         cPrevEnt, prevVer;
368     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
369
370     TRACE("hpal = %p, prev = %i, new = %i\n",
371           hPal, palPtr ? palPtr->logpalette.palNumEntries : -1, cEntries );
372     if( !palPtr ) return FALSE;
373     cPrevEnt = palPtr->logpalette.palNumEntries;
374     prevVer = palPtr->logpalette.palVersion;
375     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
376                                         sizeof(int*) + sizeof(GDIOBJHDR);
377     size += sizeof(int*) + sizeof(GDIOBJHDR);
378
379     if (!(palPtr = GDI_ReallocObject( size, hPal, palPtr ))) return FALSE;
380
381     PALETTE_UnrealizeObject( hPal, palPtr );
382
383     if( cEntries > cPrevEnt ) memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
384     palPtr->logpalette.palNumEntries = cEntries;
385     palPtr->logpalette.palVersion = prevVer;
386     GDI_ReleaseObj( hPal );
387     return TRUE;
388 }
389
390
391 /***********************************************************************
392  * AnimatePalette [GDI32.@]
393  *
394  * Replaces entries in logical palette.
395  *
396  * RETURNS
397  *    Success: TRUE
398  *    Failure: FALSE
399  *
400  * FIXME
401  *    Should use existing mapping when animating a primary palette
402  */
403 BOOL WINAPI AnimatePalette(
404     HPALETTE hPal,              /* [in] Handle to logical palette */
405     UINT StartIndex,            /* [in] First entry in palette */
406     UINT NumEntries,            /* [in] Count of entries in palette */
407     const PALETTEENTRY* PaletteColors) /* [in] Pointer to first replacement */
408 {
409     TRACE("%p (%i - %i)\n", hPal, StartIndex,StartIndex+NumEntries);
410
411     if( hPal != GetStockObject(DEFAULT_PALETTE) )
412     {
413         PALETTEOBJ * palPtr;
414         UINT pal_entries;
415         const PALETTEENTRY *pptr = PaletteColors;
416
417         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
418         if (!palPtr) return 0;
419
420         pal_entries = palPtr->logpalette.palNumEntries;
421         if (StartIndex >= pal_entries)
422         {
423           GDI_ReleaseObj( hPal );
424           return 0;
425         }
426         if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
427         
428         for (NumEntries += StartIndex; StartIndex < NumEntries; StartIndex++, pptr++) {
429           /* According to MSDN, only animate PC_RESERVED colours */
430           if (palPtr->logpalette.palPalEntry[StartIndex].peFlags & PC_RESERVED) {
431             TRACE("Animating colour (%d,%d,%d) to (%d,%d,%d)\n",
432               palPtr->logpalette.palPalEntry[StartIndex].peRed,
433               palPtr->logpalette.palPalEntry[StartIndex].peGreen,
434               palPtr->logpalette.palPalEntry[StartIndex].peBlue,
435               pptr->peRed, pptr->peGreen, pptr->peBlue);
436             memcpy( &palPtr->logpalette.palPalEntry[StartIndex], pptr,
437                     sizeof(PALETTEENTRY) );
438           } else {
439             TRACE("Not animating entry %d -- not PC_RESERVED\n", StartIndex);
440           }
441         }
442         if (palPtr->funcs && palPtr->funcs->pRealizePalette)
443             palPtr->funcs->pRealizePalette( NULL, hPal, hPal == hPrimaryPalette );
444
445         GDI_ReleaseObj( hPal );
446     }
447     return TRUE;
448 }
449
450
451 /***********************************************************************
452  * SetSystemPaletteUse [GDI32.@]
453  *
454  * Specify whether the system palette contains 2 or 20 static colors.
455  *
456  * RETURNS
457  *    Success: Previous system palette
458  *    Failure: SYSPAL_ERROR
459  */
460 UINT WINAPI SetSystemPaletteUse(
461     HDC hdc,  /* [in] Handle of device context */
462     UINT use) /* [in] Palette-usage flag */
463 {
464     UINT old = SystemPaletteUse;
465
466     /* Device doesn't support colour palettes */
467     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)) {
468         return SYSPAL_ERROR;
469     }
470
471     switch (use) {
472         case SYSPAL_NOSTATIC:
473         case SYSPAL_NOSTATIC256:        /* WINVER >= 0x0500 */
474         case SYSPAL_STATIC:
475             SystemPaletteUse = use;
476             return old;
477         default:
478             return SYSPAL_ERROR;
479     }
480 }
481
482
483 /***********************************************************************
484  * GetSystemPaletteUse [GDI32.@]
485  *
486  * Gets state of system palette.
487  *
488  * RETURNS
489  *    Current state of system palette
490  */
491 UINT WINAPI GetSystemPaletteUse(
492     HDC hdc) /* [in] Handle of device context */
493 {
494     return SystemPaletteUse;
495 }
496
497
498 /***********************************************************************
499  * GetSystemPaletteEntries [GDI32.@]
500  *
501  * Gets range of palette entries.
502  *
503  * RETURNS
504  *    Success: Number of entries retrieved from palette
505  *    Failure: 0
506  */
507 UINT WINAPI GetSystemPaletteEntries(
508     HDC hdc,              /* [in]  Handle of device context */
509     UINT start,           /* [in]  Index of first entry to be retrieved */
510     UINT count,           /* [in]  Number of entries to be retrieved */
511     LPPALETTEENTRY entries) /* [out] Array receiving system-palette entries */
512 {
513     UINT ret = 0;
514     DC *dc;
515
516     TRACE("hdc=%p,start=%i,count=%i\n", hdc,start,count);
517
518     if ((dc = DC_GetDCPtr( hdc )))
519     {
520         if (dc->funcs->pGetSystemPaletteEntries)
521             ret = dc->funcs->pGetSystemPaletteEntries( dc->physDev, start, count, entries );
522         GDI_ReleaseObj( hdc );
523     }
524     return ret;
525 }
526
527
528 /***********************************************************************
529  * GetNearestPaletteIndex [GDI32.@]
530  *
531  * Gets palette index for color.
532  *
533  * NOTES
534  *    Should index be initialized to CLR_INVALID instead of 0?
535  *
536  * RETURNS
537  *    Success: Index of entry in logical palette
538  *    Failure: CLR_INVALID
539  */
540 UINT WINAPI GetNearestPaletteIndex(
541     HPALETTE hpalette, /* [in] Handle of logical color palette */
542     COLORREF color)      /* [in] Color to be matched */
543 {
544     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
545     UINT index  = 0;
546
547     if( palObj )
548     {
549         int i, diff = 0x7fffffff;
550         int r,g,b;
551         PALETTEENTRY* entry = palObj->logpalette.palPalEntry;
552
553         for( i = 0; i < palObj->logpalette.palNumEntries && diff ; i++, entry++)
554         {
555             r = entry->peRed - GetRValue(color);
556             g = entry->peGreen - GetGValue(color);
557             b = entry->peBlue - GetBValue(color);
558
559             r = r*r + g*g + b*b;
560
561             if( r < diff ) { index = i; diff = r; }
562         }
563         GDI_ReleaseObj( hpalette );
564     }
565     TRACE("(%p,%06x): returning %d\n", hpalette, color, index );
566     return index;
567 }
568
569
570 /***********************************************************************
571  * GetNearestColor [GDI32.@]
572  *
573  * Gets a system color to match.
574  *
575  * RETURNS
576  *    Success: Color from system palette that corresponds to given color
577  *    Failure: CLR_INVALID
578  */
579 COLORREF WINAPI GetNearestColor(
580     HDC hdc,      /* [in] Handle of device context */
581     COLORREF color) /* [in] Color to be matched */
582 {
583     unsigned char spec_type;
584     COLORREF nearest;
585     DC          *dc;
586
587     if (!(dc = DC_GetDCPtr( hdc ))) return CLR_INVALID;
588
589     if (dc->funcs->pGetNearestColor)
590     {
591         nearest = dc->funcs->pGetNearestColor( dc->physDev, color );
592         GDI_ReleaseObj( hdc );
593         return nearest;
594     }
595
596     if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
597     {
598         GDI_ReleaseObj( hdc );
599         return color;
600     }
601
602     spec_type = color >> 24;
603     if (spec_type == 1 || spec_type == 2)
604     {
605         /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
606
607         UINT index;
608         PALETTEENTRY entry;
609         HPALETTE hpal = dc->hPalette ? dc->hPalette : GetStockObject( DEFAULT_PALETTE );
610
611         if (spec_type == 2) /* PALETTERGB */
612             index = GetNearestPaletteIndex( hpal, color );
613         else  /* PALETTEINDEX */
614             index = LOWORD(color);
615
616         if (!GetPaletteEntries( hpal, index, 1, &entry ))
617         {
618             WARN("RGB(%x) : idx %d is out of bounds, assuming NULL\n", color, index );
619             if (!GetPaletteEntries( hpal, 0, 1, &entry ))
620             {
621                 GDI_ReleaseObj( hdc );
622                 return CLR_INVALID;
623             }
624         }
625         color = RGB( entry.peRed, entry.peGreen, entry.peBlue );
626     }
627     nearest = color & 0x00ffffff;
628     GDI_ReleaseObj( hdc );
629
630     TRACE("(%06x): returning %06x\n", color, nearest );
631     return nearest;
632 }
633
634
635 /***********************************************************************
636  *           PALETTE_GetObject
637  */
638 static INT PALETTE_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
639 {
640     PALETTEOBJ *palette = obj;
641
642     if( !buffer )
643         return sizeof(WORD);
644
645     if (count > sizeof(WORD)) count = sizeof(WORD);
646     memcpy( buffer, &palette->logpalette.palNumEntries, count );
647     return count;
648 }
649
650
651 /***********************************************************************
652  *           PALETTE_UnrealizeObject
653  */
654 static BOOL PALETTE_UnrealizeObject( HGDIOBJ handle, void *obj )
655 {
656     PALETTEOBJ *palette = obj;
657
658     if (palette->funcs)
659     {
660         if (palette->funcs->pUnrealizePalette)
661             palette->funcs->pUnrealizePalette( handle );
662         palette->funcs = NULL;
663     }
664
665     if (hLastRealizedPalette == handle)
666     {
667         TRACE("unrealizing palette %p\n", handle);
668         hLastRealizedPalette = 0;
669     }
670     return TRUE;
671 }
672
673
674 /***********************************************************************
675  *           PALETTE_DeleteObject
676  */
677 static BOOL PALETTE_DeleteObject( HGDIOBJ handle, void *obj )
678 {
679     PALETTE_UnrealizeObject( handle, obj );
680     return GDI_FreeObject( handle, obj );
681 }
682
683
684 /***********************************************************************
685  *           GDISelectPalette    (Not a Windows API)
686  */
687 HPALETTE WINAPI GDISelectPalette( HDC hdc, HPALETTE hpal, WORD wBkg)
688 {
689     HPALETTE ret;
690     DC *dc;
691
692     TRACE("%p %p\n", hdc, hpal );
693
694     if (GetObjectType(hpal) != OBJ_PAL)
695     {
696       WARN("invalid selected palette %p\n",hpal);
697       return 0;
698     }
699     if (!(dc = DC_GetDCPtr( hdc ))) return 0;
700     ret = dc->hPalette;
701     if (dc->funcs->pSelectPalette) hpal = dc->funcs->pSelectPalette( dc->physDev, hpal, FALSE );
702     if (hpal)
703     {
704         dc->hPalette = hpal;
705         if (!wBkg) hPrimaryPalette = hpal;
706     }
707     else ret = 0;
708     GDI_ReleaseObj( hdc );
709     return ret;
710 }
711
712
713 /***********************************************************************
714  *           GDIRealizePalette    (Not a Windows API)
715  */
716 UINT WINAPI GDIRealizePalette( HDC hdc )
717 {
718     UINT realized = 0;
719     DC* dc = DC_GetDCPtr( hdc );
720
721     if (!dc) return 0;
722
723     TRACE("%p...\n", hdc );
724
725     if( dc->hPalette == GetStockObject( DEFAULT_PALETTE ))
726     {
727         if (dc->funcs->pRealizeDefaultPalette)
728             realized = dc->funcs->pRealizeDefaultPalette( dc->physDev );
729     }
730     else if(dc->hPalette != hLastRealizedPalette )
731     {
732         if (dc->funcs->pRealizePalette)
733         {
734             PALETTEOBJ *palPtr = GDI_GetObjPtr( dc->hPalette, PALETTE_MAGIC );
735             if (palPtr)
736             {
737                 realized = dc->funcs->pRealizePalette( dc->physDev, dc->hPalette,
738                                                        (dc->hPalette == hPrimaryPalette) );
739                 palPtr->funcs = dc->funcs;
740                 GDI_ReleaseObj( dc->hPalette );
741             }
742         }
743         hLastRealizedPalette = dc->hPalette;
744     }
745     else TRACE("  skipping (hLastRealizedPalette = %p)\n", hLastRealizedPalette);
746
747     GDI_ReleaseObj( hdc );
748     TRACE("   realized %i colors.\n", realized );
749     return realized;
750 }
751
752
753 /***********************************************************************
754  *           RealizeDefaultPalette    (GDI.365)
755  */
756 UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
757 {
758     UINT16 ret = 0;
759     DC          *dc;
760
761     TRACE("%04x\n", hdc );
762
763     if (!(dc = DC_GetDCPtr( HDC_32(hdc) ))) return 0;
764
765     if (dc->funcs->pRealizeDefaultPalette) ret = dc->funcs->pRealizeDefaultPalette( dc->physDev );
766     GDI_ReleaseObj( HDC_32(hdc) );
767     return ret;
768 }
769
770 /***********************************************************************
771  *           IsDCCurrentPalette   (GDI.412)
772  */
773 BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
774 {
775     DC *dc = DC_GetDCPtr( HDC_32(hDC) );
776     if (dc)
777     {
778       BOOL bRet = dc->hPalette == hPrimaryPalette;
779       GDI_ReleaseObj( HDC_32(hDC) );
780       return bRet;
781     }
782     return FALSE;
783 }
784
785
786 /***********************************************************************
787  * SelectPalette [GDI32.@]
788  *
789  * Selects logical palette into DC.
790  *
791  * RETURNS
792  *    Success: Previous logical palette
793  *    Failure: NULL
794  */
795 HPALETTE WINAPI SelectPalette(
796     HDC hDC,               /* [in] Handle of device context */
797     HPALETTE hPal,         /* [in] Handle of logical color palette */
798     BOOL bForceBackground) /* [in] Foreground/background mode */
799 {
800     return pfnSelectPalette( hDC, hPal, bForceBackground );
801 }
802
803
804 /***********************************************************************
805  * RealizePalette [GDI32.@]
806  *
807  * Maps palette entries to system palette.
808  *
809  * RETURNS
810  *    Success: Number of entries in logical palette
811  *    Failure: GDI_ERROR
812  */
813 UINT WINAPI RealizePalette(
814     HDC hDC) /* [in] Handle of device context */
815 {
816     return pfnRealizePalette( hDC );
817 }
818
819
820 typedef HWND (WINAPI *WindowFromDC_funcptr)( HDC );
821 typedef BOOL (WINAPI *RedrawWindow_funcptr)( HWND, const RECT *, HRGN, UINT );
822
823 /**********************************************************************
824  * UpdateColors [GDI32.@]
825  *
826  * Remaps current colors to logical palette.
827  *
828  * RETURNS
829  *    Success: TRUE
830  *    Failure: FALSE
831  */
832 BOOL WINAPI UpdateColors(
833     HDC hDC) /* [in] Handle of device context */
834 {
835     HMODULE mod;
836     int size = GetDeviceCaps( hDC, SIZEPALETTE );
837
838     if (!size) return 0;
839
840     mod = GetModuleHandleA("user32.dll");
841     if (mod)
842     {
843         WindowFromDC_funcptr pWindowFromDC = (WindowFromDC_funcptr)GetProcAddress(mod,"WindowFromDC");
844         if (pWindowFromDC)
845         {
846             HWND hWnd = pWindowFromDC( hDC );
847
848             /* Docs say that we have to remap current drawable pixel by pixel
849              * but it would take forever given the speed of XGet/PutPixel.
850              */
851             if (hWnd && size)
852             {
853                 RedrawWindow_funcptr pRedrawWindow = GetProcAddress( mod, "RedrawWindow" );
854                 if (pRedrawWindow) pRedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
855             }
856         }
857     }
858     return 0x666;
859 }
860
861
862 /*********************************************************************
863  *           SetMagicColors   (GDI.606)
864  */
865 VOID WINAPI SetMagicColors16(HDC16 hDC, COLORREF color, UINT16 index)
866 {
867     FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC, (int)color, index);
868
869 }
870
871 /*********************************************************************
872  *           SetMagicColors   (GDI.@)
873  */
874 BOOL WINAPI SetMagicColors(HDC hdc, ULONG u1, ULONG u2)
875 {
876     FIXME("(%p 0x%08x 0x%08x): stub\n", hdc, u1, u2);
877     return TRUE;
878 }
879
880 /**********************************************************************
881  * GetICMProfileA [GDI32.@]
882  *
883  * Returns the filename of the specified device context's color
884  * management profile, even if color management is not enabled
885  * for that DC.
886  *
887  * RETURNS
888  *    TRUE if name copied successfully OR lpszFilename is NULL
889  *    FALSE if the buffer length pointed to by lpcbName is too small
890  *
891  * NOTE
892  *    The buffer length pointed to by lpcbName is ALWAYS updated to
893  *    the length required regardless of other actions this function
894  *    may take.
895  *
896  * FIXME
897  *    How does Windows assign these?  Some registry key?
898  */
899
900
901 /*********************************************************************/
902
903 BOOL WINAPI GetICMProfileA(HDC hDC, LPDWORD lpcbName, LPSTR lpszFilename)
904 {
905     DWORD callerLen;
906     static const char icm[] = "winefake.icm";
907
908     FIXME("(%p, %p, %p): partial stub\n", hDC, lpcbName, lpszFilename);
909
910     callerLen = *lpcbName;
911
912     /* all 3 behaviors require the required buffer size to be set */
913     *lpcbName = sizeof(icm);
914
915     /* behavior 1: if lpszFilename is NULL, return size of string and no error */
916     if (!lpszFilename) return TRUE;
917
918     /* behavior 2: if buffer size too small, return size of string and error */
919     if (callerLen < sizeof(icm))
920     {
921         SetLastError(ERROR_INSUFFICIENT_BUFFER);
922         return FALSE;
923     }
924
925     /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
926     memcpy(lpszFilename, icm, sizeof(icm));
927     return TRUE;
928 }
929
930 /**********************************************************************
931  * GetICMProfileW [GDI32.@]
932  **/
933 BOOL WINAPI GetICMProfileW(HDC hDC, LPDWORD lpcbName, LPWSTR lpszFilename)
934 {
935     DWORD callerLen;
936     static const WCHAR icm[] = { 'w','i','n','e','f','a','k','e','.','i','c','m', 0 };
937
938     FIXME("(%p, %p, %p): partial stub\n", hDC, lpcbName, lpszFilename);
939
940     callerLen = *lpcbName;
941
942     /* all 3 behaviors require the required buffer size to be set */
943     *lpcbName = sizeof(icm) / sizeof(WCHAR);
944
945     /* behavior 1: if lpszFilename is NULL, return size of string and no error */
946     if (!lpszFilename) return TRUE;
947
948     /* behavior 2: if buffer size too small, return size of string and error */
949     if (callerLen < sizeof(icm)/sizeof(WCHAR))
950     {
951         SetLastError(ERROR_INSUFFICIENT_BUFFER);
952         return FALSE;
953     }
954
955     /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
956     memcpy(lpszFilename, icm, sizeof(icm));
957     return TRUE;
958 }
959
960 /**********************************************************************
961  * GetLogColorSpaceA [GDI32.@]
962  *
963  */
964 BOOL WINAPI GetLogColorSpaceA(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEA lpBuffer, DWORD nSize)
965 {
966     FIXME("%p %p 0x%08x: stub!\n", hColorSpace, lpBuffer, nSize);
967     return FALSE;
968 }
969
970 /**********************************************************************
971  * GetLogColorSpaceW [GDI32.@]
972  *
973  */
974 BOOL WINAPI GetLogColorSpaceW(HCOLORSPACE hColorSpace, LPLOGCOLORSPACEW lpBuffer, DWORD nSize)
975 {
976     FIXME("%p %p 0x%08x: stub!\n", hColorSpace, lpBuffer, nSize);
977     return FALSE;
978 }
979
980 /**********************************************************************
981  * SetICMProfileA [GDI32.@]
982  *
983  */
984 BOOL WINAPI SetICMProfileA(HDC hDC, LPSTR lpszFilename)
985 {
986     FIXME("hDC %p filename %s: stub!\n", hDC, debugstr_a(lpszFilename));
987     return TRUE; /* success */
988 }
989
990 /**********************************************************************
991  * SetICMProfileA [GDI32.@]
992  *
993  */
994 BOOL WINAPI SetICMProfileW(HDC hDC, LPWSTR lpszFilename)
995 {
996     FIXME("hDC %p filename %s: stub!\n", hDC, debugstr_w(lpszFilename));
997     return TRUE; /* success */
998 }
999
1000 /**********************************************************************
1001  * UpdateICMRegKeyA [GDI32.@]
1002  *
1003  */
1004 BOOL WINAPI UpdateICMRegKeyA(DWORD dwReserved, LPSTR lpszCMID, LPSTR lpszFileName, UINT nCommand)
1005 {
1006     FIXME("(0x%08x, %s, %s, 0x%08x): stub!\n", dwReserved, debugstr_a(lpszCMID),
1007           debugstr_a(lpszFileName), nCommand);
1008     return TRUE; /* success */
1009 }
1010
1011 /**********************************************************************
1012  * UpdateICMRegKeyW [GDI32.@]
1013  *
1014  */
1015 BOOL WINAPI UpdateICMRegKeyW(DWORD dwReserved, LPWSTR lpszCMID, LPWSTR lpszFileName, UINT nCommand)
1016 {
1017     FIXME("(0x%08x, %s, %s, 0x%08x): stub!\n", dwReserved, debugstr_w(lpszCMID),
1018           debugstr_w(lpszFileName), nCommand);
1019     return TRUE; /* success */
1020 }