palette.h File Reference

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

Go to the source code of 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
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()

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[]

extern

Definition at line 21 of file palette.c.

Referenced by InitPaletteImpl(), and SURFACE_AllocSurface().

gpalBGR

PALETTE gpalBGR

Definition at line 53 of file palette.h.

gpalRGB

PALETTE gpalRGB

extern

Definition at line 20 of file palette.c.

Referenced by DIB_16BPP_AlphaBlend(), DIB_XXBPP_AlphaBlend(), EBRUSHOBJ_vSetSolidRGBColor(), EngSetPointerShape(), EXLATEOBJ_vInitialize(), GreGradientFill(), InitPaletteImpl(), IntExtTextOutW(), IntShowMousePointer(), NtGdiExtFloodFill(), NtGdiGetNearestColor(), NtGdiGetPixel(), NtGdiSetPixel(), NtGdiTransparentBlt(), and TranslateCOLORREF().

gpalRGB555

PALETTE gpalRGB555

Definition at line 53 of file palette.h.

gpalRGB565

PALETTE gpalRGB565

Definition at line 53 of file palette.h.

gppalDefault

PALETTE * gppalDefault

Definition at line 53 of file palette.h.

gppalMono

PALETTE * gppalMono

Definition at line 53 of file palette.h.