* Timo Kreuzer
*/
-#include <w32k.h>
+#include <win32k.h>
#define NDEBUG
#include <debug.h>
static UINT SystemPaletteUse = SYSPAL_NOSTATIC; /* the program need save the pallete and restore it */
-PALETTE gpalRGB, gpalBGR;
+PALETTE gpalRGB, gpalBGR, gpalMono, gpalRGB555, gpalRGB565, *gppalDefault;
+PPALETTE appalSurfaceDefault[11];
const PALETTEENTRY g_sysPalTemplate[NB_RESERVED_COLORS] =
{
int i;
HPALETTE hpalette;
PLOGPALETTE palPtr;
-#ifndef NO_MAPPING
- PALOBJ *palObj;
-#endif
// create default palette (20 system colors)
palPtr = ExAllocatePoolWithTag(PagedPool,
hpalette = NtGdiCreatePaletteInternal(palPtr,NB_RESERVED_COLORS);
ExFreePoolWithTag(palPtr, TAG_PALETTE);
-#ifndef NO_MAPPING
- palObj = (PALOBJ*)PALETTE_LockPalette(hpalette);
- if (palObj)
- {
- if (!(palObj->mapping = ExAllocatePool(PagedPool, sizeof(int) * 20)))
- {
- DbgPrint("Win32k: Can not create palette mapping -- out of memory!");
- return FALSE;
- }
- PALETTE_UnlockPalette(palObj);
- }
-#endif
-
/* palette_size = visual->map_entries; */
- gpalRGB.Mode = PAL_RGB;
+ 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 = 0;
+ gpalRGB.BaseObject.BaseFlags = 0 ;
- gpalBGR.Mode = PAL_BGR;
+ 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 = 0;
+ gpalBGR.BaseObject.BaseFlags = 0 ;
+
+ gpalRGB555.flFlags = PAL_RGB16_555 | PAL_BITFIELDS;
+ gpalRGB555.RedMask = 0x7C00;
+ gpalRGB555.GreenMask = 0x3E0;
+ gpalRGB555.BlueMask = 0x1F;
+ gpalRGB555.BaseObject.ulShareCount = 0;
+ gpalRGB555.BaseObject.BaseFlags = 0 ;
+
+ gpalRGB565.flFlags = PAL_RGB16_565 | PAL_BITFIELDS;
+ gpalRGB565.RedMask = 0xF800;
+ gpalRGB565.GreenMask = 0x7E0;
+ gpalRGB565.BlueMask = 0x1F;
+ gpalRGB565.BaseObject.ulShareCount = 0;
+ gpalRGB565.BaseObject.BaseFlags = 0 ;
+
+ memset(&gpalMono, 0, sizeof(PALETTE));
+ gpalMono.flFlags = PAL_MONOCHROME;
+ gpalMono.BaseObject.ulShareCount = 0;
+ gpalMono.BaseObject.BaseFlags = 0 ;
+
+ /* Initialize default surface palettes */
+ gppalDefault = PALETTE_ShareLockPalette(hpalette);
+ appalSurfaceDefault[BMF_1BPP] = &gpalMono;
+ 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 hpalette;
}
NewPalette = PalGDI->BaseObject.hHmgr;
PalGDI->Self = NewPalette;
- PalGDI->Mode = Mode;
+ PalGDI->flFlags = Mode;
if (NULL != Colors)
{
RtlCopyMemory(PalGDI->IndexedColors, Colors, sizeof(PALETTEENTRY) * NumColors);
}
- if (PAL_INDEXED == Mode)
+ if (Mode & PAL_INDEXED)
{
PalGDI->NumColors = NumColors;
}
- else if (PAL_BITFIELDS == Mode)
+ else if (Mode & PAL_BITFIELDS)
{
PalGDI->RedMask = Red;
PalGDI->GreenMask = Green;
PalGDI->BlueMask = Blue;
+
+ if (Red == 0x7c00 && Green == 0x3E0 && Blue == 0x1F)
+ PalGDI->flFlags |= PAL_RGB16_555;
+ else if (Red == 0xF800 && Green == 0x7E0 && Blue == 0x1F)
+ PalGDI->flFlags |= PAL_RGB16_565;
+ else if (Red == 0xFF0000 && Green == 0xFF00 && Blue == 0xFF)
+ PalGDI->flFlags |= PAL_BGR;
}
PALETTE_UnlockPalette(PalGDI);
NewPalette = PalGDI->BaseObject.hHmgr;
PalGDI->Self = NewPalette;
- PalGDI->Mode = PAL_INDEXED;
+ PalGDI->flFlags = PAL_INDEXED;
PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool,
sizeof(PALETTEENTRY) * NumColors,
PPALETTE pPal = (PPALETTE)ObjectBody;
if (NULL != pPal->IndexedColors)
{
- ExFreePool(pPal->IndexedColors);
+ ExFreePoolWithTag(pPal->IndexedColors, TAG_PALETTE);
}
return TRUE;
return ulBestIndex;
}
+ULONG
+NTAPI
+PALETTE_ulGetNearestBitFieldsIndex(PALETTE* ppal, ULONG ulColor)
+{
+ ULONG ulNewColor;
+
+ // FIXME: HACK, should be stored already
+ ppal->ulRedShift = CalculateShift(RGB(0xff,0,0), ppal->RedMask);
+ ppal->ulGreenShift = CalculateShift(RGB(0,0xff,0), ppal->GreenMask);
+ ppal->ulBlueShift = CalculateShift(RGB(0,0,0xff), ppal->BlueMask);
+
+ ulNewColor = _rotl(ulColor, ppal->ulRedShift) & ppal->RedMask;
+ ulNewColor |= _rotl(ulColor, ppal->ulGreenShift) & ppal->GreenMask;
+ ulNewColor |= _rotl(ulColor, ppal->ulBlueShift) & ppal->BlueMask;
+
+ return ulNewColor;
+}
+
+ULONG
+NTAPI
+PALETTE_ulGetNearestIndex(PALETTE* ppal, ULONG ulColor)
+{
+ if (ppal->flFlags & PAL_INDEXED) // use fl & PALINDEXED
+ return PALETTE_ulGetNearestPaletteIndex(ppal, ulColor);
+ else
+ return PALETTE_ulGetNearestBitFieldsIndex(ppal, ulColor);
+}
+
VOID
NTAPI
PALETTE_vGetBitMasks(PPALETTE ppal, PULONG pulColors)
{
ASSERT(pulColors);
- switch (ppal->Mode)
+ 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)
{
- case PAL_INDEXED:
- case PAL_RGB:
- pulColors[0] = RGB(0xFF, 0x00, 0x00);
- pulColors[1] = RGB(0x00, 0xFF, 0x00);
- pulColors[2] = RGB(0x00, 0x00, 0xFF);
- break;
-
- case PAL_BGR:
- pulColors[0] = RGB(0x00, 0x00, 0xFF);
- pulColors[1] = RGB(0x00, 0xFF, 0x00);
- pulColors[2] = RGB(0xFF, 0x00, 0x00);
- break;
-
- case PAL_BITFIELDS:
- pulColors[0] = ppal->RedMask;
- pulColors[1] = ppal->GreenMask;
- pulColors[2] = ppal->BlueMask;
- break;
+ pulColors[0] = ppal->RedMask;
+ pulColors[1] = ppal->GreenMask;
+ pulColors[2] = ppal->BlueMask;
}
}
{
HPALETTE Palette;
- Palette = PALETTE_AllocPalette(Mode, NumColors, Colors, Red, Green, Blue);
+ Palette = PALETTE_AllocPalette(Mode, NumColors, Colors, Red, Green, Blue);
if (Palette != NULL)
{
GDIOBJ_SetOwnership(Palette, NULL);
/* NOTE: PaletteEntry ULONGs are in the same order as PALETTEENTRY. */
RtlCopyMemory(PaletteEntry, PalGDI->IndexedColors + Start, sizeof(ULONG) * Colors);
- if (PalGDI->Mode & PAL_GAMMACORRECTION)
+ if (PalGDI->flFlags & PAL_GAMMACORRECTION)
ColorCorrection(PalGDI, (PPALETTEENTRY)PaletteEntry, Colors);
return Colors;
if (PalGDI != NULL)
{
PALETTE_ValidateFlags(PalGDI->IndexedColors, PalGDI->NumColors);
- PalGDI->logicalToSystem = NULL;
PALETTE_UnlockPalette(PalGDI);
}
else
{
/* FIXME - Handle PalGDI == NULL!!!! */
- DPRINT1("waring PalGDI is NULL \n");
+ DPRINT1("PalGDI is NULL\n");
}
return NewPalette;
}
return nearest;
}
- switch (palGDI->Mode)
+ if (palGDI->flFlags & PAL_INDEXED)
{
- case PAL_INDEXED:
- {
- ULONG index;
- index = PALETTE_ulGetNearestPaletteIndex(palGDI, Color);
- nearest = PALETTE_ulGetRGBColorFromIndex(palGDI, index);
- break;
- }
- case PAL_BGR:
- case PAL_RGB:
- nearest = Color;
- break;
- case PAL_BITFIELDS:
- RBits = 8 - GetNumberOfBits(palGDI->RedMask);
- GBits = 8 - GetNumberOfBits(palGDI->GreenMask);
- BBits = 8 - GetNumberOfBits(palGDI->BlueMask);
- nearest = RGB(
- (GetRValue(Color) >> RBits) << RBits,
- (GetGValue(Color) >> GBits) << GBits,
- (GetBValue(Color) >> BBits) << BBits);
- break;
+ ULONG index;
+ index = PALETTE_ulGetNearestPaletteIndex(palGDI, Color);
+ nearest = PALETTE_ulGetRGBColorFromIndex(palGDI, index);
+ }
+ else if (palGDI->flFlags & PAL_RGB || palGDI->flFlags & PAL_BGR)
+ {
+ nearest = Color;
+ }
+ else if (palGDI->flFlags & PAL_BITFIELDS)
+ {
+ RBits = 8 - GetNumberOfBits(palGDI->RedMask);
+ GBits = 8 - GetNumberOfBits(palGDI->GreenMask);
+ BBits = 8 - GetNumberOfBits(palGDI->BlueMask);
+ nearest = RGB(
+ (GetRValue(Color) >> RBits) << RBits,
+ (GetGValue(Color) >> GBits) << GBits,
+ (GetBValue(Color) >> BBits) << BBits);
}
PALETTE_UnlockPalette(palGDI);
DC_UnlockDc(dc);
if (ppal)
{
- /* Return closest match for the given RGB color */
- index = PALETTE_ulGetNearestPaletteIndex(ppal, crColor);
+ if (ppal->flFlags & PAL_INDEXED)
+ {
+ /* Return closest match for the given RGB color */
+ index = PALETTE_ulGetNearestPaletteIndex(ppal, crColor);
+ }
+ // else SetLastError ?
PALETTE_UnlockPalette(ppal);
}
int realized = 0;
PDC dc;
HPALETTE systemPalette;
- USHORT sysMode, palMode;
dc = DC_LockDc(hDC);
if (!dc) return 0;
}
// need to pass this to IntEngCreateXlate with palettes unlocked
- sysMode = sysGDI->Mode;
- palMode = palGDI->Mode;
PALETTE_UnlockPalette(sysGDI);
PALETTE_UnlockPalette(palGDI);
- // Create the XLATEOBJ for device managed DCs
- if(dc->dctype != DC_TYPE_MEMORY)
- {
- if (palGDI->logicalToSystem != NULL)
- {
- EngDeleteXlate(palGDI->logicalToSystem);
- }
- palGDI->logicalToSystem = IntEngCreateXlate(sysMode, palMode, systemPalette, dc->dclevel.hpal);
- }
-
DC_UnlockDc(dc);
return realized;
UINT pal_entries;
HDC hDC;
PDC dc;
- PWINDOW_OBJECT Wnd;
+ PWND Wnd;
const PALETTEENTRY *pptr = PaletteColors;
palPtr = (PPALETTE)PALETTE_LockPalette(hPal);
return 0;
}
memcpy(pe, palGDI->IndexedColors + StartIndex, Entries * sizeof(PALETTEENTRY));
- for (numEntries = 0; numEntries < Entries; numEntries++)
- {
- if (pe[numEntries].peFlags & 0xF0)
- {
- pe[numEntries].peFlags = 0;
- }
- }
}
else
{
}
else
{
- Ret = dc->ppdev->GDIInfo.ulNumPalReg;
+ Ret = dc->ppdev->gdiinfo.ulNumPalReg;
}
}
Entries = numEntries - Start;
}
memcpy(palGDI->IndexedColors + Start, pe, Entries * sizeof(PALETTEENTRY));
- PALETTE_ValidateFlags(palGDI->IndexedColors, palGDI->NumColors);
- if (palGDI->logicalToSystem)
- ExFreePool(palGDI->logicalToSystem);
- palGDI->logicalToSystem = NULL;
PALETTE_UnlockPalette(palGDI);
return Entries;
if (pUnsafeEntries)
{
- pEntries = ExAllocatePool(PagedPool, cEntries * sizeof(PALETTEENTRY));
+ pEntries = ExAllocatePoolWithTag(PagedPool, cEntries * sizeof(PALETTEENTRY), TAG_PALETTE);
if (!pEntries)
return 0;
if (bInbound)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- ExFreePool(pEntries);
+ ExFreePoolWithTag(pEntries, TAG_PALETTE);
_SEH2_YIELD(return 0);
}
_SEH2_END
}
_SEH2_END
}
- ExFreePool(pEntries);
+ ExFreePoolWithTag(pEntries, TAG_PALETTE);
}
return ret;
APIENTRY
NtGdiUpdateColors(HDC hDC)
{
- PWINDOW_OBJECT Wnd;
+ PWND Wnd;
BOOL calledFromUser, ret;
USER_REFERENCE_ENTRY Ref;
projects / reactos.git / blobdiff