Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-04 03:34:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Fix various bitmap format translation bugs

Browse source 
- Fix some palette issues
- Fix some gdiobj locking warnings

svn path=/trunk/; revision=5950
This commit is contained in:
Gé van Geldorp 2003-08-31 07:56:24 +00:00
parent e9170f21ca
commit f62b36b0f1
10 changed files with 329 additions and 478 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/include/win32k/dc.h
View file

@ -171,7 +171,6 @@ HGDIOBJ STDCALL NtGdiGetCurrentObject(HDC hDC, UINT ObjectType);
VOID FASTCALL IntGetCurrentPositionEx (PDC dc, LPPOINT currentPosition);
BOOL STDCALL NtGdiGetCurrentPositionEx(HDC hDC, LPPOINT currentPosition);
BOOL STDCALL NtGdiGetDCOrgEx(HDC hDC, LPPOINT Point);
HDC STDCALL NtGdiGetDCState16(HDC hDC);
INT STDCALL NtGdiGetDeviceCaps(HDC hDC, INT Index);
INT STDCALL NtGdiGetMapMode(HDC hDC);
INT STDCALL NtGdiGetObject(HGDIOBJ hGDIObj,

41
reactos/subsys/win32k/dib/dib16bpp.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: dib16bpp.c,v 1.7 2003/08/13 20:24:04 chorns Exp $ */
/* $Id: dib16bpp.c,v 1.8 2003/08/31 07:56:24 gvg Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
@ -179,9 +179,42 @@ DIB_16BPP_BitBltSrcCopy(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
}
else
{
/* FIXME */
DPRINT1("DIB_16BPP_Bitblt: Unhandled ColorTranslation for 16 -> 16 copy");
return FALSE;
if (DestRect->top < SourcePoint->y)
{
SourceLine = SourceSurf->pvScan0 + (SourcePoint->y * SourceSurf->lDelta) + 2 * SourcePoint->x;
DestLine = DestBits;
for (j = DestRect->top; j < DestRect->bottom; j++)
{
SourceBits = SourceLine;
DestBits = DestLine;
for (i = DestRect->left; i < DestRect->right; i++)
{
*((WORD *)DestBits) = (WORD)XLATEOBJ_iXlate(ColorTranslation, *((WORD *)SourceBits));
SourceBits += 2;
DestBits += 2;
}
SourceLine += SourceSurf->lDelta;
DestLine += DestSurf->lDelta;
}
}
else
{
SourceLine = SourceSurf->pvScan0 + ((SourcePoint->y + DestRect->bottom - DestRect->top - 1) * SourceSurf->lDelta) + 2 * SourcePoint->x;
DestLine = DestSurf->pvScan0 + ((DestRect->bottom - 1) * DestSurf->lDelta) + 2 * DestRect->left;
for (j = DestRect->bottom - 1; DestRect->top <= j; j--)
{
SourceBits = SourceLine;
DestBits = DestLine;
for (i = DestRect->left; i < DestRect->right; i++)
{
*((WORD *)DestBits) = (WORD)XLATEOBJ_iXlate(ColorTranslation, *((WORD *)SourceBits));
SourceBits += 2;
DestBits += 2;
}
SourceLine -= SourceSurf->lDelta;
DestLine -= DestSurf->lDelta;
}
}
}
break;

37
reactos/subsys/win32k/dib/dib8bpp.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: dib8bpp.c,v 1.5 2003/08/13 20:24:04 chorns Exp $ */
/* $Id: dib8bpp.c,v 1.6 2003/08/31 07:56:24 gvg Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
@ -156,9 +156,38 @@ DIB_8BPP_BitBltSrcCopy(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
}
else
{
/* FIXME */
DPRINT1("DIB_8BPP_Bitblt: Unhandled ColorTranslation for 32 -> 32 copy");
return FALSE;
if (DestRect->top < SourcePoint->y)
{
SourceLine = SourceSurf->pvScan0 + (SourcePoint->y * SourceSurf->lDelta) + SourcePoint->x;
DestLine = DestBits;
for (j = DestRect->top; j < DestRect->bottom; j++)
{
SourceBits = SourceLine;
DestBits = DestLine;
for (i=DestRect->left; i<DestRect->right; i++)
{
*DestBits++ = XLATEOBJ_iXlate(ColorTranslation, *SourceBits++);
}
SourceLine += SourceSurf->lDelta;
DestLine += DestSurf->lDelta;
}
}
else
{
SourceLine = SourceSurf->pvScan0 + ((SourcePoint->y + DestRect->bottom - DestRect->top - 1) * SourceSurf->lDelta) + SourcePoint->x;
DestLine = DestSurf->pvScan0 + ((DestRect->bottom - 1) * DestSurf->lDelta) + DestRect->left;
for (j = DestRect->bottom - 1; DestRect->top <= j; j--)
{
SourceBits = SourceLine;
DestBits = DestLine;
for (i=DestRect->left; i<DestRect->right; i++)
{
*DestBits++ = XLATEOBJ_iXlate(ColorTranslation, *SourceBits++);
}
SourceLine -= SourceSurf->lDelta;
DestLine -= DestSurf->lDelta;
}
}
}
break;

14
reactos/subsys/win32k/eng/copybits.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: copybits.c,v 1.17 2003/08/04 19:57:05 royce Exp $
/* $Id: copybits.c,v 1.18 2003/08/31 07:56:24 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -119,14 +119,10 @@ EngCopyBits(SURFOBJ *Dest,
clippingType = Clip->iDComplexity;
}
// We only handle XO_TABLE translations at the momement
if ((ColorTranslation == NULL) || (ColorTranslation->flXlate & XO_TRIVIAL) ||
(ColorTranslation->flXlate & XO_TABLE))
{
SourceGDI = (PSURFGDI)AccessInternalObjectFromUserObject(Source);
DestGDI = (PSURFGDI)AccessInternalObjectFromUserObject(Dest);
SourceGDI = (PSURFGDI)AccessInternalObjectFromUserObject(Source);
DestGDI = (PSURFGDI)AccessInternalObjectFromUserObject(Dest);
switch(clippingType)
switch(clippingType)
{
case DC_TRIVIAL:
DestGDI->DIB_BitBlt(Dest, Source, DestGDI, SourceGDI, DestRect, SourcePoint, NULL, NULL, ColorTranslation, SRCCOPY);
@ -184,11 +180,11 @@ EngCopyBits(SURFOBJ *Dest,
return(TRUE);
}
}
MouseSafetyOnDrawEnd(Source, SourceGDI);
MouseSafetyOnDrawEnd(Dest, DestGDI);
return FALSE;
}
/* EOF */

50
reactos/subsys/win32k/eng/xlate.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: xlate.c,v 1.23 2003/08/28 12:35:59 gvg Exp $
/* $Id: xlate.c,v 1.24 2003/08/31 07:56:24 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -101,24 +101,20 @@ ClosestColorMatch(XLATEGDI *XlateGDI, ULONG SourceColor, ULONG *DestColors,
return CCMLastColorMatch;
}
if (PAL_BITFIELDS == XlateGDI->XlateObj.iSrcType)
if (PAL_BITFIELDS == XlateGDI->XlateObj.iSrcType || PAL_BGR == XlateGDI->XlateObj.iSrcType)
{
/* FIXME: must use bitfields */
SourceRGB = ShiftAndMask(XlateGDI, SourceColor);
cSourceColor = (PVIDEO_CLUTDATA) &SourceRGB;
/*
SourceRed = (SourceColor >> 7) & 0xff;
SourceGreen = (SourceColor >> 2) & 0xff;
SourceBlue = (SourceColor << 3) & 0xff;
*/
/* FIXME: must use bitfields */
SourceRGB = ShiftAndMask(XlateGDI, SourceColor);
cSourceColor = (PVIDEO_CLUTDATA) &SourceRGB;
}
else
{
cSourceColor = (PVIDEO_CLUTDATA)&SourceColor;
cSourceColor = (PVIDEO_CLUTDATA)&SourceColor;
}
SourceRed = cSourceColor->Red;
SourceGreen = cSourceColor->Green;
SourceBlue = cSourceColor->Blue;
for (i=0; i<NumColors; i++)
{
cDestColors = (PVIDEO_CLUTDATA)&DestColors[i];
@ -150,11 +146,18 @@ IndexedToIndexedTranslationTable(XLATEGDI *XlateGDI, ULONG *TranslationTable,
PALGDI *PalDest, PALGDI *PalSource)
{
ULONG i;
WINBOOL Trivial;
Trivial = TRUE;
for(i=0; i<PalSource->NumColors; i++)
{
TranslationTable[i] = ClosestColorMatch(XlateGDI, PalSource->IndexedColors[i], PalDest->IndexedColors, PalDest->NumColors);
}
{
TranslationTable[i] = ClosestColorMatch(XlateGDI, PalSource->IndexedColors[i], PalDest->IndexedColors, PalDest->NumColors);
Trivial = Trivial && (TranslationTable[i] == i);
}
if (Trivial)
{
XlateGDI->XlateObj.flXlate |= XO_TRIVIAL;
}
}
static VOID STDCALL
@ -301,7 +304,7 @@ XLATEOBJ * STDCALL IntEngCreateXlate(USHORT DestPalType, USHORT SourcePalType,
}
// Prepare the translation table
if( (SourcePalType == PAL_INDEXED) || (SourcePalType == PAL_RGB) )
if (PAL_INDEXED == SourcePalType || PAL_RGB == SourcePalType || PAL_BGR == SourcePalType)
{
XlateObj->flXlate |= XO_TABLE;
if ((SourcePalType == PAL_INDEXED) && (DestPalType == PAL_INDEXED))
@ -333,13 +336,7 @@ XLATEOBJ * STDCALL IntEngCreateXlate(USHORT DestPalType, USHORT SourcePalType,
// Converting from indexed to RGB
#ifdef TODO
XLATEOBJ_cGetPalette(XlateObj, XO_SRCPALETTE,
SourcePalGDI->NumColors,
XlateGDI->translationTable);
#else
RtlCopyMemory(XlateGDI->translationTable, SourcePalGDI->IndexedColors, sizeof(ULONG) * SourcePalGDI->NumColors);
#endif
if (PAL_BITFIELDS == XlateObj->iDstType)
{
for (i = 0; i < SourcePalGDI->NumColors; i++)
@ -353,19 +350,15 @@ XLATEOBJ * STDCALL IntEngCreateXlate(USHORT DestPalType, USHORT SourcePalType,
}
// Source palette is RGB
if(XlateObj->iSrcType == PAL_RGB)
if (PAL_RGB == XlateObj->iSrcType || PAL_BGR == XlateObj->iSrcType)
{
if(XlateObj->iDstType == PAL_INDEXED)
if(PAL_INDEXED == XlateObj->iDstType)
{
// FIXME: Is this necessary? I think the driver has to call this
// function anyways if pulXlate is NULL and Dest is PAL_INDEXED
// Converting from RGB to indexed
#ifdef TODO
XLATEOBJ_cGetPalette(XlateObj, XO_DESTPALETTE, DestPalGDI->NumColors, XlateGDI->translationTable);
#else
RtlCopyMemory(XlateGDI->translationTable, DestPalGDI->IndexedColors, sizeof(ULONG) * DestPalGDI->NumColors);
#endif
}
}
@ -433,7 +426,8 @@ XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
{
return ShiftAndMask(XlateGDI, Color);
} else
if(PAL_RGB == XlateObj->iSrcType || PAL_BITFIELDS == XlateObj->iSrcType)
if (PAL_RGB == XlateObj->iSrcType || PAL_BGR == XlateObj->iSrcType
|| PAL_BITFIELDS == XlateObj->iSrcType)
{
// FIXME: should we cache colors used often?
// FIXME: won't work if destination isn't indexed

81
reactos/subsys/win32k/objects/bitmaps.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: bitmaps.c,v 1.37 2003/08/28 12:35:59 gvg Exp $ */
/* $Id: bitmaps.c,v 1.38 2003/08/31 07:56:24 gvg Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
@ -54,8 +54,7 @@ BOOL STDCALL NtGdiBitBlt(HDC hDCDest,
POINTL SourcePoint;
//PBITMAPOBJ DestBitmapObj;
//PBITMAPOBJ SrcBitmapObj;
BOOL Status, SurfDestAlloc, SurfSrcAlloc, XlateAlloc;
PPALOBJ DCLogPal;
BOOL Status, SurfDestAlloc, SurfSrcAlloc;
PPALGDI PalDestGDI, PalSourceGDI;
PXLATEOBJ XlateObj = NULL;
HPALETTE SourcePalette, DestPalette;
@ -89,7 +88,6 @@ BOOL STDCALL NtGdiBitBlt(HDC hDCDest,
SurfDestAlloc = FALSE;
SurfSrcAlloc = FALSE;
XlateAlloc = FALSE;
// Determine surfaces to be used in the bitblt
SurfDest = (PSURFOBJ)AccessUserObject((ULONG)DCDest->Surface);
@ -98,62 +96,45 @@ BOOL STDCALL NtGdiBitBlt(HDC hDCDest,
SurfGDIDest = (PSURFGDI)AccessInternalObjectFromUserObject(SurfDest);
SurfGDISrc = (PSURFGDI)AccessInternalObjectFromUserObject(SurfSrc);
// Retrieve the logical palette of the destination DC
DCLogPal = (PPALOBJ)PALETTE_LockPalette(DCDest->w.hPalette);
if(DCLogPal)
if (DCDest->w.hPalette != 0)
{
if(DCLogPal->logicalToSystem)
{
XlateObj = DCLogPal->logicalToSystem;
}
PALETTE_UnlockPalette(DCDest->w.hPalette);
DestPalette = DCDest->w.hPalette;
}
else
{
DestPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
}
// If the source and destination formats differ, create an XlateObj [what if we already have one??]
if((BitsPerFormat(SurfDest->iBitmapFormat) != BitsPerFormat(SurfSrc->iBitmapFormat)) && (XlateObj == NULL))
if(DCSrc->w.hPalette != 0)
{
if(DCDest->w.hPalette != 0)
{
DestPalette = DCDest->w.hPalette;
}
else
{
DestPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
}
SourcePalette = DCSrc->w.hPalette;
}
else
{
SourcePalette = NtGdiGetStockObject(DEFAULT_PALETTE);
}
if(DCSrc->w.hPalette != 0)
{
SourcePalette = DCSrc->w.hPalette;
}
else
{
SourcePalette = NtGdiGetStockObject(DEFAULT_PALETTE);
}
PalSourceGDI = PALETTE_LockPalette(SourcePalette);
SourceMode = PalSourceGDI->Mode;
PALETTE_UnlockPalette(SourcePalette);
if (DestPalette == SourcePalette)
{
DestMode = SourceMode;
}
else
{
PalDestGDI = PALETTE_LockPalette(DestPalette);
DestMode = PalDestGDI->Mode;
PALETTE_UnlockPalette(DestPalette);
}
PalSourceGDI = PALETTE_LockPalette(SourcePalette);
SourceMode = PalSourceGDI->Mode;
PALETTE_UnlockPalette(SourcePalette);
if (DestPalette == SourcePalette)
{
DestMode = SourceMode;
}
else
{
PalDestGDI = PALETTE_LockPalette(DestPalette);
DestMode = PalDestGDI->Mode;
PALETTE_UnlockPalette(DestPalette);
}
XlateObj = (PXLATEOBJ)IntEngCreateXlate(DestMode, SourceMode, DestPalette, SourcePalette);
XlateAlloc = TRUE;
}
XlateObj = (PXLATEOBJ)IntEngCreateXlate(DestMode, SourceMode, DestPalette, SourcePalette);
// Perform the bitblt operation
Status = IntEngBitBlt(SurfDest, SurfSrc, NULL, DCDest->CombinedClip, XlateObj, &DestRect, &SourcePoint, NULL, NULL, NULL, ROP);
if (XlateAlloc) EngDeleteXlate(XlateObj);
EngDeleteXlate(XlateObj);
if (SurfDestAlloc) ExFreePool(SurfDest);
if (SurfSrcAlloc) ExFreePool(SurfSrc);
@ -530,7 +511,7 @@ BOOL STDCALL NtGdiSetPixelV(HDC hDC,
}
bm = bmp->bitmap;
//FIXME: set the actual pixel value
BITMAPOBJ_UnlockBitmap (bmp);
BITMAPOBJ_UnlockBitmap (dc->w.hBitmap);
DC_UnlockDc (hDC);
return(TRUE);
}

5
reactos/subsys/win32k/objects/cliprgn.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: cliprgn.c,v 1.22 2003/08/29 09:29:11 gvg Exp $ */
/* $Id: cliprgn.c,v 1.23 2003/08/31 07:56:24 gvg Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
@ -231,12 +231,14 @@ int STDCALL NtGdiSelectClipRgn(HDC hDC,
Copy = NtGdiCreateRectRgn(0, 0, 0, 0);
if (NULL == Copy)
{
DC_UnlockDc(hDC);
return ERROR;
}
Type = NtGdiCombineRgn(Copy, hRgn, 0, RGN_COPY);
if (ERROR == Type)
{
NtGdiDeleteObject(Copy);
DC_UnlockDc(hDC);
return ERROR;
}
NtGdiOffsetRgn(Copy, dc->w.DCOrgX, dc->w.DCOrgY);
@ -252,6 +254,7 @@ int STDCALL NtGdiSelectClipRgn(HDC hDC,
}
dc->w.hClipRgn = Copy;
CLIPPING_UpdateGCRegion(dc);
DC_UnlockDc(hDC);
return ERROR;
}

311
reactos/subsys/win32k/objects/dc.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: dc.c,v 1.77 2003/08/29 12:28:24 gvg Exp $
/* $Id: dc.c,v 1.78 2003/08/31 07:56:24 gvg Exp $
*
* DC.C - Device context functions
*
@ -113,9 +113,6 @@ INT STDCALL func_name( HDC hdc, INT mode ) \
// --------------------------------------------------------- File Statics
static VOID FASTCALL
NtGdiSetDCState16(HDC hDC, HDC hDCSave);
// ----------------------------------------------------- Public Functions
BOOL STDCALL
@ -131,6 +128,7 @@ NtGdiCreateCompatableDC(HDC hDC)
HBITMAP hBitmap;
HDC hNewDC;
HRGN hVisRgn;
BITMAPOBJ *pb;
OrigDC = DC_LockDc(hDC);
if (OrigDC == NULL)
@ -155,6 +153,11 @@ NtGdiCreateCompatableDC(HDC hDC)
/* FIXME: Should this DC request its own PDEV? */
if(OrigDC == NULL)
{
NewDC->PDev = PrimarySurface.PDev;
memcpy(NewDC->FillPatternSurfaces, PrimarySurface.FillPatterns,
sizeof(NewDC->FillPatternSurfaces));
NewDC->GDIInfo = &PrimarySurface.GDIInfo;
NewDC->DevInfo = &PrimarySurface.DevInfo;
}
else
{
@ -197,9 +200,15 @@ NtGdiCreateCompatableDC(HDC hDC)
NewDC->w.bitsPerPixel = 1;
NewDC->w.hBitmap = hBitmap;
NewDC->w.hFirstBitmap = hBitmap;
NewDC->Surface = BitmapToSurf(BITMAPOBJ_LockBitmap(hBitmap));
pb = BITMAPOBJ_LockBitmap(hBitmap);
NewDC->Surface = BitmapToSurf(pb);
BITMAPOBJ_UnlockBitmap(hBitmap);
if(OrigDC != NULL)
if(OrigDC == NULL)
{
NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
}
else
{
NewDC->w.hPalette = OrigDC->w.hPalette;
NewDC->w.textColor = OrigDC->w.textColor;
@ -560,10 +569,6 @@ NtGdiDeleteDC(HDC DCHandle)
NtGdiSelectObject (DCHandle, STOCK_WHITE_BRUSH);
NtGdiSelectObject (DCHandle, STOCK_SYSTEM_FONT);
DC_LockDC (DCHandle); NtGdiSelectObject does not recognize stock objects yet */
if ( DCToDelete->w.hBitmap != NULL )
{
BITMAPOBJ_UnlockBitmap(DCToDelete->w.hBitmap);
}
if (DCToDelete->w.flags & DC_MEMORY)
{
EngDeleteSurface (DCToDelete->Surface);
@ -649,8 +654,23 @@ NtGdiGetDCOrgEx(HDC hDC, LPPOINT Point)
return TRUE;
}
HDC STDCALL
NtGdiGetDCState16(HDC hDC)
COLORREF STDCALL
NtGdiSetBkColor(HDC hDC, COLORREF color)
{
COLORREF oldColor;
PDC dc = DC_LockDc(hDC);
if ( !dc )
return 0x80000000;
oldColor = dc->w.backgroundColor;
dc->w.backgroundColor = color;
DC_UnlockDc ( hDC );
return oldColor;
}
static HDC STDCALL
NtGdiGetDCState(HDC hDC)
{
PDC newdc, dc;
HDC hnewdc;
@ -664,7 +684,7 @@ NtGdiGetDCState16(HDC hDC)
hnewdc = DC_AllocDC(NULL);
if (hnewdc == NULL)
{
DC_UnlockDc( hDC );
DC_UnlockDc( hDC );
return 0;
}
newdc = DC_LockDc( hnewdc );
@ -744,9 +764,120 @@ NtGdiGetDCState16(HDC hDC)
newdc->w.hClipRgn = 0;
}
DC_UnlockDc( hnewdc );
DC_UnlockDc( hDC );
return hnewdc;
}
STATIC
VOID
FASTCALL
NtGdiSetDCState ( HDC hDC, HDC hDCSave )
{
PDC dc, dcs;
dc = DC_LockDc ( hDC );
if ( dc )
{
dcs = DC_LockDc ( hDCSave );
if ( dcs )
{
if ( dcs->w.flags & DC_SAVED )
{
dc->w.flags = dcs->w.flags & ~DC_SAVED;
dc->w.hFirstBitmap = dcs->w.hFirstBitmap;
#if 0
dc->w.hDevice = dcs->w.hDevice;
#endif
dc->w.totalExtent = dcs->w.totalExtent;
dc->w.ROPmode = dcs->w.ROPmode;
dc->w.polyFillMode = dcs->w.polyFillMode;
dc->w.stretchBltMode = dcs->w.stretchBltMode;
dc->w.relAbsMode = dcs->w.relAbsMode;
dc->w.backgroundMode = dcs->w.backgroundMode;
dc->w.backgroundColor = dcs->w.backgroundColor;
dc->w.textColor = dcs->w.textColor;
dc->w.brushOrgX = dcs->w.brushOrgX;
dc->w.brushOrgY = dcs->w.brushOrgY;
dc->w.textAlign = dcs->w.textAlign;
dc->w.charExtra = dcs->w.charExtra;
dc->w.breakTotalExtra = dcs->w.breakTotalExtra;
dc->w.breakCount = dcs->w.breakCount;
dc->w.breakExtra = dcs->w.breakExtra;
dc->w.breakRem = dcs->w.breakRem;
dc->w.MapMode = dcs->w.MapMode;
dc->w.GraphicsMode = dcs->w.GraphicsMode;
#if 0
/* Apparently, the DC origin is not changed by [GS]etDCState */
dc->w.DCOrgX = dcs->w.DCOrgX;
dc->w.DCOrgY = dcs->w.DCOrgY;
#endif
dc->w.CursPosX = dcs->w.CursPosX;
dc->w.CursPosY = dcs->w.CursPosY;
dc->w.ArcDirection = dcs->w.ArcDirection;
#if 0
dc->w.xformWorld2Wnd = dcs->w.xformWorld2Wnd;
dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
dc->w.xformVport2World = dcs->w.xformVport2World;
dc->w.vport2WorldValid = dcs->w.vport2WorldValid;
#endif
dc->wndOrgX = dcs->wndOrgX;
dc->wndOrgY = dcs->wndOrgY;
dc->wndExtX = dcs->wndExtX;
dc->wndExtY = dcs->wndExtY;
dc->vportOrgX = dcs->vportOrgX;
dc->vportOrgY = dcs->vportOrgY;
dc->vportExtX = dcs->vportExtX;
dc->vportExtY = dcs->vportExtY;
if (!(dc->w.flags & DC_MEMORY))
{
dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
}
#if 0
if (dcs->w.hClipRgn)
{
if (!dc->w.hClipRgn)
{
dc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
}
NtGdiCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
}
else
{
if (dc->w.hClipRgn)
{
NtGdiDeleteObject( dc->w.hClipRgn );
}
dc->w.hClipRgn = 0;
}
CLIPPING_UpdateGCRegion( dc );
#endif
NtGdiSelectObject( hDC, dcs->w.hBitmap );
NtGdiSelectObject( hDC, dcs->w.hBrush );
NtGdiSelectObject( hDC, dcs->w.hFont );
NtGdiSelectObject( hDC, dcs->w.hPen );
NtGdiSetBkColor( hDC, dcs->w.backgroundColor);
NtGdiSetTextColor( hDC, dcs->w.textColor);
#if 0
GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
#endif
}
DC_UnlockDc ( hDCSave );
}
DC_UnlockDc ( hDC );
}
}
INT STDCALL
NtGdiGetDeviceCaps(HDC hDC,
INT Index)
@ -1175,7 +1306,9 @@ NtGdiRestoreDC(HDC hDC, INT SaveLevel)
DC_SetNextDC (dcs, DC_GetNextDC (dcs));
if (--dc->saveLevel < SaveLevel)
{
NtGdiSetDCState16 (hDC, hdcs);
DC_UnlockDc( hDC );
DC_UnlockDc( hdcs );
NtGdiSetDCState(hDC, hdcs);
#if 0
if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
{
@ -1184,8 +1317,16 @@ NtGdiRestoreDC(HDC hDC, INT SaveLevel)
success = FALSE;
}
#endif
dc = DC_LockDc(hDC);
if(!dc)
{
return FALSE;
}
}
else
{
DC_UnlockDc( hdcs );
}
DC_UnlockDc( hdcs );
NtGdiDeleteDC (hdcs);
}
DC_UnlockDc( hDC );
@ -1199,17 +1340,22 @@ NtGdiSaveDC(HDC hDC)
PDC dc, dcs;
INT ret;
dc = DC_LockDc (hDC);
if (dc == NULL)
if (!(hdcs = NtGdiGetDCState(hDC)))
{
return 0;
}
if (!(hdcs = NtGdiGetDCState16 (hDC)))
dcs = DC_LockDc (hdcs);
if (dcs == NULL)
{
return 0;
}
dcs = DC_LockDc (hdcs);
dc = DC_LockDc (hDC);
if (dc == NULL)
{
DC_UnlockDc(dc);
return 0;
}
#if 0
/* Copy path. The reason why path saving / restoring is in SaveDC/
@ -1320,7 +1466,6 @@ NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj)
/* Release the old bitmap, lock the new one and convert it to a SURF */
EngDeleteSurface(dc->Surface);
BITMAPOBJ_UnlockBitmap(objOrg);
dc->w.hBitmap = hGDIObj;
pb = BITMAPOBJ_LockBitmap(hGDIObj);
ASSERT(pb);
@ -1366,6 +1511,7 @@ NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj)
hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->size.cx, pb->size.cy );
NtGdiSelectVisRgn ( hDC, hVisRgn );
NtGdiDeleteObject ( hVisRgn );
BITMAPOBJ_UnlockBitmap(hGDIObj);
return objOrg;
@ -1388,131 +1534,6 @@ DC_SET_MODE( NtGdiSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
DC_SET_MODE( NtGdiSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
DC_SET_MODE( NtGdiSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
COLORREF STDCALL
NtGdiSetBkColor(HDC hDC, COLORREF color)
{
COLORREF oldColor;
PDC dc = DC_LockDc(hDC);
if ( !dc )
return 0x80000000;
oldColor = dc->w.backgroundColor;
dc->w.backgroundColor = color;
DC_UnlockDc ( hDC );
return oldColor;
}
STATIC
VOID
FASTCALL
NtGdiSetDCState16 ( HDC hDC, HDC hDCSave )
{
PDC dc, dcs;
dc = DC_LockDc ( hDC );
if ( dc )
{
dcs = DC_LockDc ( hDCSave );
if ( dcs )
{
if ( dcs->w.flags & DC_SAVED )
{
dc->w.flags = dcs->w.flags & ~DC_SAVED;
dc->w.hFirstBitmap = dcs->w.hFirstBitmap;
#if 0
dc->w.hDevice = dcs->w.hDevice;
#endif
dc->w.totalExtent = dcs->w.totalExtent;
dc->w.ROPmode = dcs->w.ROPmode;
dc->w.polyFillMode = dcs->w.polyFillMode;
dc->w.stretchBltMode = dcs->w.stretchBltMode;
dc->w.relAbsMode = dcs->w.relAbsMode;
dc->w.backgroundMode = dcs->w.backgroundMode;
dc->w.backgroundColor = dcs->w.backgroundColor;
dc->w.textColor = dcs->w.textColor;
dc->w.brushOrgX = dcs->w.brushOrgX;
dc->w.brushOrgY = dcs->w.brushOrgY;
dc->w.textAlign = dcs->w.textAlign;
dc->w.charExtra = dcs->w.charExtra;
dc->w.breakTotalExtra = dcs->w.breakTotalExtra;
dc->w.breakCount = dcs->w.breakCount;
dc->w.breakExtra = dcs->w.breakExtra;
dc->w.breakRem = dcs->w.breakRem;
dc->w.MapMode = dcs->w.MapMode;
dc->w.GraphicsMode = dcs->w.GraphicsMode;
#if 0
/* Apparently, the DC origin is not changed by [GS]etDCState */
dc->w.DCOrgX = dcs->w.DCOrgX;
dc->w.DCOrgY = dcs->w.DCOrgY;
#endif
dc->w.CursPosX = dcs->w.CursPosX;
dc->w.CursPosY = dcs->w.CursPosY;
dc->w.ArcDirection = dcs->w.ArcDirection;
#if 0
dc->w.xformWorld2Wnd = dcs->w.xformWorld2Wnd;
dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
dc->w.xformVport2World = dcs->w.xformVport2World;
dc->w.vport2WorldValid = dcs->w.vport2WorldValid;
#endif
dc->wndOrgX = dcs->wndOrgX;
dc->wndOrgY = dcs->wndOrgY;
dc->wndExtX = dcs->wndExtX;
dc->wndExtY = dcs->wndExtY;
dc->vportOrgX = dcs->vportOrgX;
dc->vportOrgY = dcs->vportOrgY;
dc->vportExtX = dcs->vportExtX;
dc->vportExtY = dcs->vportExtY;
if (!(dc->w.flags & DC_MEMORY))
{
dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
}
#if 0
if (dcs->w.hClipRgn)
{
if (!dc->w.hClipRgn)
{
dc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
}
NtGdiCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
}
else
{
if (dc->w.hClipRgn)
{
NtGdiDeleteObject( dc->w.hClipRgn );
}
dc->w.hClipRgn = 0;
}
CLIPPING_UpdateGCRegion( dc );
#endif
NtGdiSelectObject( hDC, dcs->w.hBitmap );
NtGdiSelectObject( hDC, dcs->w.hBrush );
NtGdiSelectObject( hDC, dcs->w.hFont );
NtGdiSelectObject( hDC, dcs->w.hPen );
NtGdiSetBkColor( hDC, dcs->w.backgroundColor);
NtGdiSetTextColor( hDC, dcs->w.textColor);
#if 0
GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
#endif
}
DC_UnlockDc ( hDCSave );
}
DC_UnlockDc ( hDC );
}
}
// ---------------------------------------------------- Private Interface
HDC FASTCALL

59
reactos/subsys/win32k/objects/dib.c
View file

@ -1,5 +1,5 @@
/*
* $Id: dib.c,v 1.31 2003/08/28 12:35:59 gvg Exp $
* $Id: dib.c,v 1.32 2003/08/31 07:56:24 gvg Exp $
*
* ReactOS W32 Subsystem
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
@ -541,18 +541,14 @@ HBITMAP STDCALL NtGdiCreateDIBitmap(HDC hdc, const BITMAPINFOHEADER *header,
// Now create the bitmap
if(fColor)
{
// If we are using indexed colors, then we need to create a bitmap that is compatible with the palette
if(coloruse == DIB_PAL_COLORS)
if (init == CBM_INIT)
{
handle = NtGdiCreateCompatibleBitmap(hdc, width, height);
}
else if(coloruse == DIB_RGB_COLORS) {
handle = NtGdiCreateBitmap(width, height, 1, 24, NULL);
else
{
handle = NtGdiCreateBitmap(width, height, 1, bpp, NULL);
}
}
else handle = NtGdiCreateBitmap(width, height, 1, 1, NULL);
if (!handle) return 0;
@ -692,17 +688,20 @@ DIB_CreateDIBSection(
if (dib)
{
res = NtGdiCreateDIBitmap(dc->hSelf, bi, 0, NULL, bmi, usage);
if (res)
{
bmp = BITMAPOBJ_LockBitmap(res);
if (bmp)
{
bmp->dib = (DIBSECTION *) dib;
/* Install user-mode bits instead of kernel-mode bits */
ExFreePool(bmp->bitmap.bmBits);
bmp->bitmap.bmBits = bm.bmBits;
}
}
if (! res)
{
return NULL;
}
bmp = BITMAPOBJ_LockBitmap(res);
if (NULL == bmp)
{
NtGdiDeleteObject(bmp);
return NULL;
}
bmp->dib = (DIBSECTION *) dib;
/* Install user-mode bits instead of kernel-mode bits */
ExFreePool(bmp->bitmap.bmBits);
bmp->bitmap.bmBits = bm.bmBits;
/* WINE NOTE: WINE makes use of a colormap, which is a color translation table between the DIB and the X physical
device. Obviously, this is left out of the ReactOS implementation. Instead, we call
@ -931,7 +930,7 @@ BuildDIBPalette (PBITMAPINFO bmi, PINT paletteType)
{
BYTE bits;
ULONG ColorCount;
PALETTEENTRY *palEntries;
PALETTEENTRY *palEntries = NULL;
HPALETTE hPal;
// Determine Bits Per Pixel
@ -948,14 +947,10 @@ BuildDIBPalette (PBITMAPINFO bmi, PINT paletteType)
}
else
{
*paletteType = PAL_RGB; // Would it be BGR, considering the BGR nature of the DIB color table?
*paletteType = PAL_BGR;
}
#ifdef TODO
if (bmi->bmiHeader.biClrUsed == 0)
#else
if (bmi->bmiHeader.biClrUsed == 0 && bmi->bmiHeader.biBitCount <= 8)
#endif
{
ColorCount = 1 << bmi->bmiHeader.biBitCount;
}
@ -964,10 +959,16 @@ BuildDIBPalette (PBITMAPINFO bmi, PINT paletteType)
ColorCount = bmi->bmiHeader.biClrUsed;
}
palEntries = ExAllocatePool(NonPagedPool, sizeof(PALETTEENTRY)*ColorCount);
DIBColorTableToPaletteEntries(palEntries, bmi->bmiColors, ColorCount);
if (PAL_INDEXED == *paletteType)
{
palEntries = ExAllocatePool(NonPagedPool, sizeof(PALETTEENTRY)*ColorCount);
DIBColorTableToPaletteEntries(palEntries, bmi->bmiColors, ColorCount);
}
hPal = PALETTE_AllocPalette( *paletteType, ColorCount, (ULONG*)palEntries, 0, 0, 0 );
ExFreePool(palEntries);
if (NULL != palEntries)
{
ExFreePool(palEntries);
}
return hPal;
}

208
reactos/subsys/win32k/objects/palette.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: palette.c,v 1.11 2003/08/28 12:35:59 gvg Exp $ */
/* $Id: palette.c,v 1.12 2003/08/31 07:56:24 gvg Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
@ -33,17 +33,6 @@
static int PALETTE_firstFree = 0;
static unsigned char PALETTE_freeList[256];
#ifdef TODO
static ColorShifts PALETTE_PRed = {0,0,0};
//static ColorShifts PALETTE_LRed = {0,0,0};
static ColorShifts PALETTE_PGreen = {0,0,0};
//static ColorShifts PALETTE_LGreen = {0,0,0};
static ColorShifts PALETTE_PBlue = {0,0,0};
//static ColorShifts PALETTE_LBlue = {0,0,0};
static int PALETTE_Graymax = 0;
static int palette_size;
#endif
int PALETTE_PaletteFlags = 0;
PALETTEENTRY *COLOR_sysPal = NULL;
int COLOR_gapStart;
@ -180,63 +169,6 @@ static void FASTCALL PALETTE_FormatSystemPalette(void)
PALETTE_freeList[j] = 0;
}
#ifdef TODO
/* Ported from WINE 20020804 (graphics\x11drv\palette.c) */
static int FASTCALL SysPaletteLookupPixel( COLORREF col, BOOL skipReserved )
{
int i, best = 0, diff = 0x7fffffff;
int r,g,b;
for( i = 0; i < palette_size && diff ; i++ )
{
if( !(COLOR_sysPal[i].peFlags & PC_SYS_USED) || (skipReserved && COLOR_sysPal[i].peFlags & PC_SYS_RESERVED) )
continue;
r = COLOR_sysPal[i].peRed - GetRValue(col);
g = COLOR_sysPal[i].peGreen - GetGValue(col);
b = COLOR_sysPal[i].peBlue - GetBValue(col);
r = r*r + g*g + b*b;
if( r < diff ) { best = i; diff = r; }
}
return best;
}
/* Ported from WINE 20020804 (graphics\x11drv\palette.c) */
/* Make sure this is required - ROS's xlate may make this redundant */
UINT WINAPI GetNearestPaletteIndex(
HPALETTE hpalette, /* [in] Handle of logical color palette */
COLORREF color) /* [in] Color to be matched */
{
PPALOBJ palObj = (PPALOBJ)AccessUserObject((ULONG)hpalette);
UINT index = 0;
if( palObj )
{
int i, diff = 0x7fffffff;
int r,g,b;
PALETTEENTRY* entry = palObj->logpalette->palPalEntry;
for( i = 0; i < palObj->logpalette->palNumEntries && diff ; i++, entry++)
{
if (!(entry->peFlags & PC_SYS_USED)) continue;
r = entry->peRed - GetRValue(color);
g = entry->peGreen - GetGValue(color);
b = entry->peBlue - GetBValue(color);
r = r*r + g*g + b*b;
if( r < diff ) { index = i; diff = r; }
}
// GDI_ReleaseObj( hpalette );
}
DPRINT("(%04x,%06lx): returning %d\n", hpalette, color, index );
return index;
}
#endif
VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, INT size)
{
int i = 0;
@ -348,142 +280,4 @@ INT STDCALL PALETTE_SetMapping(PPALOBJ palPtr, UINT uStart, UINT uNum, BOOL mapO
return iRemapped;
}
#ifdef TODO
/* Return the physical color closest to 'color'. */
/* Ported from WINE 20020804 (graphics\x11drv\palette.c) */
INT FASTCALL PALETTE_ToPhysical (PDC dc, COLORREF color)
{
WORD index = 0;
HPALETTE hPal = (dc)? dc->w.hPalette: NtGdiGetStockObject(DEFAULT_PALETTE);
unsigned char spec_type = color >> 24;
PPALOBJ palPtr = (PPALOBJ)AccessUserObject((ULONG)hPal);
/* palPtr can be NULL when DC is being destroyed */
if( !palPtr ) return 0;
if ( PALETTE_PaletteFlags & PALETTE_FIXED )
{
/* there is no colormap limitation; we are going to have to compute
* the pixel value from the visual information stored earlier
*/
unsigned long red, green, blue;
unsigned idx = 0;
switch(spec_type)
{
case 1: /* PALETTEINDEX */
if( (idx = color & 0xffff) >= palPtr->logpalette->palNumEntries)
{
DPRINT("RGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx);
// GDI_ReleaseObj( hPal );
return 0;
}
if( palPtr->mapping )
{
int ret = palPtr->mapping[idx];
// GDI_ReleaseObj( hPal );
return ret;
}
color = *(COLORREF*)(palPtr->logpalette->palPalEntry + idx);
break;
default:
color &= 0xffffff;
/* fall through to RGB */
case 0: /* RGB */
if( dc && (dc->w.bitsPerPixel == 1) )
{
// GDI_ReleaseObj( hPal );
return (((color >> 16) & 0xff) +
((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
}
}
red = GetRValue(color); green = GetGValue(color); blue = GetBValue(color);
if (PALETTE_Graymax)
{
/* grayscale only; return scaled value */
// GDI_ReleaseObj( hPal );
return ( (red * 30 + green * 59 + blue * 11) * PALETTE_Graymax) / 25500;
}
else
{
/* scale each individually and construct the TrueColor pixel value */
if (PALETTE_PRed.scale < 8)
red = red >> (8-PALETTE_PRed.scale);
else if (PALETTE_PRed.scale > 8)
red = red << (PALETTE_PRed.scale-8) |
red >> (16-PALETTE_PRed.scale);
if (PALETTE_PGreen.scale < 8)
green = green >> (8-PALETTE_PGreen.scale);
else if (PALETTE_PGreen.scale > 8)
green = green << (PALETTE_PGreen.scale-8) |
green >> (16-PALETTE_PGreen.scale);
if (PALETTE_PBlue.scale < 8)
blue = blue >> (8-PALETTE_PBlue.scale);
else if (PALETTE_PBlue.scale > 8)
blue = blue << (PALETTE_PBlue.scale-8) |
blue >> (16-PALETTE_PBlue.scale);
// GDI_ReleaseObj( hPal );
return (red << PALETTE_PRed.shift) | (green << PALETTE_PGreen.shift) | (blue << PALETTE_PBlue.shift);
}
}
else
{
if( !palPtr->mapping )
DPRINT("Palette %04x is not realized\n", dc->w.hPalette);
switch(spec_type) /* we have to peruse DC and system palette */
{
default:
color &= 0xffffff;
/* fall through to RGB */
case 0: /* RGB */
if( dc && (dc->w.bitsPerPixel == 1) )
{
// GDI_ReleaseObj( hPal );
return (((color >> 16) & 0xff) +
((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
}
index = SysPaletteLookupPixel( color, FALSE);
/* if (PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; */
/* DPRINT(palette,"RGB(%lx) -> pixel %i\n", color, index);
*/
break;
case 1: /* PALETTEINDEX */
index = color & 0xffff;
if( index >= palPtr->logpalette->palNumEntries )
DbgPrint("RGB(%lx) : index %i is out of bounds\n", color, index);
else if( palPtr->mapping ) index = palPtr->mapping[index];
/* DPRINT(palette,"PALETTEINDEX(%04x) -> pixel %i\n", (WORD)color, index);
*/
break;
case 2: /* PALETTERGB */
index = GetNearestPaletteIndex( hPal, color );
if (palPtr->mapping) index = palPtr->mapping[index];
/* DPRINT(palette,"PALETTERGB(%lx) -> pixel %i\n", color, index);
*/
break;
}
}
// GDI_ReleaseObj( hPal );
return index;
}
#endif
/* EOF */