* DC.C - Device context functions
*
*/
+
#include <w32k.h>
+#define NDEBUG
+#include <debug.h>
+
#ifndef OBJ_COLORSPACE
#define OBJ_COLORSPACE (14)
#endif
return 0; \
} \
ft = dc->dc_field; \
- DC_UnlockDc( hdc ); \
+ DC_UnlockDc(dc); \
return ft; \
}
} \
BOOL STDCALL NtGdi##FuncName ( HDC hdc, LP##type pt ) \
{ \
- NTSTATUS Status; \
+ NTSTATUS Status = STATUS_SUCCESS; \
type Safept; \
PDC dc; \
if(!pt) \
return FALSE; \
} \
Int##FuncName( dc, &Safept); \
- DC_UnlockDc(hdc); \
- Status = MmCopyToCaller(pt, &Safept, sizeof( type )); \
+ DC_UnlockDc(dc); \
+ _SEH_TRY \
+ { \
+ ProbeForWrite(pt, \
+ sizeof( type ), \
+ 1); \
+ *pt = Safept; \
+ } \
+ _SEH_HANDLE \
+ { \
+ Status = _SEH_GetExceptionCode(); \
+ } \
+ _SEH_END; \
if(!NT_SUCCESS(Status)) \
{ \
SetLastNtError(Status); \
} \
prevMode = dc->dc_field; \
dc->dc_field = mode; \
- DC_UnlockDc ( hdc ); \
+ DC_UnlockDc ( dc ); \
return prevMode; \
}
}
HDC STDCALL
-NtGdiCreateCompatableDC(HDC hDC)
+NtGdiCreateCompatibleDC(HDC hDC)
{
PDC NewDC, OrigDC;
HBITMAP hBitmap;
if (NULL == hNewDC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(OrigDC);
if (NULL != DisplayDC)
{
NtGdiDeleteDC(DisplayDC);
/* Create default bitmap */
if (!(hBitmap = NtGdiCreateBitmap( 1, 1, 1, NewDC->w.bitsPerPixel, NULL )))
{
- DC_UnlockDc( hDC );
- DC_UnlockDc( hNewDC );
+ DC_UnlockDc( OrigDC );
+ DC_UnlockDc( NewDC );
DC_FreeDC( hNewDC );
if (NULL != DisplayDC)
{
NewDC->w.backgroundColor = OrigDC->w.backgroundColor;
NewDC->w.backgroundMode = OrigDC->w.backgroundMode;
NewDC->w.ROPmode = OrigDC->w.ROPmode;
- DC_UnlockDc( hDC );
+ DC_UnlockDc(NewDC);
+ DC_UnlockDc(OrigDC);
if (NULL != DisplayDC)
{
NtGdiDeleteDC(DisplayDC);
}
- DC_UnlockDc(hNewDC);
hVisRgn = NtGdiCreateRectRgn(0, 0, 1, 1);
NtGdiSelectVisRgn(hNewDC, hVisRgn);
if (Valid)
{
ProfilePath = ExAllocatePoolWithTag(PagedPool,
- (wcslen(RegistryPath.Buffer) +
+ (wcslen(RegistryPath.Buffer) +
wcslen(Insert) + 1) * sizeof(WCHAR),
TAG_DC);
if (NULL != ProfilePath)
return (PrimarySurface.PreparedDriver ? TRUE : IntPrepareDriver());
}
+static BOOL FASTCALL
+PrepareVideoPrt()
+{
+ PIRP Irp;
+ NTSTATUS Status;
+ IO_STATUS_BLOCK Iosb;
+ BOOL Prepare = TRUE;
+ ULONG Length = sizeof(BOOL);
+ PIO_STACK_LOCATION StackPtr;
+ LARGE_INTEGER StartOffset;
+ PFILE_OBJECT FileObject = PrimarySurface.VideoFileObject;
+ PDEVICE_OBJECT DeviceObject = FileObject->DeviceObject;
+
+ DPRINT("PrepareVideoPrt() called\n");
+
+ KeClearEvent(&PrimarySurface.VideoFileObject->Event);
+
+ ObReferenceObjectByPointer(FileObject, 0, IoFileObjectType, KernelMode);
+
+ StartOffset.QuadPart = 0;
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
+ DeviceObject,
+ (PVOID) &Prepare,
+ Length,
+ &StartOffset,
+ NULL,
+ &Iosb);
+ if (NULL == Irp)
+ {
+ return FALSE;
+ }
+
+ /* Set up IRP Data */
+ Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = KernelMode;
+ Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
+ Irp->Overlay.AsynchronousParameters.UserApcContext = NULL;
+ Irp->Flags |= IRP_WRITE_OPERATION;
+
+ /* Setup Stack Data */
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->FileObject = PrimarySurface.VideoFileObject;
+ StackPtr->Parameters.Write.Key = 0;
+
+ Status = IoCallDriver(DeviceObject, Irp);
+
+ if (STATUS_PENDING == Status)
+ {
+ KeWaitForSingleObject(&FileObject->Event, Executive, KernelMode, TRUE, 0);
+ Status = Iosb.Status;
+ }
+
+ return NT_SUCCESS(Status);
+}
+
BOOL FASTCALL
IntCreatePrimarySurface()
{
SIZEL SurfSize;
RECTL SurfaceRect;
SURFOBJ *SurfObj;
-
+ BOOL calledFromUser;
+
if (! IntPrepareDriverIfNeeded())
{
return FALSE;
}
+ if (! PrepareVideoPrt())
+ {
+ return FALSE;
+ }
+
DPRINT("calling EnableSurface\n");
/* Enable the drawing surface */
PrimarySurface.Handle =
PrimarySurface.DriverFunctions.AssertMode(PrimarySurface.PDev, TRUE);
+ calledFromUser = UserIsEntered(); //fixme: possibly upgrade a shared lock
+ if (!calledFromUser){
+ UserEnterExclusive();
+ }
+
/* attach monitor */
IntAttachMonitor(&PrimarySurface, PrimarySurface.DisplayNumber);
GDIDEV(SurfObj)->Pointer.Pos.y = (SurfaceRect.bottom - SurfaceRect.top) / 2;
EngUnlockSurface(SurfObj);
- IntShowDesktop(IntGetActiveDesktop(), SurfSize.cx, SurfSize.cy);
+ co_IntShowDesktop(IntGetActiveDesktop(), SurfSize.cx, SurfSize.cy);
+
+ if (!calledFromUser){
+ UserLeave();
+ }
return TRUE;
}
VOID FASTCALL
IntDestroyPrimarySurface()
{
+ BOOL calledFromUser;
+
DRIVER_UnreferenceDriver(L"DISPLAY");
+ calledFromUser = UserIsEntered();
+ if (!calledFromUser){
+ UserEnterExclusive();
+ }
+
/* detach monitor */
IntDetachMonitor(&PrimarySurface);
+ if (!calledFromUser){
+ UserLeave();
+ }
+
/*
* FIXME: Hide a mouse pointer there. Also because we have to prevent
* memory leaks with the Eng* mouse routines.
HDC hNewDC;
PDC NewDC;
HDC hDC = NULL;
- SURFOBJ *SurfObj;
HRGN hVisRgn;
UNICODE_STRING StdDriver;
+ BOOL calledFromUser;
RtlInitUnicodeString(&StdDriver, L"DISPLAY");
return NULL;
}
}
- else if (! IntGraphicsCheck(TRUE))
+ else
{
- DPRINT1("Unable to initialize graphics, returning NULL dc\n");
- return NULL;
+ calledFromUser = UserIsEntered();
+ if (!calledFromUser){
+ UserEnterExclusive();
+ }
+
+ if (! co_IntGraphicsCheck(TRUE))
+ {
+ if (!calledFromUser){
+ UserLeave();
+ }
+ DPRINT1("Unable to initialize graphics, returning NULL dc\n");
+ return NULL;
+ }
+
+ if (!calledFromUser){
+ UserLeave();
+ }
+
}
}
if ((hNewDC = DC_FindOpenDC(Driver)) != NULL)
{
hDC = hNewDC;
- return NtGdiCreateCompatableDC(hDC);
+ return NtGdiCreateCompatibleDC(hDC);
}
if (Driver != NULL && Driver->Buffer != NULL)
if (! CreateAsIC)
{
- SurfObj = EngLockSurface((HSURF)PrimarySurface.Handle);
- if ( !SurfObj )
- {
- DC_UnlockDc ( hNewDC );
- DC_FreeDC ( hNewDC) ;
- return NULL;
- }
- ASSERT(NewDC->GDIInfo->cBitsPixel * NewDC->GDIInfo->cPlanes == BitsPerFormat(SurfObj->iBitmapFormat));
- ASSERT(NewDC->GDIInfo->ulHorzRes == SurfObj->sizlBitmap.cx);
- ASSERT(NewDC->GDIInfo->ulVertRes == SurfObj->sizlBitmap.cy);
-
NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
NewDC->w.ROPmode = R2_COPYPEN;
-
- DC_UnlockDc( hNewDC );
- hVisRgn = NtGdiCreateRectRgn(0, 0, SurfObj->sizlBitmap.cx,
- SurfObj->sizlBitmap.cy);
+ DC_UnlockDc( NewDC );
+
+ hVisRgn = NtGdiCreateRectRgn(0, 0, NewDC->GDIInfo->ulHorzRes,
+ NewDC->GDIInfo->ulVertRes);
NtGdiSelectVisRgn(hNewDC, hVisRgn);
NtGdiDeleteObject(hVisRgn);
NtGdiSetTextAlign(hNewDC, TA_TOP);
NtGdiSetBkColor(hNewDC, RGB(255, 255, 255));
NtGdiSetBkMode(hNewDC, OPAQUE);
-
- EngUnlockSurface(SurfObj);
}
else
{
- DC_UnlockDc( hNewDC );
+ DC_UnlockDc( NewDC );
}
-
+
return hNewDC;
}
UNICODE_STRING SafeDriver, SafeDevice;
DEVMODEW SafeInitData;
HDC Ret;
- NTSTATUS Status;
-
+ NTSTATUS Status = STATUS_SUCCESS;
+
if(InitData)
{
- Status = MmCopyFromCaller(&SafeInitData, InitData, sizeof(DEVMODEW));
+ _SEH_TRY
+ {
+ ProbeForRead(InitData,
+ sizeof(DEVMODEW),
+ 1);
+ RtlCopyMemory(&SafeInitData,
+ InitData,
+ sizeof(DEVMODEW));
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
}
/* FIXME - InitData can have some more bytes! */
}
-
+
if(Driver)
{
Status = IntSafeCopyUnicodeString(&SafeDriver, Driver);
return NULL;
}
}
-
+
if(Device)
{
Status = IntSafeCopyUnicodeString(&SafeDevice, Device);
return NULL;
}
}
-
- Ret = IntGdiCreateDC(&SafeDriver, &SafeDevice, NULL, &SafeInitData, FALSE);
-
+
+ Ret = IntGdiCreateDC(NULL == Driver ? NULL : &SafeDriver,
+ NULL == Device ? NULL : &SafeDevice, NULL,
+ NULL == InitData ? NULL : &SafeInitData, FALSE);
+
return Ret;
}
UNICODE_STRING SafeDriver, SafeDevice;
DEVMODEW SafeInitData;
HDC Ret;
- NTSTATUS Status;
-
+ NTSTATUS Status = STATUS_SUCCESS;
+
if(InitData)
{
- Status = MmCopyFromCaller(&SafeInitData, InitData, sizeof(DEVMODEW));
+ _SEH_TRY
+ {
+ ProbeForRead(InitData,
+ sizeof(DEVMODEW),
+ 1);
+ RtlCopyMemory(&SafeInitData,
+ InitData,
+ sizeof(DEVMODEW));
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
}
/* FIXME - InitData can have some more bytes! */
}
-
+
if(Driver)
{
Status = IntSafeCopyUnicodeString(&SafeDriver, Driver);
return NULL;
}
}
-
+
if(Device)
{
Status = IntSafeCopyUnicodeString(&SafeDevice, Device);
return NULL;
}
}
-
+
Ret = IntGdiCreateDC(NULL == Driver ? NULL : &SafeDriver,
NULL == Device ? NULL : &SafeDevice, NULL,
NULL == InitData ? NULL : &SafeInitData, TRUE);
-
+
return Ret;
}
{
PDC DCToDelete;
+ if (!GDIOBJ_OwnedByCurrentProcess(DCHandle))
+ {
+ SetLastWin32Error(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
DCToDelete = DC_LockDc(DCHandle);
if (DCToDelete == NULL)
{
- return FALSE;
+ SetLastWin32Error(ERROR_INVALID_HANDLE);
+ return FALSE;
}
/* First delete all saved DCs */
}
DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
DCToDelete->saveLevel--;
- DC_UnlockDc( savedHDC );
+ DC_UnlockDc( savedDC );
NtGdiDeleteDC (savedHDC);
}
#if 0 /* FIXME */
PATH_DestroyGdiPath (&DCToDelete->w.path);
#endif
- DC_UnlockDc( DCHandle );
+ DC_UnlockDc( DCToDelete );
DC_FreeDC ( DCHandle );
return TRUE;
{
HGDIOBJ SelObject;
DC *dc;
-
+
if(!(dc = DC_LockDc(hDC)))
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
return NULL;
}
-
+
switch(ObjectType)
{
case OBJ_PEN:
SetLastWin32Error(ERROR_INVALID_PARAMETER);
break;
}
-
- DC_UnlockDc(hDC);
+
+ DC_UnlockDc(dc);
return SelObject;
}
{
Point->x = dc->w.DCOrgX;
Point->y = dc->w.DCOrgY;
-
+
return TRUE;
}
BOOL Ret;
DC *dc;
POINT SafePoint;
- NTSTATUS Status;
-
+ NTSTATUS Status = STATUS_SUCCESS;
+
if(!Point)
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
+
dc = DC_LockDc(hDC);
if(!dc)
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
-
+
Ret = IntGdiGetDCOrgEx(dc, &SafePoint);
-
- Status = MmCopyToCaller(Point, &SafePoint, sizeof(POINT));
+
+ _SEH_TRY
+ {
+ ProbeForWrite(Point,
+ sizeof(POINT),
+ 1);
+ *Point = SafePoint;
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
-
- DC_UnlockDc(hDC);
+
+ DC_UnlockDc(dc);
return Ret;
}
oldColor = dc->w.backgroundColor;
dc->w.backgroundColor = color;
hBrush = dc->w.hBrush;
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
NtGdiSelectObject(hDC, hBrush);
return oldColor;
}
hnewdc = DC_AllocDC(NULL);
if (hnewdc == NULL)
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return 0;
}
newdc = DC_LockDc( hnewdc );
newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
}
- DC_UnlockDc( hnewdc );
- DC_UnlockDc( hDC );
+ DC_UnlockDc( newdc );
+ DC_UnlockDc( dc );
return hnewdc;
}
res = CLIPPING_UpdateGCRegion( dc );
ASSERT ( res != ERROR );
}
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
#else
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
NtGdiSelectClipRgn(hDC, dcs->w.hClipRgn);
#endif
GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
#endif
} else {
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
- DC_UnlockDc ( hDCSave );
+ DC_UnlockDc ( dcs );
} else {
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
SetLastWin32Error(ERROR_INVALID_HANDLE);
}
}
INT FASTCALL
IntGdiGetDeviceCaps(PDC dc, INT Index)
{
- INT ret;
+ INT ret = 0;
POINT pt;
/* Retrieve capability */
DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return ret;
}
SetLastWin32Error(ERROR_INVALID_HANDLE);
return 0;
}
-
+
ObjectType = GDIOBJ_GetObjectType(Handle);
switch (ObjectType)
{
break;
}
- GDIOBJ_UnlockObj(Handle);
+ GDIOBJ_UnlockObjByPtr(GdiObject);
return Result;
}
{
INT Ret;
LPVOID SafeBuf;
- NTSTATUS Status;
+ NTSTATUS Status = STATUS_SUCCESS;
if (count <= 0)
{
return 0;
}
+ _SEH_TRY
+ {
+ ProbeForWrite(buffer,
+ count,
+ 1);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if(!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ return 0;
+ }
+
SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
if(!SafeBuf)
{
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
-
+
Ret = IntGdiGetObject(handle, count, SafeBuf);
-
- Status = MmCopyToCaller(buffer, SafeBuf, count);
+
+ _SEH_TRY
+ {
+ /* pointer already probed! */
+ RtlCopyMemory(buffer,
+ SafeBuf,
+ count);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
ExFreePool(SafeBuf);
if(!NT_SUCCESS(Status))
{
result = 0;
break;
}
- GDIOBJ_UnlockObj(handle);
+ GDIOBJ_UnlockObjByPtr(ptr);
return result;
}
if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
dcs = DC_LockDc (hdcs);
if (dcs == NULL)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
DC_SetNextDC (dcs, DC_GetNextDC (dcs));
if (--dc->saveLevel < SaveLevel)
{
- DC_UnlockDc( hDC );
- DC_UnlockDc( hdcs );
+ DC_UnlockDc( dc );
+ DC_UnlockDc( dcs );
NtGdiSetDCState(hDC, hdcs);
#if 0
if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
}
else
{
- DC_UnlockDc( hdcs );
+ DC_UnlockDc( dcs );
}
NtGdiDeleteDC (hdcs);
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return success;
}
dc = DC_LockDc (hDC);
if (dc == NULL)
{
- DC_UnlockDc(hdcs);
+ DC_UnlockDc(dcs);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return 0;
}
DC_SetNextDC (dcs, DC_GetNextDC (dc));
DC_SetNextDC (dc, hdcs);
ret = ++dc->saveLevel;
- DC_UnlockDc( hdcs );
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dcs );
+ DC_UnlockDc( dc );
return ret;
}
BOOLEAN Failed;
if(!hDC || !hGDIObj) return NULL;
-
+
dc = DC_LockDc(hDC);
if (NULL == dc)
{
}
XlateObj = IntGdiCreateBrushXlate(dc, pen, &Failed);
- PENOBJ_UnlockPen(hGDIObj);
+ PENOBJ_UnlockPen(pen);
if (Failed)
{
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
}
XlateObj = IntGdiCreateBrushXlate(dc, brush, &Failed);
- BRUSHOBJ_UnlockBrush(hGDIObj);
+ BRUSHOBJ_UnlockBrush(brush);
if (Failed)
{
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
// must be memory dc to select bitmap
if (!(dc->w.flags & DC_MEMORY))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return NULL;
}
pb = BITMAPOBJ_LockBitmap(hGDIObj);
if (NULL == pb)
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return NULL;
}
objOrg = (HGDIOBJ)dc->w.hBitmap;
NtGdiSelectObject ( hDC, dc->w.hBrush );
NtGdiSelectObject ( hDC, dc->w.hPen );
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->SurfObj.sizlBitmap.cx, pb->SurfObj.sizlBitmap.cy );
- BITMAPOBJ_UnlockBitmap( hGDIObj );
+ BITMAPOBJ_UnlockBitmap( pb );
NtGdiSelectVisRgn ( hDC, hVisRgn );
NtGdiDeleteObject ( hVisRgn );
return objOrg;
case GDI_OBJECT_TYPE_REGION:
- DC_UnlockDc (hDC);
+ DC_UnlockDc (dc);
/*
* The return value is one of the following values:
* SIMPLEREGION
default:
break;
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return objOrg;
}
dc->w.flags &= ~DC_DIRTY;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return wRet;
}
PDC NewDC;
HDC hDC;
PWSTR Buf = NULL;
-
+
if (Driver != NULL)
{
Buf = ExAllocatePoolWithTag(PagedPool, Driver->MaximumLength, TAG_DC);
NewDC = DC_LockDc(hDC);
/* FIXME - Handle NewDC == NULL! */
-
+
if (Driver != NULL)
{
RtlCopyMemory(&NewDC->DriverName, Driver, sizeof(UNICODE_STRING));
NewDC->w.hPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(NewDC);
return hDC;
}
{
GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(DC);
}
}
DEVMODEW DevMode;
INT Size, OldSize;
ULONG DisplayNumber = 0; /* only default display supported */
-
- DPRINT1("DevMode->dmSize = %d\n", pDevMode->dmSize);
- DPRINT1("DevMode->dmExtraSize = %d\n", pDevMode->dmDriverExtra);
+
+ DPRINT("DevMode->dmSize = %d\n", pDevMode->dmSize);
+ DPRINT("DevMode->dmExtraSize = %d\n", pDevMode->dmDriverExtra);
if (pDevMode->dmSize != SIZEOF_DEVMODEW_300 &&
pDevMode->dmSize != SIZEOF_DEVMODEW_400 &&
pDevMode->dmSize != SIZEOF_DEVMODEW_500)
if (iModeNum == ENUM_CURRENT_SETTINGS)
{
- CachedMode = &PrimarySurface.DMW;
+ CachedMode = &PrimarySurface.DMW;
ASSERT(CachedMode->dmSize > 0);
}
else if (iModeNum == ENUM_REGISTRY_SETTINGS)
UNICODE_STRING DriverFileNames;
LPWSTR CurrentName;
DRVENABLEDATA DrvEnableData;
-
+
/* Retrieve DDI driver names from registry */
RtlInitUnicodeString(&DriverFileNames, NULL);
if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
DPRINT1("FindDriverFileNames failed\n");
return FALSE;
}
-
+
if (!HalQueryDisplayOwnership())
{
IntCreatePrimarySurface();
PrimarySurfaceCreated = TRUE;
}
-
+
/*
* DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
* scan all of them until a good one found.
{
INT i;
PGD_ENABLEDRIVER GDEnableDriver;
-
+
/* Get the DDI driver's entry point */
GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
if (NULL == GDEnableDriver)
DPRINT("FindDDIDriver failed for %S\n", CurrentName);
continue;
}
-
+
/* Call DDI driver's EnableDriver function */
RtlZeroMemory(&DrvEnableData, sizeof (DrvEnableData));
-
+
if (!GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof (DrvEnableData), &DrvEnableData))
{
DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
continue;
}
-
+
CachedDevModesEnd = CachedDevModes;
-
+
/* find DrvGetModes function */
for (i = 0; i < DrvEnableData.c; i++)
{
PDRVFN DrvFn = DrvEnableData.pdrvfn + i;
PGD_GETMODES GetModes;
INT SizeNeeded, SizeUsed;
-
+
if (DrvFn->iFunc != INDEX_DrvGetModes)
continue;
-
+
GetModes = (PGD_GETMODES)DrvFn->pfn;
-
+
/* make sure we have enough memory to hold the modes */
SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject), 0, NULL);
if (SizeNeeded <= 0)
DPRINT("DrvGetModes failed for %S\n", CurrentName);
break;
}
-
+
SizeUsed = CachedDevModesEnd - CachedDevModes;
if (SizeOfCachedDevModes - SizeUsed < SizeNeeded)
{
PVOID NewBuffer;
-
+
SizeOfCachedDevModes += SizeNeeded;
NewBuffer = ExAllocatePool(PagedPool, SizeOfCachedDevModes);
if (NewBuffer == NULL)
CachedDevModes = NewBuffer;
CachedDevModesEnd = (DEVMODEW *)((PCHAR)NewBuffer + SizeUsed);
}
-
+
/* query modes */
SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject),
SizeOfCachedDevModes - SizeUsed,
break;
}
}
-
+
if (PrimarySurfaceCreated)
{
IntDestroyPrimarySurface();
}
-
+
RtlFreeUnicodeString(&DriverFileNames);
}
RtlCopyMemory(pDevMode, CachedMode, Size);
RtlZeroMemory((PCHAR)pDevMode + Size, OldSize - Size);
pDevMode->dmSize = OldSize;
-
+
Size = OldSize = pDevMode->dmDriverExtra;
if (Size > CachedMode->dmDriverExtra)
Size = CachedMode->dmDriverExtra;
return TRUE;
}
-
LONG
FASTCALL
IntChangeDisplaySettings(
BOOLEAN NoReset = FALSE;
BOOLEAN Reset = FALSE;
BOOLEAN SetPrimary = FALSE;
- LONG Ret;
+ LONG Ret=0;
+ NTSTATUS Status ;
+
+ DPRINT1("display flag : %x\n",dwflags);
if ((dwflags & CDS_UPDATEREGISTRY) == CDS_UPDATEREGISTRY)
{
if (Reset && NoReset)
return DISP_CHANGE_BADFLAGS;
- switch (dwflags)
- {
- case 0: /* Dynamically change graphics mode */
- Ret = DISP_CHANGE_FAILED;
- break;
-
- case CDS_FULLSCREEN: /* Given mode is temporary */
- Ret = DISP_CHANGE_FAILED;
- break;
-
- case CDS_UPDATEREGISTRY:
- {
+ if (dwflags == 0)
+ {
+ /* Dynamically change graphics mode */
+ DPRINT1("flag 0 UNIMPLEMENT \n");
+ return DISP_CHANGE_FAILED;
+ }
+
+ if ((dwflags & CDS_TEST) == CDS_TEST)
+ {
+ /* Test reslution */
+ dwflags &= ~CDS_TEST;
+ DPRINT1("flag CDS_TEST UNIMPLEMENT");
+ Ret = DISP_CHANGE_FAILED;
+ }
+
+ if ((dwflags & CDS_FULLSCREEN) == CDS_FULLSCREEN)
+ {
+ DEVMODE lpDevMode;
+ /* Full Screen */
+ dwflags &= ~CDS_FULLSCREEN;
+ DPRINT1("flag CDS_FULLSCREEN partially implemented");
+ Ret = DISP_CHANGE_FAILED;
+
+ lpDevMode.dmBitsPerPel =0;
+ lpDevMode.dmPelsWidth =0;
+ lpDevMode.dmPelsHeight =0;
+ lpDevMode.dmDriverExtra =0;
+
+ lpDevMode.dmSize = sizeof(DEVMODE);
+ Status = IntEnumDisplaySettings(pDeviceName, ENUM_CURRENT_SETTINGS, &lpDevMode, 0);
+ if (!NT_SUCCESS(Status)) return DISP_CHANGE_FAILED;
+
+ DPRINT1("Req Mode : %d x %d x %d\n", DevMode->dmPelsWidth,DevMode->dmPelsHeight,DevMode->dmBitsPerPel);
+ DPRINT1("Current Mode : %d x %d x %d\n", lpDevMode.dmPelsWidth,lpDevMode.dmPelsHeight, lpDevMode.dmBitsPerPel);
+
+
+ if ((lpDevMode.dmBitsPerPel == DevMode->dmBitsPerPel) &&
+ (lpDevMode.dmPelsWidth == DevMode->dmPelsWidth) &&
+ (lpDevMode.dmPelsHeight == DevMode->dmPelsHeight))
+ Ret = DISP_CHANGE_SUCCESSFUL;
+ }
+
+ if ((dwflags & CDS_VIDEOPARAMETERS) == CDS_VIDEOPARAMETERS)
+ {
+ dwflags &= ~CDS_VIDEOPARAMETERS;
+ if (lParam == NULL) Ret=DISP_CHANGE_BADPARAM;
+ else
+ {
+ DPRINT1("flag CDS_VIDEOPARAMETERS UNIMPLEMENT");
+ Ret = DISP_CHANGE_FAILED;
+ }
+
+ }
+
+ if ((dwflags & CDS_UPDATEREGISTRY) == CDS_UPDATEREGISTRY)
+ {
+
UNICODE_STRING ObjectName;
UNICODE_STRING KernelModeName;
WCHAR KernelModeNameBuffer[256];
UNICODE_STRING RegistryKey;
WCHAR RegistryKeyBuffer[512];
- PDEVICE_OBJECT DeviceObject;
- NTSTATUS Status;
+ PDEVICE_OBJECT DeviceObject;
ULONG LastSlash;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE DevInstRegKey;
ULONG NewValue;
+
+ DPRINT1("set CDS_UPDATEREGISTRY \n");
+
+ dwflags &= ~CDS_UPDATEREGISTRY;
+
/* Get device name (pDeviceName is "\.\xxx") */
for (LastSlash = pDeviceName->Length / sizeof(WCHAR); LastSlash > 0; LastSlash--)
{
if (pDeviceName->Buffer[LastSlash - 1] == L'\\')
break;
}
- if (LastSlash == 0) return DISP_CHANGE_FAILED;
+
+ if (LastSlash == 0) return DISP_CHANGE_RESTART;
ObjectName = *pDeviceName;
ObjectName.Length -= LastSlash * sizeof(WCHAR);
ObjectName.MaximumLength -= LastSlash * sizeof(WCHAR);
ObjectName.Buffer += LastSlash;
-
+
KernelModeName.Length = 0;
KernelModeName.MaximumLength = sizeof(KernelModeNameBuffer);
KernelModeName.Buffer = KernelModeNameBuffer;
-
+
/* Open \??\xxx (ex: "\??\DISPLAY1") */
Status = RtlAppendUnicodeToString(&KernelModeName, L"\\??\\");
+
if (!NT_SUCCESS(Status)) return DISP_CHANGE_FAILED;
Status = RtlAppendUnicodeStringToString(&KernelModeName, &ObjectName);
+
if (!NT_SUCCESS(Status)) return DISP_CHANGE_FAILED;
Status = ObReferenceObjectByName(
&KernelModeName,
KernelMode,
NULL,
(PVOID*)&DeviceObject);
+
if (!NT_SUCCESS(Status)) return DISP_CHANGE_FAILED;
/* Get associated driver name (ex: "VBE") */
for (LastSlash = DeviceObject->DriverObject->DriverName.Length / sizeof(WCHAR); LastSlash > 0; LastSlash--)
if (DeviceObject->DriverObject->DriverName.Buffer[LastSlash - 1] == L'\\')
break;
}
+
if (LastSlash == 0) { ObDereferenceObject(DeviceObject); return DISP_CHANGE_FAILED; }
ObjectName = DeviceObject->DriverObject->DriverName;
ObjectName.Length -= LastSlash * sizeof(WCHAR);
ObjectName.MaximumLength -= LastSlash * sizeof(WCHAR);
ObjectName.Buffer += LastSlash;
-
+
RegistryKey.Length = 0;
RegistryKey.MaximumLength = sizeof(RegistryKeyBuffer);
RegistryKey.Buffer = RegistryKeyBuffer;
-
+
/* Open registry key */
Status = RtlAppendUnicodeToString(&RegistryKey,
L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Services\\");
+
if (!NT_SUCCESS(Status)) { ObDereferenceObject(DeviceObject); return DISP_CHANGE_FAILED; }
Status = RtlAppendUnicodeStringToString(&RegistryKey, &ObjectName);
+
if (!NT_SUCCESS(Status)) { ObDereferenceObject(DeviceObject); return DISP_CHANGE_FAILED; }
Status = RtlAppendUnicodeToString(&RegistryKey,
L"\\Device0");
+
if (!NT_SUCCESS(Status)) { ObDereferenceObject(DeviceObject); return DISP_CHANGE_FAILED; }
-
+
InitializeObjectAttributes(&ObjectAttributes, &RegistryKey,
OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = ZwOpenKey(&DevInstRegKey, GENERIC_READ | GENERIC_WRITE, &ObjectAttributes);
ObDereferenceObject(DeviceObject);
if (!NT_SUCCESS(Status)) return DISP_CHANGE_FAILED;
-
+
/* Update needed fields */
if (NT_SUCCESS(Status) && DevMode->dmFields & DM_BITSPERPEL)
{
RtlInitUnicodeString(&RegistryKey, L"DefaultSettings.BitsPerPel");
NewValue = DevMode->dmBitsPerPel;
- Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
+ Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
}
-
+
if (NT_SUCCESS(Status) && DevMode->dmFields & DM_PELSWIDTH)
{
RtlInitUnicodeString(&RegistryKey, L"DefaultSettings.XResolution");
- NewValue = DevMode->dmPelsWidth;
- Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
+ NewValue = DevMode->dmPelsWidth;
+ Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
}
-
+
if (NT_SUCCESS(Status) && DevMode->dmFields & DM_PELSHEIGHT)
{
RtlInitUnicodeString(&RegistryKey, L"DefaultSettings.YResolution");
NewValue = DevMode->dmPelsHeight;
- Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
+ Status = ZwSetValueKey(DevInstRegKey, &RegistryKey, 0, REG_DWORD, &NewValue, sizeof(NewValue));
}
-
+
ZwClose(DevInstRegKey);
if (NT_SUCCESS(Status))
Ret = DISP_CHANGE_RESTART;
else
- Ret = DISP_CHANGE_FAILED;
- break;
+ /* return DISP_CHANGE_NOTUPDATED when we can save to reg only vaild for NT */
+ Ret = DISP_CHANGE_NOTUPDATED;
+
}
-
- case CDS_TEST: /* Test if the mode could be set */
- Ret = DISP_CHANGE_FAILED;
- break;
-
-#ifdef CDS_VIDEOPARAMETERS
- case CDS_VIDEOPARAMETERS:
- if (lParam == NULL)
- return DISP_CHANGE_BADPARAM;
- Ret = DISP_CHANGE_FAILED;
- break;
-#endif
-
- default:
+
+ if (dwflags != 0)
Ret = DISP_CHANGE_BADFLAGS;
- break;
- }
-
+
return Ret;
}
projects / reactos.git / blobdiff