ReactOS 0.4.15-dev-7897-g78dc504
palette.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: GDI Palette Functions
5 * FILE: win32ss/gdi/ntgdi/palette.c
6 * PROGRAMERS: Jason Filby
7 * Timo Kreuzer
8 */
9
10#include <win32k.h>
11
12#define NDEBUG
13#include <debug.h>
14
15#define PAL_SETPOWNER 0x8000
16#define MAX_PALCOLORS 65536
17
18static UINT SystemPaletteUse = SYSPAL_NOSTATIC; /* The program need save the pallete and restore it */
19
22
24{
25 // First 10 entries in the system palette
26 // Red Green Blue Flags
27 { 0x00, 0x00, 0x00, PC_SYS_USED },
28 { 0x80, 0x00, 0x00, PC_SYS_USED },
29 { 0x00, 0x80, 0x00, PC_SYS_USED },
30 { 0x80, 0x80, 0x00, PC_SYS_USED },
31 { 0x00, 0x00, 0x80, PC_SYS_USED },
32 { 0x80, 0x00, 0x80, PC_SYS_USED },
33 { 0x00, 0x80, 0x80, PC_SYS_USED },
34 { 0xc0, 0xc0, 0xc0, PC_SYS_USED },
35 { 0xc0, 0xdc, 0xc0, PC_SYS_USED },
36 { 0xa6, 0xca, 0xf0, PC_SYS_USED },
37
38 // ... c_min/2 dynamic colorcells
39 // ... gap (for sparse palettes)
40 // ... c_min/2 dynamic colorcells
41
42 { 0xff, 0xfb, 0xf0, PC_SYS_USED },
43 { 0xa0, 0xa0, 0xa4, PC_SYS_USED },
44 { 0x80, 0x80, 0x80, PC_SYS_USED },
45 { 0xff, 0x00, 0x00, PC_SYS_USED },
46 { 0x00, 0xff, 0x00, PC_SYS_USED },
47 { 0xff, 0xff, 0x00, PC_SYS_USED },
48 { 0x00, 0x00, 0xff, PC_SYS_USED },
49 { 0xff, 0x00, 0xff, PC_SYS_USED },
50 { 0x00, 0xff, 0xff, PC_SYS_USED },
51 { 0xff, 0xff, 0xff, PC_SYS_USED } // Last 10
52};
53
54unsigned short GetNumberOfBits(unsigned int dwMask)
55{
56 unsigned short wBits;
57 for (wBits = 0; dwMask; dwMask = dwMask & (dwMask - 1))
58 wBits++;
59 return wBits;
60}
61
62// Create the system palette
63CODE_SEG("INIT")
67{
68 // Create default palette (20 system colors)
70 20,
72 0, 0, 0);
75
76 /* palette_size = visual->map_entries; */
77
79 gpalRGB.RedMask = RGB(0xFF, 0x00, 0x00);
80 gpalRGB.GreenMask = RGB(0x00, 0xFF, 0x00);
81 gpalRGB.BlueMask = RGB(0x00, 0x00, 0xFF);
84
86 gpalBGR.RedMask = RGB(0x00, 0x00, 0xFF);
87 gpalBGR.GreenMask = RGB(0x00, 0xFF, 0x00);
88 gpalBGR.BlueMask = RGB(0xFF, 0x00, 0x00);
91
93 gpalRGB555.RedMask = 0x7C00;
94 gpalRGB555.GreenMask = 0x3E0;
95 gpalRGB555.BlueMask = 0x1F;
98
100 gpalRGB565.RedMask = 0xF800;
101 gpalRGB565.GreenMask = 0x7E0;
102 gpalRGB565.BlueMask = 0x1F;
105
109
110 /* Initialize default surface palettes */
121
122 return STATUS_SUCCESS;
123}
124
126{
127 int i = 0;
128 for (; i<size ; i++)
129 lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
130}
131
132
134NTAPI
137 _In_ ULONG cColors,
138 _In_opt_ const PALETTEENTRY* pEntries,
139 _In_ FLONG flRed,
140 _In_ FLONG flGreen,
141 _In_ FLONG flBlue)
142{
143 PPALETTE ppal;
144 ULONG fl = 0, cjSize = sizeof(PALETTE);
145
146 /* Check if the palette has entries */
147 if (iMode & PAL_INDEXED)
148 {
149 /* Check color count */
150 if ((cColors == 0) || (cColors > 1024)) return NULL;
151
152 /* Allocate enough space for the palete entries */
153 cjSize += cColors * sizeof(PALETTEENTRY);
154 }
155 else
156 {
157 /* There are no palette entries */
158 cColors = 0;
159
160 /* We can use the lookaside list */
162 }
163
164 /* Allocate the object (without a handle!) */
166 if (!ppal)
167 {
168 return NULL;
169 }
170
171 /* Set mode, color count and entry pointer */
172 ppal->flFlags = iMode;
173 ppal->NumColors = cColors;
174 ppal->IndexedColors = ppal->apalColors;
175
176 /* Check what kind of palette this is */
177 if (iMode & PAL_INDEXED)
178 {
179 /* Check if we got a color array */
180 if (pEntries)
181 {
182 /* Copy the entries */
183 RtlCopyMemory(ppal->IndexedColors, pEntries, cColors * sizeof(pEntries[0]));
184 }
185 }
186 else if (iMode & PAL_BITFIELDS)
187 {
188 /* Copy the color masks */
189 ppal->RedMask = flRed;
190 ppal->GreenMask = flGreen;
191 ppal->BlueMask = flBlue;
192
193 /* Check what masks we have and set optimization flags */
194 if ((flRed == 0x7c00) && (flGreen == 0x3E0) && (flBlue == 0x1F))
195 ppal->flFlags |= PAL_RGB16_555;
196 else if ((flRed == 0xF800) && (flGreen == 0x7E0) && (flBlue == 0x1F))
197 ppal->flFlags |= PAL_RGB16_565;
198 else if ((flRed == 0xFF0000) && (flGreen == 0xFF00) && (flBlue == 0xFF))
199 ppal->flFlags |= PAL_BGR;
200 else if ((flRed == 0xFF) && (flGreen == 0xFF00) && (flBlue == 0xFF0000))
201 ppal->flFlags |= PAL_RGB;
202 }
203
204 return ppal;
205}
206
208NTAPI
211 _In_ ULONG cColors,
212 _In_opt_ const PALETTEENTRY* pEntries,
213 _In_ FLONG flRed,
214 _In_ FLONG flGreen,
215 _In_ FLONG flBlue)
216{
217 PPALETTE ppal;
218
219 /* Allocate the palette without a handle */
220 ppal = PALETTE_AllocPalette(iMode, cColors, pEntries, flRed, flGreen, flBlue);
221 if (!ppal) return NULL;
222
223 /* Insert the palette into the handle table */
225 {
226 DPRINT1("Could not insert palette into handle table.\n");
228 return NULL;
229 }
230
231 return ppal;
232}
233
234VOID
235NTAPI
237{
238 PPALETTE pPal = (PPALETTE)ObjectBody;
239 if (pPal->IndexedColors && pPal->IndexedColors != pPal->apalColors)
240 {
242 }
243}
244
245INT
248{
249 if (!lpBuffer)
250 {
251 return sizeof(WORD);
252 }
253
254 if ((UINT)cbCount < sizeof(WORD)) return 0;
255 *((WORD*)lpBuffer) = (WORD)ppal->NumColors;
256 return sizeof(WORD);
257}
258
259ULONG
260NTAPI
262{
263 ULONG ulDiff, ulColorDiff, ulMinimalDiff = 0xFFFFFF;
264 ULONG i, ulBestIndex = 0;
265 PALETTEENTRY peColor = *(PPALETTEENTRY)&iColor;
266
267 /* Loop all palette entries */
268 for (i = 0; i < ppal->NumColors; i++)
269 {
270 /* Calculate distance in the color cube */
271 ulDiff = peColor.peRed - ppal->IndexedColors[i].peRed;
272 ulColorDiff = ulDiff * ulDiff;
273 ulDiff = peColor.peGreen - ppal->IndexedColors[i].peGreen;
274 ulColorDiff += ulDiff * ulDiff;
275 ulDiff = peColor.peBlue - ppal->IndexedColors[i].peBlue;
276 ulColorDiff += ulDiff * ulDiff;
277
278 /* Check for a better match */
279 if (ulColorDiff < ulMinimalDiff)
280 {
281 ulBestIndex = i;
282 ulMinimalDiff = ulColorDiff;
283
284 /* Break on exact match */
285 if (ulMinimalDiff == 0) break;
286 }
287 }
288
289 return ulBestIndex;
290}
291
292ULONG
293NTAPI
295{
296 ULONG ulNewColor;
297
298 // FIXME: HACK, should be stored already
299 ppal->ulRedShift = CalculateShift(RGB(0xff,0,0), ppal->RedMask);
300 ppal->ulGreenShift = CalculateShift(RGB(0,0xff,0), ppal->GreenMask);
301 ppal->ulBlueShift = CalculateShift(RGB(0,0,0xff), ppal->BlueMask);
302
303 ulNewColor = _rotl(ulColor, ppal->ulRedShift) & ppal->RedMask;
304 ulNewColor |= _rotl(ulColor, ppal->ulGreenShift) & ppal->GreenMask;
305 ulNewColor |= _rotl(ulColor, ppal->ulBlueShift) & ppal->BlueMask;
306
307 return ulNewColor;
308}
309
310ULONG
311NTAPI
313{
314 if (ppal->flFlags & PAL_INDEXED) // Use fl & PALINDEXED
315 return PALETTE_ulGetNearestPaletteIndex(ppal, ulColor);
316 else
317 return PALETTE_ulGetNearestBitFieldsIndex(ppal, ulColor);
318}
319
320VOID
321NTAPI
323{
324 ASSERT(pulColors);
325
326 if (ppal->flFlags & PAL_INDEXED || ppal->flFlags & PAL_RGB)
327 {
328 pulColors[0] = RGB(0xFF, 0x00, 0x00);
329 pulColors[1] = RGB(0x00, 0xFF, 0x00);
330 pulColors[2] = RGB(0x00, 0x00, 0xFF);
331 }
332 else if (ppal->flFlags & PAL_BGR)
333 {
334 pulColors[0] = RGB(0x00, 0x00, 0xFF);
335 pulColors[1] = RGB(0x00, 0xFF, 0x00);
336 pulColors[2] = RGB(0xFF, 0x00, 0x00);
337 }
338 else if (ppal->flFlags & PAL_BITFIELDS)
339 {
340 pulColors[0] = ppal->RedMask;
341 pulColors[1] = ppal->GreenMask;
342 pulColors[2] = ppal->BlueMask;
343 }
344}
345
346VOID
349{
350 PPDEVOBJ ppdev = (PPDEVOBJ)PalGDI->hPDev;
351
352 if (!ppdev) return;
353
354 if (ppdev->flFlags & PDEV_GAMMARAMP_TABLE)
355 {
356 ULONG i;
357 PGAMMARAMP GammaRamp = (PGAMMARAMP)ppdev->pvGammaRamp;
358 for ( i = 0; i < Colors; i++)
359 {
360 PaletteEntry[i].peRed += GammaRamp->Red[i];
361 PaletteEntry[i].peGreen += GammaRamp->Green[i];
362 PaletteEntry[i].peBlue += GammaRamp->Blue[i];
363 }
364 }
365 return;
366}
367
370/*
371 * @implemented
372 */
373HPALETTE
376 ULONG iMode,
377 ULONG cColors,
378 ULONG *pulColors,
379 ULONG flRed,
380 ULONG flGreen,
381 ULONG flBlue)
382{
383 PPALETTE ppal;
384 HPALETTE hpal;
385
386 ppal = PALETTE_AllocPalette(iMode, cColors, (PPALETTEENTRY)pulColors, flRed, flGreen, flBlue);
387 if (!ppal) return NULL;
388
390 if (!hpal)
391 {
392 DPRINT1("Could not insert palette into handle table.\n");
394 return NULL;
395 }
396
398 return hpal;
399}
400
401/*
402 * @implemented
403 */
404BOOL
406EngDeletePalette(IN HPALETTE hpal)
407{
408 PPALETTE ppal;
409
410 ppal = PALETTE_ShareLockPalette(hpal);
411 if (!ppal) return FALSE;
412
414
415 return TRUE;
416}
417
418/*
419 * @implemented
420 */
421ULONG
424{
425 PALETTE *PalGDI;
426
427 PalGDI = (PALETTE*)PalObj;
428
429 if (Start >= PalGDI->NumColors)
430 return 0;
431
432 Colors = min(Colors, PalGDI->NumColors - Start);
433
434 /* NOTE: PaletteEntry ULONGs are in the same order as PALETTEENTRY. */
435 RtlCopyMemory(PaletteEntry, PalGDI->IndexedColors + Start, sizeof(ULONG) * Colors);
436
437 if (PalGDI->flFlags & PAL_GAMMACORRECTION)
438 ColorCorrection(PalGDI, (PPALETTEENTRY)PaletteEntry, Colors);
439
440 return Colors;
441}
442
443
446HPALETTE
447NTAPI
449 IN LPLOGPALETTE pLogPal,
451{
452 HPALETTE hpal = NULL;
453 PPALETTE ppal;
454
455 pLogPal->palNumEntries = cEntries;
457 cEntries,
458 pLogPal->palPalEntry,
459 0, 0, 0);
460
461 if (ppal != NULL)
462 {
464
465 hpal = ppal->BaseObject.hHmgr;
467 }
468
469 return hpal;
470}
471
472/*
473 * @implemented
474 */
475HPALETTE
478 IN LPLOGPALETTE plogpalUser,
480{
481 HPALETTE hpal = NULL;
482 PPALETTE ppal;
483 ULONG i, cjSize;
484
486 if (ppal == NULL)
487 {
488 return NULL;
489 }
490
491 cjSize = FIELD_OFFSET(LOGPALETTE, palPalEntry[cEntries]);
492
494 {
495 ProbeForRead(plogpalUser, cjSize, 1);
496
497 for (i = 0; i < cEntries; i++)
498 {
499 ppal->IndexedColors[i] = plogpalUser->palPalEntry[i];
500 }
501 }
503 {
505 _SEH2_YIELD(return NULL);
506 }
507 _SEH2_END;
508
510 hpal = ppal->BaseObject.hHmgr;
512
513 return hpal;
514}
515
516HPALETTE
519{
520 int i, r, g, b;
521 PALETTEENTRY PalEntries[256];
522 PPALETTE ppal;
523 PDC pdc;
524 HPALETTE hpal = NULL;
525
526 pdc = DC_LockDc(hDC);
527 if (!pdc)
528 {
530 return NULL;
531 }
532
533 RtlZeroMemory(PalEntries, sizeof(PalEntries));
534
535 /* First and last ten entries are default ones */
536 for (i = 0; i < 10; i++)
537 {
538 PalEntries[i].peRed = g_sysPalTemplate[i].peRed;
539 PalEntries[i].peGreen = g_sysPalTemplate[i].peGreen;
540 PalEntries[i].peBlue = g_sysPalTemplate[i].peBlue;
541
542 PalEntries[246 + i].peRed = g_sysPalTemplate[10 + i].peRed;
543 PalEntries[246 + i].peGreen = g_sysPalTemplate[10 + i].peGreen;
544 PalEntries[246 + i].peBlue = g_sysPalTemplate[10 + i].peBlue;
545 }
546
547 ppal = PALETTE_ShareLockPalette(pdc->dclevel.hpal);
548 if (ppal && (ppal->flFlags & PAL_INDEXED))
549 {
550 /* FIXME: optimize the palette for the current palette */
552 }
553 else
554 {
555 for (r = 0; r < 6; r++)
556 {
557 for (g = 0; g < 6; g++)
558 {
559 for (b = 0; b < 6; b++)
560 {
561 i = r + g*6 + b*36 + 10;
562 PalEntries[i].peRed = r * 51;
563 PalEntries[i].peGreen = g * 51;
564 PalEntries[i].peBlue = b * 51;
565 }
566 }
567 }
568
569 for (i = 216; i < 246; i++)
570 {
571 int v = (i - 216) << 3;
572 PalEntries[i].peRed = v;
573 PalEntries[i].peGreen = v;
574 PalEntries[i].peBlue = v;
575 }
576 }
577
578 if (ppal)
580
581 DC_UnlockDc(pdc);
582
583 ppal = PALETTE_AllocPalWithHandle(PAL_INDEXED, 256, PalEntries, 0, 0, 0);
584 if (ppal)
585 {
586 hpal = ppal->BaseObject.hHmgr;
588 }
589
590 return hpal;
591}
592
593BOOL
596 HPALETTE hpal,
598{
599/* PALOBJ *palPtr = (PALOBJ*)AccessUserObject(hPal);
600 UINT cPrevEnt, prevVer;
601 INT prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
602 XLATEOBJ *XlateObj = NULL;
603
604 if(!palPtr) return FALSE;
605 cPrevEnt = palPtr->logpalette->palNumEntries;
606 prevVer = palPtr->logpalette->palVersion;
607 prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) + sizeof(int*) + sizeof(GDIOBJHDR);
608 size += sizeof(int*) + sizeof(GDIOBJHDR);
609 XlateObj = palPtr->logicalToSystem;
610
611 if (!(palPtr = GDI_ReallocObject(size, hPal, palPtr))) return FALSE;
612
613 if(XlateObj)
614 {
615 XLATEOBJ *NewXlateObj = (int*) HeapReAlloc(GetProcessHeap(), 0, XlateObj, cEntries * sizeof(int));
616 if(NewXlateObj == NULL)
617 {
618 ERR("Can not resize logicalToSystem -- out of memory!\n");
619 GDI_ReleaseObj( hPal );
620 return FALSE;
621 }
622 palPtr->logicalToSystem = NewXlateObj;
623 }
624
625 if(cEntries > cPrevEnt)
626 {
627 if(XlateObj) memset(palPtr->logicalToSystem + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
628 memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
629 PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize), cEntries - cPrevEnt );
630 }
631 palPtr->logpalette->palNumEntries = cEntries;
632 palPtr->logpalette->palVersion = prevVer;
633// GDI_ReleaseObj( hPal );
634 return TRUE; */
635
637 return FALSE;
638}
639
640BOOL
643 HDC hdc,
645{
647 return FALSE;
648}
649
650BOOL
653 HDC hdc,
655{
657 return FALSE;
658}
659
663 _In_ HDC hDC,
665{
666 COLORREF nearest = CLR_INVALID;
667 PDC dc;
668 EXLATEOBJ exlo;
669 PPALETTE ppal;
670
671 dc = DC_LockDc(hDC);
672
673 if(dc == NULL)
674 {
676 return CLR_INVALID;
677 }
678
680 if(dc->dclevel.pSurface == NULL)
681 ppal = gppalMono;
682 else
683 ppal = dc->dclevel.pSurface->ppal;
684
685 /* Translate the color to the DC format */
687
688 /* XLATE it back to RGB color space */
690 ppal,
691 &gpalRGB,
692 0,
693 RGB(0xff, 0xff, 0xff),
694 RGB(0, 0, 0));
695
696 nearest = XLATEOBJ_iXlate(&exlo.xlo, Color);
697
698 EXLATEOBJ_vCleanup(&exlo);
699
700 /* We're done */
702
703 return nearest;
704}
705
706UINT
709 HPALETTE hpal,
710 COLORREF crColor)
711{
713 UINT index = 0;
714
715 if (ppal)
716 {
717 if (ppal->flFlags & PAL_INDEXED)
718 {
719 /* Return closest match for the given RGB color */
721 }
722 // else SetLastError ?
724 }
725
726 return index;
727}
728
729UINT
732{
733 UINT realize = 0;
734 PDC pdc;
735 PALETTE *ppalSurf, *ppalDC;
736
737 pdc = DC_LockDc(hDC);
738 if (!pdc)
739 {
741 return 0;
742 }
743
744 if (!pdc->dclevel.pSurface)
745 {
746 goto cleanup;
747 }
748
749 if (pdc->dctype == DCTYPE_DIRECT)
750 {
751 static BOOL g_WarnedOnce = FALSE;
752 if (!g_WarnedOnce)
753 {
754 g_WarnedOnce = TRUE;
756 }
757 goto cleanup;
758 }
759
761 ppalSurf = pdc->dclevel.pSurface->ppal;
762 ppalDC = pdc->dclevel.ppal;
763
764 if (!(ppalSurf->flFlags & PAL_INDEXED))
765 {
766 // FIXME: Set error?
767 goto cleanup;
768 }
769
770 ASSERT(ppalDC->flFlags & PAL_INDEXED);
771
772 DPRINT1("RealizePalette unimplemented for %s\n",
773 (pdc->dctype == DCTYPE_MEMORY ? "memory managed DCs" : "device DCs"));
774
775cleanup:
776 DC_UnlockDc(pdc);
777 return realize;
778}
779
781IntAnimatePalette(HPALETTE hPal,
782 UINT StartIndex,
783 UINT NumEntries,
784 CONST PPALETTEENTRY PaletteColors)
785{
786 UINT ret = 0;
787
789 {
790 PPALETTE palPtr;
792 const PALETTEENTRY *pptr = PaletteColors;
793
794 palPtr = PALETTE_ShareLockPalette(hPal);
795 if (!palPtr) return FALSE;
796
797 pal_entries = palPtr->NumColors;
798 if (StartIndex >= pal_entries)
799 {
801 return FALSE;
802 }
803 if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
804
805 for (NumEntries += StartIndex; StartIndex < NumEntries; StartIndex++, pptr++)
806 {
807 /* According to MSDN, only animate PC_RESERVED colours */
808 if (palPtr->IndexedColors[StartIndex].peFlags & PC_RESERVED)
809 {
810 memcpy( &palPtr->IndexedColors[StartIndex], pptr,
811 sizeof(PALETTEENTRY) );
812 ret++;
813 PALETTE_ValidateFlags(&palPtr->IndexedColors[StartIndex], 1);
814 }
815 }
816
818
819#if 0
820/* FIXME: This is completely broken! We cannot call UserGetDesktopWindow
821 without first acquiring the USER lock. But the whole process here is
822 screwed anyway. Instead of messing with the desktop DC, we need to
823 check, whether the palette is associated with a PDEV and whether that
824 PDEV supports palette operations. Then we need to call pfnDrvSetPalette.
825 But since IntGdiRealizePalette() is not even implemented for direct DCs,
826 we can as well just do nothing, that will at least not ASSERT!
827 I leave the whole thing here, to scare people away, who want to "fix" it. */
828
829 /* Immediately apply the new palette if current window uses it */
830 Wnd = UserGetDesktopWindow();
831 hDC = UserGetWindowDC(Wnd);
832 dc = DC_LockDc(hDC);
833 if (NULL != dc)
834 {
835 if (dc->dclevel.hpal == hPal)
836 {
839 }
840 else
842 }
843 UserReleaseDC(Wnd,hDC, FALSE);
844#endif // 0
845 }
846 return ret;
847}
848
851 HPALETTE hpal,
852 UINT StartIndex,
855{
856 PPALETTE palGDI;
857 UINT numEntries;
858
859 palGDI = (PPALETTE) PALETTE_ShareLockPalette(hpal);
860 if (NULL == palGDI)
861 {
862 return 0;
863 }
864
865 numEntries = palGDI->NumColors;
866 if (NULL != pe)
867 {
868 if (numEntries < StartIndex + Entries)
869 {
870 Entries = numEntries - StartIndex;
871 }
872 if (numEntries <= StartIndex)
873 {
875 return 0;
876 }
877 memcpy(pe, palGDI->IndexedColors + StartIndex, Entries * sizeof(PALETTEENTRY));
878 }
879 else
880 {
881 Entries = numEntries;
882 }
883
885 return Entries;
886}
887
890 UINT StartIndex,
893{
894 PPALETTE palGDI = NULL;
895 PDC dc = NULL;
896 UINT EntriesSize = 0;
897 UINT Ret = 0;
898
899 if (Entries == 0)
900 {
902 return 0;
903 }
904
905 if (pe != NULL)
906 {
907 EntriesSize = Entries * sizeof(pe[0]);
908 if (Entries != EntriesSize / sizeof(pe[0]))
909 {
910 /* Integer overflow! */
912 return 0;
913 }
914 }
915
916 if (!(dc = DC_LockDc(hDC)))
917 {
919 return 0;
920 }
921
922 palGDI = PALETTE_ShareLockPalette(dc->dclevel.hpal);
923 if (palGDI != NULL)
924 {
925 if (pe != NULL)
926 {
927 if (StartIndex >= palGDI->NumColors)
928 Entries = 0;
929 else if (Entries > palGDI->NumColors - StartIndex)
930 Entries = palGDI->NumColors - StartIndex;
931
932 memcpy(pe,
933 palGDI->IndexedColors + StartIndex,
934 Entries * sizeof(pe[0]));
935
936 Ret = Entries;
937 }
938 else
939 {
940 Ret = dc->ppdev->gdiinfo.ulNumPalReg;
941 }
942 }
943
944 if (palGDI != NULL)
946
947 if (dc != NULL)
949
950 return Ret;
951}
952
953UINT
956 HPALETTE hpal,
957 UINT Start,
960{
961 PPALETTE palGDI;
962 ULONG numEntries;
963
964 if (GDI_HANDLE_IS_STOCKOBJ(hpal))
965 {
966 return 0;
967 }
968
969 palGDI = PALETTE_ShareLockPalette(hpal);
970 if (!palGDI) return 0;
971
972 numEntries = palGDI->NumColors;
973 if (Start >= numEntries)
974 {
976 return 0;
977 }
978 if (numEntries < Start + Entries)
979 {
980 Entries = numEntries - Start;
981 }
982 memcpy(palGDI->IndexedColors + Start, pe, Entries * sizeof(PALETTEENTRY));
984
985 return Entries;
986}
987
988ULONG
991 HDC hdc,
992 ULONG iStartIndex,
994 RGBQUAD *prgbColors,
995 BOOL bSet)
996{
997 PDC pdc;
998 PSURFACE psurf;
999 PPALETTE ppal = NULL;
1000 ULONG i, iEndIndex, iResult = 0;
1001
1002 /* Lock the DC */
1003 pdc = DC_LockDc(hdc);
1004 if (!pdc)
1005 {
1006 return 0;
1007 }
1008
1009 /* Get the surface from the DC */
1010 psurf = pdc->dclevel.pSurface;
1011
1012 /* Check if we have the default surface */
1013 if (psurf == NULL)
1014 {
1015 /* Use a mono palette */
1016 if (!bSet)
1017 ppal = gppalMono;
1018 }
1019 else if (psurf->SurfObj.iType == STYPE_BITMAP)
1020 {
1021 /* Get the palette of the surface */
1022 ppal = psurf->ppal;
1023 }
1024
1025 /* Check if this is an indexed palette and the range is ok */
1026 if (ppal && (ppal->flFlags & PAL_INDEXED) &&
1027 (iStartIndex < ppal->NumColors))
1028 {
1029 /* Calculate the end of the operation */
1030 iEndIndex = min(iStartIndex + cEntries, ppal->NumColors);
1031
1032 /* Check what operation to perform */
1033 if (bSet)
1034 {
1035 /* Loop all colors and set the palette entries */
1036 for (i = iStartIndex; i < iEndIndex; i++, prgbColors++)
1037 {
1038 ppal->IndexedColors[i].peRed = prgbColors->rgbRed;
1039 ppal->IndexedColors[i].peGreen = prgbColors->rgbGreen;
1040 ppal->IndexedColors[i].peBlue = prgbColors->rgbBlue;
1041 }
1042
1043 /* Mark the dc brushes invalid */
1044 pdc->pdcattr->ulDirty_ |= DIRTY_FILL|DIRTY_LINE|
1046 }
1047 else
1048 {
1049 /* Loop all colors and get the palette entries */
1050 for (i = iStartIndex; i < iEndIndex; i++, prgbColors++)
1051 {
1052 prgbColors->rgbRed = ppal->IndexedColors[i].peRed;
1053 prgbColors->rgbGreen = ppal->IndexedColors[i].peGreen;
1054 prgbColors->rgbBlue = ppal->IndexedColors[i].peBlue;
1055 prgbColors->rgbReserved = 0;
1056 }
1057 }
1058
1059 /* Calculate how many entries were modified */
1060 iResult = iEndIndex - iStartIndex;
1061 }
1062
1063 /* Unlock the DC */
1064 DC_UnlockDc(pdc);
1065
1066 return iResult;
1067}
1068
1070LONG
1073 _In_ HGDIOBJ hObj,
1076 _When_(bInbound!=0, _In_reads_bytes_(cEntries*sizeof(PALETTEENTRY)))
1077 _When_(bInbound==0, _Out_writes_bytes_(cEntries*sizeof(PALETTEENTRY))) LPVOID pUnsafeEntries,
1078 _In_ DWORD iFunc,
1079 _In_ BOOL bInbound)
1080{
1081 LONG ret;
1082 LPVOID pEntries = NULL;
1083 SIZE_T cjSize;
1084
1085 if (pUnsafeEntries)
1086 {
1087 if (cEntries == 0)
1088 return 0;
1089
1090 cjSize = cEntries * sizeof(PALETTEENTRY);
1092 if (!pEntries)
1093 return 0;
1094
1095 if (bInbound)
1096 {
1097 _SEH2_TRY
1098 {
1099 ProbeForRead(pUnsafeEntries, cjSize, 1);
1100 memcpy(pEntries, pUnsafeEntries, cjSize);
1101 }
1103 {
1104 ExFreePoolWithTag(pEntries, TAG_PALETTE);
1105 _SEH2_YIELD(return 0);
1106 }
1107 _SEH2_END
1108 }
1109 else
1110 {
1111 /* Zero it out, so we don't accidentally leak kernel data */
1112 RtlZeroMemory(pEntries, cjSize);
1113 }
1114 }
1115
1116 ret = 0;
1117 switch(iFunc)
1118 {
1119 case GdiPalAnimate:
1120 if (pEntries)
1121 ret = IntAnimatePalette((HPALETTE)hObj, iStart, cEntries, (CONST PPALETTEENTRY)pEntries);
1122 break;
1123
1124 case GdiPalSetEntries:
1125 if (pEntries)
1126 ret = IntSetPaletteEntries((HPALETTE)hObj, iStart, cEntries, (CONST LPPALETTEENTRY)pEntries);
1127 break;
1128
1129 case GdiPalGetEntries:
1130 ret = IntGetPaletteEntries((HPALETTE)hObj, iStart, cEntries, (LPPALETTEENTRY)pEntries);
1131 break;
1132
1135 break;
1136
1138 if (pEntries)
1139 ret = GreGetSetColorTable((HDC)hObj, iStart, cEntries, (RGBQUAD*)pEntries, TRUE);
1140 break;
1141
1143 if (pEntries)
1144 ret = GreGetSetColorTable((HDC)hObj, iStart, cEntries, (RGBQUAD*)pEntries, FALSE);
1145 break;
1146 }
1147
1148 if (pEntries)
1149 {
1150 if (!bInbound && (ret > 0))
1151 {
1152 cjSize = min(cEntries, ret) * sizeof(PALETTEENTRY);
1153 _SEH2_TRY
1154 {
1155 ProbeForWrite(pUnsafeEntries, cjSize, 1);
1156 memcpy(pUnsafeEntries, pEntries, cjSize);
1157 }
1159 {
1160 ret = 0;
1161 }
1162 _SEH2_END
1163 }
1164 ExFreePoolWithTag(pEntries, TAG_PALETTE);
1165 }
1166
1167 return ret;
1168}
1169
1172{
1173 UINT old = SystemPaletteUse;
1174
1175 /* Device doesn't support colour palettes */
1177 return SYSPAL_ERROR;
1178 }
1179
1180 switch (Usage)
1181 {
1182 case SYSPAL_NOSTATIC:
1183 case SYSPAL_NOSTATIC256:
1184 case SYSPAL_STATIC:
1186 break;
1187
1188 default:
1189 old=SYSPAL_ERROR;
1190 break;
1191 }
1192
1193 return old;
1194}
1195
1196UINT
1199{
1200 return SystemPaletteUse;
1201}
1202
1203BOOL
1206{
1207 PWND Wnd;
1208 BOOL calledFromUser, ret;
1210
1211 calledFromUser = UserIsEntered();
1212
1213 if (!calledFromUser){
1215 }
1216
1218 if (Wnd == NULL)
1219 {
1221
1222 if (!calledFromUser){
1223 UserLeave();
1224 }
1225
1226 return FALSE;
1227 }
1228
1229 UserRefObjectCo(Wnd, &Ref);
1231 UserDerefObjectCo(Wnd);
1232
1233 if (!calledFromUser){
1234 UserLeave();
1235 }
1236
1237 return ret;
1238}
1239
1240BOOL
1243{
1244 BOOL Ret = FALSE;
1245 PPALETTE palGDI;
1246
1247 if ( !hgdiobj ||
1248 GDI_HANDLE_IS_STOCKOBJ(hgdiobj) ||
1250 return Ret;
1251
1252 palGDI = PALETTE_ShareLockPalette(hgdiobj);
1253 if (!palGDI) return FALSE;
1254
1255 // FIXME!!
1256 // Need to do something!!!
1257 // Zero out Current and Old Translated pointers?
1258 //
1259 Ret = TRUE;
1261 return Ret;
1262}
1263
1265HPALETTE
1269 _In_ ULONG cColors,
1270 _In_ ULONG *pulColors,
1271 _In_ FLONG flRed,
1272 _In_ FLONG flGreen,
1273 _In_ FLONG flBlue)
1274{
1275 HPALETTE hPal = NULL;
1276 ULONG *pulcSafe, ulColors[WINDDI_MAXSETPALETTECOLORS];
1277
1278 if ( cColors > MAX_PALCOLORS ) return NULL;
1279
1280 if ( cColors <= WINDDI_MAXSETPALETTECOLORS )
1281 {
1282 pulcSafe = ulColors;
1283 }
1284 else
1285 {
1286 pulcSafe = ExAllocatePoolWithTag(PagedPool, cColors * sizeof(ULONG), GDITAG_UMPD );
1287 }
1288
1289 _SEH2_TRY
1290 {
1291 ProbeForRead( pulColors, cColors * sizeof(ULONG), 1);
1292 RtlCopyMemory( pulcSafe, pulColors, cColors * sizeof(ULONG) );
1293 }
1295 {
1297 if ( cColors > WINDDI_MAXSETPALETTECOLORS ) ExFreePoolWithTag( pulcSafe, GDITAG_UMPD );
1298 _SEH2_YIELD(return hPal);
1299 }
1300 _SEH2_END;
1301
1302 hPal = EngCreatePalette( iMode/*|PAL_SETPOWNER*/, cColors, pulcSafe, flRed, flGreen, flBlue );
1303
1304 if ( cColors > WINDDI_MAXSETPALETTECOLORS ) ExFreePoolWithTag( pulcSafe, GDITAG_UMPD );
1305
1306 return hPal;
1307}
1308
1310BOOL
1313 _In_ HPALETTE hPal)
1314{
1315 return EngDeletePalette(hPal);
1316}
1317
1318/* EOF */
static HDC hDC
Definition: 3dtext.c:33
#define CODE_SEG(...)
static const ENTRY Entries[]
Colors
Definition: ansiprsr.h:4
LONG NTSTATUS
Definition: precomp.h:26
#define index(s, c)
Definition: various.h:29
#define DPRINT1
Definition: precomp.h:8
#define UNIMPLEMENTED
Definition: debug.h:115
HGDIOBJ hHmgr(VOID)
Definition: baseobj.hpp:95
#define PC_SYS_USED
Definition: color.h:3
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:238
@ DCTYPE_DIRECT
Definition: dc.h:41
@ DCTYPE_MEMORY
Definition: dc.h:42
ULONG TranslateCOLORREF(PDC pdc, COLORREF crColor)
Definition: dcutil.c:869
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:220
HWND FASTCALL IntWindowFromDC(HDC hDc)
Definition: windc.c:894
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define APIENTRY
Definition: api.h:79
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
static void cleanup(void)
Definition: main.c:1335
#define RGB(r, g, b)
Definition: precomp.h:71
ULONG RGBQUAD
Definition: precomp.h:59
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
#define GDI_OBJECT_TYPE_PALETTE
Definition: gdi.h:49
#define GDI_HANDLE_IS_TYPE(h, t)
Definition: gdi.h:34
#define GDI_HANDLE_IS_STOCKOBJ(h)
Definition: gdi.h:37
@ BASEFLAG_LOOKASIDE
Definition: gdiobj.h:58
const GLdouble * v
Definition: gl.h:2040
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizeiptr size
Definition: glext.h:5919
GLuint index
Definition: glext.h:6031
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean g
Definition: glext.h:6204
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
Definition: hidpi.h:384
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_Check_return_ unsigned int __cdecl _rotl(_In_ unsigned int _Value, _In_ int _Shift)
#define b
Definition: ke_i.h:79
if(dx< 0)
Definition: linetemp.h:194
struct _PDEVOBJ * PPDEVOBJ
Definition: mdevobj.h:6
static const WCHAR dc[]
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define for
Definition: utility.h:88
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:92
static int cbCount
Definition: fiber.c:42
#define min(a, b)
Definition: monoChain.cc:55
#define _In_reads_bytes_(size)
Definition: ms_sal.h:321
#define _Out_writes_bytes_(size)
Definition: ms_sal.h:350
#define _When_(expr, annos)
Definition: ms_sal.h:254
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
unsigned int UINT
Definition: ndis.h:50
#define FASTCALL
Definition: nt_native.h:50
unsigned long FLONG
Definition: ntbasedef.h:366
__kernel_entry W32KAPI BOOL APIENTRY NtGdiUpdateColors(_In_ HDC hdc)
__kernel_entry W32KAPI INT APIENTRY NtGdiGetDeviceCaps(_In_ HDC hdc, _In_ INT i)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiResizePalette(_In_ HPALETTE hpal, _In_ UINT cEntry)
__kernel_entry W32KAPI HPALETTE APIENTRY NtGdiCreatePaletteInternal(_In_reads_bytes_(cEntries *4+4) LPLOGPALETTE pLogPal, _In_ UINT cEntries)
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiGetStockObject(_In_ INT iObject)
__kernel_entry W32KAPI LONG APIENTRY NtGdiDoPalette(_In_ HGDIOBJ hObj, _In_ WORD iStart, _In_ WORD cEntries, _When_(bInbound!=0, _In_reads_bytes_(cEntries *sizeof(PALETTEENTRY))) _When_(bInbound==0, _Out_writes_bytes_(cEntries *sizeof(PALETTEENTRY))) LPVOID pEntries, _In_ DWORD iFunc, _In_ BOOL bInbound)
Definition: palette.c:1072
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define DIRTY_FILL
Definition: ntgdihdl.h:123
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
#define DIRTY_TEXT
Definition: ntgdihdl.h:125
#define DIRTY_LINE
Definition: ntgdihdl.h:124
#define DIRTY_BACKGROUND
Definition: ntgdihdl.h:126
@ GdiPalSetColorTable
Definition: ntgdityp.h:32
@ GdiPalGetColorTable
Definition: ntgdityp.h:33
@ GdiPalSetEntries
Definition: ntgdityp.h:29
@ GdiPalAnimate
Definition: ntgdityp.h:28
@ GdiPalGetEntries
Definition: ntgdityp.h:30
@ GdiPalGetSystemEntries
Definition: ntgdityp.h:31
@ GDIObjType_PAL_TYPE
Definition: ntgdityp.h:128
BOOL FASTCALL UserIsEntered(VOID)
Definition: ntuser.c:218
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:251
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:242
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
@ PDEV_GAMMARAMP_TABLE
Definition: pdevobj.h:17
#define CONST
Definition: pedump.c:81
long LONG
Definition: pedump.c:60
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define STATUS_SUCCESS
Definition: shellext.h:65
#define __kernel_entry
Definition: specstrings.h:355
Definition: polytest.cpp:41
USHORT BaseFlags
Definition: gdiobj.h:46
ULONG ulShareCount
Definition: gdiobj.h:42
XLATEOBJ xlo
Definition: xlateobj.h:21
WORD Red[256]
Definition: winddi.h:775
WORD Blue[256]
Definition: winddi.h:777
WORD Green[256]
Definition: winddi.h:776
ULONG BlueMask
Definition: palette.h:45
HDEV hPDev
Definition: palette.h:49
ULONG GreenMask
Definition: palette.h:44
BASEOBJECT BaseObject
Definition: palette.h:36
ULONG NumColors
Definition: palette.h:41
ULONG ulGreenShift
Definition: palette.h:47
PALETTEENTRY * IndexedColors
Definition: palette.h:42
PALETTEENTRY apalColors[0]
Definition: palette.h:50
FLONG flFlags
Definition: palette.h:40
ULONG ulBlueShift
Definition: palette.h:48
ULONG ulRedShift
Definition: palette.h:46
ULONG RedMask
Definition: palette.h:43
FLONG flFlags
Definition: pdevobj.h:87
PVOID pvGammaRamp
Definition: pdevobj.h:106
SURFOBJ SurfObj
Definition: surface.h:8
struct _PALETTE *const ppal
Definition: surface.h:11
USHORT iType
Definition: winddi.h:1216
Definition: object.h:4
Definition: ntuser.h:694
uint32_t * PULONG
Definition: typedefs.h:59
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define NTAPI
Definition: typedefs.h:36
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
int pal_entries[256]
Definition: uimain.c:52
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
@ Start
Definition: partlist.h:33
int ret
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
#define NB_RESERVED_COLORS
Definition: palette.c:7
VOID NTAPI GDIOBJ_vFreeObject(POBJ pobj)
Definition: gdiobj.c:596
HGDIOBJ NTAPI GDIOBJ_hInsertObject(POBJ pobj, ULONG ulOwner)
Definition: gdiobj.c:912
POBJ NTAPI GDIOBJ_AllocateObject(UCHAR objt, ULONG cjSize, FLONG fl)
Definition: gdiobj.c:562
VOID NTAPI GDIOBJ_vDeleteObject(POBJ pobj)
Definition: gdiobj.c:1111
VOID NTAPI GDIOBJ_vReferenceObjectByPointer(POBJ pobj)
Definition: gdiobj.c:734
ULONG APIENTRY GreGetSetColorTable(HDC hdc, ULONG iStartIndex, ULONG cEntries, RGBQUAD *prgbColors, BOOL bSet)
Definition: palette.c:990
COLORREF APIENTRY NtGdiGetNearestColor(_In_ HDC hDC, _In_ COLORREF Color)
Definition: palette.c:662
const PALETTEENTRY g_sysPalTemplate[NB_RESERVED_COLORS]
Definition: palette.c:23
UINT APIENTRY IntGetPaletteEntries(HPALETTE hpal, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
Definition: palette.c:850
VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY *lpPalE, INT size)
Definition: palette.c:125
unsigned short GetNumberOfBits(unsigned int dwMask)
Definition: palette.c:54
BOOL APIENTRY NtGdiSetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT pca)
Definition: palette.c:652
INT FASTCALL PALETTE_GetObject(PPALETTE ppal, INT cbCount, LPLOGBRUSH lpBuffer)
Definition: palette.c:247
BOOL APIENTRY NtGdiUnrealizeObject(HGDIOBJ hgdiobj)
Definition: palette.c:1242
VOID NTAPI PALETTE_vCleanup(PVOID ObjectBody)
Definition: palette.c:236
PPALETTE appalSurfaceDefault[11]
Definition: palette.c:21
ULONG NTAPI PALETTE_ulGetNearestBitFieldsIndex(PALETTE *ppal, ULONG ulColor)
Definition: palette.c:294
__kernel_entry BOOL APIENTRY NtGdiEngDeletePalette(_In_ HPALETTE hPal)
Definition: palette.c:1312
PALETTE * gppalMono
Definition: palette.c:20
UINT FASTCALL IntGdiRealizePalette(HDC hDC)
Definition: palette.c:731
#define MAX_PALCOLORS
Definition: palette.c:16
PPALETTE NTAPI PALETTE_AllocPalWithHandle(_In_ ULONG iMode, _In_ ULONG cColors, _In_opt_ const PALETTEENTRY *pEntries, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
Definition: palette.c:209
HPALETTE NTAPI GreCreatePaletteInternal(IN LPLOGPALETTE pLogPal, IN UINT cEntries)
Definition: palette.c:448
VOID FASTCALL ColorCorrection(PPALETTE PalGDI, PPALETTEENTRY PaletteEntry, ULONG Colors)
Definition: palette.c:348
PPALETTE NTAPI PALETTE_AllocPalette(_In_ ULONG iMode, _In_ ULONG cColors, _In_opt_ const PALETTEENTRY *pEntries, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
Definition: palette.c:135
NTSTATUS NTAPI InitPaletteImpl(VOID)
Definition: palette.c:66
HPALETTE APIENTRY NtGdiCreateHalftonePalette(HDC hDC)
Definition: palette.c:518
static UINT SystemPaletteUse
Definition: palette.c:18
BOOL APIENTRY NtGdiGetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT pca)
Definition: palette.c:642
UINT APIENTRY NtGdiSetSystemPaletteUse(HDC hDC, UINT Usage)
Definition: palette.c:1171
UINT APIENTRY IntSetPaletteEntries(HPALETTE hpal, UINT Start, UINT Entries, CONST LPPALETTEENTRY pe)
Definition: palette.c:955
PALETTE gpalRGB555
Definition: palette.c:20
UINT APIENTRY IntGetSystemPaletteEntries(HDC hDC, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
Definition: palette.c:889
PALETTE gpalRGB
Definition: palette.c:20
ULONG NTAPI PALETTE_ulGetNearestIndex(PALETTE *ppal, ULONG ulColor)
Definition: palette.c:312
UINT APIENTRY IntAnimatePalette(HPALETTE hPal, UINT StartIndex, UINT NumEntries, CONST PPALETTEENTRY PaletteColors)
Definition: palette.c:781
PALETTE * gppalDefault
Definition: palette.c:20
PALETTE gpalBGR
Definition: palette.c:20
UINT APIENTRY NtGdiGetSystemPaletteUse(HDC hDC)
Definition: palette.c:1198
UINT APIENTRY NtGdiGetNearestPaletteIndex(HPALETTE hpal, COLORREF crColor)
Definition: palette.c:708
VOID NTAPI PALETTE_vGetBitMasks(PPALETTE ppal, PULONG pulColors)
Definition: palette.c:322
PALETTE gpalRGB565
Definition: palette.c:20
__kernel_entry HPALETTE APIENTRY NtGdiEngCreatePalette(_In_ ULONG iMode, _In_ ULONG cColors, _In_ ULONG *pulColors, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
Definition: palette.c:1267
ULONG NTAPI PALETTE_ulGetNearestPaletteIndex(PALETTE *ppal, ULONG iColor)
Definition: palette.c:261
struct _PALETTE * PPALETTE
struct _PALETTE PALETTE
#define PALETTE_UnlockPalette(pPalette)
Definition: palette.h:56
FORCEINLINE VOID PALETTE_vSetRGBColorForIndex(PPALETTE ppal, ULONG ulIndex, COLORREF crColor)
Definition: palette.h:152
@ PAL_MONOCHROME
Definition: palette.h:22
@ PAL_RGB16_565
Definition: palette.h:28
@ PAL_RGB16_555
Definition: palette.h:27
@ PAL_GAMMACORRECTION
Definition: palette.h:29
FORCEINLINE ULONG CalculateShift(ULONG ulMask1, ULONG ulMask2)
Definition: palette.h:130
#define PALETTE_ShareLockPalette(hpal)
Definition: palette.h:57
#define PALETTE_ShareUnlockPalette(ppal)
Definition: palette.h:59
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
#define TAG_PALETTE
Definition: tags.h:26
#define GDITAG_UMPD
Definition: tags.h:175
#define BMF_16BPP
Definition: winddi.h:358
#define BMF_8BPP
Definition: winddi.h:357
struct _GAMMARAMP * PGAMMARAMP
#define STYPE_BITMAP
Definition: winddi.h:1175
#define PAL_RGB
Definition: winddi.h:1563
_In_ FLONG fl
Definition: winddi.h:1279
#define BMF_1BPP
Definition: winddi.h:355
#define PAL_BITFIELDS
Definition: winddi.h:1562
ENGAPI ULONG APIENTRY XLATEOBJ_iXlate(_In_ XLATEOBJ *pxlo, _In_ ULONG iColor)
Definition: xlateobj.c:664
_Inout_ SURFOBJ _In_opt_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ _In_opt_ COLORADJUSTMENT * pca
Definition: winddi.h:3779
#define BMF_PNG
Definition: winddi.h:364
_In_ ULONG iMode
Definition: winddi.h:3520
ENGAPI BOOL APIENTRY EngDeletePalette(_In_ _Post_ptr_invalid_ HPALETTE hpal)
#define BMF_24BPP
Definition: winddi.h:359
#define BMF_32BPP
Definition: winddi.h:360
#define PAL_BGR
Definition: winddi.h:1564
ENGAPI ULONG APIENTRY PALOBJ_cGetColors(_In_ PALOBJ *ppalo, _In_ ULONG iStart, _In_ ULONG cColors, _Out_writes_(cColors) ULONG *pulColors)
#define WINDDI_MAXSETPALETTECOLORS
Definition: winddi.h:4006
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
#define PAL_INDEXED
Definition: winddi.h:1561
_In_ ULONG cjSize
Definition: winddi.h:3634
#define BMF_8RLE
Definition: winddi.h:362
#define BMF_4RLE
Definition: winddi.h:361
#define BMF_4BPP
Definition: winddi.h:356
_Must_inspect_result_ ENGAPI HPALETTE APIENTRY EngCreatePalette(_In_ ULONG iMode, _In_ ULONG cColors, _In_ ULONG *pulColors, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
#define BMF_JPEG
Definition: winddi.h:363
DWORD COLORREF
Definition: windef.h:300
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define PC_RESERVED
Definition: wingdi.h:882
#define RASTERCAPS
Definition: wingdi.h:745
#define SYSPAL_ERROR
Definition: wingdi.h:927
struct tagPALETTEENTRY PALETTEENTRY
#define DEFAULT_PALETTE
Definition: wingdi.h:913
struct tagPALETTEENTRY * PPALETTEENTRY
#define CLR_INVALID
Definition: wingdi.h:883
#define SYSPAL_STATIC
Definition: wingdi.h:926
_In_ UINT _In_ UINT cEntries
Definition: wingdi.h:3621
_In_ UINT iStart
Definition: wingdi.h:3620
#define SYSPAL_NOSTATIC
Definition: wingdi.h:925
#define SYSPAL_NOSTATIC256
Definition: wingdi.h:21
#define RC_PALETTE
Definition: wingdi.h:790
#define RDW_INVALIDATE
Definition: winuser.h:1214
VOID NTAPI EXLATEOBJ_vInitialize(_Out_ PEXLATEOBJ pexlo, _In_opt_ PALETTE *ppalSrc, _In_opt_ PALETTE *ppalDst, _In_ COLORREF crSrcBackColor, _In_ COLORREF crDstBackColor, _In_ COLORREF crDstForeColor)
Definition: xlateobj.c:358
VOID NTAPI EXLATEOBJ_vCleanup(_Inout_ PEXLATEOBJ pexlo)
Definition: xlateobj.c:649
_In_ ULONG iColor
Definition: xlateobj.h:17