dc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DCLEVEL
struct	_DC

Macros
#define	DC_FL_PAL_BACK   1
#define	ASSERT_DC_PREPARED(pdc)   NT_ASSERT((pdc)->fs & DC_PREPARED)

Typedefs
typedef enum _DCFLAGS	DCFLAGS
typedef enum _DCTYPE	DCTYPE
typedef struct _DCLEVEL	DCLEVEL
typedef struct _DCLEVEL *	PDCLEVEL
typedef struct _DC	DC

Enumerations
enum	_FONT_STATE { DC_DIRTYFONT_XFORM = 1 , DC_DIRTYFONT_LFONT = 2 , DC_UFI_MAPPING = 4 }
enum	_DCFLAGS {   DC_DISPLAY = 0x0001 , DC_DIRECT = 0x0002 , DC_CANCELED = 0x0004 , DC_PERMANANT = 0x0008 ,   DC_DIRTY_RAO = 0x0010 , DC_ACCUM_WMGR = 0x0020 , DC_ACCUM_APP = 0x0040 , DC_RESET = 0x0080 ,   DC_SYNCHRONIZEACCESS = 0x0100 , DC_EPSPRINTINGESCAPE = 0x0200 , DC_TEMPINFODC = 0x0400 , DC_FULLSCREEN = 0x0800 ,   DC_IN_CLONEPDEV = 0x1000 , DC_REDIRECTION = 0x2000 , DC_SHAREACCESS = 0x4000 }
enum	_DCTYPE { DCTYPE_DIRECT = 0 , DCTYPE_MEMORY = 1 , DCTYPE_INFO = 2 }

Functions
VOID FASTCALL	DC_vUpdateFillBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateLineBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateTextBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateBackgroundBrush (PDC pdc)
HFONT NTAPI	DC_hSelectFont (_In_ PDC pdc, _In_ HFONT hlfntNew)
HPALETTE NTAPI	GdiSelectPalette (_In_ HDC hDC, _In_ HPALETTE hpal, _In_ BOOL ForceBackground)
COLORREF FASTCALL	IntGdiSetBkColor (_In_ HDC hDC, _In_ COLORREF Color)
INT FASTCALL	IntGdiSetBkMode (HDC hDC, INT backgroundMode)
COLORREF FASTCALL	IntGdiSetTextColor (HDC hDC, COLORREF color)
UINT FASTCALL	IntGdiSetTextAlign (HDC hDC, UINT Mode)
VOID FASTCALL	DCU_SetDcUndeletable (HDC)
BOOL FASTCALL	IntSetDefaultRegion (PDC)
ULONG	TranslateCOLORREF (PDC pdc, COLORREF crColor)
int FASTCALL	GreSetStretchBltMode (HDC hdc, int iStretchMode)
int FASTCALL	GreGetBkMode (HDC)
int FASTCALL	GreGetMapMode (HDC)
COLORREF FASTCALL	GreGetTextColor (HDC)
COLORREF FASTCALL	GreGetBkColor (HDC)
COLORREF FASTCALL	IntSetDCBrushColor (HDC, COLORREF)
COLORREF FASTCALL	IntSetDCPenColor (HDC, COLORREF)
int FASTCALL	GreGetGraphicsMode (HDC)
BOOL FASTCALL	GreSetBrushOrg (HDC, INT, INT, LPPOINT)
	CODE_SEG ("INIT") NTSTATUS NTAPI InitDcImpl(VOID)
PPDEVOBJ FASTCALL	IntEnumHDev (VOID)
PDC NTAPI	DC_AllocDcWithHandle (GDILOOBJTYPE eDcObjType)
BOOL NTAPI	DC_bAllocDcAttr (PDC pdc)
VOID NTAPI	DC_vCleanup (PVOID ObjectBody)
BOOL FASTCALL	IntGdiDeleteDC (HDC, BOOL)
BOOL FASTCALL	DC_InvertXform (const XFORM *xformSrc, XFORM *xformDest)
VOID FASTCALL	DC_vUpdateViewportExt (PDC pdc)
VOID FASTCALL	DC_vCopyState (PDC pdcSrc, PDC pdcDst, BOOL To)
VOID FASTCALL	DC_vFinishBlit (PDC pdc1, PDC pdc2)
VOID FASTCALL	DC_vPrepareDCsForBlit (PDC pdcDest, const RECT *rcDest, PDC pdcSrc, const RECT *rcSrc)
VOID NTAPI	DC_vRestoreDC (IN PDC pdc, INT iSaveLevel)
VOID NTAPI	DC_vFreeDcAttr (PDC pdc)
VOID NTAPI	DC_vInitDc (PDC pdc, DCTYPE dctype, PPDEVOBJ ppdev)
HDC FASTCALL	IntGdiCreateDisplayDC (HDEV hDev, ULONG DcType, BOOL EmptyDC)
BOOL FASTCALL	IntGdiCleanDC (HDC hDC)
VOID FASTCALL	IntvGetDeviceCaps (PPDEVOBJ, PDEVCAPS)
VOID FASTCALL	IntUpdateBoundsRect (PDC, PRECTL)
BOOL NTAPI	GreSetDCOwner (HDC hdc, ULONG ulOwner)
HDC APIENTRY	GreCreateCompatibleDC (HDC hdc, BOOL bAltDc)
VOID NTAPI	DC_vSetBrushOrigin (PDC pdc, LONG x, LONG y)
FORCEINLINE PDC	DC_LockDc (HDC hdc)
FORCEINLINE VOID	DC_UnlockDc (PDC pdc)
FORCEINLINE VOID	DC_vSelectSurface (PDC pdc, PSURFACE psurfNew)
FORCEINLINE VOID	DC_vSelectFillBrush (PDC pdc, PBRUSH pbrFill)
FORCEINLINE VOID	DC_vSelectLineBrush (PDC pdc, PBRUSH pbrLine)
FORCEINLINE VOID	DC_vSelectPalette (PDC pdc, PPALETTE ppal)

Variables
PDC	defaultDCstate
_Notnull_ PBRUSH	pbrDefaultBrush
_Notnull_ PSURFACE	psurfDefaultBitmap

Macro Definition Documentation

ASSERT_DC_PREPARED

#define ASSERT_DC_PREPARED

(

pdc

)

NT_ASSERT((pdc)->fs & DC_PREPARED)

Definition at line 300 of file dc.h.

DC_FL_PAL_BACK

#define DC_FL_PAL_BACK   1

Definition at line 15 of file dc.h.

Typedef Documentation

DC

typedef struct _DC DC

DCFLAGS

typedef enum _DCFLAGS DCFLAGS

DCLEVEL

typedef struct _DCLEVEL DCLEVEL

DCTYPE

typedef enum _DCTYPE DCTYPE

PDCLEVEL

typedef struct _DCLEVEL * PDCLEVEL

Enumeration Type Documentation

_DCFLAGS

enum _DCFLAGS

Enumerator
DC_DISPLAY
DC_DIRECT
DC_CANCELED
DC_PERMANANT
DC_DIRTY_RAO
DC_ACCUM_WMGR
DC_ACCUM_APP
DC_RESET
DC_SYNCHRONIZEACCESS
DC_EPSPRINTINGESCAPE
DC_TEMPINFODC
DC_FULLSCREEN
DC_IN_CLONEPDEV
DC_REDIRECTION
DC_SHAREACCESS

Definition at line 17 of file dc.h.

{
    DC_DISPLAY           = 0x0001,
    DC_DIRECT            = 0x0002,
    DC_CANCELED          = 0x0004,
    DC_PERMANANT         = 0x0008,
    DC_DIRTY_RAO         = 0x0010,
    DC_ACCUM_WMGR        = 0x0020,
    DC_ACCUM_APP         = 0x0040,
    DC_RESET             = 0x0080,
    DC_SYNCHRONIZEACCESS = 0x0100,
    DC_EPSPRINTINGESCAPE = 0x0200,
    DC_TEMPINFODC        = 0x0400,
    DC_FULLSCREEN        = 0x0800,
    DC_IN_CLONEPDEV      = 0x1000,
    DC_REDIRECTION       = 0x2000,
    DC_SHAREACCESS       = 0x4000,
#if DBG
    DC_PREPARED          = 0x8000
#endif
} DCFLAGS;

_DCTYPE

enum _DCTYPE

Enumerator
DCTYPE_DIRECT
DCTYPE_MEMORY
DCTYPE_INFO

Definition at line 39 of file dc.h.

{
    DCTYPE_DIRECT = 0,  /* Normal device context */
    DCTYPE_MEMORY = 1,  /* Memory device context */
    DCTYPE_INFO   = 2,  /* Information context   */
} DCTYPE;

_FONT_STATE

enum _FONT_STATE

Enumerator
DC_DIRTYFONT_XFORM
DC_DIRTYFONT_LFONT
DC_UFI_MAPPING

Definition at line 7 of file dc.h.

{
    DC_DIRTYFONT_XFORM = 1,
    DC_DIRTYFONT_LFONT = 2,
    DC_UFI_MAPPING     = 4
};

Function Documentation

CODE_SEG()

CODE_SEG

(

"INIT"

)

Definition at line 1810 of file Interface.c.

{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
    PDEVICE_OBJECT RawDeviceObject;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT RawFileObject;
    UNICODE_STRING ObjectName;
    UNICODE_STRING SymLink;
 
    NTSTATUS Status;
 
    RtlZeroMemory(&DriverData, sizeof(DRIVER_DATA));
    DriverData.DriverObject = DriverObject;
 
    /* Save the registry key for this driver */
    DriverData.ServiceKey.Length = RegistryPath->Length;
    DriverData.ServiceKey.MaximumLength = RegistryPath->MaximumLength;
    DriverData.ServiceKey.Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool,
                                                                 RegistryPath->MaximumLength,
                                                                 FM_TAG_REGISTRY_DATA);
    if (!DriverData.ServiceKey.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
    RtlCopyUnicodeString(&DriverData.ServiceKey, RegistryPath);
 
    /* Do some initialization */
    ExInitializeFastMutex(&DriverData.FilterAttachLock);
 
    /* Create the main filter manager device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_DISK_FILE_SYSTEM,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("fltmgr IoCreateDevice failed.  Status = %X\n", Status);
        goto Cleanup;
    }
 
    /* Store a global reference so we can access from callbacks */
    DriverData.DeviceObject = DeviceObject;
 
    /* Generate the symbolic link name */
    RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
    Status = IoCreateSymbolicLink(&SymLink, &DeviceName);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
    Status = SetupDispatchAndCallbacksTables(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Initialize the comms objects */
    Status = FltpSetupCommunicationObjects(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
    Status = IoRegisterFsRegistrationChange(DriverObject, FltpFsNotification);
    FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
    if (!NT_SUCCESS(Status))  goto Cleanup;
 
    InitializeListHead(&FilterList);
    ExInitializeResourceLite(&FilterListLock);
 
    /* IoRegisterFsRegistrationChange isn't notified about the raw  file systems, so we attach to them manually */
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    /* We're done, clear the initializing flag */
    ClearFlag(DeviceObject->Flags, DO_DEVICE_INITIALIZING);
    Status = STATUS_SUCCESS;
 
Cleanup:
 
    if (!NT_SUCCESS(Status))
    {
        if (DriverData.FastIoDispatch)
        {
            DriverObject->FastIoDispatch = NULL;
            ExFreePoolWithTag(DriverData.FastIoDispatch, FM_TAG_DISPATCH_TABLE);
        }
 
        IoDeleteSymbolicLink(&SymLink);
 
        if (DeviceObject)
            IoDeleteDevice(DeviceObject);
 
        if (DriverData.ServiceKey.Buffer)
            ExFreePoolWithTag(DriverData.ServiceKey.Buffer, FM_TAG_REGISTRY_DATA);
    }
 
    return Status;
}

DC_AllocDcWithHandle()

PDC NTAPI DC_AllocDcWithHandle

(

GDILOOBJTYPE

eDcObjType

)

Definition at line 69 of file dclife.c.

{
    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);
    if (!pdc)
    {
        DPRINT1("Could not allocate a DC.\n");
        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");
        GDIOBJ_vFreeObject(&pdc->BaseObject);
        return NULL;
    }
 
    return pdc;
}

Referenced by GreCreateCompatibleDC(), GreOpenDCW(), and NtGdiSaveDC().

DC_bAllocDcAttr()

BOOL NTAPI DC_bAllocDcAttr

(

PDC

pdc

)

Definition at line 31 of file dcattr.c.

{
    PPROCESSINFO ppi;
    PDC_ATTR pdcattr;
 
    ppi = PsGetCurrentProcessWin32Process();
    ASSERT(ppi);
 
    pdcattr = GdiPoolAllocate(ppi->pPoolDcAttr);
    if (!pdcattr)
    {
        DPRINT1("Could not allocate DC attr\n");
        return FALSE;
    }
 
    /* Copy the content from the kernel mode dc attr */
    pdc->pdcattr = pdcattr;
    *pdc->pdcattr = pdc->dcattr;
 
    /* Set the object attribute in the handle table */
    GDIOBJ_vSetObjectAttr(&pdc->BaseObject, pdcattr);
 
    DPRINT("DC_AllocDcAttr: pdc=%p, pdc->pdcattr=%p\n", pdc, pdc->pdcattr);
    return TRUE;
}

Referenced by DC_vSetOwner(), GreCreateCompatibleDC(), and GreOpenDCW().

DC_hSelectFont()

HFONT NTAPI DC_hSelectFont	(	_In_ PDC	pdc,
		_In_ HFONT	hlfntNew
	)

Definition at line 550 of file dcobjs.c.

{
    PLFONT plfntNew;
    HFONT hlfntOld;
 
    // Legacy crap that will die with font engine rewrite
    if (!NT_SUCCESS(TextIntRealizeFont(hlfntNew, NULL)))
    {
        return NULL;
    }
 
    /* Get the current selected font */
    hlfntOld = pdc->dclevel.plfnt->BaseObject.hHmgr;
 
    /* Check if a new font should be selected */
    if (hlfntNew != hlfntOld)
    {
        /* Lock the new font */
        plfntNew = LFONT_ShareLockFont(hlfntNew);
        if (plfntNew)
        {
            /* Success, dereference the old font */
            LFONT_ShareUnlockFont(pdc->dclevel.plfnt);
 
            /* Select the new font */
            pdc->dclevel.plfnt = plfntNew;
            pdc->pdcattr->hlfntNew = hlfntNew;
 
            /* Update dirty flags */
            pdc->pdcattr->ulDirty_ |= DIRTY_CHARSET;
            pdc->pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
        }
        else
        {
            /* Failed, restore old, return NULL */
            pdc->pdcattr->hlfntNew = hlfntOld;
            hlfntOld = NULL;
        }
    }
 
    return hlfntOld;
}

Referenced by GdiFlushUserBatch(), and NtGdiSelectFont().

DC_InvertXform()

BOOL FASTCALL DC_InvertXform	(	const XFORM *	xformSrc,
		XFORM *	xformDest
	)

DC_LockDc()

FORCEINLINE PDC DC_LockDc

(

HDC

hdc

)

Definition at line 220 of file dc.h.

{
    PDC pdc;
 
    pdc = (PDC)GDIOBJ_LockObject(hdc, GDIObjType_DC_TYPE);
    if (pdc)
    {
        ASSERT((GDI_HANDLE_GET_TYPE(pdc->BaseObject.hHmgr) == GDILoObjType_LO_DC_TYPE) ||
               (GDI_HANDLE_GET_TYPE(pdc->BaseObject.hHmgr) == GDILoObjType_LO_ALTDC_TYPE));
        ASSERT(pdc->dclevel.plfnt != NULL);
        ASSERT(GDI_HANDLE_GET_TYPE(((POBJ)pdc->dclevel.plfnt)->hHmgr) == GDILoObjType_LO_FONT_TYPE);
    }
 
    return pdc;
}

Referenced by _Success_(), DC_vRestoreDC(), DceResetActiveDCEs(), DCU_SetDcUndeletable(), DxEngGetDCState(), DxEngLockDC(), DxEngSetDCState(), ftGdiGetTextMetricsW(), GdiPolyDraw(), GdiSelectPalette(), GdiSelectVisRgn(), GreCreateCompatibleDC(), GreCreateDIBitmapInternal(), GreDPtoLP(), GreExtTextOutW(), GreGetBkColor(), GreGetBkMode(), GreGetDCOrgEx(), GreGetDCPoint(), GreGetDIBitsInternal(), GreGetGraphicsMode(), GreGetKerningPairs(), GreGetMapMode(), GreGetSetColorTable(), GreGetTextColor(), GreGetTextExtentExW(), GreGetTextExtentW(), GreGradientFill(), GreLPtoDP(), GreMovePointer(), GreMoveTo(), GreSetBrushOrg(), GreSetDCOrg(), GreSetDCOwner(), GreSetPointerShape(), GreSetStretchBltMode(), GreSetViewportOrgEx(), IntAnimatePalette(), IntGdiCleanDC(), IntGdiDeleteDC(), IntGdiPolyPatBlt(), IntGdiRealizePalette(), IntGdiSetBkColor(), IntGdiSetBkMode(), IntGdiSetHookFlags(), IntGdiSetTextAlign(), IntGdiSetTextColor(), IntGetCharDimensions(), IntGetSystemPaletteEntries(), IntPaintDesktop(), IntPolygon(), IntSetDCBrushColor(), IntSetDCPenColor(), NtGdiAbortPath(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiBeginPath(), NtGdiCloseFigure(), NtGdiCreateCompatibleBitmap(), NtGdiCreateDIBSection(), NtGdiCreateHalftonePalette(), NtGdiEllipse(), NtGdiEndPath(), NtGdiEscape(), NtGdiExcludeClipRect(), NtGdiExtEscape(), NtGdiExtFloodFill(), NtGdiExtSelectClipRgn(), NtGdiFillPath(), NtGdiFillRgn(), NtGdiFlattenPath(), NtGdiFlushUserBatch(), NtGdiGetBoundsRect(), NtGdiGetCharABCWidthsW(), NtGdiGetCharSet(), NtGdiGetCharWidthW(), NtGdiGetDCDword(), NtGdiGetDCObject(), NtGdiGetDeviceCaps(), NtGdiGetDeviceGammaRamp(), NtGdiGetDeviceWidth(), NtGdiGetFontData(), NtGdiGetFontUnicodeRanges(), NtGdiGetGlyphIndicesW(), NtGdiGetGlyphOutline(), NtGdiGetKerningPairs(), NtGdiGetNearestColor(), NtGdiGetOutlineTextMetricsInternalW(), NtGdiGetPath(), NtGdiGetPixel(), NtGdiGetRandomRgn(), NtGdiGetRealizationInfo(), NtGdiGetTextCharsetInfo(), NtGdiGetTextExtentExW(), NtGdiGetTextFaceW(), NtGdiGetTransform(), NtGdiIntersectClipRect(), NtGdiInvertRgn(), NtGdiLineTo(), NtGdiMakeInfoDC(), NtGdiMirrorWindowOrg(), NtGdiModifyWorldTransform(), NtGdiOffsetClipRgn(), NtGdiOffsetViewportOrgEx(), NtGdiOffsetWindowOrgEx(), NtGdiPatBlt(), NtGdiPathToRegion(), NtGdiPolyPolyDraw(), NtGdiPtVisible(), NtGdiRectangle(), NtGdiRectVisible(), NtGdiRestoreDC(), NtGdiRoundRect(), NtGdiSaveDC(), NtGdiScaleViewportExtEx(), NtGdiScaleWindowExtEx(), NtGdiSelectBitmap(), NtGdiSelectBrush(), NtGdiSelectClipPath(), NtGdiSelectFont(), NtGdiSelectPen(), NtGdiSetBoundsRect(), NtGdiSetColorSpace(), NtGdiSetDeviceGammaRamp(), NtGdiSetDIBitsToDeviceInternal(), NtGdiSetLayout(), NtGdiSetMetaRgn(), NtGdiSetMiterLimit(), NtGdiSetPixel(), NtGdiSetPixelFormat(), NtGdiSetSizeDevice(), NtGdiSetTextJustification(), NtGdiSetViewportOrgEx(), NtGdiSetVirtualResolution(), NtGdiSetWindowOrgEx(), NtGdiStretchDIBitsInternal(), NtGdiStrokeAndFillPath(), NtGdiStrokePath(), NtGdiSwapBuffers(), NtGdiTransformPoints(), NtGdiWidenPath(), NtUserEnumDisplayMonitors(), UserDrawIconEx(), and UserScrollDC().

DC_UnlockDc()

FORCEINLINE VOID DC_UnlockDc

(

PDC

pdc

)

Definition at line 238 of file dc.h.

{
    ASSERT(pdc->dclevel.plfnt != NULL);
    ASSERT(GDI_HANDLE_GET_TYPE(((POBJ)pdc->dclevel.plfnt)->hHmgr) == GDILoObjType_LO_FONT_TYPE);
 
    GDIOBJ_vUnlockObject(&pdc->BaseObject);
}

Referenced by _Success_(), DC_vRestoreDC(), DceResetActiveDCEs(), DCU_SetDcUndeletable(), DxEngGetDCState(), DxEngSetDCState(), DxEngUnlockDC(), ftGdiGetTextMetricsW(), GdiPolyDraw(), GdiSelectPalette(), GdiSelectVisRgn(), GreCreateCompatibleDC(), GreCreateDIBitmapInternal(), GreDPtoLP(), GreExtTextOutW(), GreGetBkColor(), GreGetBkMode(), GreGetDCOrgEx(), GreGetDCPoint(), GreGetDIBitsInternal(), GreGetGraphicsMode(), GreGetKerningPairs(), GreGetMapMode(), GreGetSetColorTable(), GreGetTextColor(), GreGetTextExtentExW(), GreGetTextExtentW(), GreGradientFill(), GreLPtoDP(), GreMovePointer(), GreMoveTo(), GreOpenDCW(), GreSetBrushOrg(), GreSetDCOrg(), GreSetDCOwner(), GreSetPointerShape(), GreSetStretchBltMode(), GreSetViewportOrgEx(), GreStretchBltMask(), IntAnimatePalette(), IntGdiCleanDC(), IntGdiDeleteDC(), IntGdiPolyPatBlt(), IntGdiRealizePalette(), IntGdiSetBkColor(), IntGdiSetBkMode(), IntGdiSetHookFlags(), IntGdiSetTextAlign(), IntGdiSetTextColor(), IntGetCharDimensions(), IntGetSystemPaletteEntries(), IntPaintDesktop(), IntPolygon(), IntSetDCBrushColor(), IntSetDCPenColor(), NtGdiAbortPath(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiBeginPath(), NtGdiCloseFigure(), NtGdiCreateCompatibleBitmap(), NtGdiCreateDIBSection(), NtGdiCreateHalftonePalette(), NtGdiEllipse(), NtGdiEndPath(), NtGdiEscape(), NtGdiExcludeClipRect(), NtGdiExtEscape(), NtGdiExtFloodFill(), NtGdiExtSelectClipRgn(), NtGdiFillPath(), NtGdiFillRgn(), NtGdiFlattenPath(), NtGdiFlushUserBatch(), NtGdiGetBoundsRect(), NtGdiGetCharABCWidthsW(), NtGdiGetCharSet(), NtGdiGetCharWidthW(), NtGdiGetDCDword(), NtGdiGetDCObject(), NtGdiGetDeviceCaps(), NtGdiGetDeviceGammaRamp(), NtGdiGetDeviceWidth(), NtGdiGetFontData(), NtGdiGetFontUnicodeRanges(), NtGdiGetGlyphIndicesW(), NtGdiGetGlyphOutline(), NtGdiGetKerningPairs(), NtGdiGetNearestColor(), NtGdiGetOutlineTextMetricsInternalW(), NtGdiGetPath(), NtGdiGetPixel(), NtGdiGetRandomRgn(), NtGdiGetRealizationInfo(), NtGdiGetTextCharsetInfo(), NtGdiGetTextExtentExW(), NtGdiGetTextFaceW(), NtGdiGetTransform(), NtGdiIntersectClipRect(), NtGdiInvertRgn(), NtGdiLineTo(), NtGdiMakeInfoDC(), NtGdiMaskBlt(), NtGdiMirrorWindowOrg(), NtGdiModifyWorldTransform(), NtGdiOffsetClipRgn(), NtGdiOffsetViewportOrgEx(), NtGdiOffsetWindowOrgEx(), NtGdiPatBlt(), NtGdiPathToRegion(), NtGdiPolyPolyDraw(), NtGdiPtVisible(), NtGdiRectangle(), NtGdiRectVisible(), NtGdiRestoreDC(), NtGdiRoundRect(), NtGdiSaveDC(), NtGdiScaleViewportExtEx(), NtGdiScaleWindowExtEx(), NtGdiSelectBitmap(), NtGdiSelectBrush(), NtGdiSelectClipPath(), NtGdiSelectFont(), NtGdiSelectPen(), NtGdiSetBoundsRect(), NtGdiSetColorSpace(), NtGdiSetDeviceGammaRamp(), NtGdiSetDIBitsToDeviceInternal(), NtGdiSetLayout(), NtGdiSetMetaRgn(), NtGdiSetMiterLimit(), NtGdiSetPixel(), NtGdiSetPixelFormat(), NtGdiSetSizeDevice(), NtGdiSetTextJustification(), NtGdiSetViewportOrgEx(), NtGdiSetVirtualResolution(), NtGdiSetWindowOrgEx(), NtGdiStretchDIBitsInternal(), NtGdiStrokeAndFillPath(), NtGdiStrokePath(), NtGdiSwapBuffers(), NtGdiTransformPoints(), NtGdiWidenPath(), NtUserEnumDisplayMonitors(), UserDrawIconEx(), and UserScrollDC().

DC_vCleanup()

VOID NTAPI DC_vCleanup

(

PVOID

ObjectBody

)

Definition at line 357 of file dclife.c.

{
    PDC pdc = (PDC)ObjectBody;
 
    /* Free DC_ATTR */
    DC_vFreeDcAttr(pdc);
 
    /* Delete saved DCs */
    DC_vRestoreDC(pdc, 1);
 
    /* Deselect dc objects */
    DC_vSelectSurface(pdc, NULL);
    DC_vSelectFillBrush(pdc, NULL);
    DC_vSelectLineBrush(pdc, NULL);
    DC_vSelectPalette(pdc, NULL);
 
    /* Cleanup the dc brushes */
    EBRUSHOBJ_vCleanup(&pdc->eboFill);
    EBRUSHOBJ_vCleanup(&pdc->eboLine);
    EBRUSHOBJ_vCleanup(&pdc->eboText);
    EBRUSHOBJ_vCleanup(&pdc->eboBackground);
 
    /* Release font */
    if (pdc->dclevel.plfnt)
        LFONT_ShareUnlockFont(pdc->dclevel.plfnt);
 
    /*  Free regions */
    if (pdc->dclevel.prgnClip)
        REGION_Delete(pdc->dclevel.prgnClip);
    if (pdc->dclevel.prgnMeta)
        REGION_Delete(pdc->dclevel.prgnMeta);
    if (pdc->prgnVis)
        REGION_Delete(pdc->prgnVis);
    if (pdc->prgnRao)
        REGION_Delete(pdc->prgnRao);
    if (pdc->prgnAPI)
        REGION_Delete(pdc->prgnAPI);
 
    /* Free CLIPOBJ resources */
    IntEngFreeClipResources(&pdc->co);
 
    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);
 
    if (pdc->ppdev)
        PDEVOBJ_vRelease(pdc->ppdev);
}

DC_vCopyState()

VOID FASTCALL DC_vCopyState	(	PDC	pdcSrc,
		PDC	pdcDst,
		BOOL	To
	)

Todo:

should aways be != NULL

Definition at line 16 of file dcstate.c.

{
    DPRINT("DC_vCopyState(%p, %p)\n", pdcSrc->BaseObject.hHmgr, pdcDst->BaseObject.hHmgr);
 
    /* Copy full DC attribute */
    *pdcDst->pdcattr = *pdcSrc->pdcattr;
 
    /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
    /* The VisRectRegion field needs to be set to a valid state */
 
    /* Mark some fields as dirty */
    pdcDst->pdcattr->ulDirty_ |= (DIRTY_FILL|DIRTY_LINE|DIRTY_TEXT|DIRTY_BACKGROUND|DIRTY_CHARSET|DC_ICM_NOT_CALIBRATED|DC_ICM_NOT_SET); // Note: Use if, To is FALSE....
 
    /* Copy DC level */
    pdcDst->dclevel.pColorSpace     = pdcSrc->dclevel.pColorSpace;
    pdcDst->dclevel.laPath          = pdcSrc->dclevel.laPath;
    pdcDst->dclevel.ca              = pdcSrc->dclevel.ca;
    pdcDst->dclevel.mxWorldToDevice = pdcSrc->dclevel.mxWorldToDevice;
    pdcDst->dclevel.mxDeviceToWorld = pdcSrc->dclevel.mxDeviceToWorld;
    pdcDst->dclevel.mxWorldToPage   = pdcSrc->dclevel.mxWorldToPage;
    pdcDst->dclevel.efM11PtoD       = pdcSrc->dclevel.efM11PtoD;
    pdcDst->dclevel.efM22PtoD       = pdcSrc->dclevel.efM22PtoD;
    pdcDst->dclevel.sizl            = pdcSrc->dclevel.sizl;
    pdcDst->dclevel.hpal            = pdcSrc->dclevel.hpal;
 
    /* Handle references here correctly */
    DC_vSelectFillBrush(pdcDst, pdcSrc->dclevel.pbrFill);
    DC_vSelectLineBrush(pdcDst, pdcSrc->dclevel.pbrLine);
    DC_vSelectPalette(pdcDst, pdcSrc->dclevel.ppal);
 
    /* Dereference the old font, reference the new one */
    if (pdcDst->dclevel.plfnt) LFONT_ShareUnlockFont(pdcDst->dclevel.plfnt); 
    GDIOBJ_vReferenceObjectByPointer(&pdcSrc->dclevel.plfnt->BaseObject);
    pdcDst->dclevel.plfnt           = pdcSrc->dclevel.plfnt;
 
    /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
    if (!To)
    {
        IntGdiExtSelectClipRgn(pdcDst, pdcSrc->dclevel.prgnClip, RGN_COPY);
        if (pdcDst->dclevel.prgnMeta)
        {
            REGION_Delete(pdcDst->dclevel.prgnMeta);
            pdcDst->dclevel.prgnMeta = NULL;
        }
        /* The only way to reset the Meta Region to its original state is to return to a previously saved version of the DC with SaveDC. */
        if (pdcSrc->dclevel.prgnMeta)
        {
            pdcDst->dclevel.prgnMeta = IntSysCreateRectpRgn(0, 0, 0, 0);
            IntGdiCombineRgn(pdcDst->dclevel.prgnMeta, pdcSrc->dclevel.prgnMeta, NULL, RGN_COPY);
        }
        pdcDst->fs |= DC_DIRTY_RAO;
    }
}

Referenced by DC_InitHack(), DC_vRestoreDC(), IntGdiCleanDC(), and NtGdiSaveDC().

DC_vFinishBlit()

VOID FASTCALL DC_vFinishBlit	(	PDC	pdc1,
		PDC	pdc2
	)

Definition at line 614 of file dclife.c.

{
    if (pdc1->dctype == DCTYPE_DIRECT)
    {
        MouseSafetyOnDrawEnd(pdc1->ppdev);
        EngReleaseSemaphore(pdc1->ppdev->hsemDevLock);
    }
#if DBG
    pdc1->fs &= ~DC_PREPARED;
#endif
 
    if (pdc2)
    {
        if (pdc2->dctype == DCTYPE_DIRECT)
        {
            MouseSafetyOnDrawEnd(pdc2->ppdev);
            EngReleaseSemaphore(pdc2->ppdev->hsemDevLock);
        }
#if DBG
        pdc2->fs &= ~DC_PREPARED;
#endif
    }
}

Referenced by GreGradientFill(), GreStretchBltMask(), IntExtTextOutW(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntGdiPolyline(), IntPatBlt(), IntRectangle(), IntRoundRect(), NtGdiAlphaBlend(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiExtFloodFill(), NtGdiFillPath(), NtGdiGetPixel(), NtGdiLineTo(), NtGdiMaskBlt(), NtGdiPolyPolyDraw(), NtGdiSetDIBitsToDeviceInternal(), NtGdiStretchDIBitsInternal(), NtGdiStrokeAndFillPath(), NtGdiStrokePath(), NtGdiTransparentBlt(), and UserDrawIconEx().

DC_vFreeDcAttr()

VOID NTAPI DC_vFreeDcAttr

(

PDC

pdc

)

Definition at line 59 of file dcattr.c.

{
    PPROCESSINFO ppi;
 
    if (pdc->pdcattr == &pdc->dcattr)
    {
        // Internal DC object!
        return;
    }
 
    /* Reset the object attribute in the handle table */
    GDIOBJ_vSetObjectAttr(&pdc->BaseObject, NULL);
 
    ppi = PsGetCurrentProcessWin32Process();
    ASSERT(ppi);
    GdiPoolFree(ppi->pPoolDcAttr, pdc->pdcattr);
 
    /* Reset to kmode dcattr */
    pdc->pdcattr = &pdc->dcattr;
}

Referenced by DC_vCleanup(), and DC_vSetOwner().

DC_vInitDc()

VOID NTAPI DC_vInitDc	(	PDC	pdc,
		DCTYPE	dctype,
		PPDEVOBJ	ppdev
	)

Definition at line 129 of file dclife.c.

{
    /* Setup some basic fields */
    pdc->dctype = dctype;
    pdc->ppdev = ppdev;
    pdc->dhpdev = ppdev->dhpdev;
    pdc->hsem = ppdev->hsemDevLock;
    pdc->flGraphicsCaps = ppdev->devinfo.flGraphicsCaps;
    pdc->flGraphicsCaps2 = ppdev->devinfo.flGraphicsCaps2;
    pdc->fs = DC_DIRTY_RAO;
 
    /* Setup dc attribute */
    pdc->pdcattr = &pdc->dcattr;
    pdc->dcattr.pvLDC = NULL;
    pdc->dcattr.ulDirty_ = DIRTY_DEFAULT;
    if (ppdev == gpmdev->ppdevGlobal)
        pdc->dcattr.ulDirty_ |= DC_PRIMARY_DISPLAY;
 
    /* Setup the DC size */
    if (dctype == DCTYPE_MEMORY)
    {
        /* Memory DCs have a 1 x 1 bitmap by default */
        pdc->dclevel.sizl.cx = 1;
        pdc->dclevel.sizl.cy = 1;
    }
    else
    {
        /* Other DC's are as big as the related PDEV */
        pdc->dclevel.sizl.cx = ppdev->gdiinfo.ulHorzRes;
        pdc->dclevel.sizl.cy = ppdev->gdiinfo.ulVertRes;
    }
 
    /* Setup Window rect based on DC size */
    pdc->erclWindow.left = 0;
    pdc->erclWindow.top = 0;
    pdc->erclWindow.right = pdc->dclevel.sizl.cx;
    pdc->erclWindow.bottom = pdc->dclevel.sizl.cy;
 
    if (dctype == DCTYPE_DIRECT)
    {
        /* Direct DCs get the surface from the PDEV */
        pdc->dclevel.pSurface = PDEVOBJ_pSurface(ppdev);
 
        pdc->erclBounds.left = 0x7fffffff;
        pdc->erclBounds.top = 0x7fffffff;
        pdc->erclBounds.right = 0x80000000;
        pdc->erclBounds.bottom = 0x80000000;
        pdc->erclBoundsApp.left = 0xffffffff;
        pdc->erclBoundsApp.top = 0xfffffffc;
        pdc->erclBoundsApp.right = 0x00007ffc; // FIXME
        pdc->erclBoundsApp.bottom = 0x00000333; // FIXME
        pdc->erclClip = pdc->erclBounds;
        pdc->co = gxcoTrivial;
    }
    else
    {
        /* Non-direct DCs don't have a surface by default */
        pdc->dclevel.pSurface = NULL;
 
        pdc->erclBounds.left = 0;
        pdc->erclBounds.top = 0;
        pdc->erclBounds.right = 0;
        pdc->erclBounds.bottom = 0;
        pdc->erclBoundsApp = pdc->erclBounds;
        pdc->erclClip = pdc->erclWindow;
        pdc->co = gxcoTrivial;
    }
 
      //pdc->dcattr.VisRectRegion:
 
    /* Setup coordinate transformation data */
    pdc->dclevel.mxWorldToDevice = gmxWorldToDeviceDefault;
    pdc->dclevel.mxDeviceToWorld = gmxDeviceToWorldDefault;
    pdc->dclevel.mxWorldToPage = gmxWorldToPageDefault;
    pdc->dclevel.efM11PtoD = gef16;
    pdc->dclevel.efM22PtoD = gef16;
    pdc->dclevel.efDxPtoD = gef0;
    pdc->dclevel.efDyPtoD = gef0;
    pdc->dclevel.efM11_TWIPS = gef0;
    pdc->dclevel.efM22_TWIPS = gef0;
    pdc->dclevel.efPr11 = gef0;
    pdc->dclevel.efPr22 = gef0;
    pdc->dcattr.mxWorldToDevice = pdc->dclevel.mxWorldToDevice;
    pdc->dcattr.mxDeviceToWorld = pdc->dclevel.mxDeviceToWorld;
    pdc->dcattr.mxWorldToPage = pdc->dclevel.mxWorldToPage;
    pdc->dcattr.efM11PtoD = pdc->dclevel.efM11PtoD;
    pdc->dcattr.efM22PtoD = pdc->dclevel.efM22PtoD;
    pdc->dcattr.efDxPtoD = pdc->dclevel.efDxPtoD;
    pdc->dcattr.efDyPtoD = pdc->dclevel.efDyPtoD;
    pdc->dcattr.iMapMode = MM_TEXT;
    pdc->dcattr.dwLayout = 0;
    pdc->dcattr.flXform = PAGE_TO_DEVICE_SCALE_IDENTITY |
                          PAGE_TO_DEVICE_IDENTITY |
                          WORLD_TO_PAGE_IDENTITY;
 
    /* Setup more coordinates */
    pdc->ptlDCOrig.x = 0;
    pdc->ptlDCOrig.y = 0;
    pdc->dcattr.lWindowOrgx = 0;
    pdc->dcattr.ptlWindowOrg.x = 0;
    pdc->dcattr.ptlWindowOrg.y = 0;
    pdc->dcattr.szlWindowExt.cx = 1;
    pdc->dcattr.szlWindowExt.cy = 1;
    pdc->dcattr.ptlViewportOrg.x = 0;
    pdc->dcattr.ptlViewportOrg.y = 0;
    pdc->dcattr.szlViewportExt.cx = 1;
    pdc->dcattr.szlViewportExt.cy = 1;
    pdc->dcattr.szlVirtualDevicePixel.cx = ppdev->gdiinfo.ulHorzRes;
    pdc->dcattr.szlVirtualDevicePixel.cy = ppdev->gdiinfo.ulVertRes;
    pdc->dcattr.szlVirtualDeviceMm.cx = ppdev->gdiinfo.ulHorzSize;
    pdc->dcattr.szlVirtualDeviceMm.cy = ppdev->gdiinfo.ulVertSize;
    pdc->dcattr.szlVirtualDeviceSize.cx = 0;
    pdc->dcattr.szlVirtualDeviceSize.cy = 0;
 
    /* Setup regions */
    pdc->prgnAPI = NULL;
    pdc->prgnRao = NULL;
    pdc->dclevel.prgnClip = NULL;
    pdc->dclevel.prgnMeta = NULL;
    /* Allocate a Vis region */
    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);
 
    /* Setup palette */
    pdc->dclevel.hpal = StockObjects[DEFAULT_PALETTE];
    pdc->dclevel.ppal = PALETTE_ShareLockPalette(pdc->dclevel.hpal);
 
    /* Setup path */
    pdc->dclevel.hPath = NULL;
    pdc->dclevel.flPath = 0;
//  pdc->dclevel.lapath:
 
    /* Setup colors */
    pdc->dcattr.crBackgroundClr = RGB(0xff, 0xff, 0xff);
    pdc->dcattr.ulBackgroundClr = RGB(0xff, 0xff, 0xff);
    pdc->dcattr.crForegroundClr = RGB(0, 0, 0);
    pdc->dcattr.ulForegroundClr = RGB(0, 0, 0);
    pdc->dcattr.crBrushClr = RGB(0xff, 0xff, 0xff);
    pdc->dcattr.ulBrushClr = RGB(0xff, 0xff, 0xff);
    pdc->dcattr.crPenClr = RGB(0, 0, 0);
    pdc->dcattr.ulPenClr = RGB(0, 0, 0);
 
    /* Select the default fill and line brush */
    pdc->dcattr.hbrush = StockObjects[WHITE_BRUSH];
    pdc->dcattr.hpen = StockObjects[BLACK_PEN];
    pdc->dclevel.pbrFill = BRUSH_ShareLockBrush(pdc->pdcattr->hbrush);
    pdc->dclevel.pbrLine = PEN_ShareLockPen(pdc->pdcattr->hpen);
    pdc->dclevel.ptlBrushOrigin.x = 0;
    pdc->dclevel.ptlBrushOrigin.y = 0;
    pdc->dcattr.ptlBrushOrigin = pdc->dclevel.ptlBrushOrigin;
 
    /* Initialize EBRUSHOBJs */
    EBRUSHOBJ_vInitFromDC(&pdc->eboFill, pdc->dclevel.pbrFill, pdc);
    EBRUSHOBJ_vInitFromDC(&pdc->eboLine, pdc->dclevel.pbrLine, pdc);
    EBRUSHOBJ_vInitFromDC(&pdc->eboText, pbrDefaultBrush, pdc);
    EBRUSHOBJ_vInitFromDC(&pdc->eboBackground, pbrDefaultBrush, pdc);
 
    /* Setup fill data */
    pdc->dcattr.jROP2 = R2_COPYPEN;
    pdc->dcattr.jBkMode = 2;
    pdc->dcattr.lBkMode = 2;
    pdc->dcattr.jFillMode = ALTERNATE;
    pdc->dcattr.lFillMode = 1;
    pdc->dcattr.jStretchBltMode = 1;
    pdc->dcattr.lStretchBltMode = 1;
    pdc->ptlFillOrigin.x = 0;
    pdc->ptlFillOrigin.y = 0;
 
    /* Setup drawing position */
    pdc->dcattr.ptlCurrent.x = 0;
    pdc->dcattr.ptlCurrent.y = 0;
    pdc->dcattr.ptfxCurrent.x = 0;
    pdc->dcattr.ptfxCurrent.y = 0;
 
    /* Setup ICM data */
    pdc->dclevel.lIcmMode = 0;
    pdc->dcattr.lIcmMode = 0;
    pdc->dcattr.hcmXform = NULL;
    pdc->dcattr.flIcmFlags = 0;
    pdc->dcattr.IcmBrushColor = CLR_INVALID;
    pdc->dcattr.IcmPenColor = CLR_INVALID;
    pdc->dcattr.pvLIcm = NULL;
    pdc->dcattr.hColorSpace = NULL; // FIXME: 0189001f
    pdc->dclevel.pColorSpace = NULL; // FIXME
    pdc->pClrxFormLnk = NULL;
//  pdc->dclevel.ca =
 
    /* Setup font data */
    pdc->hlfntCur = NULL; // FIXME: 2f0a0cf8
    pdc->pPFFList = NULL;
    pdc->flSimulationFlags = 0;
    pdc->lEscapement = 0;
    pdc->prfnt = NULL;
    pdc->dcattr.flFontMapper = 0;
    pdc->dcattr.flTextAlign = 0;
    pdc->dcattr.lTextAlign = 0;
    pdc->dcattr.lTextExtra = 0;
    pdc->dcattr.lRelAbs = 1;
    pdc->dcattr.lBreakExtra = 0;
    pdc->dcattr.cBreak = 0;
    pdc->dcattr.hlfntNew = StockObjects[SYSTEM_FONT];
    pdc->dclevel.plfnt = LFONT_ShareLockFont(pdc->dcattr.hlfntNew);
 
    /* Other stuff */
    pdc->hdcNext = NULL;
    pdc->hdcPrev = NULL;
    pdc->ipfdDevMax = 0;
    pdc->ulCopyCount = -1;
    pdc->ptlDoBanding.x = 0;
    pdc->ptlDoBanding.y = 0;
    pdc->dclevel.lSaveDepth = 1;
    pdc->dclevel.hdcSave = NULL;
    pdc->dcattr.iGraphicsMode = GM_COMPATIBLE;
    pdc->dcattr.iCS_CP = 0;
    pdc->pSurfInfo = NULL;
}

Referenced by GreCreateCompatibleDC(), GreOpenDCW(), and NtGdiSaveDC().

DC_vPrepareDCsForBlit()

VOID FASTCALL DC_vPrepareDCsForBlit	(	PDC	pdcDest,
		const RECT *	rcDest,
		PDC	pdcSrc,
		const RECT *	rcSrc
	)

Definition at line 505 of file dclife.c.

{
    PDC pdcFirst, pdcSecond;
    const RECT *prcFirst, *prcSecond;
 
    /* Update brushes */
    if (pdcDest->pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
        DC_vUpdateFillBrush(pdcDest);
    if (pdcDest->pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
        DC_vUpdateLineBrush(pdcDest);
    if(pdcDest->pdcattr->ulDirty_ & DIRTY_TEXT)
        DC_vUpdateTextBrush(pdcDest);
 
    /* Lock them in good order */
    if (pdcSrc)
    {
        if((ULONG_PTR)pdcDest->ppdev->hsemDevLock >=
           (ULONG_PTR)pdcSrc->ppdev->hsemDevLock)
        {
            pdcFirst = pdcDest;
            prcFirst = rcDest;
            pdcSecond = pdcSrc;
            prcSecond = rcSrc;
        }
        else
        {
            pdcFirst = pdcSrc;
            prcFirst = rcSrc;
            pdcSecond = pdcDest;
            prcSecond = rcDest;
        }
    }
    else
    {
        pdcFirst = pdcDest;
        prcFirst = rcDest;
        pdcSecond = NULL;
        prcSecond = NULL;
    }
 
    if (pdcDest->fs & DC_DIRTY_RAO)
        CLIPPING_UpdateGCRegion(pdcDest);
 
    /* Lock and update first DC */
    if (pdcFirst->dctype == DCTYPE_DIRECT)
    {
        EngAcquireSemaphore(pdcFirst->ppdev->hsemDevLock);
 
        /* Update surface if needed */
        if (pdcFirst->ppdev->pSurface != pdcFirst->dclevel.pSurface)
        {
            DC_vUpdateDC(pdcFirst);
        }
    }
 
    if (pdcFirst->dctype == DCTYPE_DIRECT)
    {
        if (!prcFirst)
            prcFirst = &pdcFirst->erclClip;
 
        MouseSafetyOnDrawStart(pdcFirst->ppdev,
                               prcFirst->left,
                               prcFirst->top,
                               prcFirst->right,
                               prcFirst->bottom) ;
    }
 
#if DBG
    pdcFirst->fs |= DC_PREPARED;
#endif
 
    if (!pdcSecond)
        return;
 
    /* Lock and update second DC */
    if (pdcSecond->dctype == DCTYPE_DIRECT)
    {
        EngAcquireSemaphore(pdcSecond->ppdev->hsemDevLock);
 
        /* Update surface if needed */
        if (pdcSecond->ppdev->pSurface != pdcSecond->dclevel.pSurface)
        {
            DC_vUpdateDC(pdcSecond);
        }
    }
 
    if (pdcSecond->dctype == DCTYPE_DIRECT)
    {
        if (!prcSecond)
            prcSecond = &pdcSecond->erclClip;
        MouseSafetyOnDrawStart(pdcSecond->ppdev,
                               prcSecond->left,
                               prcSecond->top,
                               prcSecond->right,
                               prcSecond->bottom) ;
    }
 
#if DBG
    pdcSecond->fs |= DC_PREPARED;
#endif
}

Referenced by GreGradientFill(), GreStretchBltMask(), IntExtTextOutW(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntGdiPolyline(), IntPatBlt(), IntRectangle(), IntRoundRect(), NtGdiAlphaBlend(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiExtFloodFill(), NtGdiFillPath(), NtGdiGetPixel(), NtGdiLineTo(), NtGdiMaskBlt(), NtGdiPolyPolyDraw(), NtGdiSetDIBitsToDeviceInternal(), NtGdiStretchDIBitsInternal(), NtGdiStrokeAndFillPath(), NtGdiStrokePath(), NtGdiTransparentBlt(), and UserDrawIconEx().

DC_vRestoreDC()

VOID NTAPI DC_vRestoreDC	(	IN PDC	pdc,
		INT	iSaveLevel
	)

Definition at line 138 of file dcstate.c.

{
    HDC hdcSave;
    PDC pdcSave;
 
    NT_ASSERT(iSaveLevel > 0);
    DPRINT("DC_vRestoreDC(%p, %ld)\n", pdc->BaseObject.hHmgr, iSaveLevel);
 
    /* Loop the save levels */
    while (pdc->dclevel.lSaveDepth > iSaveLevel)
    {
        hdcSave = pdc->dclevel.hdcSave;
        DPRINT("RestoreDC = %p\n", hdcSave);
 
        /* Set us as the owner */
        if (!GreSetObjectOwner(hdcSave, GDI_OBJ_HMGR_POWNED))
        {
            /* Could not get ownership. That's bad! */
            DPRINT1("Could not get ownership of saved DC (%p) for hdc %p!\n",
                    hdcSave, pdc->BaseObject.hHmgr);
            NT_ASSERT(FALSE);
            return;// FALSE;
        }
 
        /* Lock the saved dc */
        pdcSave = DC_LockDc(hdcSave);
        if (!pdcSave)
        {
            /* WTF? Internal error! */
            DPRINT1("Could not lock the saved DC (%p) for dc %p!\n",
                    hdcSave, pdc->BaseObject.hHmgr);
            NT_ASSERT(FALSE);
            return;// FALSE;
        }
 
        /* Remove the saved dc from the queue */
        pdc->dclevel.hdcSave = pdcSave->dclevel.hdcSave;
 
        /* Decrement save level */
        pdc->dclevel.lSaveDepth--;
 
        /* Is this the state we want? */
        if (pdc->dclevel.lSaveDepth == iSaveLevel)
        {
            /* Copy the state back */
            DC_vCopyState(pdcSave, pdc, FALSE);
 
            /* Only memory DC's change their surface */
            if (pdc->dctype == DCTYPE_MEMORY)
                DC_vSelectSurface(pdc, pdcSave->dclevel.pSurface);
 
            if (pdcSave->dclevel.hPath)
            {
               PATH_RestorePath( pdc, pdcSave );
            }
        }
 
        /* Prevent save dc from being restored */
        pdcSave->dclevel.lSaveDepth = 1;
 
        /* Unlock it */
        DC_UnlockDc(pdcSave);
        /* Delete the saved dc */
        GreDeleteObject(hdcSave);
    }
 
    DPRINT("Leave DC_vRestoreDC()\n");
}

Referenced by DC_vCleanup(), DC_vSetOwner(), and NtGdiRestoreDC().

DC_vSelectFillBrush()

FORCEINLINE VOID DC_vSelectFillBrush	(	PDC	pdc,
		PBRUSH	pbrFill
	)

Definition at line 263 of file dc.h.

{
    PBRUSH pbrFillOld = pdc->dclevel.pbrFill;
    if (pbrFillOld)
        BRUSH_ShareUnlockBrush(pbrFillOld);
    if (pbrFill)
        GDIOBJ_vReferenceObjectByPointer((POBJ)pbrFill);
    pdc->dclevel.pbrFill = pbrFill;
}

Referenced by DC_vCleanup(), and DC_vCopyState().

DC_vSelectLineBrush()

FORCEINLINE VOID DC_vSelectLineBrush	(	PDC	pdc,
		PBRUSH	pbrLine
	)

Definition at line 275 of file dc.h.

{
    PBRUSH pbrLineOld = pdc->dclevel.pbrLine;
    if (pbrLineOld)
        BRUSH_ShareUnlockBrush(pbrLineOld);
    if (pbrLine)
        GDIOBJ_vReferenceObjectByPointer((POBJ)pbrLine);
    pdc->dclevel.pbrLine = pbrLine;
}

Referenced by DC_vCleanup(), and DC_vCopyState().

DC_vSelectPalette()

FORCEINLINE VOID DC_vSelectPalette	(	PDC	pdc,
		PPALETTE	ppal
	)

Definition at line 287 of file dc.h.

{
    PPALETTE ppalOld = pdc->dclevel.ppal;
    if (ppalOld)
        PALETTE_ShareUnlockPalette(ppalOld);
    if (ppal)
        GDIOBJ_vReferenceObjectByPointer((POBJ)ppal);
    pdc->dclevel.ppal = ppal;
}

Referenced by DC_vCleanup(), DC_vCopyState(), and GdiSelectPalette().

DC_vSelectSurface()

FORCEINLINE VOID DC_vSelectSurface	(	PDC	pdc,
		PSURFACE	psurfNew
	)

Definition at line 248 of file dc.h.

{
    PSURFACE psurfOld = pdc->dclevel.pSurface;
    if (psurfOld)
    {
        psurfOld->hdc = NULL;
        SURFACE_ShareUnlockSurface(psurfOld);
    }
    if (psurfNew)
        GDIOBJ_vReferenceObjectByPointer((POBJ)psurfNew);
    pdc->dclevel.pSurface = psurfNew;
}

Referenced by DC_vCleanup(), DC_vRestoreDC(), and NtGdiSaveDC().

DC_vSetBrushOrigin()

VOID NTAPI DC_vSetBrushOrigin	(	PDC	pdc,
		LONG	x,
		LONG	y
	)

Definition at line 142 of file dcobjs.c.

{
    /* Set the brush origin */
    pdc->dclevel.ptlBrushOrigin.x = x;
    pdc->dclevel.ptlBrushOrigin.y = y;
 
    /* Set the fill origin */
    pdc->ptlFillOrigin.x = x + pdc->ptlDCOrig.x;
    pdc->ptlFillOrigin.y = y + pdc->ptlDCOrig.y;
}

Referenced by GdiFlushUserBatch(), and GreSetBrushOrg().

DC_vUpdateBackgroundBrush()

VOID FASTCALL DC_vUpdateBackgroundBrush

(

PDC

pdc

)

Definition at line 126 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
 
    if(pdcattr->ulDirty_ & DIRTY_BACKGROUND)
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboBackground, pbrDefaultBrush, pdc);
 
    /* Update the eboBackground's solid color */
    EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboBackground, pdcattr->crBackgroundClr);
 
    /* Clear flag */
    pdcattr->ulDirty_ &= ~DIRTY_BACKGROUND;
}

Referenced by GdiFlushUserBatch(), IntExtTextOutW(), and IntGdiCleanDC().

DC_vUpdateFillBrush()

VOID FASTCALL DC_vUpdateFillBrush

(

PDC

pdc

)

Definition at line 16 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
    PBRUSH pbrFill;
 
    /* Check if the brush handle has changed */
    if (pdcattr->hbrush != pdc->dclevel.pbrFill->BaseObject.hHmgr)
    {
        /* Try to lock the new brush */
        pbrFill = BRUSH_ShareLockBrush(pdcattr->hbrush);
        if (pbrFill)
        {
            /* Unlock old brush, set new brush */
            BRUSH_ShareUnlockBrush(pdc->dclevel.pbrFill);
            pdc->dclevel.pbrFill = pbrFill;
 
            /* Mark eboFill as dirty */
            pdcattr->ulDirty_ |= DIRTY_FILL;
        }
        else
        {
            /* Invalid brush handle, restore old one */
            pdcattr->hbrush = pdc->dclevel.pbrFill->BaseObject.hHmgr;
        }
    }
 
    /* Check if the EBRUSHOBJ needs update */
    if (pdcattr->ulDirty_ & DIRTY_FILL)
    {
        /* Update eboFill */
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboFill, pdc->dclevel.pbrFill, pdc);
    }
 
    /* Check for DC brush */
    if (pdcattr->hbrush == StockObjects[DC_BRUSH])
    {
        /* Update the eboFill's solid color */
        EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboFill, pdcattr->crBrushClr);
    }
 
    /* Clear flags */
    pdcattr->ulDirty_ &= ~(DIRTY_FILL | DC_BRUSH_DIRTY);
}

Referenced by DC_vPrepareDCsForBlit(), GdiFlushUserBatch(), GdiPolyDraw(), GreStretchBltMask(), IntGdiCleanDC(), IntGdiFillRgn(), IntGdiPolygon(), IntGdiSetTextColor(), IntRectangle(), IntRoundRect(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiFillPath(), NtGdiGetDCObject(), NtGdiMaskBlt(), NtGdiPatBlt(), NtGdiPolyPolyDraw(), NtGdiSelectBrush(), and NtGdiStrokeAndFillPath().

DC_vUpdateLineBrush()

VOID FASTCALL DC_vUpdateLineBrush

(

PDC

pdc

)

Definition at line 62 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
    PBRUSH pbrLine;
 
    /* Check if the pen handle has changed */
    if (pdcattr->hpen != pdc->dclevel.pbrLine->BaseObject.hHmgr)
    {
        /* Try to lock the new pen */
        pbrLine = PEN_ShareLockPen(pdcattr->hpen);
        if (pbrLine)
        {
            /* Unlock old brush, set new brush */
            BRUSH_ShareUnlockBrush(pdc->dclevel.pbrLine);
            pdc->dclevel.pbrLine = pbrLine;
 
            /* Mark eboLine as dirty */
            pdcattr->ulDirty_ |= DIRTY_LINE;
        }
        else
        {
            /* Invalid pen handle, restore old one */
            pdcattr->hpen = pdc->dclevel.pbrLine->BaseObject.hHmgr;
        }
    }
 
    /* Check if the EBRUSHOBJ needs update */
    if (pdcattr->ulDirty_ & DIRTY_LINE)
    {
        /* Update eboLine */
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboLine, pdc->dclevel.pbrLine, pdc);
    }
 
    /* Check for DC pen */
    if (pdcattr->hpen == StockObjects[DC_PEN])
    {
        /* Update the eboLine's solid color */
        EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboLine, pdcattr->crPenClr);
    }
 
    /* Clear flags */
    pdcattr->ulDirty_ &= ~(DIRTY_LINE | DC_PEN_DIRTY);
}

Referenced by DC_vPrepareDCsForBlit(), GdiPolyDraw(), IntGdiCleanDC(), IntGdiPolygon(), IntGdiSetTextColor(), IntRectangle(), IntRoundRect(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiFillPath(), NtGdiGetDCObject(), NtGdiPolyPolyDraw(), NtGdiSelectPen(), NtGdiStrokeAndFillPath(), and NtGdiStrokePath().

DC_vUpdateTextBrush()

VOID FASTCALL DC_vUpdateTextBrush

(

PDC

pdc

)

Definition at line 108 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
 
    /* Timo : The text brush should never be changed.
     * Jérôme : Yeah, but its palette must be updated anyway! */
    if(pdcattr->ulDirty_ & DIRTY_TEXT)
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboText, pbrDefaultBrush, pdc);
 
    /* Update the eboText's solid color */
    EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboText, pdcattr->crForegroundClr);
 
    /* Clear flag */
    pdcattr->ulDirty_ &= ~DIRTY_TEXT;
}

Referenced by DC_vPrepareDCsForBlit(), GdiFlushUserBatch(), IntExtTextOutW(), IntGdiCleanDC(), and IntGdiSetTextColor().

DC_vUpdateViewportExt()

VOID FASTCALL DC_vUpdateViewportExt

(

PDC

pdc

)

DCU_SetDcUndeletable()

VOID FASTCALL DCU_SetDcUndeletable

(

HDC

hDC

)

Definition at line 322 of file dcutil.c.

{
    PDC dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return;
    }
 
    dc->fs |= DC_PERMANANT;
    DC_UnlockDc(dc);
    return;
}

Referenced by DceAllocDCE().

GdiSelectPalette()

HPALETTE NTAPI GdiSelectPalette	(	_In_ HDC	hDC,
		_In_ HPALETTE	hpal,
		_In_ BOOL	ForceBackground
	)

Referenced by NtGdiStretchDIBitsInternal(), and NtUserSelectPalette().

GreCreateCompatibleDC()

HDC APIENTRY GreCreateCompatibleDC	(	HDC	hdc,
		BOOL	bAltDc
	)

Definition at line 817 of file dclife.c.

{
    GDILOOBJTYPE eDcObjType;
    HDC hdcNew;
    PPDEVOBJ ppdev;
    PDC pdc, pdcNew;
 
    DPRINT("NtGdiCreateCompatibleDC(0x%p)\n", hdc);
 
    /* Did the caller provide a DC? */
    if (hdc)
    {
        /* Yes, try to lock it */
        pdc = DC_LockDc(hdc);
        if (!pdc)
        {
            DPRINT1("Could not lock source DC %p\n", hdc);
            return NULL;
        }
 
        /* Get the pdev from the DC */
        ppdev = pdc->ppdev;
        PDEVOBJ_vReference(ppdev);
 
        /* Unlock the source DC */
        DC_UnlockDc(pdc);
    }
    else
    {
        /* No DC given, get default device */
        ppdev = EngpGetPDEV(NULL);
    }
 
    if (!ppdev)
    {
        DPRINT1("Didn't find a suitable PDEV\n");
        return NULL;
    }
 
    /* Allocate a new DC */
    eDcObjType = bAltDc ? GDILoObjType_LO_ALTDC_TYPE : GDILoObjType_LO_DC_TYPE;
    pdcNew = DC_AllocDcWithHandle(eDcObjType);
    if (!pdcNew)
    {
        DPRINT1("Could not allocate a new DC\n");
        PDEVOBJ_vRelease(ppdev);
        return NULL;
    }
    hdcNew = pdcNew->BaseObject.hHmgr;
 
    /* Lock ppdev and initialize the new DC */
    DC_vInitDc(pdcNew, bAltDc ? DCTYPE_INFO : DCTYPE_MEMORY, ppdev);
    /* FIXME: HACK! */
    DC_InitHack(pdcNew);
 
    /* Allocate a dc attribute */
    DC_bAllocDcAttr(pdcNew);
 
    DC_UnlockDc(pdcNew);
 
    DPRINT("Leave NtGdiCreateCompatibleDC hdcNew = %p\n", hdcNew);
 
    return hdcNew;
}

Referenced by NtGdiCreateCompatibleDC(), and NtGdiCreateMetafileDC().

GreGetBkColor()

COLORREF FASTCALL GreGetBkColor

(

HDC

hdc

)

Definition at line 50 of file dcutil.c.

{
   PDC dc;
   COLORREF crBk;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   crBk = dc->pdcattr->ulBackgroundClr;
   DC_UnlockDc(dc);
   return crBk;
}

Referenced by MENU_DrawMenuItem().

GreGetBkMode()

int FASTCALL GreGetBkMode

(

HDC

hdc

)

Definition at line 35 of file dcutil.c.

{
   PDC dc;
   LONG lBkMode;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   lBkMode = dc->pdcattr->lBkMode;
   DC_UnlockDc(dc);
   return lBkMode;
}

Referenced by MENU_DrawPopupGlyph(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), and UITOOLS95_DrawFrameScroll().

GreGetGraphicsMode()

int FASTCALL GreGetGraphicsMode

(

HDC

hdc

)

Definition at line 306 of file dcutil.c.

{
   PDC dc;
   int GraphicsMode;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   GraphicsMode = dc->pdcattr->iGraphicsMode;
   DC_UnlockDc(dc);
   return GraphicsMode;
}

Referenced by DrawTextExWorker().

GreGetMapMode()

int FASTCALL GreGetMapMode

(

HDC

hdc

)

Definition at line 65 of file dcutil.c.

{
   PDC dc;
   INT iMapMode;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   iMapMode = dc->pdcattr->iMapMode;
   DC_UnlockDc(dc);
   return iMapMode;
}

Referenced by DrawFrameControl().

GreGetTextColor()

COLORREF FASTCALL GreGetTextColor

(

HDC

hdc

)

Definition at line 80 of file dcutil.c.

{
   PDC dc;
   ULONG ulForegroundClr;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   ulForegroundClr = dc->pdcattr->ulForegroundClr;
   DC_UnlockDc(dc);
   return ulForegroundClr;
}

Referenced by MENU_DrawMenuItem(), MENU_DrawPopupGlyph(), TEXT_DrawUnderscore(), UITOOLS95_DrawFrameCaption(), and UITOOLS95_DrawFrameScroll().

GreSetBrushOrg()

BOOL FASTCALL GreSetBrushOrg	(	HDC	hdc,
		INT	x,
		INT	y,
		LPPOINT	pptOut
	)

Definition at line 231 of file dcutil.c.

{
    PDC pdc = DC_LockDc(hdc);
    if (pdc == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pptOut != NULL)
    {
        *pptOut = pdc->pdcattr->ptlBrushOrigin;
    }
 
    pdc->pdcattr->ptlBrushOrigin.x = x;
    pdc->pdcattr->ptlBrushOrigin.y = y;
 
    DC_vSetBrushOrigin(pdc, x, y);
 
    DC_UnlockDc(pdc);
    return TRUE;
}

Referenced by _Success_(), and IntFillWindow().

GreSetDCOwner()

BOOL NTAPI GreSetDCOwner	(	HDC	hdc,
		ULONG	ulOwner
	)

Definition at line 455 of file dclife.c.

{
    PDC pdc;
 
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        DPRINT1("GreSetDCOwner: Could not lock DC\n");
        return FALSE;
    }
 
    /* Call the internal DC function */
    DC_vSetOwner(pdc, ulOwner);
 
    DC_UnlockDc(pdc);
    return TRUE;
}

Referenced by co_IntInitializeDesktopGraphics(), DceAllocDCE(), DceFreeDCE(), DceFreeWindowDCE(), DceReleaseDC(), DxEngSetDCOwner(), IntEndDesktopGraphics(), and UserGetDCEx().

GreSetStretchBltMode()

int FASTCALL GreSetStretchBltMode	(	HDC	hdc,
		int	iStretchMode
	)

Definition at line 283 of file dcutil.c.

{
    PDC pdc;
    PDC_ATTR pdcattr;
    INT oSMode = 0;
 
    pdc = DC_LockDc(hDC);
    if (pdc)
    {
       pdcattr = pdc->pdcattr;
       oSMode = pdcattr->lStretchBltMode;
       pdcattr->lStretchBltMode = iStretchMode;
 
       // Wine returns an error here. We set the default.
       if ((iStretchMode <= 0) || (iStretchMode > MAXSTRETCHBLTMODE)) iStretchMode = WHITEONBLACK;
 
       pdcattr->jStretchBltMode = iStretchMode;
       DC_UnlockDc(pdc);
    }
    return oSMode;
}

IntEnumHDev()

PPDEVOBJ FASTCALL IntEnumHDev

(

VOID

)

Definition at line 38 of file device.c.

{
// I guess we will soon have more than one primary surface.
// This will do for now.
    return gpmdev->ppdevGlobal;
}

IntGdiCleanDC()

BOOL FASTCALL IntGdiCleanDC

(

HDC

hDC

)

Definition at line 73 of file dcstate.c.

{
    PDC dc;
    if (!hDC) return FALSE;
    dc = DC_LockDc(hDC);
    if (!dc) return FALSE;
    // Clean the DC
    if (defaultDCstate)
    {
        DC_vCopyState(defaultDCstate, dc, FALSE);
        /* Update the brushes now, because they reference some objects (the DC palette)
         * Which belong to the current process, and this DC might be used for another process
         * after being cleaned up (for GetDC(0) for instance) */
        DC_vUpdateFillBrush(dc);
        DC_vUpdateBackgroundBrush(dc);
        DC_vUpdateLineBrush(dc);
        DC_vUpdateTextBrush(dc);
    }
 
    // Remove Path and reset flags.
    if (dc->dclevel.hPath)
    {
        DPRINT("Clean DC Remove Path\n");
        if (!PATH_Delete(dc->dclevel.hPath))
        {
           DPRINT1("Failed to remove Path\n");
        }
        dc->dclevel.hPath = 0;
        dc->dclevel.flPath = 0;
    }
 
    /* DC_vCopyState frees the Clip rgn and the Meta rgn. Take care of the other ones
     * There is no need to clear prgnVis, as UserGetDC updates it immediately. */
    if (dc->prgnRao)
        REGION_Delete(dc->prgnRao);
    if (dc->prgnAPI)
        REGION_Delete(dc->prgnAPI);
    dc->prgnRao = dc->prgnAPI = NULL;
 
    dc->fs |= DC_DIRTY_RAO;
 
    DC_UnlockDc(dc);
 
    return TRUE;
}

Referenced by DceReleaseDC(), and DxEngCleanDC().

IntGdiCreateDisplayDC()

HDC FASTCALL IntGdiCreateDisplayDC	(	HDEV	hDev,
		ULONG	DcType,
		BOOL	EmptyDC
	)

Definition at line 1063 of file dclife.c.

{
    HDC hDC;
    UNIMPLEMENTED;
 
    if (DcType == DCTYPE_MEMORY)
        hDC = NtGdiCreateCompatibleDC(NULL); // OH~ Yuck! I think I taste vomit in my mouth!
    else
        hDC = IntGdiCreateDC(NULL, NULL, NULL, NULL, (DcType == DCTYPE_INFO));
 
    return hDC;
}

Referenced by DxEngCreateMemoryDC(), and UserGetDesktopDC().

IntGdiDeleteDC()

BOOL FASTCALL IntGdiDeleteDC	(	HDC	hDC,
		BOOL	Force
	)

Definition at line 892 of file dclife.c.

{
    PDC DCToDelete = DC_LockDc(hDC);
 
    if (DCToDelete == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!Force)
    {
        /* Windows permits NtGdiDeleteObjectApp to delete a permanent DC
         * For some reason, it's still a valid handle, pointing to some kernel data.
         * Not sure if this is a bug, a feature, some cache stuff... Who knows?
         * See NtGdiDeleteObjectApp test for details */
        if (DCToDelete->fs & DC_PERMANANT)
        {
            DC_UnlockDc(DCToDelete);
            if(UserReleaseDC(NULL, hDC, FALSE))
            {
                /* ReactOS feature: Call UserReleaseDC
                 * I don't think Windows does it.
                 * Still, complain, no one should ever call DeleteDC
                 * on a window DC */
                 DPRINT1("No, you naughty application!\n");
                 return TRUE;
            }
            else
            {
                /* This is not a window owned DC.
                 * Force its deletion */
                return IntGdiDeleteDC(hDC, TRUE);
            }
        }
    }
 
    DC_UnlockDc(DCToDelete);
 
    if (GreIsHandleValid(hDC))
    {
        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;
}

Referenced by DceFreeDCE(), DxEngDeleteDC(), IntGdiDeleteDC(), IntUpdateLayeredWindowI(), MENU_DrawBitmapItem(), MENU_DrawMenuItem(), NtGdiDeleteObjectApp(), and SnapWindow().

IntGdiSetBkColor()

COLORREF FASTCALL IntGdiSetBkColor	(	_In_ HDC	hDC,
		_In_ COLORREF	Color
	)

Referenced by DefWndControlColor(), MENU_DrawBitmapItem(), MENU_DrawMenuItem(), and UITOOLS_DrawCheckedRect().

IntGdiSetBkMode()

INT FASTCALL IntGdiSetBkMode	(	HDC	hDC,
		INT	backgroundMode
	)

Definition at line 124 of file dcutil.c.

{
    COLORREF oldMode;
    PDC dc;
    PDC_ATTR pdcattr;
 
    if (!(dc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return CLR_INVALID;
    }
    pdcattr = dc->pdcattr;
    oldMode = pdcattr->lBkMode;
    pdcattr->jBkMode = Mode;
    pdcattr->lBkMode = Mode;
    DC_UnlockDc(dc);
    return oldMode;
}

Referenced by DrawFrameControl(), IntPaintDesktop(), MENU_DrawMenuItem(), MENU_DrawPopupGlyph(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameScroll(), and UserDrawCaptionText().

IntGdiSetTextAlign()

UINT FASTCALL IntGdiSetTextAlign	(	HDC	hDC,
		UINT	Mode
	)

Definition at line 145 of file dcutil.c.

{
    UINT prevAlign;
    DC *dc;
    PDC_ATTR pdcattr;
 
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return GDI_ERROR;
    }
    pdcattr = dc->pdcattr;
    prevAlign = pdcattr->lTextAlign;
    pdcattr->lTextAlign = Mode;
    if (pdcattr->dwLayout & LAYOUT_RTL)
    {
        if ((Mode & TA_CENTER) != TA_CENTER) Mode ^= TA_RIGHT;
    }
    pdcattr->flTextAlign = Mode & TA_MASK;
    DC_UnlockDc(dc);
    return  prevAlign;
}

Referenced by IntPaintDesktop().

IntGdiSetTextColor()

COLORREF FASTCALL IntGdiSetTextColor	(	HDC	hDC,
		COLORREF	color
	)

Definition at line 172 of file dcutil.c.

{
    COLORREF crOldColor;
    PDC pdc;
    PDC_ATTR pdcattr;
 
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return CLR_INVALID;
    }
    pdcattr = pdc->pdcattr;
 
    crOldColor = (COLORREF) pdcattr->ulForegroundClr;
    pdcattr->ulForegroundClr = (ULONG)color;
 
    if (pdcattr->crForegroundClr != color)
    {
        pdcattr->ulDirty_ |= (DIRTY_TEXT|DIRTY_LINE|DIRTY_FILL);
        pdcattr->crForegroundClr = color;
    }
 
    DC_vUpdateTextBrush(pdc);
    DC_vUpdateLineBrush(pdc);
    DC_vUpdateFillBrush(pdc);
 
    DC_UnlockDc(pdc);
 
    return  crOldColor;
}

Referenced by DefWndControlColor(), DrawFrameControl(), IntPaintDesktop(), MENU_DrawMenuItem(), MENU_DrawPopupGlyph(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), UITOOLS95_DrawFrameScroll(), and UserDrawCaptionText().

IntSetDCBrushColor()

COLORREF FASTCALL IntSetDCBrushColor	(	HDC	hdc,
		COLORREF	crColor
	)

Definition at line 206 of file dcutil.c.

{
   COLORREF OldColor = CLR_INVALID;
   PDC dc;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return CLR_INVALID;
   }
   else
   {
      OldColor = (COLORREF) dc->pdcattr->ulBrushClr;
      dc->pdcattr->ulBrushClr = (ULONG) crColor;
 
      if ( dc->pdcattr->crBrushClr != crColor )
      {
         dc->pdcattr->ulDirty_ |= DIRTY_FILL;
         dc->pdcattr->crBrushClr = crColor;
      }
   }
   DC_UnlockDc(dc);
   return OldColor;
}

Referenced by IntDrawDiagEdge().

IntSetDCPenColor()

COLORREF FASTCALL IntSetDCPenColor	(	HDC	hdc,
		COLORREF	crColor
	)

Definition at line 259 of file dcutil.c.

{
   COLORREF OldColor;
   PDC dc;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      return CLR_INVALID;
   }
 
   OldColor = (COLORREF)dc->pdcattr->ulPenClr;
   dc->pdcattr->ulPenClr = (ULONG)crColor;
 
   if (dc->pdcattr->crPenClr != crColor)
   {
      dc->pdcattr->ulDirty_ |= DIRTY_LINE;
      dc->pdcattr->crPenClr = crColor;
   }
   DC_UnlockDc(dc);
   return OldColor;
}

Referenced by IntDrawDiagEdge(), IntDrawMenuBarTemp(), IntDrawRectEdge(), MENU_DrawMenuItem(), NC_DoNCPaint(), and UserDrawCaptionBar().

IntSetDefaultRegion()

BOOL FASTCALL IntSetDefaultRegion

(

PDC

pdc

)

Definition at line 350 of file dcutil.c.

{
    PSURFACE pSurface;
    PREGION prgn;
    RECTL rclWnd, rclClip;
 
    IntGdiReleaseRaoRgn(pdc);
 
    rclWnd.left   = 0;
    rclWnd.top    = 0;
    rclWnd.right  = pdc->dclevel.sizl.cx;
    rclWnd.bottom = pdc->dclevel.sizl.cy;
    rclClip = rclWnd;
 
    //EngAcquireSemaphoreShared(pdc->ppdev->hsemDevLock);
    if (pdc->ppdev->flFlags & PDEV_META_DEVICE)
    {
        pSurface = pdc->dclevel.pSurface;
        if (pSurface && pSurface->flags & PDEV_SURFACE)
        {
            rclClip.left   += pdc->ppdev->ptlOrigion.x;
            rclClip.top    += pdc->ppdev->ptlOrigion.y;
            rclClip.right  += pdc->ppdev->ptlOrigion.x;
            rclClip.bottom += pdc->ppdev->ptlOrigion.y;
        }
    }
    //EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
 
    prgn = pdc->prgnVis;
 
    if (prgn && prgn != prgnDefault)
    {
        REGION_SetRectRgn( prgn,
                           rclClip.left,
                           rclClip.top,
                           rclClip.right ,
                           rclClip.bottom );
    }
    else
    {
        prgn = IntSysCreateRectpRgn( rclClip.left,
                                     rclClip.top,
                                     rclClip.right ,
                                     rclClip.bottom );
        pdc->prgnVis = prgn;
    }
 
    if (prgn)
    {
        pdc->ptlDCOrig.x = 0;
        pdc->ptlDCOrig.y = 0;
        pdc->erclWindow = rclWnd;
        pdc->erclClip = rclClip;
        /* Might be an InitDC or DCE... */
        pdc->ptlFillOrigin = pdc->dcattr.ptlBrushOrigin;
        return TRUE;
    }
    // No Vis use the Default System Region.
    pdc->prgnVis = prgnDefault;
    return FALSE;
}

Referenced by GdiSelectVisRgn(), and MakeInfoDC().

IntUpdateBoundsRect()

VOID FASTCALL IntUpdateBoundsRect	(	PDC	pdc,
		PRECTL	pRect
	)

Definition at line 694 of file dcutil.c.

{
   if (pdc->fs & DC_ACCUM_APP)
   {
      RECTL_bUnionRect(&pdc->erclBoundsApp, &pdc->erclBoundsApp, pRect);
   }
   if (pdc->fs & DC_ACCUM_WMGR)
   {
      RECTL_bUnionRect(&pdc->erclBounds, &pdc->erclBounds, pRect);
   }
}

Referenced by AddPenLinesBounds(), GreGradientFill(), GreStretchBltMask(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntPatBlt(), IntRectangle(), NtGdiAlphaBlend(), NtGdiExtFloodFill(), NtGdiMaskBlt(), NtGdiSetDIBitsToDeviceInternal(), NtGdiSetPixel(), NtGdiStretchDIBitsInternal(), and NtGdiTransparentBlt().

IntvGetDeviceCaps()

VOID FASTCALL IntvGetDeviceCaps	(	PPDEVOBJ	,
		PDEVCAPS
	)

TranslateCOLORREF()

ULONG TranslateCOLORREF	(	PDC	pdc,
		COLORREF	crColor
	)

Definition at line 869 of file dcutil.c.

{
    PSURFACE psurfDC;
    PPALETTE ppalDC;
    ULONG index, ulColor, iBitmapFormat;
    EXLATEOBJ exlo;
 
    /* Get the DC surface */
    psurfDC = pdc->dclevel.pSurface;
 
    /* If no surface is selected, use the default bitmap */
    if (!psurfDC)
        psurfDC = psurfDefaultBitmap;
 
    /* Check what color type this is */
    switch (crColor >> 24)
    {
        case 0x00: /* RGB color */
            break;
 
        case 0x01: /* PALETTEINDEX */
            index = crColor & 0xFFFFFF;
            ppalDC = pdc->dclevel.ppal;
            if (index >= ppalDC->NumColors) index = 0;
 
            /* Get the RGB value */
            crColor = PALETTE_ulGetRGBColorFromIndex(ppalDC, index);
            break;
 
        case 0x02: /* PALETTERGB */
 
            if (pdc->dclevel.hpal != StockObjects[DEFAULT_PALETTE])
            {
                /* First find the nearest index in the dc palette */
                ppalDC = pdc->dclevel.ppal;
                index = PALETTE_ulGetNearestIndex(ppalDC, crColor & 0xFFFFFF);
 
                /* Get the RGB value */
                crColor = PALETTE_ulGetRGBColorFromIndex(ppalDC, index);
            }
            else
            {
                /* Use the pure color */
                crColor = crColor & 0x00FFFFFF;
            }
            break;
 
        case 0x10: /* DIBINDEX */
            /* Mask the value to match the target bpp */
            iBitmapFormat = psurfDC->SurfObj.iBitmapFormat;
            if (iBitmapFormat == BMF_1BPP) index = crColor & 0x1;
            else if (iBitmapFormat == BMF_4BPP) index = crColor & 0xf;
            else if (iBitmapFormat == BMF_8BPP) index = crColor & 0xFF;
            else if (iBitmapFormat == BMF_16BPP) index = crColor & 0xFFFF;
            else index = crColor & 0xFFFFFF;
            return index;
 
        default:
            DPRINT("Unsupported color type %u passed\n", crColor >> 24);
            crColor &= 0xFFFFFF;
    }
 
    /* Initialize an XLATEOBJ from RGB to the target surface */
    EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurfDC->ppal, 0xFFFFFF, 0, 0);
 
    /* Translate the color to the target format */
    ulColor = XLATEOBJ_iXlate(&exlo.xlo, crColor);
 
    /* Cleanup the XLATEOBJ */
    EXLATEOBJ_vCleanup(&exlo);
 
    return ulColor;
}

Referenced by NtGdiGetNearestColor(), and NtGdiSetPixel().

Variable Documentation

defaultDCstate

PDC defaultDCstate

extern

Definition at line 14 of file device.c.

Referenced by DC_InitHack(), and IntGdiCleanDC().

pbrDefaultBrush

_Notnull_ PBRUSH pbrDefaultBrush

extern

Definition at line 18 of file dclife.c.

Referenced by DC_vInitDc(), DC_vUpdateBackgroundBrush(), DC_vUpdateTextBrush(), and InitDcImpl().

psurfDefaultBitmap

_Notnull_ PSURFACE psurfDefaultBitmap

extern

Definition at line 17 of file dclife.c.

Referenced by EBRUSHOBJ_vInit(), InitDcImpl(), IntCreateCompatibleBitmap(), and TranslateCOLORREF().