ReactOS 0.4.15-dev-8119-g4fb2fdb
palette.c File Reference
#include <win32k.h>
#include <debug.h>
Include dependency graph for palette.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define PAL_SETPOWNER   0x8000
 
#define MAX_PALCOLORS   65536
 

Functions

unsigned short GetNumberOfBits (unsigned int dwMask)
 
NTSTATUS NTAPI InitPaletteImpl (VOID)
 
VOID FASTCALL PALETTE_ValidateFlags (PALETTEENTRY *lpPalE, INT size)
 
PPALETTE NTAPI PALETTE_AllocPalette (_In_ ULONG iMode, _In_ ULONG cColors, _In_opt_ const PALETTEENTRY *pEntries, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
 
PPALETTE NTAPI PALETTE_AllocPalWithHandle (_In_ ULONG iMode, _In_ ULONG cColors, _In_opt_ const PALETTEENTRY *pEntries, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
 
VOID NTAPI PALETTE_vCleanup (PVOID ObjectBody)
 
INT FASTCALL PALETTE_GetObject (PPALETTE ppal, INT cbCount, LPLOGBRUSH lpBuffer)
 
ULONG NTAPI PALETTE_ulGetNearestPaletteIndex (PALETTE *ppal, ULONG iColor)
 
ULONG NTAPI PALETTE_ulGetNearestBitFieldsIndex (PALETTE *ppal, ULONG ulColor)
 
ULONG NTAPI PALETTE_ulGetNearestIndex (PALETTE *ppal, ULONG ulColor)
 
VOID NTAPI PALETTE_vGetBitMasks (PPALETTE ppal, PULONG pulColors)
 
VOID FASTCALL ColorCorrection (PPALETTE PalGDI, PPALETTEENTRY PaletteEntry, ULONG Colors)
 
HPALETTE APIENTRY EngCreatePalette (ULONG iMode, ULONG cColors, ULONG *pulColors, ULONG flRed, ULONG flGreen, ULONG flBlue)
 
BOOL APIENTRY EngDeletePalette (IN HPALETTE hpal)
 
ULONG APIENTRY PALOBJ_cGetColors (PALOBJ *PalObj, ULONG Start, ULONG Colors, ULONG *PaletteEntry)
 
HPALETTE NTAPI GreCreatePaletteInternal (IN LPLOGPALETTE pLogPal, IN UINT cEntries)
 
HPALETTE APIENTRY NtGdiCreatePaletteInternal (IN LPLOGPALETTE plogpalUser, IN UINT cEntries)
 
HPALETTE APIENTRY NtGdiCreateHalftonePalette (HDC hDC)
 
BOOL APIENTRY NtGdiResizePalette (HPALETTE hpal, UINT Entries)
 
BOOL APIENTRY NtGdiGetColorAdjustment (HDC hdc, LPCOLORADJUSTMENT pca)
 
BOOL APIENTRY NtGdiSetColorAdjustment (HDC hdc, LPCOLORADJUSTMENT pca)
 
COLORREF APIENTRY NtGdiGetNearestColor (_In_ HDC hDC, _In_ COLORREF Color)
 
UINT APIENTRY NtGdiGetNearestPaletteIndex (HPALETTE hpal, COLORREF crColor)
 
UINT FASTCALL IntGdiRealizePalette (HDC hDC)
 
UINT APIENTRY IntAnimatePalette (HPALETTE hPal, UINT StartIndex, UINT NumEntries, CONST PPALETTEENTRY PaletteColors)
 
UINT APIENTRY IntGetPaletteEntries (HPALETTE hpal, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
 
UINT APIENTRY IntGetSystemPaletteEntries (HDC hDC, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
 
UINT APIENTRY IntSetPaletteEntries (HPALETTE hpal, UINT Start, UINT Entries, CONST LPPALETTEENTRY pe)
 
ULONG APIENTRY GreGetSetColorTable (HDC hdc, ULONG iStartIndex, ULONG cEntries, RGBQUAD *prgbColors, BOOL bSet)
 
__kernel_entry 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 pUnsafeEntries, _In_ DWORD iFunc, _In_ BOOL bInbound)
 
UINT APIENTRY NtGdiSetSystemPaletteUse (HDC hDC, UINT Usage)
 
UINT APIENTRY NtGdiGetSystemPaletteUse (HDC hDC)
 
BOOL APIENTRY NtGdiUpdateColors (HDC hDC)
 
BOOL APIENTRY NtGdiUnrealizeObject (HGDIOBJ hgdiobj)
 
__kernel_entry HPALETTE APIENTRY NtGdiEngCreatePalette (_In_ ULONG iMode, _In_ ULONG cColors, _In_ ULONG *pulColors, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)
 
__kernel_entry BOOL APIENTRY NtGdiEngDeletePalette (_In_ HPALETTE hPal)
 

Variables

static UINT SystemPaletteUse = SYSPAL_NOSTATIC
 
PALETTE gpalRGB
 
PALETTE gpalBGR
 
PALETTE gpalRGB555
 
PALETTE gpalRGB565
 
PALETTEgppalMono
 
PALETTEgppalDefault
 
PPALETTE appalSurfaceDefault [11]
 
const PALETTEENTRY g_sysPalTemplate [NB_RESERVED_COLORS]
 

Macro Definition Documentation

◆ MAX_PALCOLORS

#define MAX_PALCOLORS   65536

Definition at line 16 of file palette.c.

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file palette.c.

◆ PAL_SETPOWNER

#define PAL_SETPOWNER   0x8000

Definition at line 15 of file palette.c.

Function Documentation

◆ ColorCorrection()

VOID FASTCALL ColorCorrection ( PPALETTE  PalGDI,
PPALETTEENTRY  PaletteEntry,
ULONG  Colors 
)

Definition at line 348 of file palette.c.

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}
Colors
Definition: ansiprsr.h:4
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
if(dx< 0)
Definition: linetemp.h:194
struct _PDEVOBJ * PPDEVOBJ
Definition: mdevobj.h:6
#define for
Definition: utility.h:88
@ PDEV_GAMMARAMP_TABLE
Definition: pdevobj.h:17
WORD Red[256]
Definition: winddi.h:775
WORD Blue[256]
Definition: winddi.h:777
WORD Green[256]
Definition: winddi.h:776
HDEV hPDev
Definition: palette.h:49
FLONG flFlags
Definition: pdevobj.h:87
PVOID pvGammaRamp
Definition: pdevobj.h:106
uint32_t ULONG
Definition: typedefs.h:59
struct _GAMMARAMP * PGAMMARAMP

Referenced by PALOBJ_cGetColors().

◆ EngCreatePalette()

HPALETTE APIENTRY EngCreatePalette ( ULONG  iMode,
ULONG  cColors,
ULONG pulColors,
ULONG  flRed,
ULONG  flGreen,
ULONG  flBlue 
)

Display Driver Interface

Definition at line 375 of file palette.c.

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}
#define DPRINT1
Definition: precomp.h:8
#define NULL
Definition: types.h:112
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
BASEOBJECT BaseObject
Definition: palette.h:36
VOID NTAPI GDIOBJ_vFreeObject(POBJ pobj)
Definition: gdiobj.c:596
HGDIOBJ NTAPI GDIOBJ_hInsertObject(POBJ pobj, ULONG ulOwner)
Definition: gdiobj.c:912
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
#define PALETTE_UnlockPalette(pPalette)
Definition: palette.h:56
_In_ ULONG iMode
Definition: winddi.h:3520

◆ EngDeletePalette()

BOOL APIENTRY EngDeletePalette ( IN HPALETTE  hpal)

Definition at line 406 of file palette.c.

407{
408 PPALETTE ppal;
409
410 ppal = PALETTE_ShareLockPalette(hpal);
411 if (!ppal) return FALSE;
412
414
415 return TRUE;
416}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
VOID NTAPI GDIOBJ_vDeleteObject(POBJ pobj)
Definition: gdiobj.c:1111
#define PALETTE_ShareLockPalette(hpal)
Definition: palette.h:57

◆ GetNumberOfBits()

unsigned short GetNumberOfBits ( unsigned int  dwMask)

Definition at line 54 of file palette.c.

55{
56 unsigned short wBits;
57 for (wBits = 0; dwMask; dwMask = dwMask & (dwMask - 1))
58 wBits++;
59 return wBits;
60}

◆ GreCreatePaletteInternal()

HPALETTE NTAPI GreCreatePaletteInternal ( IN LPLOGPALETTE  pLogPal,
IN UINT  cEntries 
)

Systemcall Interface

Definition at line 448 of file palette.c.

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}
HGDIOBJ hHmgr(VOID)
Definition: baseobj.hpp:95
ULONG NumColors
Definition: palette.h:41
PALETTEENTRY * IndexedColors
Definition: palette.h:42
VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY *lpPalE, INT size)
Definition: palette.c:125
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
#define PAL_INDEXED
Definition: winddi.h:1561
_In_ UINT _In_ UINT cEntries
Definition: wingdi.h:3621

◆ GreGetSetColorTable()

ULONG APIENTRY GreGetSetColorTable ( HDC  hdc,
ULONG  iStartIndex,
ULONG  cEntries,
RGBQUAD prgbColors,
BOOL  bSet 
)

Definition at line 990 of file palette.c.

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}
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:238
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:220
HDC hdc
Definition: main.c:9
#define min(a, b)
Definition: monoChain.cc:55
#define DIRTY_FILL
Definition: ntgdihdl.h:123
#define DIRTY_TEXT
Definition: ntgdihdl.h:125
#define DIRTY_LINE
Definition: ntgdihdl.h:124
#define DIRTY_BACKGROUND
Definition: ntgdihdl.h:126
Definition: polytest.cpp:41
FLONG flFlags
Definition: palette.h:40
SURFOBJ SurfObj
Definition: surface.h:8
struct _PALETTE *const ppal
Definition: surface.h:11
USHORT iType
Definition: winddi.h:1216
PALETTE * gppalMono
Definition: palette.c:20
#define STYPE_BITMAP
Definition: winddi.h:1175

Referenced by NtGdiDoPalette().

◆ InitPaletteImpl()

NTSTATUS NTAPI InitPaletteImpl ( VOID  )

Definition at line 66 of file palette.c.

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}
#define RGB(r, g, b)
Definition: precomp.h:71
#define STATUS_SUCCESS
Definition: shellext.h:65
USHORT BaseFlags
Definition: gdiobj.h:46
ULONG ulShareCount
Definition: gdiobj.h:42
ULONG BlueMask
Definition: palette.h:45
ULONG GreenMask
Definition: palette.h:44
ULONG RedMask
Definition: palette.h:43
VOID NTAPI GDIOBJ_vReferenceObjectByPointer(POBJ pobj)
Definition: gdiobj.c:734
const PALETTEENTRY g_sysPalTemplate[NB_RESERVED_COLORS]
Definition: palette.c:23
PPALETTE appalSurfaceDefault[11]
Definition: palette.c:21
PALETTE gpalRGB555
Definition: palette.c:20
PALETTE gpalRGB
Definition: palette.c:20
PALETTE * gppalDefault
Definition: palette.c:20
PALETTE gpalBGR
Definition: palette.c:20
PALETTE gpalRGB565
Definition: palette.c:20
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
#define BMF_16BPP
Definition: winddi.h:358
#define BMF_8BPP
Definition: winddi.h:357
#define PAL_RGB
Definition: winddi.h:1563
#define BMF_1BPP
Definition: winddi.h:355
#define PAL_BITFIELDS
Definition: winddi.h:1562
#define BMF_PNG
Definition: winddi.h:364
#define BMF_24BPP
Definition: winddi.h:359
#define BMF_32BPP
Definition: winddi.h:360
#define PAL_BGR
Definition: winddi.h:1564
#define BMF_8RLE
Definition: winddi.h:362
#define BMF_4RLE
Definition: winddi.h:361
#define BMF_4BPP
Definition: winddi.h:356
#define BMF_JPEG
Definition: winddi.h:363

Referenced by DriverEntry().

◆ IntAnimatePalette()

UINT APIENTRY IntAnimatePalette ( HPALETTE  hPal,
UINT  StartIndex,
UINT  NumEntries,
CONST PPALETTEENTRY  PaletteColors 
)

Definition at line 781 of file palette.c.

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}
static HDC hDC
Definition: 3dtext.c:33
static const WCHAR dc[]
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned int UINT
Definition: ndis.h:50
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiGetStockObject(_In_ INT iObject)
int pal_entries[256]
Definition: uimain.c:52
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
int ret
UINT FASTCALL IntGdiRealizePalette(HDC hDC)
Definition: palette.c:731
#define PALETTE_ShareUnlockPalette(ppal)
Definition: palette.h:59
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
#define PC_RESERVED
Definition: wingdi.h:882
#define DEFAULT_PALETTE
Definition: wingdi.h:913

Referenced by NtGdiDoPalette().

◆ IntGdiRealizePalette()

UINT FASTCALL IntGdiRealizePalette ( HDC  hDC)

FIXME: shouldn't dereference pSurface while the PDEV is not locked

Definition at line 731 of file palette.c.

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}
#define UNIMPLEMENTED
Definition: debug.h:118
@ DCTYPE_DIRECT
Definition: dc.h:41
@ DCTYPE_MEMORY
Definition: dc.h:42
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
static void cleanup(void)
Definition: main.c:1335
unsigned int BOOL
Definition: ntddk_ex.h:94
#define ASSERT(a)
Definition: mode.c:44
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22

Referenced by IntAnimatePalette(), and UserRealizePalette().

◆ IntGetPaletteEntries()

UINT APIENTRY IntGetPaletteEntries ( HPALETTE  hpal,
UINT  StartIndex,
UINT  Entries,
LPPALETTEENTRY  pe 
)

Definition at line 850 of file palette.c.

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}
static const ENTRY Entries[]
struct _PALETTE * PPALETTE

Referenced by NtGdiDoPalette().

◆ IntGetSystemPaletteEntries()

UINT APIENTRY IntGetSystemPaletteEntries ( HDC  hDC,
UINT  StartIndex,
UINT  Entries,
LPPALETTEENTRY  pe 
)

Definition at line 889 of file palette.c.

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}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101

Referenced by NtGdiDoPalette().

◆ IntSetPaletteEntries()

UINT APIENTRY IntSetPaletteEntries ( HPALETTE  hpal,
UINT  Start,
UINT  Entries,
CONST LPPALETTEENTRY  pe 
)

Definition at line 955 of file palette.c.

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}
#define GDI_HANDLE_IS_STOCKOBJ(h)
Definition: gdi.h:37
@ Start
Definition: partlist.h:33

Referenced by NtGdiDoPalette().

◆ NtGdiCreateHalftonePalette()

HPALETTE APIENTRY NtGdiCreateHalftonePalette ( HDC  hDC)

Definition at line 518 of file palette.c.

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}
const GLdouble * v
Definition: gl.h:2040
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean g
Definition: glext.h:6204
#define b
Definition: ke_i.h:79
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

◆ NtGdiCreatePaletteInternal()

HPALETTE APIENTRY NtGdiCreatePaletteInternal ( IN LPLOGPALETTE  plogpalUser,
IN UINT  cEntries 
)

Definition at line 477 of file palette.c.

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}
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
_In_ ULONG cjSize
Definition: winddi.h:3634

◆ NtGdiDoPalette()

__kernel_entry 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  pUnsafeEntries,
_In_ DWORD  iFunc,
_In_ BOOL  bInbound 
)

Definition at line 1072 of file palette.c.

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}
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 ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
static HDC
Definition: imagelist.c:92
@ 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
#define CONST
Definition: pedump.c:81
long LONG
Definition: pedump.c:60
ULONG_PTR SIZE_T
Definition: typedefs.h:80
ULONG APIENTRY GreGetSetColorTable(HDC hdc, ULONG iStartIndex, ULONG cEntries, RGBQUAD *prgbColors, BOOL bSet)
Definition: palette.c:990
UINT APIENTRY IntGetPaletteEntries(HPALETTE hpal, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
Definition: palette.c:850
UINT APIENTRY IntSetPaletteEntries(HPALETTE hpal, UINT Start, UINT Entries, CONST LPPALETTEENTRY pe)
Definition: palette.c:955
UINT APIENTRY IntGetSystemPaletteEntries(HDC hDC, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
Definition: palette.c:889
UINT APIENTRY IntAnimatePalette(HPALETTE hPal, UINT StartIndex, UINT NumEntries, CONST PPALETTEENTRY PaletteColors)
Definition: palette.c:781
#define TAG_PALETTE
Definition: tags.h:26
struct tagPALETTEENTRY PALETTEENTRY
_In_ UINT iStart
Definition: wingdi.h:3620

Referenced by AnimatePalette(), GetDIBColorTable(), GetPaletteEntries(), GetSystemPaletteEntries(), SetDIBColorTable(), SetPaletteEntries(), Test_NtGdiDoPalette_GdiPalAnimate(), Test_NtGdiDoPalette_GdiPalGetEntries(), Test_NtGdiDoPalette_GdiPalSetEntries(), and Test_NtGdiDoPalette_SetDIBColorTable().

◆ NtGdiEngCreatePalette()

__kernel_entry HPALETTE APIENTRY NtGdiEngCreatePalette ( _In_ ULONG  iMode,
_In_ ULONG  cColors,
_In_ ULONG pulColors,
_In_ FLONG  flRed,
_In_ FLONG  flGreen,
_In_ FLONG  flBlue 
)

Definition at line 1267 of file palette.c.

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}
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
#define MAX_PALCOLORS
Definition: palette.c:16
#define GDITAG_UMPD
Definition: tags.h:175
#define WINDDI_MAXSETPALETTECOLORS
Definition: winddi.h:4006
_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)

Referenced by START_TEST().

◆ NtGdiEngDeletePalette()

__kernel_entry BOOL APIENTRY NtGdiEngDeletePalette ( _In_ HPALETTE  hPal)

Definition at line 1312 of file palette.c.

1314{
1315 return EngDeletePalette(hPal);
1316}
ENGAPI BOOL APIENTRY EngDeletePalette(_In_ _Post_ptr_invalid_ HPALETTE hpal)

◆ NtGdiGetColorAdjustment()

BOOL APIENTRY NtGdiGetColorAdjustment ( HDC  hdc,
LPCOLORADJUSTMENT  pca 
)

Definition at line 642 of file palette.c.

645{
647 return FALSE;
648}

◆ NtGdiGetNearestColor()

COLORREF APIENTRY NtGdiGetNearestColor ( _In_ HDC  hDC,
_In_ COLORREF  Color 
)

FIXME: shouldn't dereference pSurface while the PDEV is not locked

Definition at line 662 of file palette.c.

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}
ULONG TranslateCOLORREF(PDC pdc, COLORREF crColor)
Definition: dcutil.c:869
XLATEOBJ xlo
Definition: xlateobj.h:21
ENGAPI ULONG APIENTRY XLATEOBJ_iXlate(_In_ XLATEOBJ *pxlo, _In_ ULONG iColor)
Definition: xlateobj.c:664
DWORD COLORREF
Definition: windef.h:300
#define CLR_INVALID
Definition: wingdi.h:883
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

◆ NtGdiGetNearestPaletteIndex()

UINT APIENTRY NtGdiGetNearestPaletteIndex ( HPALETTE  hpal,
COLORREF  crColor 
)

Definition at line 708 of file palette.c.

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}
#define index(s, c)
Definition: various.h:29
GLuint index
Definition: glext.h:6031
ULONG NTAPI PALETTE_ulGetNearestPaletteIndex(PALETTE *ppal, ULONG iColor)
Definition: palette.c:261

◆ NtGdiGetSystemPaletteUse()

UINT APIENTRY NtGdiGetSystemPaletteUse ( HDC  hDC)

Definition at line 1198 of file palette.c.

1199{
1200 return SystemPaletteUse;
1201}
static UINT SystemPaletteUse
Definition: palette.c:18

◆ NtGdiResizePalette()

BOOL APIENTRY NtGdiResizePalette ( HPALETTE  hpal,
UINT  Entries 
)

Definition at line 595 of file palette.c.

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}

◆ NtGdiSetColorAdjustment()

BOOL APIENTRY NtGdiSetColorAdjustment ( HDC  hdc,
LPCOLORADJUSTMENT  pca 
)

Definition at line 652 of file palette.c.

655{
657 return FALSE;
658}

◆ NtGdiSetSystemPaletteUse()

UINT APIENTRY NtGdiSetSystemPaletteUse ( HDC  hDC,
UINT  Usage 
)

Definition at line 1171 of file palette.c.

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}
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
Definition: hidpi.h:384
__kernel_entry W32KAPI INT APIENTRY NtGdiGetDeviceCaps(_In_ HDC hdc, _In_ INT i)
#define RASTERCAPS
Definition: wingdi.h:745
#define SYSPAL_ERROR
Definition: wingdi.h:927
#define SYSPAL_STATIC
Definition: wingdi.h:926
#define SYSPAL_NOSTATIC
Definition: wingdi.h:925
#define SYSPAL_NOSTATIC256
Definition: wingdi.h:21
#define RC_PALETTE
Definition: wingdi.h:790

◆ NtGdiUnrealizeObject()

BOOL APIENTRY NtGdiUnrealizeObject ( HGDIOBJ  hgdiobj)

Definition at line 1242 of file palette.c.

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}
#define GDI_OBJECT_TYPE_PALETTE
Definition: gdi.h:49
#define GDI_HANDLE_IS_TYPE(h, t)
Definition: gdi.h:34

◆ NtGdiUpdateColors()

BOOL APIENTRY NtGdiUpdateColors ( HDC  hDC)

Definition at line 1205 of file palette.c.

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}
HWND FASTCALL IntWindowFromDC(HDC hDc)
Definition: windc.c:894
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
Definition: object.h:4
Definition: ntuser.h:694
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:894
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define RDW_INVALIDATE
Definition: winuser.h:1214

◆ PALETTE_AllocPalette()

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 at line 135 of file palette.c.

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}
@ BASEFLAG_LOOKASIDE
Definition: gdiobj.h:58
@ GDIObjType_PAL_TYPE
Definition: ntgdityp.h:128
PALETTEENTRY apalColors[0]
Definition: palette.h:50
POBJ NTAPI GDIOBJ_AllocateObject(UCHAR objt, ULONG cjSize, FLONG fl)
Definition: gdiobj.c:562
struct _PALETTE PALETTE
_In_ FLONG fl
Definition: winddi.h:1279

Referenced by CreateDIBPalette(), EngCreatePalette(), FixupDIBBrushPalette(), InitPaletteImpl(), NtGdiDdDDICreateDCFromMemory(), and PALETTE_AllocPalWithHandle().

◆ PALETTE_AllocPalWithHandle()

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 at line 209 of file palette.c.

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}
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117

Referenced by DIB_MapPaletteColors(), GreCreatePaletteInternal(), InitPaletteImpl(), NtGdiCreateHalftonePalette(), and NtGdiCreatePaletteInternal().

◆ PALETTE_GetObject()

INT FASTCALL PALETTE_GetObject ( PPALETTE  ppal,
INT  cbCount,
LPLOGBRUSH  lpBuffer 
)

Definition at line 247 of file palette.c.

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}
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
unsigned short WORD
Definition: ntddk_ex.h:93
static int cbCount
Definition: fiber.c:42

Referenced by GreGetObject().

◆ PALETTE_ulGetNearestBitFieldsIndex()

ULONG NTAPI PALETTE_ulGetNearestBitFieldsIndex ( PALETTE ppal,
ULONG  ulColor 
)

Definition at line 294 of file palette.c.

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}
_Check_return_ unsigned int __cdecl _rotl(_In_ unsigned int _Value, _In_ int _Shift)
ULONG ulGreenShift
Definition: palette.h:47
ULONG ulBlueShift
Definition: palette.h:48
ULONG ulRedShift
Definition: palette.h:46
FORCEINLINE ULONG CalculateShift(ULONG ulMask1, ULONG ulMask2)
Definition: palette.h:130

Referenced by EXLATEOBJ_vInitialize(), and PALETTE_ulGetNearestIndex().

◆ PALETTE_ulGetNearestIndex()

ULONG NTAPI PALETTE_ulGetNearestIndex ( PALETTE ppal,
ULONG  ulColor 
)

Definition at line 312 of file palette.c.

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}
ULONG NTAPI PALETTE_ulGetNearestBitFieldsIndex(PALETTE *ppal, ULONG ulColor)
Definition: palette.c:294

Referenced by EXLATEOBJ_vInitialize(), and TranslateCOLORREF().

◆ PALETTE_ulGetNearestPaletteIndex()

ULONG NTAPI PALETTE_ulGetNearestPaletteIndex ( PALETTE ppal,
ULONG  iColor 
)

Definition at line 261 of file palette.c.

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}
struct tagPALETTEENTRY * PPALETTEENTRY
_In_ ULONG iColor
Definition: xlateobj.h:17

Referenced by EXLATEOBJ_vInitialize(), NtGdiGetNearestPaletteIndex(), and PALETTE_ulGetNearestIndex().

◆ PALETTE_ValidateFlags()

VOID FASTCALL PALETTE_ValidateFlags ( PALETTEENTRY lpPalE,
INT  size 
)

Definition at line 125 of file palette.c.

126{
127 int i = 0;
128 for (; i<size ; i++)
129 lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
130}
#define PC_SYS_USED
Definition: color.h:3
GLsizeiptr size
Definition: glext.h:5919

Referenced by GreCreatePaletteInternal(), IntAnimatePalette(), and NtGdiCreatePaletteInternal().

◆ PALETTE_vCleanup()

VOID NTAPI PALETTE_vCleanup ( PVOID  ObjectBody)

Definition at line 236 of file palette.c.

237{
238 PPALETTE pPal = (PPALETTE)ObjectBody;
239 if (pPal->IndexedColors && pPal->IndexedColors != pPal->apalColors)
240 {
242 }
243}

◆ PALETTE_vGetBitMasks()

VOID NTAPI PALETTE_vGetBitMasks ( PPALETTE  ppal,
PULONG  pulColors 
)

Definition at line 322 of file palette.c.

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}

Referenced by EXLATEOBJ_vInitialize().

◆ PALOBJ_cGetColors()

ULONG APIENTRY PALOBJ_cGetColors ( PALOBJ PalObj,
ULONG  Start,
ULONG  Colors,
ULONG PaletteEntry 
)

Definition at line 423 of file palette.c.

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}
VOID FASTCALL ColorCorrection(PPALETTE PalGDI, PPALETTEENTRY PaletteEntry, ULONG Colors)
Definition: palette.c:348
@ PAL_GAMMACORRECTION
Definition: palette.h:29

Variable Documentation

◆ appalSurfaceDefault

PPALETTE appalSurfaceDefault[11]

Definition at line 21 of file palette.c.

Referenced by InitPaletteImpl(), and SURFACE_AllocSurface().

◆ g_sysPalTemplate

Initial value:
=
{
{ 0x00, 0x00, 0x00, PC_SYS_USED },
{ 0x80, 0x00, 0x00, PC_SYS_USED },
{ 0x00, 0x80, 0x00, PC_SYS_USED },
{ 0x80, 0x80, 0x00, PC_SYS_USED },
{ 0x00, 0x00, 0x80, PC_SYS_USED },
{ 0x80, 0x00, 0x80, PC_SYS_USED },
{ 0x00, 0x80, 0x80, PC_SYS_USED },
{ 0xc0, 0xc0, 0xc0, PC_SYS_USED },
{ 0xc0, 0xdc, 0xc0, PC_SYS_USED },
{ 0xa6, 0xca, 0xf0, PC_SYS_USED },
{ 0xff, 0xfb, 0xf0, PC_SYS_USED },
{ 0xa0, 0xa0, 0xa4, PC_SYS_USED },
{ 0x80, 0x80, 0x80, PC_SYS_USED },
{ 0xff, 0x00, 0x00, PC_SYS_USED },
{ 0x00, 0xff, 0x00, PC_SYS_USED },
{ 0xff, 0xff, 0x00, PC_SYS_USED },
{ 0x00, 0x00, 0xff, PC_SYS_USED },
{ 0xff, 0x00, 0xff, PC_SYS_USED },
{ 0x00, 0xff, 0xff, PC_SYS_USED },
{ 0xff, 0xff, 0xff, PC_SYS_USED }
}

Definition at line 23 of file palette.c.

Referenced by InitPaletteImpl(), and NtGdiCreateHalftonePalette().

◆ gpalBGR

PALETTE gpalBGR

Definition at line 20 of file palette.c.

Referenced by InitPaletteImpl().

◆ gpalRGB

◆ gpalRGB555

PALETTE gpalRGB555

Definition at line 20 of file palette.c.

Referenced by InitPaletteImpl().

◆ gpalRGB565

PALETTE gpalRGB565

Definition at line 20 of file palette.c.

Referenced by InitPaletteImpl().

◆ gppalDefault

PALETTE * gppalDefault

Definition at line 20 of file palette.c.

Referenced by CreateDIBPalette(), CreateStockObjects(), EBRUSHOBJ_vInit(), and InitPaletteImpl().

◆ gppalMono

◆ SystemPaletteUse

UINT SystemPaletteUse = SYSPAL_NOSTATIC
static

Definition at line 18 of file palette.c.

Referenced by NtGdiGetSystemPaletteUse(), and NtGdiSetSystemPaletteUse().