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