* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Functions for creation and destruction of DCs
- * FILE: subsystem/win32/win32k/objects/dclife.c
+ * FILE: win32ss/gdi/ntgdi/dclife.c
* PROGRAMER: Timo Kreuzer (timo.kreuzer@rectos.org)
*/
PSURFACE psurfDefaultBitmap = NULL;
PBRUSH pbrDefaultBrush = NULL;
-static const MATRIX gmxWorldToDeviceDefault =
+const MATRIX gmxWorldToDeviceDefault =
{
FLOATOBJ_16, FLOATOBJ_0,
FLOATOBJ_0, FLOATOBJ_16,
0, 0, 0x4b
};
-static const MATRIX gmxDeviceToWorldDefault =
+const MATRIX gmxDeviceToWorldDefault =
{
FLOATOBJ_1_16, FLOATOBJ_0,
FLOATOBJ_0, FLOATOBJ_1_16,
0, 0, 0x53
};
-static const MATRIX gmxWorldToPageDefault =
+const MATRIX gmxWorldToPageDefault =
{
FLOATOBJ_1, FLOATOBJ_0,
FLOATOBJ_0, FLOATOBJ_1,
INIT_FUNCTION
NTSTATUS
NTAPI
-InitDcImpl()
+InitDcImpl(VOID)
{
psurfDefaultBitmap = SURFACE_ShareLockSurface(StockObjects[DEFAULT_BITMAP]);
if (!psurfDefaultBitmap)
PDC
NTAPI
-DC_AllocDcWithHandle()
+DC_AllocDcWithHandle(GDILOOBJTYPE eDcObjType)
{
PDC pdc;
+ NT_ASSERT((eDcObjType == GDILoObjType_LO_DC_TYPE) ||
+ (eDcObjType == GDILoObjType_LO_ALTDC_TYPE));
+
+ /* Allocate the object */
pdc = (PDC)GDIOBJ_AllocateObject(GDIObjType_DC_TYPE,
sizeof(DC),
BASEFLAG_LOOKASIDE);
return NULL;
}
+ /* Set the actual DC type */
+ pdc->BaseObject.hHmgr = UlongToHandle(eDcObjType);
+
+ pdc->pdcattr = &pdc->dcattr;
+
+ /* Insert the object */
if (!GDIOBJ_hInsertObject(&pdc->BaseObject, GDI_OBJ_HMGR_POWNED))
{
DPRINT1("Could not insert DC into handle table.\n");
return NULL;
}
- pdc->pdcattr = &pdc->dcattr;
-
return pdc;
}
void
DC_InitHack(PDC pdc)
{
+ if (defaultDCstate == NULL)
+ {
+ defaultDCstate = ExAllocatePoolWithTag(PagedPool, sizeof(DC), TAG_DC);
+ ASSERT(defaultDCstate);
+ RtlZeroMemory(defaultDCstate, sizeof(DC));
+ defaultDCstate->pdcattr = &defaultDCstate->dcattr;
+ DC_vCopyState(pdc, defaultDCstate, TRUE);
+ }
+
+ if (prgnDefault == NULL)
+ {
+ prgnDefault = IntSysCreateRectpRgn(0, 0, 0, 0);
+ }
+
TextIntRealizeFont(pdc->pdcattr->hlfntNew,NULL);
pdc->pdcattr->iCS_CP = ftGdiGetTextCharsetInfo(pdc,NULL,0);
pdc->erclBoundsApp.bottom = 0x00000333; // FIXME
pdc->erclClip = pdc->erclBounds;
pdc->co = gxcoTrivial;
-
- pdc->fs |= DC_SYNCHRONIZEACCESS | DC_ACCUM_APP | DC_PERMANANT | DC_DISPLAY;
}
else
{
pdc->prgnVis = IntSysCreateRectpRgn(0, 0, pdc->dclevel.sizl.cx, pdc->dclevel.sizl.cy);
ASSERT(pdc->prgnVis);
+ /* Setup Vis Region Attribute information */
+ UpdateVisRgn(pdc);
+
/* Initialize Clip object */
IntEngInitClipObj(&pdc->co);
pdc->dcattr.iGraphicsMode = GM_COMPATIBLE;
pdc->dcattr.iCS_CP = 0;
pdc->pSurfInfo = NULL;
-
- if (defaultDCstate == NULL)
- {
- defaultDCstate = ExAllocatePoolWithTag(PagedPool, sizeof(DC), TAG_DC);
- ASSERT(defaultDCstate);
- RtlZeroMemory(defaultDCstate, sizeof(DC));
- defaultDCstate->pdcattr = &defaultDCstate->dcattr;
- DC_vCopyState(pdc, defaultDCstate, TRUE);
- }
}
VOID
EBRUSHOBJ_vCleanup(&pdc->eboBackground);
/* Release font */
- LFONT_ShareUnlockFont(pdc->dclevel.plfnt);
+ if (pdc->dclevel.plfnt)
+ LFONT_ShareUnlockFont(pdc->dclevel.plfnt);
/* Free regions */
if (pdc->dclevel.prgnClip)
/* Free CLIPOBJ resources */
IntEngFreeClipResources(&pdc->co);
- PATH_Delete(pdc->dclevel.hPath);
-
- if(pdc->dclevel.pSurface)
+ if (pdc->dclevel.hPath)
+ {
+ DPRINT("DC_vCleanup Path\n");
+ PATH_Delete(pdc->dclevel.hPath);
+ pdc->dclevel.hPath = 0;
+ pdc->dclevel.flPath = 0;
+ }
+ if (pdc->dclevel.pSurface)
SURFACE_ShareUnlockSurface(pdc->dclevel.pSurface);
- PDEVOBJ_vRelease(pdc->ppdev) ;
+ if (pdc->ppdev)
+ PDEVOBJ_vRelease(pdc->ppdev);
}
VOID
NTAPI
DC_vSetOwner(PDC pdc, ULONG ulOwner)
{
+ /* Delete saved DCs */
+ DC_vRestoreDC(pdc, 1);
+
if (pdc->dclevel.hPath)
{
GreSetObjectOwner(pdc->dclevel.hPath, ulOwner);
DC_vUpdateDC(PDC pdc)
{
// PREGION VisRgn ;
- PPDEVOBJ ppdev = pdc->ppdev ;
+ PPDEVOBJ ppdev = pdc->ppdev;
pdc->dhpdev = ppdev->dhpdev;
DC_vUpdateTextBrush(pdcDest);
/* Lock them in good order */
- if(pdcSrc)
+ if (pdcSrc)
{
- if((ULONG_PTR)pdcDest->ppdev->hsemDevLock >= (ULONG_PTR)pdcSrc->ppdev->hsemDevLock)
+ if((ULONG_PTR)pdcDest->ppdev->hsemDevLock >=
+ (ULONG_PTR)pdcSrc->ppdev->hsemDevLock)
{
pdcFirst = pdcDest;
prcFirst = rcDest;
}
else
{
- pdcFirst = pdcDest ;
+ pdcFirst = pdcDest;
prcFirst = rcDest;
pdcSecond = NULL;
prcSecond = NULL;
}
- /* Update clipping of dest DC if needed */
- if (pdcDest->dctype == DCTYPE_DIRECT)
- {
- DCE* dce = DceGetDceFromDC(pdcDest->BaseObject.hHmgr);
- if (dce)
- DceUpdateVisRgn(dce, dce->pwndOrg, dce->DCXFlags);
- }
-
if (pdcDest->fs & DC_FLAG_DIRTY_RAO)
CLIPPING_UpdateGCRegion(pdcDest);
/* Lock and update first DC */
- if(pdcFirst->dctype == DCTYPE_DIRECT)
+ if (pdcFirst->dctype == DCTYPE_DIRECT)
{
EngAcquireSemaphore(pdcFirst->ppdev->hsemDevLock);
+
/* Update surface if needed */
- if(pdcFirst->ppdev->pSurface != pdcFirst->dclevel.pSurface)
+ if (pdcFirst->ppdev->pSurface != pdcFirst->dclevel.pSurface)
{
DC_vUpdateDC(pdcFirst);
}
}
- if(pdcFirst->dctype == DCTYPE_DIRECT)
+ if (pdcFirst->dctype == DCTYPE_DIRECT)
{
if (!prcFirst)
prcFirst = &pdcFirst->erclClip;
prcFirst->bottom) ;
}
+#if DBG
+ pdcFirst->fs |= DC_PREPARED;
+#endif
+
if (!pdcSecond)
return;
/* Lock and update second DC */
- if(pdcSecond->dctype == DCTYPE_DIRECT)
+ if (pdcSecond->dctype == DCTYPE_DIRECT)
{
EngAcquireSemaphore(pdcSecond->ppdev->hsemDevLock);
+
/* Update surface if needed */
- if(pdcSecond->ppdev->pSurface != pdcSecond->dclevel.pSurface)
+ if (pdcSecond->ppdev->pSurface != pdcSecond->dclevel.pSurface)
{
DC_vUpdateDC(pdcSecond);
}
}
- if(pdcSecond->dctype == DCTYPE_DIRECT)
+ if (pdcSecond->dctype == DCTYPE_DIRECT)
{
if (!prcSecond)
prcSecond = &pdcSecond->erclClip;
prcSecond->right,
prcSecond->bottom) ;
}
+
+#if DBG
+ pdcSecond->fs |= DC_PREPARED;
+#endif
}
/* Finishes a blit for one or two DCs */
FASTCALL
DC_vFinishBlit(PDC pdc1, PDC pdc2)
{
- if(pdc1->dctype == DCTYPE_DIRECT)
+ if (pdc1->dctype == DCTYPE_DIRECT)
{
MouseSafetyOnDrawEnd(pdc1->ppdev);
EngReleaseSemaphore(pdc1->ppdev->hsemDevLock);
}
+#if DBG
+ pdc1->fs &= ~DC_PREPARED;
+#endif
- if(pdc2)
+ if (pdc2)
{
- if(pdc2->dctype == DCTYPE_DIRECT)
+ if (pdc2->dctype == DCTYPE_DIRECT)
{
MouseSafetyOnDrawEnd(pdc2->ppdev);
EngReleaseSemaphore(pdc2->ppdev->hsemDevLock);
}
+#if DBG
+ pdc2->fs &= ~DC_PREPARED;
+#endif
}
}
BOOL bDisplay,
HANDLE hspool,
VOID *pDriverInfo2,
- VOID *pUMdhpdev)
+ PVOID *pUMdhpdev)
{
PPDEVOBJ ppdev;
PDC pdc;
DPRINT("GreOpenDCW - ppdev = %p\n", ppdev);
- pdc = DC_AllocDcWithHandle();
+ pdc = DC_AllocDcWithHandle(GDILoObjType_LO_DC_TYPE);
if (!pdc)
{
DPRINT1("Could not Allocate a DC\n");
/* Lock ppdev and initialize the new DC */
DC_vInitDc(pdc, iType, ppdev);
+ if (pUMdhpdev) *pUMdhpdev = ppdev->dhpdev;
/* FIXME: HACK! */
DC_InitHack(pdc);
return hdc;
}
+__kernel_entry
HDC
APIENTRY
NtGdiOpenDCW(
- PUNICODE_STRING pustrDevice,
- DEVMODEW *pdmInit,
- PUNICODE_STRING pustrLogAddr,
- ULONG iType,
- BOOL bDisplay,
- HANDLE hspool,
- VOID *pDriverInfo2,
- VOID *pUMdhpdev)
+ _In_opt_ PUNICODE_STRING pustrDevice,
+ _In_ DEVMODEW *pdmInit,
+ _In_ PUNICODE_STRING pustrLogAddr,
+ _In_ ULONG iType,
+ _In_ BOOL bDisplay,
+ _In_opt_ HANDLE hspool,
+ /*_In_opt_ DRIVER_INFO2W *pdDriverInfo2, Need this soon!!!! */
+ _At_((PUMDHPDEV*)pUMdhpdev, _Out_) PVOID pUMdhpdev)
{
UNICODE_STRING ustrDevice;
WCHAR awcDevice[CCHDEVICENAME];
- DEVMODEW dmInit;
PVOID dhpdev;
HDC hdc;
+ WORD dmSize, dmDriverExtra;
+ DWORD Size;
+ DEVMODEW * _SEH2_VOLATILE pdmAllocated = NULL;
/* Only if a devicename is given, we need any data */
if (pustrDevice)
/* Copy the string */
RtlCopyUnicodeString(&ustrDevice, pustrDevice);
+ /* Allocate and store pdmAllocated if pdmInit is not NULL */
if (pdmInit)
{
- /* FIXME: could be larger */
ProbeForRead(pdmInit, sizeof(DEVMODEW), 1);
- RtlCopyMemory(&dmInit, pdmInit, sizeof(DEVMODEW));
+
+ dmSize = pdmInit->dmSize;
+ dmDriverExtra = pdmInit->dmDriverExtra;
+ Size = dmSize + dmDriverExtra;
+ ProbeForRead(pdmInit, Size, 1);
+
+ pdmAllocated = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE,
+ Size,
+ TAG_DC);
+ RtlCopyMemory(pdmAllocated, pdmInit, Size);
+ pdmAllocated->dmSize = dmSize;
+ pdmAllocated->dmDriverExtra = dmDriverExtra;
}
if (pUMdhpdev)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ if (pdmAllocated)
+ {
+ ExFreePoolWithTag(pdmAllocated, TAG_DC);
+ }
SetLastNtError(_SEH2_GetExceptionCode());
_SEH2_YIELD(return NULL);
}
{
pdmInit = NULL;
pUMdhpdev = NULL;
+ // return UserGetDesktopDC(iType, FALSE, TRUE);
}
/* FIXME: HACK! */
/* Call the internal function */
hdc = GreOpenDCW(pustrDevice ? &ustrDevice : NULL,
- pdmInit ? &dmInit : NULL,
+ pdmAllocated,
NULL, // FIXME: pwszLogAddress
iType,
bDisplay,
/* If we got a HDC and a UM dhpdev is requested,... */
if (hdc && pUMdhpdev)
{
- /* Copy dhpdev to caller (FIXME: use dhpdev?) */
+ /* Copy dhpdev to caller */
_SEH2_TRY
{
/* Pointer was already probed */
_SEH2_END
}
+ /* Free the allocated */
+ if (pdmAllocated)
+ {
+ ExFreePoolWithTag(pdmAllocated, TAG_DC);
+ }
+
return hdc;
}
HDC
APIENTRY
-NtGdiCreateCompatibleDC(HDC hdc)
+GreCreateCompatibleDC(HDC hdc, BOOL bAltDc)
{
+ GDILOOBJTYPE eDcObjType;
HDC hdcNew;
PPDEVOBJ ppdev;
PDC pdc, pdcNew;
}
/* Allocate a new DC */
- pdcNew = DC_AllocDcWithHandle();
+ eDcObjType = bAltDc ? GDILoObjType_LO_ALTDC_TYPE : GDILoObjType_LO_DC_TYPE;
+ pdcNew = DC_AllocDcWithHandle(eDcObjType);
if (!pdcNew)
{
DPRINT1("Could not allocate a new DC\n");
hdcNew = pdcNew->BaseObject.hHmgr;
/* Lock ppdev and initialize the new DC */
- DC_vInitDc(pdcNew, DCTYPE_MEMORY, ppdev);
+ DC_vInitDc(pdcNew, bAltDc ? DCTYPE_INFO : DCTYPE_MEMORY, ppdev);
/* FIXME: HACK! */
DC_InitHack(pdcNew);
return hdcNew;
}
+HDC
+APIENTRY
+NtGdiCreateCompatibleDC(HDC hdc)
+{
+ /* Call the internal function to create a normal memory DC */
+ return GreCreateCompatibleDC(hdc, FALSE);
+}
+
BOOL
FASTCALL
IntGdiDeleteDC(HDC hDC, BOOL Force)
if (!GreDeleteObject(hDC))
{
DPRINT1("DC_FreeDC failed\n");
+ return FALSE;
}
}
else
{
DPRINT1("Attempted to Delete 0x%p currently being destroyed!!!\n", hDC);
+ return FALSE;
}
return TRUE;
projects / reactos.git / blobdiff