4 * Copyright 1993,1994 Alexandre Julliard
5 * Copyright 1996 Alex Korobka
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.
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.
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
22 * PALETTEOBJ is documented in the Dr. Dobbs Journal May 1993.
23 * Information in the "Undocumented Windows" is incorrect.
34 #include "wine/winuser16.h"
36 #include "gdi_private.h"
37 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(palette
);
42 static INT
PALETTE_GetObject( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
);
43 static BOOL
PALETTE_UnrealizeObject( HGDIOBJ handle
, void *obj
);
44 static BOOL
PALETTE_DeleteObject( HGDIOBJ handle
, void *obj
);
46 static const struct gdi_obj_funcs palette_funcs
=
48 NULL
, /* pSelectObject */
49 PALETTE_GetObject
, /* pGetObject16 */
50 PALETTE_GetObject
, /* pGetObjectA */
51 PALETTE_GetObject
, /* pGetObjectW */
52 PALETTE_UnrealizeObject
, /* pUnrealizeObject */
53 PALETTE_DeleteObject
/* pDeleteObject */
56 /* Pointers to USER implementation of SelectPalette/RealizePalette */
57 /* they will be patched by USER on startup */
58 HPALETTE (WINAPI
*pfnSelectPalette
)(HDC hdc
, HPALETTE hpal
, WORD bkgnd
) = GDISelectPalette
;
59 UINT (WINAPI
*pfnRealizePalette
)(HDC hdc
) = GDIRealizePalette
;
61 static UINT SystemPaletteUse
= SYSPAL_STATIC
; /* currently not considered */
63 static HPALETTE hPrimaryPalette
= 0; /* used for WM_PALETTECHANGED */
64 static HPALETTE hLastRealizedPalette
= 0; /* UnrealizeObject() needs it */
65 static const DC_FUNCTIONS
*pLastRealizedDC
;
67 static const PALETTEENTRY sys_pal_template
[NB_RESERVED_COLORS
] =
69 /* first 10 entries in the system palette */
70 /* red green blue flags */
71 { 0x00, 0x00, 0x00, 0 },
72 { 0x80, 0x00, 0x00, 0 },
73 { 0x00, 0x80, 0x00, 0 },
74 { 0x80, 0x80, 0x00, 0 },
75 { 0x00, 0x00, 0x80, 0 },
76 { 0x80, 0x00, 0x80, 0 },
77 { 0x00, 0x80, 0x80, 0 },
78 { 0xc0, 0xc0, 0xc0, 0 },
79 { 0xc0, 0xdc, 0xc0, 0 },
80 { 0xa6, 0xca, 0xf0, 0 },
82 /* ... c_min/2 dynamic colorcells */
84 /* ... gap (for sparse palettes) */
86 /* ... c_min/2 dynamic colorcells */
88 { 0xff, 0xfb, 0xf0, 0 },
89 { 0xa0, 0xa0, 0xa4, 0 },
90 { 0x80, 0x80, 0x80, 0 },
91 { 0xff, 0x00, 0x00, 0 },
92 { 0x00, 0xff, 0x00, 0 },
93 { 0xff, 0xff, 0x00, 0 },
94 { 0x00, 0x00, 0xff, 0 },
95 { 0xff, 0x00, 0xff, 0 },
96 { 0x00, 0xff, 0xff, 0 },
97 { 0xff, 0xff, 0xff, 0 } /* last 10 */
100 /***********************************************************************
103 * Create the system palette.
105 HPALETTE
PALETTE_Init(void)
111 /* create default palette (20 system colors) */
113 palPtr
= HeapAlloc( GetProcessHeap(), 0,
114 sizeof(LOGPALETTE
) + (NB_RESERVED_COLORS
-1)*sizeof(PALETTEENTRY
));
115 if (!palPtr
) return FALSE
;
117 palPtr
->palVersion
= 0x300;
118 palPtr
->palNumEntries
= NB_RESERVED_COLORS
;
119 memcpy( palPtr
->palPalEntry
, sys_pal_template
, sizeof(sys_pal_template
) );
120 hpalette
= CreatePalette( palPtr
);
121 HeapFree( GetProcessHeap(), 0, palPtr
);
123 palObj
= (PALETTEOBJ
*) GDI_GetObjPtr( hpalette
, PALETTE_MAGIC
);
126 if (!(palObj
->mapping
= HeapAlloc( GetProcessHeap(), 0, sizeof(int) * NB_RESERVED_COLORS
)))
127 ERR("Can not create palette mapping -- out of memory!\n");
128 GDI_ReleaseObj( hpalette
);
133 /***********************************************************************
134 * PALETTE_ValidateFlags
136 static void PALETTE_ValidateFlags(PALETTEENTRY
* lpPalE
, int size
)
139 for( ; i
<size
; i
++ )
140 lpPalE
[i
].peFlags
= PC_SYS_USED
| (lpPalE
[i
].peFlags
& 0x07);
144 /***********************************************************************
145 * CreatePalette [GDI32.@]
147 * Creates a logical color palette.
150 * Success: Handle to logical palette
153 HPALETTE WINAPI
CreatePalette(
154 const LOGPALETTE
* palette
) /* [in] Pointer to logical color palette */
156 PALETTEOBJ
* palettePtr
;
160 if (!palette
) return 0;
161 TRACE("entries=%i\n", palette
->palNumEntries
);
163 size
= sizeof(LOGPALETTE
) + (palette
->palNumEntries
- 1) * sizeof(PALETTEENTRY
);
165 if (!(palettePtr
= GDI_AllocObject( size
+ sizeof(int*) +sizeof(GDIOBJHDR
),
166 PALETTE_MAGIC
, (HGDIOBJ
*)&hpalette
,
167 &palette_funcs
))) return 0;
168 memcpy( &palettePtr
->logpalette
, palette
, size
);
169 PALETTE_ValidateFlags(palettePtr
->logpalette
.palPalEntry
,
170 palettePtr
->logpalette
.palNumEntries
);
171 palettePtr
->mapping
= NULL
;
172 GDI_ReleaseObj( hpalette
);
174 TRACE(" returning %p\n", hpalette
);
179 /***********************************************************************
180 * CreateHalftonePalette [GDI32.@]
182 * Creates a halftone palette.
185 * Success: Handle to logical halftone palette
188 * FIXME: This simply creates the halftone palette derived from running
189 * tests on an windows NT machine. this is assuming a color depth
190 * of greater that 256 color. On a 256 color device the halftone
191 * palette will be different and this function will be incorrect
193 HPALETTE WINAPI
CreateHalftonePalette(
194 HDC hdc
) /* [in] Handle to device context */
199 WORD NumberOfEntries
;
200 PALETTEENTRY aEntries
[256];
203 Palette
.Version
= 0x300;
204 Palette
.NumberOfEntries
= 256;
205 GetSystemPaletteEntries(hdc
, 0, 256, Palette
.aEntries
);
207 Palette
.NumberOfEntries
= 20;
209 for (i
= 0; i
< Palette
.NumberOfEntries
; i
++)
211 Palette
.aEntries
[i
].peRed
=0xff;
212 Palette
.aEntries
[i
].peGreen
=0xff;
213 Palette
.aEntries
[i
].peBlue
=0xff;
214 Palette
.aEntries
[i
].peFlags
=0x00;
217 Palette
.aEntries
[0].peRed
=0x00;
218 Palette
.aEntries
[0].peBlue
=0x00;
219 Palette
.aEntries
[0].peGreen
=0x00;
222 for (i
=1; i
<= 6; i
++)
224 Palette
.aEntries
[i
].peRed
=(i
%2)?0x80:0;
225 Palette
.aEntries
[i
].peGreen
=(i
==2)?0x80:(i
==3)?0x80:(i
==6)?0x80:0;
226 Palette
.aEntries
[i
].peBlue
=(i
>3)?0x80:0;
229 for (i
=7; i
<= 12; i
++)
234 Palette
.aEntries
[i
].peRed
=0xc0;
235 Palette
.aEntries
[i
].peBlue
=0xc0;
236 Palette
.aEntries
[i
].peGreen
=0xc0;
239 Palette
.aEntries
[i
].peRed
=0xc0;
240 Palette
.aEntries
[i
].peGreen
=0xdc;
241 Palette
.aEntries
[i
].peBlue
=0xc0;
244 Palette
.aEntries
[i
].peRed
=0xa6;
245 Palette
.aEntries
[i
].peGreen
=0xca;
246 Palette
.aEntries
[i
].peBlue
=0xf0;
249 Palette
.aEntries
[i
].peRed
=0xff;
250 Palette
.aEntries
[i
].peGreen
=0xfb;
251 Palette
.aEntries
[i
].peBlue
=0xf0;
254 Palette
.aEntries
[i
].peRed
=0xa0;
255 Palette
.aEntries
[i
].peGreen
=0xa0;
256 Palette
.aEntries
[i
].peBlue
=0xa4;
259 Palette
.aEntries
[i
].peRed
=0x80;
260 Palette
.aEntries
[i
].peGreen
=0x80;
261 Palette
.aEntries
[i
].peBlue
=0x80;
265 for (i
=13; i
<= 18; i
++)
267 Palette
.aEntries
[i
].peRed
=(i
%2)?0xff:0;
268 Palette
.aEntries
[i
].peGreen
=(i
==14)?0xff:(i
==15)?0xff:(i
==18)?0xff:0;
269 Palette
.aEntries
[i
].peBlue
=(i
>15)?0xff:0x00;
272 return CreatePalette((LOGPALETTE
*)&Palette
);
276 /***********************************************************************
277 * GetPaletteEntries [GDI32.@]
279 * Retrieves palette entries.
282 * Success: Number of entries from logical palette
285 UINT WINAPI
GetPaletteEntries(
286 HPALETTE hpalette
, /* [in] Handle of logical palette */
287 UINT start
, /* [in] First entry to receive */
288 UINT count
, /* [in] Number of entries to receive */
289 LPPALETTEENTRY entries
) /* [out] Address of array receiving entries */
294 TRACE("hpal = %p, count=%i\n", hpalette
, count
);
296 palPtr
= (PALETTEOBJ
*) GDI_GetObjPtr( hpalette
, PALETTE_MAGIC
);
297 if (!palPtr
) return 0;
299 /* NOTE: not documented but test show this to be the case */
302 int rc
= palPtr
->logpalette
.palNumEntries
;
303 GDI_ReleaseObj( hpalette
);
307 numEntries
= palPtr
->logpalette
.palNumEntries
;
308 if (start
+count
> numEntries
) count
= numEntries
- start
;
311 if (start
>= numEntries
)
313 GDI_ReleaseObj( hpalette
);
316 memcpy( entries
, &palPtr
->logpalette
.palPalEntry
[start
],
317 count
* sizeof(PALETTEENTRY
) );
318 for( numEntries
= 0; numEntries
< count
; numEntries
++ )
319 if (entries
[numEntries
].peFlags
& 0xF0)
320 entries
[numEntries
].peFlags
= 0;
323 GDI_ReleaseObj( hpalette
);
328 /***********************************************************************
329 * SetPaletteEntries [GDI32.@]
331 * Sets color values for range in palette.
334 * Success: Number of entries that were set
337 UINT WINAPI
SetPaletteEntries(
338 HPALETTE hpalette
, /* [in] Handle of logical palette */
339 UINT start
, /* [in] Index of first entry to set */
340 UINT count
, /* [in] Number of entries to set */
341 const PALETTEENTRY
*entries
) /* [in] Address of array of structures */
346 TRACE("hpal=%p,start=%i,count=%i\n",hpalette
,start
,count
);
348 if (hpalette
== GetStockObject(DEFAULT_PALETTE
)) return 0;
349 palPtr
= (PALETTEOBJ
*) GDI_GetObjPtr( hpalette
, PALETTE_MAGIC
);
350 if (!palPtr
) return 0;
352 numEntries
= palPtr
->logpalette
.palNumEntries
;
353 if (start
>= numEntries
)
355 GDI_ReleaseObj( hpalette
);
358 if (start
+count
> numEntries
) count
= numEntries
- start
;
359 memcpy( &palPtr
->logpalette
.palPalEntry
[start
], entries
,
360 count
* sizeof(PALETTEENTRY
) );
361 PALETTE_ValidateFlags(palPtr
->logpalette
.palPalEntry
,
362 palPtr
->logpalette
.palNumEntries
);
363 UnrealizeObject( hpalette
);
364 GDI_ReleaseObj( hpalette
);
369 /***********************************************************************
370 * ResizePalette [GDI32.@]
372 * Resizes logical palette.
378 BOOL WINAPI
ResizePalette(
379 HPALETTE hPal
, /* [in] Handle of logical palette */
380 UINT cEntries
) /* [in] Number of entries in logical palette */
382 PALETTEOBJ
* palPtr
= (PALETTEOBJ
*) GDI_GetObjPtr( hPal
, PALETTE_MAGIC
);
383 UINT cPrevEnt
, prevVer
;
384 int prevsize
, size
= sizeof(LOGPALETTE
) + (cEntries
- 1) * sizeof(PALETTEENTRY
);
387 TRACE("hpal = %p, prev = %i, new = %i\n",
388 hPal
, palPtr
? palPtr
->logpalette
.palNumEntries
: -1, cEntries
);
389 if( !palPtr
) return FALSE
;
390 cPrevEnt
= palPtr
->logpalette
.palNumEntries
;
391 prevVer
= palPtr
->logpalette
.palVersion
;
392 prevsize
= sizeof(LOGPALETTE
) + (cPrevEnt
- 1) * sizeof(PALETTEENTRY
) +
393 sizeof(int*) + sizeof(GDIOBJHDR
);
394 size
+= sizeof(int*) + sizeof(GDIOBJHDR
);
395 mapping
= palPtr
->mapping
;
397 if (!(palPtr
= GDI_ReallocObject( size
, hPal
, palPtr
))) return FALSE
;
401 int *newMap
= (int*) HeapReAlloc(GetProcessHeap(), 0,
402 mapping
, cEntries
* sizeof(int) );
405 ERR("Can not resize mapping -- out of memory!\n");
406 GDI_ReleaseObj( hPal
);
409 palPtr
->mapping
= newMap
;
412 if( cEntries
> cPrevEnt
)
415 memset(palPtr
->mapping
+ cPrevEnt
, 0, (cEntries
- cPrevEnt
)*sizeof(int));
416 memset( (BYTE
*)palPtr
+ prevsize
, 0, size
- prevsize
);
417 PALETTE_ValidateFlags((PALETTEENTRY
*)((BYTE
*)palPtr
+ prevsize
),
418 cEntries
- cPrevEnt
);
420 palPtr
->logpalette
.palNumEntries
= cEntries
;
421 palPtr
->logpalette
.palVersion
= prevVer
;
422 GDI_ReleaseObj( hPal
);
427 /***********************************************************************
428 * AnimatePalette [GDI32.@]
430 * Replaces entries in logical palette.
437 * Should use existing mapping when animating a primary palette
439 BOOL WINAPI
AnimatePalette(
440 HPALETTE hPal
, /* [in] Handle to logical palette */
441 UINT StartIndex
, /* [in] First entry in palette */
442 UINT NumEntries
, /* [in] Count of entries in palette */
443 const PALETTEENTRY
* PaletteColors
) /* [in] Pointer to first replacement */
445 TRACE("%p (%i - %i)\n", hPal
, StartIndex
,StartIndex
+NumEntries
);
447 if( hPal
!= GetStockObject(DEFAULT_PALETTE
) )
451 const PALETTEENTRY
*pptr
= PaletteColors
;
453 palPtr
= (PALETTEOBJ
*) GDI_GetObjPtr( hPal
, PALETTE_MAGIC
);
454 if (!palPtr
) return 0;
456 pal_entries
= palPtr
->logpalette
.palNumEntries
;
457 if (StartIndex
>= pal_entries
)
459 GDI_ReleaseObj( hPal
);
462 if (StartIndex
+NumEntries
> pal_entries
) NumEntries
= pal_entries
- StartIndex
;
464 for (NumEntries
+= StartIndex
; StartIndex
< NumEntries
; StartIndex
++, pptr
++) {
465 /* According to MSDN, only animate PC_RESERVED colours */
466 if (palPtr
->logpalette
.palPalEntry
[StartIndex
].peFlags
& PC_RESERVED
) {
467 TRACE("Animating colour (%d,%d,%d) to (%d,%d,%d)\n",
468 palPtr
->logpalette
.palPalEntry
[StartIndex
].peRed
,
469 palPtr
->logpalette
.palPalEntry
[StartIndex
].peGreen
,
470 palPtr
->logpalette
.palPalEntry
[StartIndex
].peBlue
,
471 pptr
->peRed
, pptr
->peGreen
, pptr
->peBlue
);
472 memcpy( &palPtr
->logpalette
.palPalEntry
[StartIndex
], pptr
,
473 sizeof(PALETTEENTRY
) );
474 PALETTE_ValidateFlags(&palPtr
->logpalette
.palPalEntry
[StartIndex
], 1);
476 TRACE("Not animating entry %d -- not PC_RESERVED\n", StartIndex
);
480 GDI_ReleaseObj( hPal
);
482 TRACE("pLastRealizedDC %p -- pLastRealizedDC->pRealizePalette %p\n",
483 pLastRealizedDC
, pLastRealizedDC
? pLastRealizedDC
->pRealizePalette
: 0);
485 if (pLastRealizedDC
&& pLastRealizedDC
->pRealizePalette
)
486 pLastRealizedDC
->pRealizePalette( NULL
, hPal
, hPal
== hPrimaryPalette
);
492 /***********************************************************************
493 * SetSystemPaletteUse [GDI32.@]
496 * Success: Previous system palette
497 * Failure: SYSPAL_ERROR
499 UINT WINAPI
SetSystemPaletteUse(
500 HDC hdc
, /* [in] Handle of device context */
501 UINT use
) /* [in] Palette-usage flag */
503 UINT old
= SystemPaletteUse
;
505 /* Device doesn't support colour palettes */
506 if (!(GetDeviceCaps(hdc
, RASTERCAPS
) & RC_PALETTE
)) {
511 case SYSPAL_NOSTATIC
:
512 case SYSPAL_NOSTATIC256
: /* WINVER >= 0x0500 */
514 SystemPaletteUse
= use
;
522 /***********************************************************************
523 * GetSystemPaletteUse [GDI32.@]
525 * Gets state of system palette.
528 * Current state of system palette
530 UINT WINAPI
GetSystemPaletteUse(
531 HDC hdc
) /* [in] Handle of device context */
533 return SystemPaletteUse
;
537 /***********************************************************************
538 * GetSystemPaletteEntries [GDI32.@]
540 * Gets range of palette entries.
543 * Success: Number of entries retrieved from palette
546 UINT WINAPI
GetSystemPaletteEntries(
547 HDC hdc
, /* [in] Handle of device context */
548 UINT start
, /* [in] Index of first entry to be retrieved */
549 UINT count
, /* [in] Number of entries to be retrieved */
550 LPPALETTEENTRY entries
) /* [out] Array receiving system-palette entries */
555 TRACE("hdc=%p,start=%i,count=%i\n", hdc
,start
,count
);
557 if ((dc
= DC_GetDCPtr( hdc
)))
559 if (dc
->funcs
->pGetSystemPaletteEntries
)
560 ret
= dc
->funcs
->pGetSystemPaletteEntries( dc
->physDev
, start
, count
, entries
);
561 GDI_ReleaseObj( hdc
);
567 /***********************************************************************
568 * GetNearestPaletteIndex [GDI32.@]
570 * Gets palette index for color.
573 * Should index be initialized to CLR_INVALID instead of 0?
576 * Success: Index of entry in logical palette
577 * Failure: CLR_INVALID
579 UINT WINAPI
GetNearestPaletteIndex(
580 HPALETTE hpalette
, /* [in] Handle of logical color palette */
581 COLORREF color
) /* [in] Color to be matched */
583 PALETTEOBJ
* palObj
= (PALETTEOBJ
*)GDI_GetObjPtr( hpalette
, PALETTE_MAGIC
);
588 int i
, diff
= 0x7fffffff;
590 PALETTEENTRY
* entry
= palObj
->logpalette
.palPalEntry
;
592 for( i
= 0; i
< palObj
->logpalette
.palNumEntries
&& diff
; i
++, entry
++)
594 if (!(entry
->peFlags
& PC_SYS_USED
)) continue;
596 r
= entry
->peRed
- GetRValue(color
);
597 g
= entry
->peGreen
- GetGValue(color
);
598 b
= entry
->peBlue
- GetBValue(color
);
602 if( r
< diff
) { index
= i
; diff
= r
; }
604 GDI_ReleaseObj( hpalette
);
606 TRACE("(%p,%06lx): returning %d\n", hpalette
, color
, index
);
611 /***********************************************************************
612 * GetNearestColor [GDI32.@]
614 * Gets a system color to match.
617 * Success: Color from system palette that corresponds to given color
618 * Failure: CLR_INVALID
620 COLORREF WINAPI
GetNearestColor(
621 HDC hdc
, /* [in] Handle of device context */
622 COLORREF color
) /* [in] Color to be matched */
624 unsigned char spec_type
;
628 if (!(dc
= DC_GetDCPtr( hdc
))) return CLR_INVALID
;
630 if (dc
->funcs
->pGetNearestColor
)
632 nearest
= dc
->funcs
->pGetNearestColor( dc
->physDev
, color
);
633 GDI_ReleaseObj( hdc
);
637 if (!(GetDeviceCaps(hdc
, RASTERCAPS
) & RC_PALETTE
))
639 GDI_ReleaseObj( hdc
);
643 spec_type
= color
>> 24;
644 if (spec_type
== 1 || spec_type
== 2)
646 /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
650 HPALETTE hpal
= dc
->hPalette
? dc
->hPalette
: GetStockObject( DEFAULT_PALETTE
);
652 if (spec_type
== 2) /* PALETTERGB */
653 index
= GetNearestPaletteIndex( hpal
, color
);
654 else /* PALETTEINDEX */
655 index
= LOWORD(color
);
657 if (!GetPaletteEntries( hpal
, index
, 1, &entry
))
659 WARN("RGB(%lx) : idx %d is out of bounds, assuming NULL\n", color
, index
);
660 if (!GetPaletteEntries( hpal
, 0, 1, &entry
))
662 GDI_ReleaseObj( hdc
);
666 color
= RGB( entry
.peRed
, entry
.peGreen
, entry
.peBlue
);
668 nearest
= color
& 0x00ffffff;
669 GDI_ReleaseObj( hdc
);
671 TRACE("(%06lx): returning %06lx\n", color
, nearest
);
676 /***********************************************************************
679 static INT
PALETTE_GetObject( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
)
681 PALETTEOBJ
*palette
= obj
;
686 if (count
> sizeof(WORD
)) count
= sizeof(WORD
);
687 memcpy( buffer
, &palette
->logpalette
.palNumEntries
, count
);
692 /***********************************************************************
693 * PALETTE_UnrealizeObject
695 static BOOL
PALETTE_UnrealizeObject( HGDIOBJ handle
, void *obj
)
697 PALETTEOBJ
*palette
= obj
;
699 if (palette
->mapping
)
701 HeapFree( GetProcessHeap(), 0, palette
->mapping
);
702 palette
->mapping
= NULL
;
704 if (hLastRealizedPalette
== handle
)
706 TRACE("unrealizing palette %p\n", handle
);
707 hLastRealizedPalette
= 0;
708 pLastRealizedDC
= NULL
;
714 /***********************************************************************
715 * PALETTE_DeleteObject
717 static BOOL
PALETTE_DeleteObject( HGDIOBJ handle
, void *obj
)
719 PALETTEOBJ
*palette
= obj
;
721 HeapFree( GetProcessHeap(), 0, palette
->mapping
);
722 if (hLastRealizedPalette
== handle
)
724 TRACE("unrealizing palette %p\n", handle
);
725 hLastRealizedPalette
= 0;
726 pLastRealizedDC
= NULL
;
728 return GDI_FreeObject( handle
, obj
);
732 /***********************************************************************
733 * GDISelectPalette (Not a Windows API)
735 HPALETTE WINAPI
GDISelectPalette( HDC hdc
, HPALETTE hpal
, WORD wBkg
)
740 TRACE("%p %p\n", hdc
, hpal
);
742 if (GetObjectType(hpal
) != OBJ_PAL
)
744 WARN("invalid selected palette %p\n",hpal
);
747 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
749 if (dc
->funcs
->pSelectPalette
) hpal
= dc
->funcs
->pSelectPalette( dc
->physDev
, hpal
, FALSE
);
753 if (!wBkg
) hPrimaryPalette
= hpal
;
756 GDI_ReleaseObj( hdc
);
761 /***********************************************************************
762 * GDIRealizePalette (Not a Windows API)
764 UINT WINAPI
GDIRealizePalette( HDC hdc
)
767 DC
* dc
= DC_GetDCPtr( hdc
);
771 TRACE("%p...\n", hdc
);
773 if( dc
->hPalette
== GetStockObject( DEFAULT_PALETTE
))
775 if (dc
->funcs
->pRealizeDefaultPalette
)
776 realized
= dc
->funcs
->pRealizeDefaultPalette( dc
->physDev
);
778 else if(dc
->hPalette
!= hLastRealizedPalette
)
780 if (dc
->funcs
->pRealizePalette
)
781 realized
= dc
->funcs
->pRealizePalette( dc
->physDev
, dc
->hPalette
,
782 (dc
->hPalette
== hPrimaryPalette
) );
783 hLastRealizedPalette
= dc
->hPalette
;
784 pLastRealizedDC
= dc
->funcs
;
786 else TRACE(" skipping (hLastRealizedPalette = %p)\n", hLastRealizedPalette
);
788 GDI_ReleaseObj( hdc
);
789 TRACE(" realized %i colors.\n", realized
);
794 /***********************************************************************
795 * RealizeDefaultPalette (GDI.365)
797 UINT16 WINAPI
RealizeDefaultPalette16( HDC16 hdc
)
802 TRACE("%04x\n", hdc
);
804 if (!(dc
= DC_GetDCPtr( HDC_32(hdc
) ))) return 0;
806 if (dc
->funcs
->pRealizeDefaultPalette
) ret
= dc
->funcs
->pRealizeDefaultPalette( dc
->physDev
);
807 GDI_ReleaseObj( HDC_32(hdc
) );
811 /***********************************************************************
812 * IsDCCurrentPalette (GDI.412)
814 BOOL16 WINAPI
IsDCCurrentPalette16(HDC16 hDC
)
816 DC
*dc
= DC_GetDCPtr( HDC_32(hDC
) );
819 BOOL bRet
= dc
->hPalette
== hPrimaryPalette
;
820 GDI_ReleaseObj( HDC_32(hDC
) );
827 /***********************************************************************
828 * SelectPalette [GDI32.@]
830 * Selects logical palette into DC.
833 * Success: Previous logical palette
836 HPALETTE WINAPI
SelectPalette(
837 HDC hDC
, /* [in] Handle of device context */
838 HPALETTE hPal
, /* [in] Handle of logical color palette */
839 BOOL bForceBackground
) /* [in] Foreground/background mode */
841 return pfnSelectPalette( hDC
, hPal
, bForceBackground
);
845 /***********************************************************************
846 * RealizePalette [GDI32.@]
848 * Maps palette entries to system palette.
851 * Success: Number of entries in logical palette
854 UINT WINAPI
RealizePalette(
855 HDC hDC
) /* [in] Handle of device context */
857 return pfnRealizePalette( hDC
);
861 typedef HWND (WINAPI
*WindowFromDC_funcptr
)( HDC
);
862 typedef BOOL (WINAPI
*RedrawWindow_funcptr
)( HWND
, const RECT
*, HRGN
, UINT
);
864 /**********************************************************************
865 * UpdateColors [GDI32.@]
867 * Remaps current colors to logical palette.
873 BOOL WINAPI
UpdateColors(
874 HDC hDC
) /* [in] Handle of device context */
877 int size
= GetDeviceCaps( hDC
, SIZEPALETTE
);
881 mod
= GetModuleHandleA("user32.dll");
884 WindowFromDC_funcptr pWindowFromDC
= (WindowFromDC_funcptr
)GetProcAddress(mod
,"WindowFromDC");
887 HWND hWnd
= pWindowFromDC( hDC
);
889 /* Docs say that we have to remap current drawable pixel by pixel
890 * but it would take forever given the speed of XGet/PutPixel.
894 RedrawWindow_funcptr pRedrawWindow
= GetProcAddress( mod
, "RedrawWindow" );
895 if (pRedrawWindow
) pRedrawWindow( hWnd
, NULL
, 0, RDW_INVALIDATE
);
903 /*********************************************************************
904 * SetMagicColors (GDI.606)
906 VOID WINAPI
SetMagicColors16(HDC16 hDC
, COLORREF color
, UINT16 index
)
908 FIXME("(hDC %04x, color %04x, index %04x): stub\n", hDC
, (int)color
, index
);
912 /**********************************************************************
913 * GetICMProfileA [GDI32.@]
915 * Returns the filename of the specified device context's color
916 * management profile, even if color management is not enabled
920 * TRUE if name copied successfully OR lpszFilename is NULL
921 * FALSE if the buffer length pointed to by lpcbName is too small
924 * The buffer length pointed to by lpcbName is ALWAYS updated to
925 * the length required regardless of other actions this function
929 * How does Windows assign these? Some registry key?
932 #define WINEICM "winefake.icm" /* easy-to-identify fake filename */
934 /*********************************************************************/
936 BOOL WINAPI
GetICMProfileA(HDC hDC
, LPDWORD lpcbName
, LPSTR lpszFilename
)
940 FIXME("(%p, %p, %p): partial stub\n", hDC
, lpcbName
, lpszFilename
);
942 callerLen
= *lpcbName
;
944 /* all 3 behaviors require the required buffer size to be set */
945 *lpcbName
= strlen(WINEICM
);
947 /* behavior 1: if lpszFilename is NULL, return size of string and no error */
948 if ((DWORD
)lpszFilename
== (DWORD
)0x00000000)
951 /* behavior 2: if buffer size too small, return size of string and error */
952 if (callerLen
< strlen(WINEICM
))
954 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
958 /* behavior 3: if buffer size OK and pointer not NULL, copy and return size */
959 strcpy(lpszFilename
, WINEICM
);
963 /**********************************************************************
964 * SetICMProfileA [GDI32.@]
967 BOOL WINAPI
SetICMProfileA(HDC hDC
, LPSTR lpszFilename
)
969 FIXME("hDC %p filename '%s': stub!\n", hDC
, debugstr_a(lpszFilename
));
970 return TRUE
; /* success */