+/*
+ * 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.
+ */
+/* $Id$ */
+
// FIXME: Use PXLATEOBJ logicalToSystem instead of int *mapping
#undef WIN32_LEAN_AND_MEAN
#include <win32k/pen.h>
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/color.h>
+#include <include/palette.h>
#define NDEBUG
#include <win32k/debug1.h>
int COLOR_max = 256;
static HPALETTE hPrimaryPalette = 0; // used for WM_PALETTECHANGED
-static HPALETTE hLastRealizedPalette = 0; // UnrealizeObject() needs it
+//static HPALETTE hLastRealizedPalette = 0; // UnrealizeObject() needs it
const PALETTEENTRY COLOR_sysPalTemplate[NB_RESERVED_COLORS] =
{
{ 0xff, 0xff, 0xff, PC_SYS_USED } // last 10
};
-ULONG W32kGetSysColor(int nIndex)
+ULONG FASTCALL NtGdiGetSysColor(int nIndex)
{
- PALETTEENTRY *p = COLOR_sysPalTemplate + (nIndex * sizeof(PALETTEENTRY));
+ const PALETTEENTRY *p = COLOR_sysPalTemplate + (nIndex * sizeof(PALETTEENTRY));
return RGB(p->peRed, p->peGreen, p->peBlue);
}
-HPEN STDCALL W32kGetSysColorPen(int nIndex)
+HPEN STDCALL NtGdiGetSysColorPen(int nIndex)
{
COLORREF Col;
memcpy(&Col, COLOR_sysPalTemplate + nIndex, sizeof(COLORREF));
- return(W32kCreatePen(PS_SOLID, 1, Col));
+ return(NtGdiCreatePen(PS_SOLID, 1, Col));
}
-HBRUSH STDCALL W32kGetSysColorBrush(int nIndex)
+HBRUSH STDCALL NtGdiGetSysColorBrush(int nIndex)
{
COLORREF Col;
memcpy(&Col, COLOR_sysPalTemplate + nIndex, sizeof(COLORREF));
- return(W32kCreateSolidBrush(Col));
+ return(NtGdiCreateSolidBrush(Col));
}
-//forward declarations
-COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color );
-const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(void)
+const PALETTEENTRY* FASTCALL COLOR_GetSystemPaletteTemplate(void)
{
return (const PALETTEENTRY*)&COLOR_sysPalTemplate;
}
-BOOL STDCALL W32kAnimatePalette(HPALETTE hpal,
+BOOL STDCALL NtGdiAnimatePalette(HPALETTE hpal,
UINT StartIndex,
UINT Entries,
CONST PPALETTEENTRY ppe)
{
/*
- if( hPal != W32kGetStockObject(DEFAULT_PALETTE) )
+ if( hPal != NtGdiGetStockObject(DEFAULT_PALETTE) )
{
PALETTEOBJ* palPtr = (PALETTEOBJ *)GDI_GetObjPtr(hPal, PALETTE_MAGIC);
if (!palPtr) return FALSE;
UNIMPLEMENTED;
}
-HPALETTE STDCALL W32kCreateHalftonePalette(HDC hDC)
+HPALETTE STDCALL NtGdiCreateHalftonePalette(HDC hDC)
{
int i, r, g, b;
struct {
Palette.Version = 0x300;
Palette.NumberOfEntries = 256;
- W32kGetSystemPaletteEntries(hDC, 0, 256, Palette.aEntries);
+ NtGdiGetSystemPaletteEntries(hDC, 0, 256, Palette.aEntries);
for (r = 0; r < 6; r++) {
for (g = 0; g < 6; g++) {
Palette.aEntries[i].peBlue = v;
}
- return W32kCreatePalette((LOGPALETTE *)&Palette);
+ return NtGdiCreatePalette((LOGPALETTE *)&Palette);
}
-HPALETTE STDCALL W32kCreatePalette(CONST PLOGPALETTE palette)
+HPALETTE STDCALL NtGdiCreatePalette(CONST PLOGPALETTE palette)
{
PPALOBJ PalObj;
- HPALETTE NewPalette = (HPALETTE)EngCreatePalette(PAL_INDEXED, palette->palNumEntries, (PULONG*) palette->palPalEntry, 0, 0, 0);
+ HPALETTE NewPalette = PALETTE_AllocPalette(
+ PAL_INDEXED,
+ palette->palNumEntries,
+ (PULONG)palette->palPalEntry,
+ 0, 0, 0);
ULONG size;
- PalObj = (PPALOBJ)AccessUserObject(NewPalette);
+ PalObj = (PPALOBJ) PALETTE_LockPalette(NewPalette);
size = sizeof(LOGPALETTE) + (palette->palNumEntries * sizeof(PALETTEENTRY));
PalObj->logpalette = ExAllocatePool(NonPagedPool, size);
PALETTE_ValidateFlags(PalObj->logpalette->palPalEntry, PalObj->logpalette->palNumEntries);
PalObj->logicalToSystem = NULL;
+ PALETTE_UnlockPalette(NewPalette);
+
return NewPalette;
}
-BOOL STDCALL W32kGetColorAdjustment(HDC hDC,
+BOOL STDCALL NtGdiGetColorAdjustment(HDC hDC,
LPCOLORADJUSTMENT ca)
{
UNIMPLEMENTED;
}
-COLORREF STDCALL W32kGetNearestColor(HDC hDC,
+COLORREF STDCALL NtGdiGetNearestColor(HDC hDC,
COLORREF Color)
{
COLORREF nearest = CLR_INVALID;
PDC dc;
PPALOBJ palObj;
- if( (dc = DC_HandleToPtr(hDC) ) )
- {
- HPALETTE hpal = (dc->w.hPalette)? dc->w.hPalette : W32kGetStockObject(DEFAULT_PALETTE);
- palObj = (PPALOBJ)AccessUserObject(hpal);
- if (!palObj) {
-// GDI_ReleaseObj(hdc);
- return nearest;
+ dc = DC_LockDc(hDC);
+ if (NULL != dc)
+ {
+ HPALETTE hpal = (dc->w.hPalette) ? dc->w.hPalette : NtGdiGetStockObject(DEFAULT_PALETTE);
+ palObj = (PPALOBJ) PALETTE_LockPalette(hpal);
+ if (!palObj)
+ {
+ DC_UnlockDc(hDC);
+ return nearest;
+ }
+
+ nearest = COLOR_LookupNearestColor(palObj->logpalette->palPalEntry,
+ palObj->logpalette->palNumEntries, Color);
+ PALETTE_UnlockPalette(hpal);
+ DC_UnlockDc( hDC );
}
- nearest = COLOR_LookupNearestColor(palObj->logpalette->palPalEntry,
- palObj->logpalette->palNumEntries, Color);
- // FIXME: release hpal!!
-// GDI_ReleaseObj( hpal );
- DC_ReleasePtr( hDC );
- }
-
return nearest;
}
-UINT STDCALL W32kGetNearestPaletteIndex(HPALETTE hpal,
+UINT STDCALL NtGdiGetNearestPaletteIndex(HPALETTE hpal,
COLORREF Color)
{
- PPALOBJ palObj = (PPALOBJ)AccessUserObject(hpal);
+ PPALOBJ palObj = (PPALOBJ) PALETTE_LockPalette(hpal);
UINT index = 0;
- if( palObj )
- {
- // Return closest match for the given RGB color
- index = COLOR_PaletteLookupPixel(palObj->logpalette->palPalEntry, palObj->logpalette->palNumEntries, NULL, Color, FALSE);
-// GDI_ReleaseObj( hpalette );
- }
+ if (NULL != palObj)
+ {
+ /* Return closest match for the given RGB color */
+ index = COLOR_PaletteLookupPixel(palObj->logpalette->palPalEntry, palObj->logpalette->palNumEntries, NULL, Color, FALSE);
+ PALETTE_UnlockPalette(hpal);
+ }
return index;
}
-UINT STDCALL W32kGetPaletteEntries(HPALETTE hpal,
+UINT STDCALL NtGdiGetPaletteEntries(HPALETTE hpal,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe)
PPALOBJ palPtr;
UINT numEntries;
- palPtr = (PPALOBJ)AccessUserObject(hpal);
- if (!palPtr) return 0;
+ palPtr = (PPALOBJ) PALETTE_LockPalette(hpal);
+ if (NULL == palPtr)
+ {
+ return 0;
+ }
numEntries = palPtr->logpalette->palNumEntries;
- if (StartIndex + Entries > numEntries) Entries = numEntries - StartIndex;
- if (pe)
- {
- if (StartIndex >= numEntries)
+ if (numEntries < StartIndex + Entries)
{
-// GDI_ReleaseObj( hpalette );
- return 0;
+ Entries = numEntries - StartIndex;
+ }
+ if (NULL != pe)
+ {
+ if (numEntries <= StartIndex)
+ {
+ PALETTE_UnlockPalette(hpal);
+ return 0;
+ }
+ memcpy(pe, &palPtr->logpalette->palPalEntry[StartIndex], Entries * sizeof(PALETTEENTRY));
+ for (numEntries = 0; numEntries < Entries; numEntries++)
+ {
+ if (pe[numEntries].peFlags & 0xF0)
+ {
+ pe[numEntries].peFlags = 0;
+ }
+ }
}
- memcpy(pe, &palPtr->logpalette->palPalEntry[StartIndex], Entries * sizeof(PALETTEENTRY));
- for(numEntries = 0; numEntries < Entries ; numEntries++)
- if (pe[numEntries].peFlags & 0xF0)
- pe[numEntries].peFlags = 0;
- }
-// GDI_ReleaseObj( hpalette );
+ PALETTE_UnlockPalette(hpal);
return Entries;
}
-UINT STDCALL W32kGetSystemPaletteEntries(HDC hDC,
+UINT STDCALL NtGdiGetSystemPaletteEntries(HDC hDC,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe)
{
- UINT i;
- PDC dc;
+ //UINT i;
+ //PDC dc;
/*
if (!(dc = AccessUserObject(hdc))) return 0;
if (!pe)
{
- Entries = dc->devCaps->sizePalette;
+ Entries = dc->GDIInfo->ulNumPalReg;
goto done;
}
- if (StartIndex >= dc->devCaps->sizePalette)
+ if (StartIndex >= dc->GDIInfo->ulNumPalReg)
{
Entries = 0;
goto done;
}
- if (StartIndex + Entries >= dc->devCaps->sizePalette) Entries = dc->devCaps->sizePalette - StartIndex;
+ if (StartIndex + Entries >= dc->GDIInfo->ulNumPalReg) Entries = dc->GDIInfo->ulNumPalReg - StartIndex;
for (i = 0; i < Entries; i++)
{
done:
// GDI_ReleaseObj(hdc);
return count; */
+ // FIXME UNIMPLEMENTED;
+ return 0;
}
-UINT STDCALL W32kGetSystemPaletteUse(HDC hDC)
+UINT STDCALL NtGdiGetSystemPaletteUse(HDC hDC)
{
UNIMPLEMENTED;
+ return 0;
}
/*!
the dc palette.
-- If it is an RGB palette, then an XLATEOBJ is created between the RGB values and the dc palette.
*/
-UINT STDCALL W32kRealizePalette(HDC hDC)
+UINT STDCALL NtGdiRealizePalette(HDC hDC)
{
PPALOBJ palPtr, sysPtr;
PPALGDI palGDI, sysGDI;
HPALETTE systemPalette;
PSURFGDI SurfGDI;
BOOLEAN success;
+ USHORT sysMode, palMode;
- dc = DC_HandleToPtr(hDC);
+ dc = DC_LockDc(hDC);
if (!dc)
return 0;
- palPtr = (PPALOBJ)AccessUserObject(dc->w.hPalette);
- SurfGDI = (PSURFGDI)AccessInternalObjectFromUserObject(dc->Surface);
- systemPalette = W32kGetStockObject(STOCK_DEFAULT_PALETTE);
- sysPtr = (PPALOBJ)AccessInternalObject(systemPalette);
- palGDI = (PPALGDI)AccessInternalObject(dc->w.hPalette);
- sysGDI = (PPALGDI)AccessInternalObject(systemPalette);
+ SurfGDI = (PSURFGDI)AccessInternalObject((ULONG)dc->Surface);
+ systemPalette = NtGdiGetStockObject((INT)DEFAULT_PALETTE);
+ palGDI = PALETTE_LockPalette(dc->w.hPalette);
+ palPtr = (PPALOBJ) palGDI;
+ sysGDI = PALETTE_LockPalette(systemPalette);
+ sysPtr = (PPALOBJ) sysGDI;
// Step 1: Create mapping of system palette\DC palette
realized = PALETTE_SetMapping(palPtr, 0, palPtr->logpalette->palNumEntries,
(dc->w.hPalette != hPrimaryPalette) ||
- (dc->w.hPalette == W32kGetStockObject(DEFAULT_PALETTE)));
+ (dc->w.hPalette == NtGdiGetStockObject(DEFAULT_PALETTE)));
// Step 2:
// The RealizePalette function modifies the palette for the device associated with the specified device context. If the
}
}
+ // need to pass this to IntEngCreateXlate with palettes unlocked
+ sysMode = sysGDI->Mode;
+ palMode = palGDI->Mode;
+ PALETTE_UnlockPalette(systemPalette);
+ PALETTE_UnlockPalette(dc->w.hPalette);
+
// Step 3: Create the XLATEOBJ for device managed DCs
if(dc->w.flags != DC_MEMORY)
{
palPtr->logicalToSystem = IntEngCreateXlate(sysGDI->Mode, palGDI->Mode, systemPalette, dc->w.hPalette);
}
-// GDI_ReleaseObj(dc->w.hPalette);
-// GDI_ReleaseObj(hdc);
+ DC_UnlockDc(hDC);
return realized;
}
-BOOL STDCALL W32kResizePalette(HPALETTE hpal,
+BOOL STDCALL NtGdiResizePalette(HPALETTE hpal,
UINT Entries)
{
/* PPALOBJ palPtr = (PPALOBJ)AccessUserObject(hPal);
*
* \todo implement ForceBackground == TRUE
*/
-HPALETTE STDCALL W32kSelectPalette(HDC hDC,
+HPALETTE STDCALL NtGdiSelectPalette(HDC hDC,
HPALETTE hpal,
BOOL ForceBackground)
{
PDC dc;
HPALETTE oldPal;
+ PPALGDI PalGDI;
// FIXME: mark the palette as a [fore\back]ground pal
- dc = DC_HandleToPtr(hDC);
- if( dc ){
- oldPal = dc->w.hPalette;
- dc->w.hPalette = hpal;
- DC_ReleasePtr( hDC );
- }
+ dc = DC_LockDc(hDC);
+ if (NULL != dc)
+ {
+ /* Check if this is a valid palette handle */
+ PalGDI = PALETTE_LockPalette(hpal);
+ if (NULL != PalGDI)
+ {
+ PALETTE_UnlockPalette(hpal);
+ oldPal = dc->w.hPalette;
+ dc->w.hPalette = hpal;
+ }
+ else
+ {
+ oldPal = NULL;
+ }
+ DC_UnlockDc(hDC);
+ }
return oldPal;
}
-BOOL STDCALL W32kSetColorAdjustment(HDC hDC,
+BOOL STDCALL NtGdiSetColorAdjustment(HDC hDC,
CONST LPCOLORADJUSTMENT ca)
{
UNIMPLEMENTED;
}
-UINT STDCALL W32kSetPaletteEntries(HPALETTE hpal,
+UINT STDCALL NtGdiSetPaletteEntries(HPALETTE hpal,
UINT Start,
UINT Entries,
CONST LPPALETTEENTRY pe)
{
PPALOBJ palPtr;
- INT numEntries;
+ WORD numEntries;
- palPtr = (PPALOBJ)AccessUserObject(hpal);
+ palPtr = (PPALOBJ)PALETTE_LockPalette(hpal);
if (!palPtr) return 0;
numEntries = palPtr->logpalette->palNumEntries;
if (Start >= numEntries)
- {
-// GDI_ReleaseObj( hpalette );
- return 0;
- }
- if (Start + Entries > numEntries) Entries = numEntries - Start;
+ {
+ PALETTE_UnlockPalette(hpal);
+ return 0;
+ }
+ if (numEntries < Start + Entries)
+ {
+ Entries = numEntries - Start;
+ }
memcpy(&palPtr->logpalette->palPalEntry[Start], pe, Entries * sizeof(PALETTEENTRY));
PALETTE_ValidateFlags(palPtr->logpalette->palPalEntry, palPtr->logpalette->palNumEntries);
ExFreePool(palPtr->logicalToSystem);
palPtr->logicalToSystem = NULL;
-// GDI_ReleaseObj( hpalette );
+ PALETTE_UnlockPalette(hpal);
+
return Entries;
}
-UINT STDCALL W32kSetSystemPaletteUse(HDC hDC,
+UINT STDCALL NtGdiSetSystemPaletteUse(HDC hDC,
UINT Usage)
{
UNIMPLEMENTED;
}
-BOOL STDCALL W32kUnrealizeObject(HGDIOBJ hgdiobj)
+BOOL STDCALL NtGdiUnrealizeObject(HGDIOBJ hgdiobj)
{
UNIMPLEMENTED;
}
-BOOL STDCALL W32kUpdateColors(HDC hDC)
+BOOL STDCALL NtGdiUpdateColors(HDC hDC)
{
- PDC dc;
- HWND hWnd;
- int size;
+ //PDC dc;
+ //HWND hWnd;
+ //int size;
/*
if (!(dc = AccessUserObject(hDC))) return 0;
- size = dc->devCaps->sizePalette;
+ size = dc->GDIInfo->ulNumPalReg;
// GDI_ReleaseObj( hDC );
if (Callout.WindowFromDC)
// but it would take forever given the speed of XGet/PutPixel.
if (hWnd && size) Callout.RedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
} */
+ // FIXME UNIMPLEMENTED
return 0x666;
}
-int COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, int size,
+INT STDCALL COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size,
PXLATEOBJ XlateObj, COLORREF col, BOOL skipReserved)
{
int i, best = 0, diff = 0x7fffffff;
if( r < diff ) { best = i; diff = r; }
}
- return (XlateObj->pulXlate) ? XlateObj->pulXlate[best] : best;
+ return (XlateObj->pulXlate) ? (INT)XlateObj->pulXlate[best] : best;
}
-COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color )
+COLORREF STDCALL COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color )
{
unsigned char spec_type = color >> 24;
int i;
return (0x00ffffff & *(COLORREF*)(COLOR_sysPal + COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, color, FALSE)));
}
-int COLOR_PaletteLookupExactIndex( PALETTEENTRY* palPalEntry, int size,
+int STDCALL COLOR_PaletteLookupExactIndex( PALETTEENTRY* palPalEntry, int size,
COLORREF col )
{
int i;
}
return -1;
}
+/* EOF */
git://git.jankratochvil.net / reactos.git / blobdiff