Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-23 17:05:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge eng/palette.c, objects/palobj.c and objects/color.c into objects/palette.c, dropping some useless bitrotting code. The rest of the code needs some love and cleanup.

Browse source 
Btw, Arch, how's the weather?

svn path=/trunk/; revision=41762
This commit is contained in:
Timo Kreuzer 2009-07-04 00:18:32 +00:00
parent 37671f6a9e
commit 4e4637dbb8
4 changed files with 654 additions and 882 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
reactos/subsystems/win32/win32k/eng/palette.c
View file

@ -1,101 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Palette Functions
* FILE: subsys/win32k/eng/palette.c
* PROGRAMER: Jason Filby
*/
#include <w32k.h>
#define NDEBUG
#include <debug.h>
//
//
//
VOID
FASTCALL
ColorCorrection(PPALETTE PalGDI, PPALETTEENTRY PaletteEntry, ULONG Colors)
{
PPDEVOBJ ppdev = (PPDEVOBJ)PalGDI->hPDev;
if (!ppdev) return;
if (ppdev->flFlags & PDEV_GAMMARAMP_TABLE)
{
INT i;
PGAMMARAMP GammaRamp = (PGAMMARAMP)ppdev->pvGammaRamp;
for ( i = 0; i < Colors; i++)
{
PaletteEntry[i].peRed += GammaRamp->Red[i];
PaletteEntry[i].peGreen += GammaRamp->Green[i];
PaletteEntry[i].peBlue += GammaRamp->Blue[i];
}
}
return;
}
/*
* @implemented
*/
HPALETTE
APIENTRY
EngCreatePalette(
ULONG Mode,
ULONG NumColors,
ULONG *Colors,
ULONG Red,
ULONG Green,
ULONG Blue)
{
HPALETTE Palette;
Palette = PALETTE_AllocPalette(Mode, NumColors, Colors, Red, Green, Blue);
if (Palette != NULL)
{
GDIOBJ_SetOwnership(Palette, NULL);
}
return Palette;
}
/*
* @implemented
*/
BOOL
APIENTRY
EngDeletePalette(IN HPALETTE Palette)
{
GDIOBJ_SetOwnership(Palette, PsGetCurrentProcess());
return PALETTE_FreePaletteByHandle(Palette);
}
/*
* @implemented
*/
ULONG
APIENTRY
PALOBJ_cGetColors(PALOBJ *PalObj, ULONG Start, ULONG Colors, ULONG *PaletteEntry)
{
PALETTE *PalGDI;
PalGDI = (PALETTE*)PalObj;
/* PalGDI = (PALETTE*)AccessInternalObjectFromUserObject(PalObj); */
if (Start >= PalGDI->NumColors)
return 0;
Colors = min(Colors, PalGDI->NumColors - Start);
/* NOTE: PaletteEntry ULONGs are in the same order as PALETTEENTRY. */
RtlCopyMemory(PaletteEntry, PalGDI->IndexedColors + Start, sizeof(ULONG) * Colors);
if (PalGDI->Mode & PAL_GAMMACORRECTION)
ColorCorrection(PalGDI, (PPALETTEENTRY)PaletteEntry, Colors);
return Colors;
}
/* EOF */

1069
reactos/subsystems/win32/win32k/objects/color.c → reactos/subsystems/win32/win32k/objects/palette.c
View file

File diff suppressed because it is too large Load diff

362
reactos/subsystems/win32/win32k/objects/palobj.c
View file

@ -1,362 +0,0 @@
/*
* ReactOS W32 Subsystem
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <w32k.h>
#define NDEBUG
#include <debug.h>
#ifndef NO_MAPPING
static int PALETTE_firstFree = 0;
static unsigned char PALETTE_freeList[256];
#endif
int PALETTE_PaletteFlags = 0;
PALETTEENTRY *COLOR_sysPal = NULL;
int COLOR_gapStart;
int COLOR_gapEnd;
int COLOR_gapFilled;
int COLOR_max;
PPALETTEENTRY FASTCALL ReturnSystemPalette(VOID)
{
return COLOR_sysPal;
}
BOOL INTERNAL_CALL
PALETTE_Cleanup(PVOID ObjectBody)
{
PPALETTE pPal = (PPALETTE)ObjectBody;
if (NULL != pPal->IndexedColors)
{
ExFreePool(pPal->IndexedColors);
}
return TRUE;
}
HPALETTE
FASTCALL
PALETTE_AllocPalette(ULONG Mode,
ULONG NumColors,
ULONG *Colors,
ULONG Red,
ULONG Green,
ULONG Blue)
{
HPALETTE NewPalette;
PPALETTE PalGDI;
PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
if (!PalGDI)
{
return NULL;
}
NewPalette = PalGDI->BaseObject.hHmgr;
PalGDI->Self = NewPalette;
PalGDI->Mode = Mode;
if (NULL != Colors)
{
PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool,
sizeof(PALETTEENTRY) * NumColors,
TAG_PALETTE);
if (NULL == PalGDI->IndexedColors)
{
PALETTE_UnlockPalette(PalGDI);
PALETTE_FreePaletteByHandle(NewPalette);
return NULL;
}
RtlCopyMemory(PalGDI->IndexedColors, Colors, sizeof(PALETTEENTRY) * NumColors);
}
if (PAL_INDEXED == Mode)
{
PalGDI->NumColors = NumColors;
}
else if (PAL_BITFIELDS == Mode)
{
PalGDI->RedMask = Red;
PalGDI->GreenMask = Green;
PalGDI->BlueMask = Blue;
}
PALETTE_UnlockPalette(PalGDI);
return NewPalette;
}
HPALETTE
FASTCALL
PALETTE_AllocPaletteIndexedRGB(ULONG NumColors,
CONST RGBQUAD *Colors)
{
HPALETTE NewPalette;
PPALETTE PalGDI;
UINT i;
PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
if (!PalGDI)
{
return NULL;
}
NewPalette = PalGDI->BaseObject.hHmgr;
PalGDI->Self = NewPalette;
PalGDI->Mode = PAL_INDEXED;
PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool,
sizeof(PALETTEENTRY) * NumColors,
TAG_PALETTE);
if (NULL == PalGDI->IndexedColors)
{
PALETTE_UnlockPalette(PalGDI);
PALETTE_FreePaletteByHandle(NewPalette);
return NULL;
}
for (i = 0; i < NumColors; i++)
{
PalGDI->IndexedColors[i].peRed = Colors[i].rgbRed;
PalGDI->IndexedColors[i].peGreen = Colors[i].rgbGreen;
PalGDI->IndexedColors[i].peBlue = Colors[i].rgbBlue;
PalGDI->IndexedColors[i].peFlags = 0;
}
PalGDI->NumColors = NumColors;
PALETTE_UnlockPalette(PalGDI);
return NewPalette;
}
// Create the system palette
HPALETTE FASTCALL PALETTE_Init(VOID)
{
int i;
HPALETTE hpalette;
PLOGPALETTE palPtr;
#ifndef NO_MAPPING
PALOBJ *palObj;
#endif
const PALETTEENTRY* __sysPalTemplate = (const PALETTEENTRY*)COLOR_GetSystemPaletteTemplate();
// create default palette (20 system colors)
palPtr = ExAllocatePoolWithTag(PagedPool,
sizeof(LOGPALETTE) +
(NB_RESERVED_COLORS * sizeof(PALETTEENTRY)),
TAG_PALETTE);
if (!palPtr) return FALSE;
palPtr->palVersion = 0x300;
palPtr->palNumEntries = NB_RESERVED_COLORS;
for (i=0; i<NB_RESERVED_COLORS; i++)
{
palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
palPtr->palPalEntry[i].peFlags = 0;
}
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; */
return hpalette;
}
#ifndef NO_MAPPING
static void FASTCALL PALETTE_FormatSystemPalette(void)
{
// Build free list so we'd have an easy way to find
// out if there are any available colorcells.
int i, j = PALETTE_firstFree = NB_RESERVED_COLORS/2;
COLOR_sysPal[j].peFlags = 0;
for (i = (NB_RESERVED_COLORS>>1) + 1 ; i < 256 - (NB_RESERVED_COLORS>>1) ; i++)
{
if (i < COLOR_gapStart || i > COLOR_gapEnd)
{
COLOR_sysPal[i].peFlags = 0; // unused tag
PALETTE_freeList[j] = i; // next
j = i;
}
}
PALETTE_freeList[j] = 0;
}
#endif
VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, INT size)
{
int i = 0;
for (; i<size ; i++)
lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
}
#ifndef NO_MAPPING
// Set the color-mapping table for selected palette.
// Return number of entries which mapping has changed.
INT APIENTRY PALETTE_SetMapping(PALOBJ *palPtr, UINT uStart, UINT uNum, BOOL mapOnly)
{
char flag;
int prevMapping = (palPtr->mapping) ? 1 : 0;
int index, iRemapped = 0;
int *mapping;
HPALETTE hSysPal = NtGdiGetStockObject(DEFAULT_PALETTE);
PPALETTE pSysPal = PALETTE_LockPalette(hSysPal);
PPALETTE palGDI = CONTAINING_RECORD(palPtr,PALETTE,PalObj);
/* FIXME - handle pSysPal == NULL!!!!!!! */
COLOR_sysPal = pSysPal->IndexedColors;
PALETTE_UnlockPalette(pSysPal); // FIXME: Is this a right way to obtain pointer to the system palette?
// reset dynamic system palette entries
if (!mapOnly && PALETTE_firstFree != -1) PALETTE_FormatSystemPalette();
// initialize palette mapping table
//mapping = HeapReAlloc( GetProcessHeap(), 0, palPtr->mapping,
// sizeof(int)*palPtr->logpalette->palNumEntries);
ExFreePool(palPtr->mapping);
mapping = ExAllocatePoolWithTag(PagedPool, sizeof(int)*palGDI->NumColors, TAG_PALETTEMAP);
if (!mapping)
{
DPRINT1("Failed allocating memory for palette mapping!\n");
return 0;
}
palPtr->mapping = mapping;
for (uNum += uStart; uStart < uNum; uStart++)
{
index = -1;
flag = PC_SYS_USED;
switch (palGDI->IndexedColors[uStart].peFlags & 0x07)
{
case PC_EXPLICIT: // palette entries are indices into system palette
// The PC_EXPLICIT flag is used to copy an entry from the system palette into the logical palette
index = *(WORD*)(palGDI->IndexedColors + uStart);
if (index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd))
{
DbgPrint("Win32k: PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index);
index = 0;
}
break;
case PC_RESERVED: // forbid future mappings to this entry
// For palette animation, the entries in the logical palette need the PC_RESERVED flag
flag |= PC_SYS_RESERVED;
// fall through
default: // try to collapse identical colors
index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256,
*(COLORREF*)(palGDI->IndexedColors + uStart));
// fall through
case PC_NOCOLLAPSE:
// If an entry in the logical palette is marked with the PC_NOCOLLAPSE flag, the palette
// manager allocates a free entry in the system palette if one is available and only uses the
// closest colour match if there are no (more) free entries in the system palette
DbgPrint("Win32k: WARNING: PC_NOCOLLAPSE is not yet working properly\n");
if (index < 0)
{
if (PALETTE_firstFree > 0 /* && !(PALETTE_PaletteFlags & PALETTE_FIXED) FIXME */)
{
DbgPrint("Win32k: Unimplemented Palette Operation: PC_NOCOLLAPSE [objects/palette.c]\n");
/* XColor color;
index = PALETTE_firstFree; // ought to be available
PALETTE_firstFree = PALETTE_freeList[index];
color.pixel = (PALETTE_PaletteToXPixel) ? PALETTE_PaletteToXPixel[index] : index;
color.red = palPtr->logpalette->palPalEntry[uStart].peRed << 8;
color.green = palPtr->logpalette->palPalEntry[uStart].peGreen << 8;
color.blue = palPtr->logpalette->palPalEntry[uStart].peBlue << 8;
color.flags = DoRed | DoGreen | DoBlue;
TSXStoreColor(display, PALETTE_PaletteXColormap, &color);
COLOR_sysPal[index] = palPtr->logpalette->palPalEntry[uStart];
COLOR_sysPal[index].peFlags = flag;
PALETTE_freeList[index] = 0;
if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; */
break;
}
/* else if (PALETTE_PaletteFlags & PALETTE_VIRTUAL)
{
index = PALETTE_ToPhysical(NULL, 0x00ffffff &
*(COLORREF*)(palPtr->logpalette->palPalEntry + uStart));
break;
} FIXME */
// we have to map to existing entry in the system palette
index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL,
*(COLORREF*)(palGDI->IndexedColors + uStart), TRUE);
}
palGDI->IndexedColors[uStart].peFlags |= PC_SYS_USED;
/* if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; FIXME */
break;
}
if (!prevMapping || palPtr->mapping[uStart] != index) iRemapped++;
palPtr->mapping[uStart] = index;
}
return iRemapped;
}
#endif
INT FASTCALL
PALETTE_GetObject(PPALETTE pGdiObject, INT cbCount, LPLOGBRUSH lpBuffer)
{
if (!lpBuffer)
{
return sizeof(WORD);
}
if ((UINT)cbCount < sizeof(WORD)) return 0;
*((WORD*)lpBuffer) = (WORD)pGdiObject->NumColors;
return sizeof(WORD);
}
/* EOF */

4
reactos/subsystems/win32/win32k/win32k.rbuild
View file

@ -67,7 +67,6 @@
<file>engmisc.c</file>
<file>mouse.c</file>
<file>paint.c</file>
<file>palette.c</file>
<file>perfcnt.c</file>
<file>semaphor.c</file>
<file>sort.c</file>
@ -163,7 +162,6 @@
<file>bitmaps.c</file>
<file>brush.c</file>
<file>cliprgn.c</file>
<file>color.c</file>
<file>coord.c</file>
<file>dcattr.c</file>
<file>dclife.c</file>
@ -181,7 +179,7 @@
<file>icm.c</file>
<file>line.c</file>
<file>metafile.c</file>
<file>palobj.c</file>
<file>palette.c</file>
<file>path.c</file>
<file>pen.c</file>
<file>polyfill.c</file>