This graph shows which files directly or indirectly include this file:

Classes
struct	_PALETTE

Macros
#define	PALETTE_UnlockPalette(pPalette) GDIOBJ_vUnlockObject((POBJ)pPalette)

#define	PALETTE_ShareLockPalette(hpal) ((PPALETTE)GDIOBJ_ShareLockObj((HGDIOBJ)hpal, GDI_OBJECT_TYPE_PALETTE))

#define	PALETTE_ShareUnlockPalette(ppal) GDIOBJ_vDereferenceObject(&ppal->BaseObject)

Typedefs
typedef struct _PALETTE	PALETTE

typedef struct _PALETTE *	PPALETTE

Enumerations
enum	_PALFLAGS { PAL_INDEXED = 0x00000001, PAL_BITFIELDS = 0x00000002, PAL_RGB = 0x00000004, PAL_BGR = 0x00000008, PAL_CMYK = 0x00000010, PAL_DC = 0x00000100, PAL_FIXED = 0x00000200, PAL_FREE = 0x00000400, PAL_MANAGED = 0x00000800, PAL_NOSTATIC = 0x00001000, PAL_MONOCHROME = 0x00002000, PAL_BRUSHHACK = 0x00004000, PAL_DIBSECTION = 0x00008000, PAL_NOSTATIC256 = 0x00010000, PAL_HT = 0x00100000, PAL_RGB16_555 = 0x00200000, PAL_RGB16_565 = 0x00400000, PAL_GAMMACORRECTION = 0x00800000 }

Functions
INIT_FUNCTION NTSTATUS NTAPI	InitPaletteImpl (VOID)

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 FASTCALL	PALETTE_ValidateFlags (PALETTEENTRY *lpPalE, INT size)

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

ULONG NTAPI	PALETTE_ulGetNearestPaletteIndex (PPALETTE ppal, ULONG iColor)

ULONG NTAPI	PALETTE_ulGetNearestIndex (PPALETTE ppal, ULONG iColor)

ULONG NTAPI	PALETTE_ulGetNearestBitFieldsIndex (PPALETTE ppal, ULONG ulColor)

VOID NTAPI	PALETTE_vGetBitMasks (PPALETTE ppal, PULONG pulColors)

VOID NTAPI	PALETTE_vCleanup (PVOID ObjectBody)

FORCEINLINE ULONG	CalculateShift (ULONG ulMask1, ULONG ulMask2)

FORCEINLINE ULONG	PALETTE_ulGetRGBColorFromIndex (PPALETTE ppal, ULONG ulIndex)

FORCEINLINE VOID	PALETTE_vSetRGBColorForIndex (PPALETTE ppal, ULONG ulIndex, COLORREF crColor)

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

Variables
PALETTE	gpalRGB

PALETTE	gpalBGR

PALETTE	gpalRGB555

PALETTE	gpalRGB565

PALETTE *	gppalMono

PALETTE *	gppalDefault

PPALETTE	appalSurfaceDefault []

Macro Definition Documentation

◆ PALETTE_ShareLockPalette

#define PALETTE_ShareLockPalette ( hpal ) ((PPALETTE)GDIOBJ_ShareLockObj((HGDIOBJ)hpal, GDI_OBJECT_TYPE_PALETTE))

Definition at line 57 of file palette.h.

◆ PALETTE_ShareUnlockPalette

#define PALETTE_ShareUnlockPalette ( ppal ) GDIOBJ_vDereferenceObject(&ppal->BaseObject)

Definition at line 59 of file palette.h.

◆ PALETTE_UnlockPalette

#define PALETTE_UnlockPalette ( pPalette ) GDIOBJ_vUnlockObject((POBJ)pPalette)

Definition at line 56 of file palette.h.

Typedef Documentation

◆ PALETTE

typedef struct _PALETTE PALETTE

◆ PPALETTE

typedef struct _PALETTE * PPALETTE

Enumeration Type Documentation

◆ _PALFLAGS

enum _PALFLAGS

Enumerator
PAL_INDEXED
PAL_BITFIELDS
PAL_RGB
PAL_BGR
PAL_CMYK
PAL_DC
PAL_FIXED
PAL_FREE
PAL_MANAGED
PAL_NOSTATIC
PAL_MONOCHROME
PAL_BRUSHHACK
PAL_DIBSECTION
PAL_NOSTATIC256
PAL_HT
PAL_RGB16_555
PAL_RGB16_565
PAL_GAMMACORRECTION

Definition at line 8 of file palette.h.

 {
 #ifndef _WINDDI_ // Defined in ddk/winddi.h
     PAL_INDEXED         = 0x00000001, // Indexed palette
     PAL_BITFIELDS       = 0x00000002, // Bit fields used for DIB, DIB section
     PAL_RGB             = 0x00000004, // Red, green, blue
     PAL_BGR             = 0x00000008, // Blue, green, red
     PAL_CMYK            = 0x00000010, // Cyan, magenta, yellow, black
 #endif
     PAL_DC              = 0x00000100,
     PAL_FIXED           = 0x00000200, // Can't be changed
     PAL_FREE            = 0x00000400,
     PAL_MANAGED         = 0x00000800,
     PAL_NOSTATIC        = 0x00001000,
     PAL_MONOCHROME      = 0x00002000, // Two colors only
     PAL_BRUSHHACK       = 0x00004000,
     PAL_DIBSECTION      = 0x00008000, // Used for a DIB section
     PAL_NOSTATIC256     = 0x00010000,
     PAL_HT              = 0x00100000, // Halftone palette
     PAL_RGB16_555       = 0x00200000, // 16-bit RGB in 555 format
     PAL_RGB16_565       = 0x00400000, // 16-bit RGB in 565 format
     PAL_GAMMACORRECTION = 0x00800000, // Correct colors
 };

Function Documentation

◆ CalculateShift()

FORCEINLINE ULONG CalculateShift	(	ULONG	ulMask1,
		ULONG	ulMask2
	)

Definition at line 130 of file palette.h.

 {
     ULONG ulShift1, ulShift2;
     BitScanReverse(&ulShift1, ulMask1);
     BitScanReverse(&ulShift2, ulMask2);
     ulShift2 -= ulShift1;
     if ((INT)ulShift2 < 0) ulShift2 += 32;
     return ulShift2;
 }

Referenced by EXLATEOBJ_vInitialize(), and PALETTE_ulGetNearestBitFieldsIndex().

◆ GreCreatePaletteInternal()

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

Systemcall Interface

Definition at line 448 of file palette.c.

 {
     HPALETTE hpal = NULL;
     PPALETTE ppal;
 
     pLogPal->palNumEntries = cEntries;
     ppal = PALETTE_AllocPalWithHandle(PAL_INDEXED,
                                       cEntries,
                                       pLogPal->palPalEntry,
                                       0, 0, 0);
 
     if (ppal != NULL)
     {
         PALETTE_ValidateFlags(ppal->IndexedColors, ppal->NumColors);
 
         hpal = ppal->BaseObject.hHmgr;
         PALETTE_UnlockPalette(ppal);
     }
 
     return hpal;
 }

◆ InitPaletteImpl()

INIT_FUNCTION NTSTATUS NTAPI InitPaletteImpl ( VOID )

Definition at line 66 of file palette.c.

 {
     // Create default palette (20 system colors)
     gppalDefault = PALETTE_AllocPalWithHandle(PAL_INDEXED,
                                               20,
                                               g_sysPalTemplate,
                                               0, 0, 0);
     GDIOBJ_vReferenceObjectByPointer(&gppalDefault->BaseObject);
     PALETTE_UnlockPalette(gppalDefault);
 
     /*  palette_size = visual->map_entries; */
 
     gpalRGB.flFlags = PAL_RGB;
     gpalRGB.RedMask = RGB(0xFF, 0x00, 0x00);
     gpalRGB.GreenMask = RGB(0x00, 0xFF, 0x00);
     gpalRGB.BlueMask = RGB(0x00, 0x00, 0xFF);
     gpalRGB.BaseObject.ulShareCount = 1;
     gpalRGB.BaseObject.BaseFlags = 0 ;
 
     gpalBGR.flFlags = PAL_BGR;
     gpalBGR.RedMask = RGB(0x00, 0x00, 0xFF);
     gpalBGR.GreenMask = RGB(0x00, 0xFF, 0x00);
     gpalBGR.BlueMask = RGB(0xFF, 0x00, 0x00);
     gpalBGR.BaseObject.ulShareCount = 1;
     gpalBGR.BaseObject.BaseFlags = 0 ;
 
     gpalRGB555.flFlags = PAL_RGB16_555 | PAL_BITFIELDS;
     gpalRGB555.RedMask = 0x7C00;
     gpalRGB555.GreenMask = 0x3E0;
     gpalRGB555.BlueMask = 0x1F;
     gpalRGB555.BaseObject.ulShareCount = 1;
     gpalRGB555.BaseObject.BaseFlags = 0 ;
 
     gpalRGB565.flFlags = PAL_RGB16_565 | PAL_BITFIELDS;
     gpalRGB565.RedMask = 0xF800;
     gpalRGB565.GreenMask = 0x7E0;
     gpalRGB565.BlueMask = 0x1F;
     gpalRGB565.BaseObject.ulShareCount = 1;
     gpalRGB565.BaseObject.BaseFlags = 0 ;
 
     gppalMono = PALETTE_AllocPalette(PAL_MONOCHROME|PAL_INDEXED, 2, NULL, 0, 0, 0);
     PALETTE_vSetRGBColorForIndex(gppalMono, 0, 0x000000);
     PALETTE_vSetRGBColorForIndex(gppalMono, 1, 0xffffff);
 
     /* Initialize default surface palettes */
     appalSurfaceDefault[BMF_1BPP] = gppalMono;
     appalSurfaceDefault[BMF_4BPP] = gppalDefault;
     appalSurfaceDefault[BMF_8BPP] = gppalDefault;
     appalSurfaceDefault[BMF_16BPP] = &gpalRGB565;
     appalSurfaceDefault[BMF_24BPP] = &gpalBGR;
     appalSurfaceDefault[BMF_32BPP] = &gpalBGR;
     appalSurfaceDefault[BMF_4RLE] = gppalDefault;
     appalSurfaceDefault[BMF_8RLE] = gppalDefault;
     appalSurfaceDefault[BMF_JPEG] = &gpalRGB;
     appalSurfaceDefault[BMF_PNG] = &gpalRGB;
 
     return STATUS_SUCCESS;
 }

Referenced by DriverEntry().

◆ 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.

 {
     PPALETTE ppal;
     ULONG fl = 0, cjSize = sizeof(PALETTE);
 
     /* Check if the palette has entries */
     if (iMode & PAL_INDEXED)
     {
         /* Check color count */
         if ((cColors == 0) || (cColors > 1024)) return NULL;
 
         /* Allocate enough space for the palete entries */
         cjSize += cColors * sizeof(PALETTEENTRY);
     }
     else
     {
         /* There are no palette entries */
         cColors = 0;
 
         /* We can use the lookaside list */
         fl |= BASEFLAG_LOOKASIDE;
     }
 
     /* Allocate the object (without a handle!) */
     ppal = (PPALETTE)GDIOBJ_AllocateObject(GDIObjType_PAL_TYPE, cjSize, fl);
     if (!ppal)
     {
         return NULL;
     }
 
     /* Set mode, color count and entry pointer */
     ppal->flFlags = iMode;
     ppal->NumColors = cColors;
     ppal->IndexedColors = ppal->apalColors;
 
     /* Check what kind of palette this is */
     if (iMode & PAL_INDEXED)
     {
         /* Check if we got a color array */
         if (pEntries)
         {
             /* Copy the entries */
             RtlCopyMemory(ppal->IndexedColors, pEntries, cColors * sizeof(pEntries[0]));
         }
     }
     else if (iMode & PAL_BITFIELDS)
     {
         /* Copy the color masks */
         ppal->RedMask = flRed;
         ppal->GreenMask = flGreen;
         ppal->BlueMask = flBlue;
 
         /* Check what masks we have and set optimization flags */
         if ((flRed == 0x7c00) && (flGreen == 0x3E0) && (flBlue == 0x1F))
             ppal->flFlags |= PAL_RGB16_555;
         else if ((flRed == 0xF800) && (flGreen == 0x7E0) && (flBlue == 0x1F))
             ppal->flFlags |= PAL_RGB16_565;
         else if ((flRed == 0xFF0000) && (flGreen == 0xFF00) && (flBlue == 0xFF))
             ppal->flFlags |= PAL_BGR;
         else if ((flRed == 0xFF) && (flGreen == 0xFF00) && (flBlue == 0xFF0000))
             ppal->flFlags |= PAL_RGB;
     }
 
     return ppal;
 }

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.

 {
     PPALETTE ppal;
 
     /* Allocate the palette without a handle */
     ppal = PALETTE_AllocPalette(iMode, cColors, pEntries, flRed, flGreen, flBlue);
     if (!ppal) return NULL;
 
     /* Insert the palette into the handle table */
     if (!GDIOBJ_hInsertObject(&ppal->BaseObject, GDI_OBJ_HMGR_POWNED))
     {
         DPRINT1("Could not insert palette into handle table.\n");
         GDIOBJ_vFreeObject(&ppal->BaseObject);
         return NULL;
     }
 
     return ppal;
 }

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

◆ PALETTE_GetObject()

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

Definition at line 247 of file palette.c.

 {
     if (!lpBuffer)
     {
         return sizeof(WORD);
     }
 
     if ((UINT)cbCount < sizeof(WORD)) return 0;
     *((WORD*)lpBuffer) = (WORD)ppal->NumColors;
     return sizeof(WORD);
 }

Referenced by GreGetObject().

◆ PALETTE_ulGetNearestBitFieldsIndex()

ULONG NTAPI PALETTE_ulGetNearestBitFieldsIndex	(	PPALETTE	ppal,
		ULONG	ulColor
	)

◆ PALETTE_ulGetNearestIndex()

ULONG NTAPI PALETTE_ulGetNearestIndex	(	PPALETTE	ppal,
		ULONG	iColor
	)

◆ PALETTE_ulGetNearestPaletteIndex()

ULONG NTAPI PALETTE_ulGetNearestPaletteIndex	(	PPALETTE	ppal,
		ULONG	iColor
	)

◆ PALETTE_ulGetRGBColorFromIndex()

FORCEINLINE ULONG PALETTE_ulGetRGBColorFromIndex	(	PPALETTE	ppal,
		ULONG	ulIndex
	)

Definition at line 142 of file palette.h.

 {
     if (ulIndex >= ppal->NumColors) return 0;
     return RGB(ppal->IndexedColors[ulIndex].peRed,
                ppal->IndexedColors[ulIndex].peGreen,
                ppal->IndexedColors[ulIndex].peBlue);
 }

Referenced by CreateDIBPalette(), FixupDIBBrushPalette(), and TranslateCOLORREF().

◆ PALETTE_ValidateFlags()

VOID FASTCALL PALETTE_ValidateFlags	(	PALETTEENTRY *	lpPalE,
		INT	size
	)

Definition at line 125 of file palette.c.

 {
     int i = 0;
     for (; i<size ; i++)
         lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
 }

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

◆ PALETTE_vCleanup()

VOID NTAPI PALETTE_vCleanup ( PVOID ObjectBody )

Definition at line 236 of file palette.c.

 {
     PPALETTE pPal = (PPALETTE)ObjectBody;
     if (pPal->IndexedColors && pPal->IndexedColors != pPal->apalColors)
     {
         ExFreePoolWithTag(pPal->IndexedColors, TAG_PALETTE);
     }
 }

◆ PALETTE_vGetBitMasks()

VOID NTAPI PALETTE_vGetBitMasks	(	PPALETTE	ppal,
		PULONG	pulColors
	)

Definition at line 322 of file palette.c.

 {
     ASSERT(pulColors);
 
     if (ppal->flFlags & PAL_INDEXED || ppal->flFlags & PAL_RGB)
     {
         pulColors[0] = RGB(0xFF, 0x00, 0x00);
         pulColors[1] = RGB(0x00, 0xFF, 0x00);
         pulColors[2] = RGB(0x00, 0x00, 0xFF);
     }
     else if (ppal->flFlags & PAL_BGR)
     {
         pulColors[0] = RGB(0x00, 0x00, 0xFF);
         pulColors[1] = RGB(0x00, 0xFF, 0x00);
         pulColors[2] = RGB(0xFF, 0x00, 0x00);
     }
     else if (ppal->flFlags & PAL_BITFIELDS)
     {
         pulColors[0] = ppal->RedMask;
         pulColors[1] = ppal->GreenMask;
         pulColors[2] = ppal->BlueMask;
     }
 }

Referenced by EXLATEOBJ_vInitialize().

◆ PALETTE_vSetRGBColorForIndex()

FORCEINLINE VOID PALETTE_vSetRGBColorForIndex	(	PPALETTE	ppal,
		ULONG	ulIndex,
		COLORREF	crColor
	)

Definition at line 152 of file palette.h.

 {
     if (ulIndex >= ppal->NumColors) return;
     ppal->IndexedColors[ulIndex].peRed = GetRValue(crColor);
     ppal->IndexedColors[ulIndex].peGreen = GetGValue(crColor);
     ppal->IndexedColors[ulIndex].peBlue = GetBValue(crColor);
 }

Referenced by CreateDIBPalette(), FixupDIBBrushPalette(), and InitPaletteImpl().

Variable Documentation

◆ appalSurfaceDefault

PPALETTE appalSurfaceDefault[]

Definition at line 21 of file palette.c.

Referenced by InitPaletteImpl(), and SURFACE_AllocSurface().