+/*
+ * 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$
*
* DC.C - Device context functions
#include <ddk/ntddvid.h>
#include <win32k/bitmaps.h>
+#include <win32k/brush.h>
+#include <win32k/cliprgn.h>
#include <win32k/coord.h>
#include <win32k/driver.h>
#include <win32k/dc.h>
+#include <win32k/misc.h>
#include <win32k/print.h>
#include <win32k/region.h>
#include <win32k/gdiobj.h>
+#include <win32k/paint.h>
#include <win32k/pen.h>
#include <win32k/text.h>
+#include "../eng/clip.h"
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/eng.h>
+#include <include/palette.h>
#define NDEBUG
#include <win32k/debug1.h>
func_type STDCALL func_name( HDC hdc ) \
{ \
func_type ft; \
- PDC dc = DC_HandleToPtr( hdc ); \
+ PDC dc = DC_LockDc( hdc ); \
if (!dc) \
{ \
return 0; \
} \
ft = dc->dc_field; \
- DC_ReleasePtr( hdc ); \
+ DC_UnlockDc( hdc ); \
return ft; \
}
* important that the function has the right signature, for the implementation
* we can do whatever we want.
*/
-#define DC_GET_VAL_EX( func_name, ret_x, ret_y, type ) \
-BOOL STDCALL func_name( HDC hdc, LP##type pt ) \
-{ \
- PDC dc = DC_HandleToPtr( hdc ); \
- if (!dc) \
- { \
- return FALSE; \
- } \
- ((LPPOINT)pt)->x = dc->ret_x; \
- ((LPPOINT)pt)->y = dc->ret_y; \
- DC_ReleasePtr( hdc ); \
- return TRUE; \
+#define DC_GET_VAL_EX( NtGdiFuncName, IntFuncName, ret_x, ret_y, type ) \
+VOID FASTCALL IntFuncName ( PDC dc, LP##type pt ) \
+{ \
+ ASSERT ( dc ); \
+ ASSERT ( pt ); \
+ ((LPPOINT)pt)->x = dc->ret_x; \
+ ((LPPOINT)pt)->y = dc->ret_y; \
+} \
+BOOL STDCALL NtGdiFuncName ( HDC hdc, LP##type pt ) \
+{ \
+ PDC dc = DC_LockDc ( hdc ); \
+ if ( !dc ) \
+ return FALSE; \
+ IntFuncName ( dc, pt ); \
+ DC_UnlockDc ( hdc ); \
+ return TRUE; \
}
#define DC_SET_MODE( func_name, dc_field, min_val, max_val ) \
INT STDCALL func_name( HDC hdc, INT mode ) \
{ \
INT prevMode; \
- PDC dc = DC_HandleToPtr( hdc ); \
- if(!dc) \
- { \
- return 0; \
- } \
+ PDC dc; \
if ((mode < min_val) || (mode > max_val)) \
- { \
return 0; \
- } \
+ dc = DC_LockDc ( hdc ); \
+ if ( !dc ) \
+ return 0; \
prevMode = dc->dc_field; \
dc->dc_field = mode; \
- DC_ReleasePtr( hdc ); \
+ DC_UnlockDc ( hdc ); \
return prevMode; \
}
// --------------------------------------------------------- File Statics
-static void W32kSetDCState16(HDC hDC, HDC hDCSave);
-
// ----------------------------------------------------- Public Functions
-BOOL STDCALL W32kCancelDC(HDC hDC)
+BOOL STDCALL
+NtGdiCancelDC(HDC hDC)
{
UNIMPLEMENTED;
}
-HDC STDCALL W32kCreateCompatableDC(HDC hDC)
+HDC STDCALL
+NtGdiCreateCompatableDC(HDC hDC)
{
- PDC NewDC, OrigDC = NULL;
+ PDC NewDC, OrigDC;
HBITMAP hBitmap;
HDC hNewDC;
+ HRGN hVisRgn;
+ BITMAPOBJ *pb;
- OrigDC = DC_HandleToPtr(hDC);
- if (OrigDC == NULL)
+ if (hDC == NULL)
{
+ OrigDC = NULL;
hNewDC = DC_AllocDC(L"DISPLAY");
- if( hNewDC )
- NewDC = DC_HandleToPtr( hNewDC );
}
- else {
+ else
+ {
/* Allocate a new DC based on the original DC's device */
+ OrigDC = DC_LockDc(hDC);
+ if (NULL == OrigDC)
+ {
+ return NULL;
+ }
hNewDC = DC_AllocDC(OrigDC->DriverName);
- if( hNewDC )
- NewDC = DC_HandleToPtr( hNewDC );
}
- if (NewDC == NULL)
+ if (NULL == hNewDC)
{
return NULL;
}
+ NewDC = DC_LockDc( hNewDC );
/* Copy information from original DC to new DC */
NewDC->hSelf = NewDC;
/* FIXME: Should this DC request its own PDEV? */
- if(OrigDC == NULL) {
- } else {
+ if(OrigDC == NULL)
+ {
+ NewDC->PDev = PrimarySurface.PDev;
+ memcpy(NewDC->FillPatternSurfaces, PrimarySurface.FillPatterns,
+ sizeof(NewDC->FillPatternSurfaces));
+ NewDC->GDIInfo = &PrimarySurface.GDIInfo;
+ NewDC->DevInfo = &PrimarySurface.DevInfo;
+ }
+ else
+ {
NewDC->PDev = OrigDC->PDev;
NewDC->DMW = OrigDC->DMW;
memcpy(NewDC->FillPatternSurfaces,
}
/* DriverName is copied in the AllocDC routine */
- if(OrigDC == NULL) {
+ if(OrigDC == NULL)
+ {
NewDC->DeviceDriver = DRIVER_FindMPDriver(NewDC->DriverName);
- } else {
+ }
+ else
+ {
NewDC->DeviceDriver = OrigDC->DeviceDriver;
NewDC->wndOrgX = OrigDC->wndOrgX;
NewDC->wndOrgY = OrigDC->wndOrgY;
}
/* Create default bitmap */
- if (!(hBitmap = W32kCreateBitmap( 1, 1, 1, 1, NULL )))
+ if (!(hBitmap = NtGdiCreateBitmap( 1, 1, 1, 1, NULL )))
{
- DC_ReleasePtr( hNewDC );
+ DC_UnlockDc( hDC );
+ DC_UnlockDc( hNewDC );
DC_FreeDC( hNewDC );
return NULL;
}
NewDC->w.bitsPerPixel = 1;
NewDC->w.hBitmap = hBitmap;
NewDC->w.hFirstBitmap = hBitmap;
- NewDC->Surface = BitmapToSurf(BITMAPOBJ_HandleToPtr(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;
NewDC->w.textAlign = OrigDC->w.textAlign;
+ NewDC->w.backgroundColor = OrigDC->w.backgroundColor;
+ NewDC->w.backgroundMode = OrigDC->w.backgroundMode;
+ }
+ if (NULL != hDC)
+ {
+ DC_UnlockDc( hDC );
}
- DC_ReleasePtr( hDC );
- DC_ReleasePtr( hNewDC );
+ DC_UnlockDc( hNewDC );
+
+ hVisRgn = NtGdiCreateRectRgn(0, 0, 1, 1);
+ NtGdiSelectVisRgn(hNewDC, hVisRgn);
+ NtGdiDeleteObject(hVisRgn);
+
DC_InitDC(hNewDC);
return hNewDC;
}
-static BOOL STDCALL FindDriverFileNames(PUNICODE_STRING DriverFileNames)
+static BOOL STDCALL
+FindDriverFileNames(PUNICODE_STRING DriverFileNames)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
UNICODE_STRING RegistryPath;
return TRUE;
}
-BOOL STDCALL W32kCreatePrimarySurface(LPCWSTR Driver,
+
+BOOL STDCALL
+NtGdiCreatePrimarySurface(LPCWSTR Driver,
LPCWSTR Device)
{
PGD_ENABLEDRIVER GDEnableDriver;
- HANDLE DeviceDriver;
DRVENABLEDATA DED;
PSURFOBJ SurfObj;
+ PSURFGDI SurfGDI;
UNICODE_STRING DriverFileNames;
PWSTR CurrentName;
BOOL GotDriver;
+ extern void FASTCALL IntInitDesktopWindow(ULONG Width, ULONG Height);
/* Open the miniport driver */
- if ((DeviceDriver = DRIVER_FindMPDriver(Driver)) == NULL)
+ if ((PrimarySurface.DisplayDevice = DRIVER_FindMPDriver(Driver)) == NULL)
{
DPRINT("FindMPDriver failed\n");
return(FALSE);
return FALSE;
}
- DPRINT("Display driver %S loaded\n", DriverName);
+ DPRINT("Display driver %S loaded\n", CurrentName);
DPRINT("Building DDI Functions\n");
&PrimarySurface.DevInfo,
NULL,
L"",
- DeviceDriver);
+ PrimarySurface.DisplayDevice);
if (PrimarySurface.PDev == NULL)
{
DPRINT("DrvEnablePDEV failed\n");
SurfObj = (PSURFOBJ)AccessUserObject((ULONG) PrimarySurface.Handle);
SurfObj->dhpdev = PrimarySurface.PDev;
+ SurfGDI = (PSURFGDI)AccessInternalObject((ULONG) PrimarySurface.Handle);
+ IntInitDesktopWindow(SurfGDI->SurfObj.sizlBitmap.cx, SurfGDI->SurfObj.sizlBitmap.cy);
return TRUE;
}
-HDC STDCALL W32kCreateDC(LPCWSTR Driver,
- LPCWSTR Device,
- LPCWSTR Output,
- CONST PDEVMODEW InitData)
+HDC STDCALL
+NtGdiCreateDC(LPCWSTR Driver,
+ LPCWSTR Device,
+ LPCWSTR Output,
+ CONST PDEVMODEW InitData)
{
HDC hNewDC;
PDC NewDC;
HDC hDC = NULL;
PSURFGDI SurfGDI;
+ HRGN hVisRgn;
/* Check for existing DC object */
if ((hNewDC = DC_FindOpenDC(Driver)) != NULL)
{
hDC = hNewDC;
- return W32kCreateCompatableDC(hDC);
+ return NtGdiCreateCompatableDC(hDC);
}
DPRINT("NAME: %S\n", Driver); // FIXME: Should not crash if NULL
return NULL;
}
- NewDC = DC_HandleToPtr( hNewDC );
+ NewDC = DC_LockDc( hNewDC );
ASSERT( NewDC );
- if (!PrimarySurfaceCreated)
+ if (! PrimarySurfaceCreated)
{
- if (!W32kCreatePrimarySurface(Driver, Device))
+ PrimarySurfaceCreated = TRUE;
+ if (!NtGdiCreatePrimarySurface(Driver, Device))
{
- DC_ReleasePtr( hNewDC );
+ PrimarySurfaceCreated = FALSE;
+ DC_UnlockDc( hNewDC );
DC_FreeDC(hNewDC);
return NULL;
}
}
- PrimarySurfaceCreated = TRUE;
NewDC->DMW = PrimarySurface.DMW;
- NewDC->DevInfo = PrimarySurface.DevInfo;
- NewDC->GDIInfo = PrimarySurface.GDIInfo;
+ NewDC->DevInfo = &PrimarySurface.DevInfo;
+ NewDC->GDIInfo = &PrimarySurface.GDIInfo;
memcpy(NewDC->FillPatternSurfaces, PrimarySurface.FillPatterns,
sizeof(NewDC->FillPatternSurfaces));
NewDC->PDev = PrimarySurface.PDev;
NewDC->w.bitsPerPixel = SurfGDI->BitsPerPixel; // FIXME: set this here??
- NewDC->w.hPalette = NewDC->DevInfo.hpalDefault;
+ NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
DPRINT("Bits per pel: %u\n", NewDC->w.bitsPerPixel);
+
+ DC_UnlockDc( hNewDC );
- NewDC->w.hVisRgn = W32kCreateRectRgn(0, 0, SurfGDI->SurfObj.sizlBitmap.cx,
- SurfGDI->SurfObj.sizlBitmap.cy);
- DC_ReleasePtr( hNewDC );
+ hVisRgn = NtGdiCreateRectRgn(0, 0, SurfGDI->SurfObj.sizlBitmap.cx,
+ SurfGDI->SurfObj.sizlBitmap.cy);
+ NtGdiSelectVisRgn(hNewDC, hVisRgn);
+ NtGdiDeleteObject(hVisRgn);
/* Initialize the DC state */
DC_InitDC(hNewDC);
- W32kSetTextColor(hNewDC, RGB(0, 0, 0));
- W32kSetTextAlign(hNewDC, TA_TOP);
+ NtGdiSetTextColor(hNewDC, RGB(0, 0, 0));
+ NtGdiSetTextAlign(hNewDC, TA_TOP);
+ NtGdiSetBkColor(hNewDC, RGB(255, 255, 255));
+ NtGdiSetBkMode(hNewDC, OPAQUE);
return hNewDC;
}
-HDC STDCALL W32kCreateIC(LPCWSTR Driver,
- LPCWSTR Device,
- LPCWSTR Output,
- CONST PDEVMODEW DevMode)
+HDC STDCALL
+NtGdiCreateIC(LPCWSTR Driver,
+ LPCWSTR Device,
+ LPCWSTR Output,
+ CONST PDEVMODEW DevMode)
{
/* FIXME: this should probably do something else... */
- return W32kCreateDC(Driver, Device, Output, DevMode);
+ return NtGdiCreateDC(Driver, Device, Output, DevMode);
}
-BOOL STDCALL W32kDeleteDC(HDC DCHandle)
+BOOL STDCALL
+NtGdiDeleteDC(HDC DCHandle)
{
PDC DCToDelete;
- DCToDelete = DC_HandleToPtr(DCHandle);
+ DCToDelete = DC_LockDc(DCHandle);
if (DCToDelete == NULL)
{
return FALSE;
{
if (!DRIVER_UnreferenceDriver (DCToDelete->DriverName))
{
+ PEPROCESS CurrentProcess;
DPRINT( "No more references to driver, reseting display\n" );
- DCToDelete->DriverFunctions.DisableSurface(DCToDelete->PDev);
- CHECKPOINT;
DCToDelete->DriverFunctions.AssertMode( DCToDelete->PDev, FALSE );
CHECKPOINT;
+ DCToDelete->DriverFunctions.DisableSurface(DCToDelete->PDev);
+ CHECKPOINT;
DCToDelete->DriverFunctions.DisablePDev(DCToDelete->PDev);
- PrimarySurfaceCreated = FALSE;
+
+ CurrentProcess = PsGetCurrentProcess();
+ if (CurrentProcess != Win32kDeviceProcess)
+ {
+ KeAttachProcess(Win32kDeviceProcess);
+ }
+ ZwClose(PrimarySurface.DisplayDevice);
+ if (CurrentProcess != Win32kDeviceProcess)
+ {
+ KeDetachProcess();
}
+
+ PrimarySurfaceCreated = FALSE;
+ }
}
CHECKPOINT;
/* First delete all saved DCs */
HDC savedHDC;
savedHDC = DC_GetNextDC (DCToDelete);
- savedDC = DC_HandleToPtr (savedHDC);
+ savedDC = DC_LockDc (savedHDC);
if (savedDC == NULL)
{
break;
}
DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
DCToDelete->saveLevel--;
- DC_ReleasePtr( savedHDC );
- W32kDeleteDC (savedHDC);
+ DC_UnlockDc( savedHDC );
+ NtGdiDeleteDC (savedHDC);
}
/* Free GDI resources allocated to this DC */
if (!(DCToDelete->w.flags & DC_SAVED))
{
/*
- W32kSelectObject (DCHandle, STOCK_BLACK_PEN);
- W32kSelectObject (DCHandle, STOCK_WHITE_BRUSH);
- W32kSelectObject (DCHandle, STOCK_SYSTEM_FONT);
- DC_LockDC (DCHandle); W32kSelectObject does not recognize stock objects yet */
- BITMAPOBJ_ReleasePtr(DCToDelete->w.hBitmap);
+ NtGdiSelectObject (DCHandle, STOCK_BLACK_PEN);
+ NtGdiSelectObject (DCHandle, STOCK_WHITE_BRUSH);
+ NtGdiSelectObject (DCHandle, STOCK_SYSTEM_FONT);
+ DC_LockDC (DCHandle); NtGdiSelectObject does not recognize stock objects yet */
if (DCToDelete->w.flags & DC_MEMORY)
{
EngDeleteSurface (DCToDelete->Surface);
- W32kDeleteObject (DCToDelete->w.hFirstBitmap);
+ NtGdiDeleteObject (DCToDelete->w.hFirstBitmap);
}
}
if (DCToDelete->w.hClipRgn)
{
- W32kDeleteObject (DCToDelete->w.hClipRgn);
+ NtGdiDeleteObject (DCToDelete->w.hClipRgn);
}
if (DCToDelete->w.hVisRgn)
{
- W32kDeleteObject (DCToDelete->w.hVisRgn);
+ NtGdiDeleteObject (DCToDelete->w.hVisRgn);
}
+ if (NULL != DCToDelete->CombinedClip)
+ {
+ IntEngDeleteClipRegion(DCToDelete->CombinedClip);
+ }
if (DCToDelete->w.hGCClipRgn)
{
- W32kDeleteObject (DCToDelete->w.hGCClipRgn);
+ NtGdiDeleteObject (DCToDelete->w.hGCClipRgn);
}
#if 0 /* FIXME */
PATH_DestroyGdiPath (&DCToDelete->w.path);
#endif
- DC_ReleasePtr( DCToDelete );
- DC_FreeDC (DCToDelete);
+ DC_UnlockDc( DCHandle );
+ DC_FreeDC ( DCHandle );
return TRUE;
}
-INT STDCALL W32kDrawEscape(HDC hDC,
- INT nEscape,
- INT cbInput,
- LPCSTR lpszInData)
+INT STDCALL
+NtGdiDrawEscape(HDC hDC,
+ INT nEscape,
+ INT cbInput,
+ LPCSTR lpszInData)
{
UNIMPLEMENTED;
}
-INT STDCALL W32kEnumObjects(HDC hDC,
- INT ObjectType,
- GOBJENUMPROC ObjectFunc,
- LPARAM lParam)
+INT STDCALL
+NtGdiEnumObjects(HDC hDC,
+ INT ObjectType,
+ GOBJENUMPROC ObjectFunc,
+ LPARAM lParam)
{
UNIMPLEMENTED;
}
-DC_GET_VAL( COLORREF, W32kGetBkColor, w.backgroundColor )
-DC_GET_VAL( INT, W32kGetBkMode, w.backgroundMode )
-DC_GET_VAL_EX( W32kGetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT )
-DC_GET_VAL( HRGN, W32kGetClipRgn, w.hClipRgn )
+DC_GET_VAL( COLORREF, NtGdiGetBkColor, w.backgroundColor )
+DC_GET_VAL( INT, NtGdiGetBkMode, w.backgroundMode )
+DC_GET_VAL_EX( NtGdiGetBrushOrgEx, IntGetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT )
+DC_GET_VAL( HRGN, NtGdiGetClipRgn, w.hClipRgn )
-HGDIOBJ STDCALL W32kGetCurrentObject(HDC hDC,
- UINT ObjectType)
+HGDIOBJ STDCALL
+NtGdiGetCurrentObject(HDC hDC, UINT ObjectType)
{
UNIMPLEMENTED;
}
-DC_GET_VAL_EX( W32kGetCurrentPositionEx, w.CursPosX, w.CursPosY, POINT )
+DC_GET_VAL_EX ( NtGdiGetCurrentPositionEx, IntGetCurrentPositionEx, w.CursPosX, w.CursPosY, POINT )
-BOOL STDCALL W32kGetDCOrgEx(HDC hDC,
- LPPOINT Point)
+BOOL STDCALL
+NtGdiGetDCOrgEx(HDC hDC, LPPOINT Point)
{
PDC dc;
{
return FALSE;
}
- dc = DC_HandleToPtr(hDC);
+ dc = DC_LockDc(hDC);
if (dc == NULL)
{
return FALSE;
Point->x += dc->w.DCOrgX;
Point->y += dc->w.DCOrgY;
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return TRUE;
}
-HDC STDCALL W32kGetDCState16(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;
- dc = DC_HandleToPtr(hDC);
+ dc = DC_LockDc(hDC);
if (dc == NULL)
{
return 0;
hnewdc = DC_AllocDC(NULL);
if (hnewdc == NULL)
{
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return 0;
}
- newdc = DC_HandleToPtr( hnewdc );
+ newdc = DC_LockDc( hnewdc );
ASSERT( newdc );
newdc->w.flags = dc->w.flags | DC_SAVED;
-#if 0
- newdc->w.devCaps = dc->w.devCaps;
-#endif
newdc->w.hPen = dc->w.hPen;
newdc->w.hBrush = dc->w.hBrush;
newdc->w.hFont = dc->w.hFont;
#endif
if (dc->w.hClipRgn)
{
- newdc->w.hClipRgn = W32kCreateRectRgn( 0, 0, 0, 0 );
- W32kCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
+ newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
+ NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
}
else
{
newdc->w.hClipRgn = 0;
}
- DC_ReleasePtr( hnewdc );
+ DC_UnlockDc( hnewdc );
+ DC_UnlockDc( hDC );
return hnewdc;
}
-INT STDCALL W32kGetDeviceCaps(HDC hDC,
- INT Index)
+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)
{
PDC dc;
INT ret;
POINT pt;
- dc = DC_HandleToPtr(hDC);
+ dc = DC_LockDc(hDC);
if (dc == NULL)
{
return 0;
}
- /* Device capabilities for the printer */
+ /* Retrieve capability */
switch (Index)
{
+ case DRIVERVERSION:
+ ret = dc->GDIInfo->ulVersion;
+ break;
+
+ case TECHNOLOGY:
+ ret = dc->GDIInfo->ulTechnology;
+ break;
+
+ case HORZSIZE:
+ ret = dc->GDIInfo->ulHorzSize;
+ break;
+
+ case VERTSIZE:
+ ret = dc->GDIInfo->ulVertSize;
+ break;
+
+ case HORZRES:
+ ret = dc->GDIInfo->ulHorzRes;
+ break;
+
+ case VERTRES:
+ ret = dc->GDIInfo->ulVertRes;
+ break;
+
+ case LOGPIXELSX:
+ ret = dc->GDIInfo->ulLogPixelsX;
+ break;
+
+ case LOGPIXELSY:
+ ret = dc->GDIInfo->ulLogPixelsY;
+ break;
+
+ case BITSPIXEL:
+ ret = dc->GDIInfo->cBitsPixel;
+ break;
+
+ case PLANES:
+ ret = dc->GDIInfo->cPlanes;
+ break;
+
+ case NUMBRUSHES:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case NUMPENS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case NUMFONTS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case NUMCOLORS:
+ ret = dc->GDIInfo->ulNumColors;
+ break;
+
+ case ASPECTX:
+ ret = dc->GDIInfo->ulAspectX;
+ break;
+
+ case ASPECTY:
+ ret = dc->GDIInfo->ulAspectY;
+ break;
+
+ case ASPECTXY:
+ ret = dc->GDIInfo->ulAspectXY;
+ break;
+
+ case PDEVICESIZE:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case CLIPCAPS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case SIZEPALETTE:
+ ret = dc->GDIInfo->ulNumPalReg; /* FIXME not sure */
+ break;
+
+ case NUMRESERVED:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case COLORRES:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
case PHYSICALWIDTH:
- if(W32kEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
+ {
+ ret = pt.x;
+ }
+ else
{
- return pt.x;
+ ret = 0;
}
break;
case PHYSICALHEIGHT:
- if(W32kEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
{
- return pt.y;
+ ret = pt.y;
+ }
+ else
+ {
+ ret = 0;
}
break;
case PHYSICALOFFSETX:
- if(W32kEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
+ {
+ ret = pt.x;
+ }
+ else
{
- return pt.x;
+ ret = 0;
}
break;
case PHYSICALOFFSETY:
- if(W32kEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
+ {
+ ret = pt.y;
+ }
+ else
{
- return pt.y;
+ ret = 0;
}
break;
+ case VREFRESH:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
case SCALINGFACTORX:
- if(W32kEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
{
- return pt.x;
+ ret = pt.x;
+ }
+ else
+ {
+ ret = 0;
}
break;
case SCALINGFACTORY:
- if(W32kEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
+ if(NtGdiEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
+ {
+ ret = pt.y;
+ }
+ else
{
- return pt.y;
+ ret = 0;
}
break;
- }
- if ((Index < 0) || (Index > sizeof(DEVICECAPS) - sizeof(WORD)))
- {
- return 0;
+ case RASTERCAPS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case CURVECAPS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case LINECAPS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case POLYGONALCAPS:
+ UNIMPLEMENTED; /* FIXME */
+ break;
+
+ case TEXTCAPS:
+ ret = dc->GDIInfo->flTextCaps;
+ break;
+
+ default:
+ ret = 0;
+ break;
}
- DPRINT("(%04x,%d): returning %d\n",
- hDC, Index, *(WORD *)(((char *)dc->w.devCaps) + Index));
- ret = *(WORD *)(((char *)dc->w.devCaps) + Index);
+ DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return ret;
}
-DC_GET_VAL( INT, W32kGetMapMode, w.MapMode )
-DC_GET_VAL( INT, W32kGetPolyFillMode, w.polyFillMode )
+DC_GET_VAL( INT, NtGdiGetMapMode, w.MapMode )
+DC_GET_VAL( INT, NtGdiGetPolyFillMode, w.polyFillMode )
-INT STDCALL W32kGetObjectA(HANDLE handle, INT count, LPVOID buffer)
+INT STDCALL
+NtGdiGetObjectA(HANDLE handle, INT count, LPVOID buffer)
{
PGDIOBJ gdiObject;
INT result = 0;
- WORD magic;
+ DWORD objectType;
if (!count)
return 0;
- gdiObject = GDIOBJ_LockObj (handle, GO_MAGIC_DONTCARE);
+ gdiObject = GDIOBJ_LockObj (handle, GDI_OBJECT_TYPE_DONTCARE);
if (gdiObject == 0)
return 0;
- magic = GDIOBJ_GetHandleMagic (handle);
- switch(magic)
+ objectType = GDIOBJ_GetObjectType(handle);
+ switch(objectType)
{
-/* case GO_PEN_MAGIC:
+/* case GDI_OBJECT_TYPE_PEN:
result = PEN_GetObject((PENOBJ *)gdiObject, count, buffer);
break;
- case GO_BRUSH_MAGIC:
+ case GDI_OBJECT_TYPE_BRUSH:
result = BRUSH_GetObject((BRUSHOBJ *)gdiObject, count, buffer);
break; */
- case GO_BITMAP_MAGIC:
+ case GDI_OBJECT_TYPE_BITMAP:
result = BITMAP_GetObject((BITMAPOBJ *)gdiObject, count, buffer);
break;
-/* case GO_FONT_MAGIC:
+/* case GDI_OBJECT_TYPE_FONT:
result = FONT_GetObjectA((FONTOBJ *)gdiObject, count, buffer);
// FIXME: Fix the LOGFONT structure for the stock fonts
if ( (handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE) )
FixStockFontSizeA(handle, count, buffer);
break;
- case GO_PALETTE_MAGIC:
+ case GDI_OBJECT_TYPE_PALETTE:
result = PALETTE_GetObject((PALETTEOBJ *)gdiObject, count, buffer);
break; */
- case GO_REGION_MAGIC:
- case GO_DC_MAGIC:
- case GO_DISABLED_DC_MAGIC:
- case GO_META_DC_MAGIC:
- case GO_METAFILE_MAGIC:
- case GO_METAFILE_DC_MAGIC:
- case GO_ENHMETAFILE_MAGIC:
- case GO_ENHMETAFILE_DC_MAGIC:
- // FIXME("Magic %04x not implemented\n", magic);
+ case GDI_OBJECT_TYPE_REGION:
+ case GDI_OBJECT_TYPE_DC:
+ case GDI_OBJECT_TYPE_METADC:
+ case GDI_OBJECT_TYPE_METAFILE:
+ case GDI_OBJECT_TYPE_ENHMETADC:
+ case GDI_OBJECT_TYPE_EMF:
+ DPRINT1("GDI object type 0x%08x not implemented\n", objectType);
break;
default:
- DbgPrint("Invalid GDI Magic %04x\n", magic);
+ DPRINT1("Invalid GDI object type 0x%08x\n", objectType);
break;
}
- GDIOBJ_UnlockObj (handle, GO_MAGIC_DONTCARE);
- return result;
+ GDIOBJ_UnlockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
+
+ return result;
}
-INT STDCALL W32kGetObjectW(HANDLE handle, INT count, LPVOID buffer)
+INT STDCALL
+NtGdiGetObjectW(HANDLE handle, INT count, LPVOID buffer)
{
PGDIOBJHDR gdiObject;
INT result = 0;
- WORD magic;
+ DWORD objectType;
if (!count)
return 0;
- gdiObject = GDIOBJ_LockObj(handle, GO_MAGIC_DONTCARE);
+ gdiObject = GDIOBJ_LockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
if (gdiObject == 0)
return 0;
- magic = GDIOBJ_GetHandleMagic (handle);
- switch(magic)
+ objectType = GDIOBJ_GetObjectType(handle);
+ switch(objectType)
{
-/* case GO_PEN_MAGIC:
+/* case GDI_OBJECT_TYPE_PEN:
result = PEN_GetObject((PENOBJ *)gdiObject, count, buffer);
break;
- case GO_BRUSH_MAGIC:
+ case GDI_OBJECT_TYPE_BRUSH:
result = BRUSH_GetObject((BRUSHOBJ *)gdiObject, count, buffer);
break; */
- case GO_BITMAP_MAGIC:
+ case GDI_OBJECT_TYPE_BITMAP:
result = BITMAP_GetObject((BITMAPOBJ *)gdiObject, count, buffer);
break;
-/* case GO_FONT_MAGIC:
+/* case GDI_OBJECT_TYPE_FONT:
result = FONT_GetObjectW((FONTOBJ *)gdiObject, count, buffer);
// Fix the LOGFONT structure for the stock fonts
if ( (handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE) )
FixStockFontSizeW(handle, count, buffer);
break;
- case GO_PALETTE_MAGIC:
+ case GDI_OBJECT_TYPE_PALETTE:
result = PALETTE_GetObject((PALETTEOBJ *)gdiObject, count, buffer);
break; */
default:
- // FIXME("Magic %04x not implemented\n", gdiObject->magic);
+ DPRINT1("GDI object type 0x%08x not implemented\n", objectType);
break;
}
- GDIOBJ_UnlockObj(handle, GO_MAGIC_DONTCARE);
- return result;
+
+ GDIOBJ_UnlockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
+
+ return result;
}
-INT STDCALL W32kGetObject(HANDLE handle, INT count, LPVOID buffer)
+INT STDCALL
+NtGdiGetObject(HANDLE handle, INT count, LPVOID buffer)
{
- return W32kGetObjectW(handle, count, buffer);
+ return NtGdiGetObjectW(handle, count, buffer);
}
-DWORD STDCALL W32kGetObjectType(HANDLE handle)
+DWORD STDCALL
+NtGdiGetObjectType(HANDLE handle)
{
GDIOBJHDR * ptr;
INT result = 0;
- WORD magic;
+ DWORD objectType;
- ptr = GDIOBJ_LockObj(handle, GO_MAGIC_DONTCARE);
+ ptr = GDIOBJ_LockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
if (ptr == 0)
return 0;
- magic = GDIOBJ_GetHandleMagic (handle);
- switch(magic)
+ objectType = GDIOBJ_GetObjectType(handle);
+ switch(objectType)
{
- case GO_PEN_MAGIC:
+ case GDI_OBJECT_TYPE_PEN:
result = OBJ_PEN;
break;
- case GO_BRUSH_MAGIC:
+ case GDI_OBJECT_TYPE_BRUSH:
result = OBJ_BRUSH;
break;
- case GO_BITMAP_MAGIC:
+ case GDI_OBJECT_TYPE_BITMAP:
result = OBJ_BITMAP;
break;
- case GO_FONT_MAGIC:
+ case GDI_OBJECT_TYPE_FONT:
result = OBJ_FONT;
break;
- case GO_PALETTE_MAGIC:
+ case GDI_OBJECT_TYPE_PALETTE:
result = OBJ_PAL;
break;
- case GO_REGION_MAGIC:
+ case GDI_OBJECT_TYPE_REGION:
result = OBJ_REGION;
break;
- case GO_DC_MAGIC:
+ case GDI_OBJECT_TYPE_DC:
result = OBJ_DC;
break;
- case GO_META_DC_MAGIC:
+ case GDI_OBJECT_TYPE_METADC:
result = OBJ_METADC;
break;
- case GO_METAFILE_MAGIC:
+ case GDI_OBJECT_TYPE_METAFILE:
result = OBJ_METAFILE;
break;
- case GO_METAFILE_DC_MAGIC:
- result = OBJ_METADC;
- break;
- case GO_ENHMETAFILE_MAGIC:
+ case GDI_OBJECT_TYPE_ENHMETAFILE:
result = OBJ_ENHMETAFILE;
break;
- case GO_ENHMETAFILE_DC_MAGIC:
+ case GDI_OBJECT_TYPE_ENHMETADC:
result = OBJ_ENHMETADC;
break;
+ case GDI_OBJECT_TYPE_EXTPEN:
+ result = OBJ_EXTPEN;
+ break;
+ case GDI_OBJECT_TYPE_MEMDC:
+ result = OBJ_MEMDC;
+ break;
default:
- // FIXME("Magic %04x not implemented\n", magic);
+ DPRINT1("Magic 0x%08x not implemented\n", objectType);
break;
}
- GDIOBJ_UnlockObj(handle, GO_MAGIC_DONTCARE);
+ GDIOBJ_UnlockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
return result;
}
-DC_GET_VAL( INT, W32kGetRelAbs, w.relAbsMode )
-DC_GET_VAL( INT, W32kGetROP2, w.ROPmode )
-DC_GET_VAL( INT, W32kGetStretchBltMode, w.stretchBltMode )
-DC_GET_VAL( UINT, W32kGetTextAlign, w.textAlign )
-DC_GET_VAL( COLORREF, W32kGetTextColor, w.textColor )
-DC_GET_VAL_EX( W32kGetViewportExtEx, vportExtX, vportExtY, SIZE )
-DC_GET_VAL_EX( W32kGetViewportOrgEx, vportOrgX, vportOrgY, POINT )
-DC_GET_VAL_EX( W32kGetWindowExtEx, wndExtX, wndExtY, SIZE )
-DC_GET_VAL_EX( W32kGetWindowOrgEx, wndOrgX, wndOrgY, POINT )
-
-HDC STDCALL W32kResetDC(HDC hDC, CONST DEVMODEW *InitData)
+DC_GET_VAL( INT, NtGdiGetRelAbs, w.relAbsMode )
+DC_GET_VAL( INT, NtGdiGetROP2, w.ROPmode )
+DC_GET_VAL( INT, NtGdiGetStretchBltMode, w.stretchBltMode )
+DC_GET_VAL( UINT, NtGdiGetTextAlign, w.textAlign )
+DC_GET_VAL( COLORREF, NtGdiGetTextColor, w.textColor )
+DC_GET_VAL_EX( NtGdiGetViewportExtEx, IntGetViewportExtEx, vportExtX, vportExtY, SIZE )
+DC_GET_VAL_EX( NtGdiGetViewportOrgEx, IntGetViewportOrgEx, vportOrgX, vportOrgY, POINT )
+DC_GET_VAL_EX( NtGdiGetWindowExtEx, IntGetWindowExtEx, wndExtX, wndExtY, SIZE )
+DC_GET_VAL_EX( NtGdiGetWindowOrgEx, IntGetWindowOrgEx, wndOrgX, wndOrgY, POINT )
+
+HDC STDCALL
+NtGdiResetDC(HDC hDC, CONST DEVMODEW *InitData)
{
UNIMPLEMENTED;
}
-BOOL STDCALL W32kRestoreDC(HDC hDC, INT SaveLevel)
+BOOL STDCALL
+NtGdiRestoreDC(HDC hDC, INT SaveLevel)
{
PDC dc, dcs;
BOOL success;
- dc = DC_HandleToPtr(hDC);
+ dc = DC_LockDc(hDC);
if(!dc)
{
return FALSE;
{
HDC hdcs = DC_GetNextDC (dc);
- dcs = DC_HandleToPtr (hdcs);
+ dcs = DC_LockDc (hdcs);
if (dcs == NULL)
{
return FALSE;
DC_SetNextDC (dcs, DC_GetNextDC (dcs));
if (--dc->saveLevel < SaveLevel)
{
- W32kSetDCState16 (hDC, hdcs);
+ DC_UnlockDc( hDC );
+ DC_UnlockDc( hdcs );
+ NtGdiSetDCState(hDC, hdcs);
#if 0
if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
{
success = FALSE;
}
#endif
+ dc = DC_LockDc(hDC);
+ if(!dc)
+ {
+ return FALSE;
+ }
}
- DC_ReleasePtr( hdcs );
- W32kDeleteDC (hdcs);
+ else
+ {
+ DC_UnlockDc( hdcs );
+ }
+ NtGdiDeleteDC (hdcs);
}
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return success;
}
-INT STDCALL W32kSaveDC(HDC hDC)
+INT STDCALL
+NtGdiSaveDC(HDC hDC)
{
HDC hdcs;
PDC dc, dcs;
INT ret;
- dc = DC_HandleToPtr (hDC);
- if (dc == NULL)
+ if (!(hdcs = NtGdiGetDCState(hDC)))
{
return 0;
}
- if (!(hdcs = W32kGetDCState16 (hDC)))
+ dcs = DC_LockDc (hdcs);
+ if (dcs == NULL)
+ {
+ return 0;
+ }
+ dc = DC_LockDc (hDC);
+ if (dc == NULL)
{
+ DC_UnlockDc(dc);
return 0;
}
- dcs = DC_HandleToPtr (hdcs);
#if 0
/* Copy path. The reason why path saving / restoring is in SaveDC/
*/
if (!PATH_AssignGdiPath (&dcs->w.path, &dc->w.path))
{
- W32kDeleteDC (hdcs);
+ NtGdiDeleteDC (hdcs);
return 0;
}
#endif
DC_SetNextDC (dcs, DC_GetNextDC (dc));
DC_SetNextDC (dc, hdcs);
ret = ++dc->saveLevel;
- DC_ReleasePtr( hdcs );
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hdcs );
+ DC_UnlockDc( hDC );
return ret;
}
-HGDIOBJ STDCALL W32kSelectObject(HDC hDC, HGDIOBJ hGDIObj)
+HGDIOBJ
+STDCALL
+NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj)
{
- HGDIOBJ objOrg;
+ HGDIOBJ objOrg = NULL; // default to failure
BITMAPOBJ *pb;
PDC dc;
PPENOBJ pen;
PBRUSHOBJ brush;
PXLATEOBJ XlateObj;
PPALGDI PalGDI;
- WORD objectMagic;
+ DWORD objectType;
COLORREF *ColorMap;
ULONG NumColors, Index;
+ HRGN hVisRgn;
+ USHORT Mode;
if(!hDC || !hGDIObj) return NULL;
- dc = DC_HandleToPtr(hDC);
- objectMagic = GDIOBJ_GetHandleMagic (hGDIObj);
+ dc = DC_LockDc(hDC);
+ ASSERT ( dc );
+
+ objectType = GDIOBJ_GetObjectType(hGDIObj);
// GdiObjHdr = hGDIObj;
// FIXME: Get object handle from GDIObj and use it instead of GDIObj below?
- switch(objectMagic) {
- case GO_PEN_MAGIC:
+ switch (objectType)
+ {
+ case GDI_OBJECT_TYPE_PEN:
objOrg = (HGDIOBJ)dc->w.hPen;
dc->w.hPen = hGDIObj;
- // Convert the color of the pen to the format of the DC
- PalGDI = (PPALGDI)AccessInternalObject((ULONG) dc->w.hPalette);
- if( PalGDI ){
- XlateObj = (PXLATEOBJ)IntEngCreateXlate(PalGDI->Mode, PAL_RGB, dc->w.hPalette, NULL);
- pen = GDIOBJ_LockObj(dc->w.hPen, GO_PEN_MAGIC);
- if( pen ){
- pen->logpen.lopnColor = XLATEOBJ_iXlate(XlateObj, pen->logpen.lopnColor);
+ /* Convert the color of the pen to the format of the DC */
+ PalGDI = PALETTE_LockPalette(dc->w.hPalette);
+ if (NULL != PalGDI)
+ {
+ Mode = PalGDI->Mode;
+ PALETTE_UnlockPalette(dc->w.hPalette);
+ XlateObj = (PXLATEOBJ)IntEngCreateXlate(Mode, PAL_RGB, dc->w.hPalette, NULL);
+ ASSERT ( XlateObj );
+ pen = PENOBJ_LockPen(dc->w.hPen);
+ if( pen )
+ {
+ pen->logpen.lopnColor = XLATEOBJ_iXlate(XlateObj, pen->logpen.lopnColor);
+ PENOBJ_UnlockPen(dc->w.hPen);
}
- GDIOBJ_UnlockObj( dc->w.hPen, GO_PEN_MAGIC);
EngDeleteXlate(XlateObj);
}
break;
- case GO_BRUSH_MAGIC:
+ case GDI_OBJECT_TYPE_BRUSH:
objOrg = (HGDIOBJ)dc->w.hBrush;
dc->w.hBrush = (HBRUSH) hGDIObj;
- // Convert the color of the brush to the format of the DC
- PalGDI = (PPALGDI)AccessInternalObject((ULONG) dc->w.hPalette);
- if( PalGDI ){
- XlateObj = (PXLATEOBJ)IntEngCreateXlate(PalGDI->Mode, PAL_RGB, dc->w.hPalette, NULL);
- brush = GDIOBJ_LockObj(dc->w.hBrush, GO_BRUSH_MAGIC);
- if( brush ){
- brush->iSolidColor = XLATEOBJ_iXlate(XlateObj, brush->logbrush.lbColor);
+ /* Convert the color of the brush to the format of the DC */
+ PalGDI = PALETTE_LockPalette(dc->w.hPalette);
+ if (NULL != PalGDI)
+ {
+ Mode = PalGDI->Mode;
+ PALETTE_UnlockPalette(dc->w.hPalette);
+ XlateObj = (PXLATEOBJ)IntEngCreateXlate(Mode, PAL_RGB, dc->w.hPalette, NULL);
+ ASSERT(XlateObj);
+ brush = BRUSHOBJ_LockBrush(dc->w.hBrush);
+ if( brush )
+ {
+ brush->iSolidColor = XLATEOBJ_iXlate(XlateObj, brush->logbrush.lbColor);
}
- GDIOBJ_UnlockObj( dc->w.hBrush, GO_BRUSH_MAGIC);
+ BRUSHOBJ_UnlockBrush(dc->w.hBrush);
EngDeleteXlate(XlateObj);
}
break;
- case GO_FONT_MAGIC:
+ case GDI_OBJECT_TYPE_FONT:
objOrg = (HGDIOBJ)dc->w.hFont;
dc->w.hFont = (HFONT) hGDIObj;
TextIntRealizeFont(dc->w.hFont);
break;
- case GO_BITMAP_MAGIC:
+ case GDI_OBJECT_TYPE_BITMAP:
// must be memory dc to select bitmap
if (!(dc->w.flags & DC_MEMORY)) return NULL;
objOrg = (HGDIOBJ)dc->w.hBitmap;
/* Release the old bitmap, lock the new one and convert it to a SURF */
EngDeleteSurface(dc->Surface);
- BITMAPOBJ_ReleasePtr(objOrg);
dc->w.hBitmap = hGDIObj;
- pb = BITMAPOBJ_HandleToPtr(hGDIObj);
+ pb = BITMAPOBJ_LockBitmap(hGDIObj);
+ ASSERT(pb);
dc->Surface = BitmapToSurf(pb);
// if we're working with a DIB, get the palette [fixme: only create if the selected palette is null]
if(pb->dib->dsBmih.biBitCount == 8) { NumColors = 256; }
ColorMap = ExAllocatePool(PagedPool, sizeof(COLORREF) * NumColors);
+ ASSERT(ColorMap);
for (Index = 0; Index < NumColors; Index++)
- {
+ {
ColorMap[Index] = RGB(pb->ColorMap[Index].rgbRed,
pb->ColorMap[Index].rgbGreen,
pb->ColorMap[Index].rgbBlue);
}
- dc->w.hPalette = EngCreatePalette(PAL_INDEXED, NumColors, (ULONG *) ColorMap, 0, 0, 0);
+ dc->w.hPalette = PALETTE_AllocPalette(PAL_INDEXED, NumColors, (ULONG *) ColorMap, 0, 0, 0);
ExFreePool(ColorMap);
- } else
- if(16 == pb->dib->dsBmih.biBitCount)
+ }
+ else if ( 16 == pb->dib->dsBmih.biBitCount )
{
- dc->w.hPalette = EngCreatePalette(PAL_BITFIELDS, pb->dib->dsBmih.biClrUsed, NULL, 0x7c00, 0x03e0, 0x001f);
- } else
- if(pb->dib->dsBmih.biBitCount >= 24)
+ dc->w.hPalette = PALETTE_AllocPalette(PAL_BITFIELDS, pb->dib->dsBmih.biClrUsed, NULL, 0x7c00, 0x03e0, 0x001f);
+ }
+ else if(pb->dib->dsBmih.biBitCount >= 24)
{
- dc->w.hPalette = EngCreatePalette(PAL_RGB, pb->dib->dsBmih.biClrUsed, NULL, 0, 0, 0);
+ dc->w.hPalette = PALETTE_AllocPalette(PAL_RGB, pb->dib->dsBmih.biClrUsed, NULL, 0, 0, 0);
}
- } else {
+ }
+ else
+ {
dc->w.bitsPerPixel = pb->bitmap.bmBitsPixel;
}
- break;
+
+ DC_UnlockDc ( hDC );
+ hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->size.cx, pb->size.cy );
+ NtGdiSelectVisRgn ( hDC, hVisRgn );
+ NtGdiDeleteObject ( hVisRgn );
+ BITMAPOBJ_UnlockBitmap(hGDIObj);
+
+ return objOrg;
#if UPDATEREGIONS
- case GO_REGION_MAGIC:
- /* objOrg = (HGDIOBJ)hDC->region; */
- objOrg = NULL; /* FIXME? hDC->region is destroyed below */
+ case GDI_OBJECT_TYPE_REGION:
+ DC_UnlockDc ( hDC );
SelectClipRgn(hDC, (HRGN)hGDIObj);
- break;
+ return NULL;
#endif
default:
- return NULL;
+ break;
}
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return objOrg;
}
-DC_SET_MODE( W32kSetBkMode, w.backgroundMode, TRANSPARENT, OPAQUE )
-DC_SET_MODE( W32kSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
-// DC_SET_MODE( W32kSetRelAbs, w.relAbsMode, ABSOLUTE, RELATIVE )
-DC_SET_MODE( W32kSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
-DC_SET_MODE( W32kSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
-
-COLORREF STDCALL W32kSetBkColor(HDC hDC, COLORREF color)
-{
- COLORREF oldColor;
- PDC dc = DC_HandleToPtr(hDC);
-
- if (!dc)
- {
- return 0x80000000;
- }
+DC_SET_MODE( NtGdiSetBkMode, w.backgroundMode, TRANSPARENT, OPAQUE )
+DC_SET_MODE( NtGdiSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
+// DC_SET_MODE( NtGdiSetRelAbs, w.relAbsMode, ABSOLUTE, RELATIVE )
+DC_SET_MODE( NtGdiSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
+DC_SET_MODE( NtGdiSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
- oldColor = dc->w.backgroundColor;
- dc->w.backgroundColor = color;
- DC_ReleasePtr( hDC );
- return oldColor;
-}
+// ---------------------------------------------------- Private Interface
-static void W32kSetDCState16(HDC hDC, HDC hDCSave)
+HDC FASTCALL
+DC_AllocDC(LPCWSTR Driver)
{
- PDC dc, dcs;
+ PDC NewDC;
+ HDC hDC;
- dc = DC_HandleToPtr(hDC);
- if (dc == NULL)
- {
- return;
- }
-
- dcs = DC_HandleToPtr(hDCSave);
- if (dcs == NULL)
+ hDC = (HDC) GDIOBJ_AllocObj(sizeof(DC), GDI_OBJECT_TYPE_DC, (GDICLEANUPPROC) DC_InternalDeleteDC);
+ if (hDC == NULL)
{
- DC_ReleasePtr( hDC );
- return;
- }
- if (!dcs->w.flags & DC_SAVED)
- {
- return;
+ return NULL;
}
- dc->w.flags = dcs->w.flags & ~DC_SAVED;
-
-#if 0
- dc->w.devCaps = dcs->w.devCaps;
-#endif
+ NewDC = DC_LockDc(hDC);
- 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))
+ if (Driver != NULL)
{
- dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
+ NewDC->DriverName = ExAllocatePool(PagedPool, (wcslen(Driver) + 1) * sizeof(WCHAR));
+ wcscpy(NewDC->DriverName, Driver);
}
-#if 0
- if (dcs->w.hClipRgn)
- {
- if (!dc->w.hClipRgn)
- {
- dc->w.hClipRgn = W32kCreateRectRgn( 0, 0, 0, 0 );
- }
- W32kCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
- }
- else
- {
- if (dc->w.hClipRgn)
- {
- W32kDeleteObject( dc->w.hClipRgn );
- }
-
- dc->w.hClipRgn = 0;
- }
- CLIPPING_UpdateGCRegion( dc );
-#endif
-
- W32kSelectObject( hDC, dcs->w.hBitmap );
- W32kSelectObject( hDC, dcs->w.hBrush );
- W32kSelectObject( hDC, dcs->w.hFont );
- W32kSelectObject( hDC, dcs->w.hPen );
- W32kSetBkColor( hDC, dcs->w.backgroundColor);
- W32kSetTextColor( hDC, dcs->w.textColor);
-
-#if 0
- GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
-#endif
+ NewDC->w.xformWorld2Wnd.eM11 = 1.0f;
+ NewDC->w.xformWorld2Wnd.eM12 = 0.0f;
+ NewDC->w.xformWorld2Wnd.eM21 = 0.0f;
+ NewDC->w.xformWorld2Wnd.eM22 = 1.0f;
+ NewDC->w.xformWorld2Wnd.eDx = 0.0f;
+ NewDC->w.xformWorld2Wnd.eDy = 0.0f;
+ NewDC->w.xformWorld2Vport = NewDC->w.xformWorld2Wnd;
+ NewDC->w.xformVport2World = NewDC->w.xformWorld2Wnd;
+ NewDC->w.vport2WorldValid = TRUE;
- DC_ReleasePtr( hDCSave );
- DC_ReleasePtr( hDC );
-}
+ NewDC->w.hFont = NtGdiGetStockObject(SYSTEM_FONT);
+ TextIntRealizeFont(NewDC->w.hFont);
-// ---------------------------------------------------- Private Interface
+ DC_UnlockDc(hDC);
-HDC DC_AllocDC(LPCWSTR Driver)
-{
- PDC NewDC;
- HDC hDC;
-
- hDC = (HDC) GDIOBJ_AllocObj(sizeof(DC), GO_DC_MAGIC);
- if (hDC == NULL)
- {
- return NULL;
- }
-
- NewDC = (PDC) GDIOBJ_LockObj( hDC, GO_DC_MAGIC );
-
- if (Driver != NULL)
- {
- NewDC->DriverName = ExAllocatePool(PagedPool, (wcslen(Driver) + 1) * sizeof(WCHAR));
- wcscpy(NewDC->DriverName, Driver);
- }
-
- NewDC->w.xformWorld2Wnd.eM11 = 1.0f;
- NewDC->w.xformWorld2Wnd.eM12 = 0.0f;
- NewDC->w.xformWorld2Wnd.eM21 = 0.0f;
- NewDC->w.xformWorld2Wnd.eM22 = 1.0f;
- NewDC->w.xformWorld2Wnd.eDx = 0.0f;
- NewDC->w.xformWorld2Wnd.eDy = 0.0f;
- NewDC->w.xformWorld2Vport = NewDC->w.xformWorld2Wnd;
- NewDC->w.xformVport2World = NewDC->w.xformWorld2Wnd;
- NewDC->w.vport2WorldValid = TRUE;
-
- NewDC->w.hFont = W32kGetStockObject(SYSTEM_FONT);
-
- GDIOBJ_UnlockObj( hDC, GO_DC_MAGIC );
- return hDC;
+ return hDC;
}
-HDC DC_FindOpenDC(LPCWSTR Driver)
+HDC FASTCALL
+DC_FindOpenDC(LPCWSTR Driver)
{
return NULL;
}
/*!
* Initialize some common fields in the Device Context structure.
*/
-void DC_InitDC(HDC DCHandle)
+VOID FASTCALL
+DC_InitDC(HDC DCHandle)
{
-// W32kRealizeDefaultPalette(DCHandle);
+// NtGdiRealizeDefaultPalette(DCHandle);
- W32kSelectObject(DCHandle, W32kGetStockObject( WHITE_BRUSH ));
- W32kSelectObject(DCHandle, W32kGetStockObject( BLACK_PEN ));
- //W32kSelectObject(DCHandle, hFont);
+ NtGdiSelectObject(DCHandle, NtGdiGetStockObject( WHITE_BRUSH ));
+ NtGdiSelectObject(DCHandle, NtGdiGetStockObject( BLACK_PEN ));
+ //NtGdiSelectObject(DCHandle, hFont);
// CLIPPING_UpdateGCRegion(DCToInit);
}
-void DC_FreeDC(HDC DCToFree)
+VOID FASTCALL
+DC_FreeDC(HDC DCToFree)
{
- if (!GDIOBJ_FreeObj(DCToFree, GO_DC_MAGIC, GDIOBJFLAG_DEFAULT))
+ if (!GDIOBJ_FreeObj(DCToFree, GDI_OBJECT_TYPE_DC, GDIOBJFLAG_DEFAULT))
{
DPRINT("DC_FreeDC failed\n");
}
}
-BOOL DC_InternalDeleteDC( PDC DCToDelete )
+BOOL FASTCALL
+DC_InternalDeleteDC( PDC DCToDelete )
{
- if( DCToDelete->DriverName )
- ExFreePool(DCToDelete->DriverName);
- return TRUE;
+ if( DCToDelete->DriverName )
+ {
+ ExFreePool(DCToDelete->DriverName);
+ }
+
+ return TRUE;
}
-HDC DC_GetNextDC (PDC pDC)
+HDC FASTCALL
+DC_GetNextDC (PDC pDC)
{
return pDC->hNext;
}
-void DC_SetNextDC (PDC pDC, HDC hNextDC)
+VOID FASTCALL
+DC_SetNextDC (PDC pDC, HDC hNextDC)
{
pDC->hNext = hNextDC;
}
-void
+VOID FASTCALL
DC_UpdateXforms(PDC dc)
{
XFORM xformWnd2Vport;
xformWnd2Vport.eDy = (FLOAT)dc->vportOrgY - scaleY * (FLOAT)dc->wndOrgY;
/* Combine with the world transformation */
- W32kCombineTransform(&dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd, &xformWnd2Vport);
+ NtGdiCombineTransform(&dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd, &xformWnd2Vport);
/* Create inverse of world-to-viewport transformation */
dc->w.vport2WorldValid = DC_InvertXform(&dc->w.xformWorld2Vport, &dc->w.xformVport2World);
}
-BOOL
+BOOL FASTCALL
DC_InvertXform(const XFORM *xformSrc,
XFORM *xformDest)
{
return TRUE;
}
+/* EOF */
git://git.jankratochvil.net / reactos.git / blobdiff