- Remove old GDI structure and use the new one.
svn path=/trunk/; revision=75326
//ASSERT(pBlendObj);
/* If no clip object is given, use trivial one */
- if (!pco) pco = &gxcoTrivial.ClipObj;
+ if (!pco) pco = (CLIPOBJ *)&gxcoTrivial;
/* Check if there is anything to draw */
if ((pco->rclBounds.left >= pco->rclBounds.right) ||
{
/* CLIPOBJ */
{
- {
- 0, /* iUniq */
- {LONG_MIN, LONG_MIN, LONG_MAX, LONG_MAX}, /* rclBounds */
- DC_TRIVIAL, /* idCOmplexity */
- FC_RECT, /* iFComplexity */
- TC_RECTANGLES, /* iMode */
- 0 /* fjOptions */
- },
+ 0, /* iUniq */
+ {LONG_MIN, LONG_MIN, LONG_MAX, LONG_MAX}, /* rclBounds */
+ DC_TRIVIAL, /* idCOmplexity */
+ FC_RECT, /* iFComplexity */
+ TC_RECTANGLES, /* iMode */
+ 0 /* fjOptions */
},
- 0, 0, 0
+ { 0, {0,0,0,0}, 0},
+ 0, {0,0,0,0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
typedef BOOLEAN (APIENTRY *PBLTRECTFUNC)(SURFOBJ* OutputObj,
pco = NULL;
}
else
- pco = &gxcoTrivial.ClipObj;
+ pco = (CLIPOBJ *)&gxcoTrivial;
if (ROP4_USES_SOURCE(Rop4))
{
FASTCALL
IntEngInitClipObj(XCLIPOBJ *Clip)
{
- Clip->Rects = &Clip->ClipObj.rclBounds;
+ Clip->Rects = &Clip->rclBounds;
}
VOID FASTCALL
IntEngFreeClipResources(XCLIPOBJ *Clip)
{
- if (Clip->Rects != &Clip->ClipObj.rclBounds)
+ if (Clip->Rects != &Clip->rclBounds)
EngFreeMem(Clip->Rects);
}
if(NewRects != NULL)
{
Clip->RectCount = count;
- Clip->EnumOrder = CD_ANY;
+ Clip->iDirection = CD_ANY;
RtlCopyMemory(NewRects, pRect, count * sizeof(RECTL));
- Clip->ClipObj.iDComplexity = DC_COMPLEX;
- Clip->ClipObj.iFComplexity = ((Clip->RectCount <= 4) ? FC_RECT4 : FC_COMPLEX);
- Clip->ClipObj.iMode = TC_RECTANGLES;
- Clip->ClipObj.rclBounds = *rcBounds;
+ Clip->iDComplexity = DC_COMPLEX;
+ Clip->iFComplexity = ((Clip->RectCount <= 4) ? FC_RECT4 : FC_COMPLEX);
+ Clip->iMode = TC_RECTANGLES;
+ Clip->rclBounds = *rcBounds;
- if (Clip->Rects != &Clip->ClipObj.rclBounds)
+ if (Clip->Rects != &Clip->rclBounds)
EngFreeMem(Clip->Rects);
Clip->Rects = NewRects;
}
}
else
{
- Clip->EnumOrder = CD_ANY;
+ Clip->iDirection = CD_ANY;
- Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
+ Clip->iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
(rcBounds->left == rcBounds->right))
? DC_TRIVIAL : DC_RECT);
- Clip->ClipObj.iFComplexity = FC_RECT;
- Clip->ClipObj.iMode = TC_RECTANGLES;
- Clip->ClipObj.rclBounds = *rcBounds;
+ Clip->iFComplexity = FC_RECT;
+ Clip->iMode = TC_RECTANGLES;
+ Clip->rclBounds = *rcBounds;
Clip->RectCount = 1;
- if (Clip->Rects != &Clip->ClipObj.rclBounds)
+ if (Clip->Rects != &Clip->rclBounds)
EngFreeMem(Clip->Rects);
- Clip->Rects = &Clip->ClipObj.rclBounds;
+ Clip->Rects = &Clip->rclBounds;
}
}
{
IntEngInitClipObj(Clip);
TRACE("Created Clip Obj %p.\n", Clip);
- return &Clip->ClipObj;
+ return (CLIPOBJ *)Clip;
}
ERR("Clip object allocation failed!\n");
EngDeleteClip(
_In_ _Post_ptr_invalid_ CLIPOBJ *pco)
{
- XCLIPOBJ* pxco = CONTAINING_RECORD(pco, XCLIPOBJ, ClipObj);
+ XCLIPOBJ* pxco = (XCLIPOBJ *)pco;
TRACE("Deleting %p.\n", pco);
IntEngFreeClipResources(pxco);
EngFreeMem(pxco);
_In_ ULONG iDirection,
_In_ ULONG cMaxRects)
{
- XCLIPOBJ* Clip = CONTAINING_RECORD(pco, XCLIPOBJ, ClipObj);
+ XCLIPOBJ* Clip = (XCLIPOBJ *)pco;
SORTCOMP CompareFunc;
+ Clip->bAll = bAll;
+ Clip->iType = iType;
Clip->EnumPos = 0;
Clip->EnumMax = (cMaxRects > 0) ? cMaxRects : Clip->RectCount;
- if (CD_ANY != iDirection && Clip->EnumOrder != iDirection)
+ if (CD_ANY != iDirection && Clip->iDirection != iDirection)
{
switch (iDirection)
{
default:
ERR("Invalid iDirection %lu\n", iDirection);
- iDirection = Clip->EnumOrder;
+ iDirection = Clip->iDirection;
CompareFunc = NULL;
break;
}
EngSort((PBYTE) Clip->Rects, sizeof(RECTL), Clip->RectCount, CompareFunc);
}
- Clip->EnumOrder = iDirection;
+ Clip->iDirection = iDirection;
}
/* Return the number of rectangles enumerated */
_Out_bytecap_(cj) ULONG *pulEnumRects)
{
const RECTL* src;
- XCLIPOBJ* Clip = CONTAINING_RECORD(pco, XCLIPOBJ, ClipObj);
+ XCLIPOBJ* Clip = (XCLIPOBJ *)pco;
ULONG nCopy;
ENUMRECTS* pERects = (ENUMRECTS*)pulEnumRects;
---------------------------------------------------------------------------*/
-/* EXtended CLip and Window Region Object */
+typedef struct _RWNDOBJ {
+ PVOID pvConsumer;
+ RECTL rclClient;
+ SURFOBJ *psoOwner;
+} RWNDOBJ;
+
+/* EXtended CLip and Window Region Objects */
#ifdef __cplusplus
-typedef struct _XCLIPOBJ : _WNDOBJ
+typedef struct _XCLIPOBJ : _CLIPOBJ, _RWNDOBJ
{
#else
typedef struct _XCLIPOBJ
{
- WNDOBJ;
+ CLIPOBJ;
+ RWNDOBJ;
#endif
- PVOID pClipRgn; /* prgnRao_ or (prgnVis_ if (prgnRao_ == z)) */
+ struct _REGION *pClipRgn; /* prgnRao_ or (prgnVis_ if (prgnRao_ == z)) */
+ //
RECTL rclClipRgn;
- PVOID pscanClipRgn; /* Ptr to regions rect buffer based on iDirection. */
+ //PVOID pscanClipRgn; /* Ptr to regions rect buffer based on iDirection. */
+ RECTL* Rects;
DWORD cScan;
DWORD reserved;
- ULONG ulBSize;
+ ULONG EnumPos;
LONG lscnSize;
- ULONG ulObjSize;
+ ULONG EnumMax;
ULONG iDirection;
- ULONG ulClipType;
+ ULONG iType;
DWORD reserved1;
LONG lUpDown;
DWORD reserved2;
- BOOL bShouldDoAll;
- DWORD nComplexity; /* count/mode based on # of rect in regions scan. */
+ BOOL bAll;
+ //
+ DWORD RectCount; /* count/mode based on # of rect in regions scan. */
PVOID pDDA; /* Pointer to a large drawing structure. */
} XCLIPOBJ, *PXCLIPOBJ;
+
/*
- EngCreateClip allocates XCLIPOBJ and RGNOBJ, pco->co.pClipRgn = &pco->ro.
+ EngCreateClip allocates XCLIPOBJ and REGION, pco->co.pClipRgn = &pco->ro.
{
XCLIPOBJ co;
- RGNOBJ ro;
+ REGION ro;
}
*/
-typedef struct _CLIPGDI {
- union
- {
- CLIPOBJ ClipObj;
- WNDOBJ WndObj;
- };
- /* WNDOBJ part */
+
+extern XCLIPOBJ gxcoTrivial;
+
+#ifdef __cplusplus
+typedef struct _EWNDOBJ : _XCLIPOBJ
+{
+#else
+typedef struct _EWNDOBJ
+{
+ XCLIPOBJ;
+#endif
+ /* Extended WNDOBJ part */
HWND Hwnd;
WNDOBJCHANGEPROC ChangeProc;
FLONG Flags;
int PixelFormat;
- /* CLIPOBJ part */
- ULONG EnumPos;
- ULONG EnumOrder;
- ULONG EnumMax;
- ULONG RectCount;
- RECTL* Rects;
-} CLIPGDI, *PCLIPGDI;
-C_ASSERT(FIELD_OFFSET(CLIPGDI, ClipObj) == FIELD_OFFSET(CLIPGDI, WndObj.coClient));
-
-// HACK, until we use the original structure
-#define XCLIPOBJ CLIPGDI
+} EWNDOBJ, *PEWNDOBJ;
-extern XCLIPOBJ gxcoTrivial;
/*ei What is this for? */
typedef struct _DRVFUNCTIONSGDI {
VOID
FASTCALL
IntEngWndCallChangeProc(
- _In_ XCLIPOBJ *Clip,
+ _In_ EWNDOBJ *Clip,
_In_ FLONG flChanged)
{
if (Clip->ChangeProc == NULL)
if (flChanged == WOC_CHANGED)
Clip->ChangeProc(NULL, flChanged);
else
- Clip->ChangeProc(&Clip->WndObj, flChanged);
+ Clip->ChangeProc((WNDOBJ *)Clip, flChanged);
}
/*
BOOLEAN
FASTCALL
IntEngWndUpdateClipObj(
- XCLIPOBJ* Clip,
+ EWNDOBJ* Clip,
PWND Window)
{
PREGION visRgn;
{
if (visRgn->rdh.nCount > 0)
{
- IntEngUpdateClipRegion(Clip, visRgn->rdh.nCount, visRgn->Buffer, &visRgn->rdh.rcBound);
+ IntEngUpdateClipRegion((XCLIPOBJ*)Clip, visRgn->rdh.nCount, visRgn->Buffer, &visRgn->rdh.rcBound);
TRACE("Created visible region with %lu rects\n", visRgn->rdh.nCount);
TRACE(" BoundingRect: %d, %d %d, %d\n",
visRgn->rdh.rcBound.left, visRgn->rdh.rcBound.top,
else
{
/* Fall back to client rect */
- IntEngUpdateClipRegion(Clip, 1, &Window->rcClient, &Window->rcClient);
+ IntEngUpdateClipRegion((XCLIPOBJ*)Clip, 1, &Window->rcClient, &Window->rcClient);
}
/* Update the WNDOBJ */
- Clip->WndObj.rclClient = Window->rcClient;
- Clip->WndObj.coClient.iUniq++;
+ Clip->rclClient = Window->rcClient;
+ Clip->iUniq++;
return TRUE;
}
_In_ PWND Window,
_In_ FLONG flChanged)
{
- XCLIPOBJ *Clip;
+ EWNDOBJ *Clip;
ASSERT_IRQL_LESS_OR_EQUAL(PASSIVE_LEVEL);
}
ASSERT(Clip->Hwnd == Window->head.h);
- // if (Clip->WndObj.pvConsumer != NULL)
+ // if (Clip->pvConsumer != NULL)
{
/* Update the WNDOBJ */
switch (flChanged)
FLONG fl,
int iPixelFormat)
{
- XCLIPOBJ *Clip = NULL;
+ EWNDOBJ *Clip = NULL;
WNDOBJ *WndObjUser = NULL;
PWND Window;
BOOL calledFromUser;
}
/* Create WNDOBJ */
- Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof (XCLIPOBJ), GDITAG_WNDOBJ);
+ Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof (EWNDOBJ), GDITAG_WNDOBJ);
if (Clip == NULL)
{
ERR("Failed to allocate memory for a WND structure!\n");
RETURN( NULL);
}
- IntEngInitClipObj(Clip);
+ IntEngInitClipObj((XCLIPOBJ*)Clip);
/* Fill the clipobj */
if (!IntEngWndUpdateClipObj(Clip, Window))
}
/* Fill user object */
- WndObjUser = &Clip->WndObj;
+ WndObjUser = (WNDOBJ *)Clip;
WndObjUser->psoOwner = pso;
WndObjUser->pvConsumer = NULL;
EngDeleteWnd(
IN WNDOBJ *pwo)
{
- XCLIPOBJ* Clip = CONTAINING_RECORD(pwo, XCLIPOBJ, WndObj);
+ EWNDOBJ* Clip = (EWNDOBJ *)pwo;//CONTAINING_RECORD(pwo, XCLIPOBJ, WndObj);
PWND Window;
BOOL calledFromUser;
}
/* Free resources */
- IntEngFreeClipResources(Clip);
+ IntEngFreeClipResources((XCLIPOBJ*)Clip);
EngFreeMem(Clip);
}
IN WNDOBJ *pwo,
IN PVOID pvConsumer)
{
- XCLIPOBJ* Clip = CONTAINING_RECORD(pwo, XCLIPOBJ, WndObj);
+ EWNDOBJ* Clip = (EWNDOBJ *)pwo;//CONTAINING_RECORD(pwo, XCLIPOBJ, WndObj);
BOOL Hack;
TRACE("WNDOBJ_vSetConsumer: pwo = 0x%p, pvConsumer = 0x%p\n", pwo, pvConsumer);
if (pco == NULL)
{
/* Use the trivial one instead */
- pco = &gxcoTrivial.ClipObj;
+ pco = (CLIPOBJ *)&gxcoTrivial;//.coClient;
}
switch(ulMode)
//ASSERT(!RECTL_bIsEmptyRect(SourceRect)); // FIXME!
/* If no clip object is given, use trivial one */
- if (!ClipRegion) ClipRegion = &gxcoTrivial.ClipObj;
+ if (!ClipRegion) ClipRegion = (CLIPOBJ *)&gxcoTrivial;
psurfDest = CONTAINING_RECORD(psoDest, SURFACE, SurfObj);
ASSERT(psurfSource);
/* If no clip object is given, use trivial one */
- if (!Clip) Clip = &gxcoTrivial.ClipObj;
+ if (!Clip) Clip = (CLIPOBJ *)&gxcoTrivial;
InputClippedRect = *DestRect;
if (InputClippedRect.right < InputClippedRect.left)
*/
#define PUTPIXEL(x,y,BrushInst) \
ret = ret && IntEngLineTo(&psurf->SurfObj, \
- &dc->co.ClipObj, \
+ (CLIPOBJ *)&dc->co, \
&BrushInst.BrushObject, \
x, y, (x)+1, y, \
&RectBounds, \
#define PUTLINE(x1,y1,x2,y2,BrushInst) \
ret = ret && IntEngLineTo(&psurf->SurfObj, \
- &dc->co.ClipObj, \
+ (CLIPOBJ *)&dc->co, \
&BrushInst.BrushObject, \
x1, y1, x2, y2, \
&RectBounds, \
TRACE("Performing the alpha blend\n");
bResult = IntEngAlphaBlend(&BitmapDest->SurfObj,
&BitmapSrc->SurfObj,
- &DCDest->co.ClipObj,
+ (CLIPOBJ *)&DCDest->co,
&exlo.xlo,
&DestRect,
&SourceRect,
EXLATEOBJ_vInitXlateFromDCs(&exlo, DCSrc, DCDest);
Ret = IntEngTransparentBlt(&BitmapDest->SurfObj, &BitmapSrc->SurfObj,
- &DCDest->co.ClipObj, &exlo.xlo, &rcDest, &rcSrc,
+ (CLIPOBJ *)&DCDest->co, &exlo.xlo, &rcDest, &rcSrc,
TransparentColor, 0);
EXLATEOBJ_vCleanup(&exlo);
XlateObj = &exlo.xlo;
}
-
/* Perform the bitblt operation */
Status = IntEngBitBlt(&BitmapDest->SurfObj,
BitmapSrc ? &BitmapSrc->SurfObj : NULL,
psurfMask ? &psurfMask->SurfObj : NULL,
- &DCDest->co.ClipObj,
+ (CLIPOBJ *)&DCDest->co,
XlateObj,
&DestRect,
&SourcePoint,
Status = IntEngStretchBlt(&BitmapDest->SurfObj,
BitmapSrc ? &BitmapSrc->SurfObj : NULL,
BitmapMask ? &BitmapMask->SurfObj : NULL,
- &DCDest->co.ClipObj,
+ (CLIPOBJ *)&DCDest->co,
XlateObj,
&DCDest->dclevel.ca,
&DestRect,
ret = IntEngBitBlt(&psurf->SurfObj,
NULL,
NULL,
- &pdc->co.ClipObj,
+ (CLIPOBJ *)&pdc->co,
NULL,
&DestRect,
NULL,
bResult = IntEngBitBlt(&pdc->dclevel.pSurface->SurfObj,
NULL,
NULL,
- &xcoClip.ClipObj,
+ (CLIPOBJ *)&xcoClip,
NULL,
&prgnClip->rdh.rcBound,
NULL,
/* Call the internal function */
bRet = IntEngPaint(&pdc->dclevel.pSurface->SurfObj,
- &xcoClip.ClipObj,
+ (CLIPOBJ *)&xcoClip,
pbo,
&pdc->pdcattr->ptlBrushOrigin,
mix);
Status = IntEngBitBlt(pDestSurf,
pSourceSurf,
pMaskSurf,
- &pDC->co.ClipObj,
+ (CLIPOBJ *)&pDC->co,
&exlo.xlo,
&rcDest,
&ptSource,
bResult = IntEngStretchBlt(&psurfDst->SurfObj,
&psurfTmp->SurfObj,
NULL,
- &pdc->co.ClipObj,
+ (CLIPOBJ *)&pdc->co,
&exlo.xlo,
&pdc->dclevel.ca,
&rcDst,
&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&DestRect,
NULL,
// Points[1].x, Points[1].y );
ret = IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
Points[i].x, /* From */
Points[i].y,
if (ret)
{
ret = IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
Points[Count-1].x, /* From */
Points[Count-1].y,
ret = IntEngBitBlt(&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&DestRect,
NULL,
{
Mix = ROP2_TO_MIX(pdcattr->jROP2);
ret = ret && IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
DestRect.left, DestRect.top, DestRect.right, DestRect.top,
&DestRect, // Bounding rectangle
Mix);
ret = ret && IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
DestRect.right, DestRect.top, DestRect.right, DestRect.bottom,
&DestRect, // Bounding rectangle
Mix);
ret = ret && IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
DestRect.right, DestRect.bottom, DestRect.left, DestRect.bottom,
&DestRect, // Bounding rectangle
Mix);
ret = ret && IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
DestRect.left, DestRect.bottom, DestRect.left, DestRect.top,
&DestRect, // Bounding rectangle
EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurf->ppal, 0, 0, 0);
bRet = IntEngGradientFill(&psurf->SurfObj,
- &pdc->co.ClipObj,
+ (CLIPOBJ *)&pdc->co,
&exlo.xlo,
pVertex,
nVertex,
&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&DestRect,
&SourcePoint,
&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&DestRect,
&SourcePoint,
&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&DestRect,
&SourcePoint,
if (!IntEngMaskBlt(
SurfObj,
SourceGlyphSurf,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&exloRGB2Dst.xlo,
&exloDst2RGB.xlo,
&DestRect,
for (i = -thickness / 2; i < -thickness / 2 + thickness; ++i)
{
EngLineTo(SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboText.BrushObject,
(TextLeft >> 6),
TextTop + yoff - position + i,
for (i = -thickness / 2; i < -thickness / 2 + thickness; ++i)
{
EngLineTo(SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboText.BrushObject,
(TextLeft >> 6),
TextTop + yoff - (fixAscender >> 6) / 3 + i,
if (!(pbrLine->flAttrs & BR_IS_NULL))
{
Ret = IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
Points[0].x, Points[0].y,
Points[1].x, Points[1].y,
}
Ret = IntEngPolyline(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
&dc->eboLine.BrushObject,
Points,
Count,
//DPRINT("Fill Line (%d, %d) to (%d, %d)\n",x1, ScanLine, x2, ScanLine);
IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
BrushObj,
x1,
ScanLine,
//DPRINT("Fill Line (%d, %d) to (%d, %d)\n",x1, ScanLine, x2, ScanLine);
IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
BrushObj,
x1,
ScanLine,
//DPRINT("Fill Line (%d, %d) to (%d, %d)\n",x1, ScanLine, x2, ScanLine);
IntEngLineTo(&psurf->SurfObj,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
BrushObj,
x1,
ScanLine,
IntEngBitBlt(&psurf->SurfObj,
NULL,
NULL,
- &dc->co.ClipObj,
+ (CLIPOBJ *)&dc->co,
NULL,
&LineRect,
NULL,
/* We now have our destination surface */
psurfDest = psurfOffScreen;
#else
- pdcClipObj = &pdc->co.ClipObj;
+ pdcClipObj = (CLIPOBJ *)&pdc->co;
/* Paint the brush */
EBRUSHOBJ_vInit(&eboFill, pbrush, psurfDest, 0x00FFFFFF, 0, NULL);
{
/* We directly draw to the DC */
TRACE("Performing on screen rendering.\n");
- pdcClipObj = &pdc->co.ClipObj;
+ pdcClipObj = (CLIPOBJ *)&pdc->co;
// psurfOffScreen = NULL;
}
HWND FASTCALL
UserGethWnd( HDC hdc, PWNDOBJ *pwndo)
{
- XCLIPOBJ* Clip;
+ EWNDOBJ* Clip;
PWND Wnd;
HWND hWnd;
if (hWnd && (Wnd = UserGetWindowObject(hWnd)))
{
- Clip = (XCLIPOBJ*)UserGetProp(Wnd, AtomWndObj, TRUE);
+ Clip = (EWNDOBJ*)UserGetProp(Wnd, AtomWndObj, TRUE);
if ( Clip && Clip->Hwnd == hWnd )
{
- if (pwndo) *pwndo = &Clip->WndObj;
+ if (pwndo) *pwndo = (PWNDOBJ)Clip;
}
}
return hWnd;