/****************************** Module Header ******************************\
* Module Name: scrollw.c
*
* Copyright (c) 1985 - 1999, Microsoft Corporation
*
* Window and DC scrolling routines.
*
* History:
* 18-Jul-1991 DarrinM Recreated from Win 3.1 source.
\***************************************************************************/
#include "precomp.h"
#pragma hdrstop
/*
* Problems so far:
* DCs not at origin (0, 0)
* funny coordinate systems
*/
/***************************************************************************\
* GetTrueClipRgn
*
* Get copy of true clip region and its bounds.
*
* History:
* 18-Jul-1991 DarrinM Ported from Win 3.1 sources.
\***************************************************************************/
int GetTrueClipRgn(
HDC hdc,
HRGN hrgnClip)
{
POINT pt;
int code;
code = GreCopyVisRgn(hdc, hrgnClip);
/*
* NOTE!!! The global ghrgnScrl2 is used in this routine!
*/
GreGetDCOrg(hdc, &pt);
if (GreGetRandomRgn(hdc, ghrgnScrl2, 1)) {
GreOffsetRgn(ghrgnScrl2, pt.x, pt.y);
code = IntersectRgn(hrgnClip, hrgnClip, ghrgnScrl2);
}
/*
* Finally convert the result to DC coordinates
*/
GreOffsetRgn(hrgnClip, -pt.x, -pt.y);
return code;
}
/***************************************************************************\
* InternalScrollDC
*
* This function requires all input parameters in device coordinates
* (NOT screen!)
*
* History:
* 18-Jul-1991 DarrinM Ported from Win 3.1 sources.
\***************************************************************************/
int InternalScrollDC(
HDC hdc,
int dx,
int dy,
RECT *prcSrc,
RECT *prcClip,
HRGN hrgnInvalid,
HRGN hrgnUpdate,
LPRECT prcUpdate,
BOOL fLogUnits)
{
RECT rcVis;
RECT rcSrc;
RECT rcClip;
RECT rcUnclippedSrc;
RECT rcDst;
RECT rcUpdate;
RECT rcValid;
BOOL fSrcNotEmpty;
BOOL fHaveVisRgn;
POINT rgpt[2];
int dxLog;
int dyLog;
int wClip;
int wClipValid;
BOOL bMirroredDC=FALSE;
fHaveVisRgn = FALSE;
/*
* Enter a critical region to ensure that no one changes visrgns
* or update regions while we scroll bits around.
*/
GreLockDisplay(gpDispInfo->hDev);
if ((wClip = GreGetClipBox(hdc, &rcVis, TRUE)) == ERROR) {
ErrorExit:
GreUnlockDisplay(gpDispInfo->hDev);
return ERROR;
}
CopyRect(&rcSrc, (prcSrc) ? prcSrc : &rcVis);
if (prcClip) {
CopyRect(&rcClip, prcClip);
}
dxLog = dx;
dyLog = dy;
if (fLogUnits) {
/*
* Convert input parameters to device coordinates
*/
GreLPtoDP(hdc, (LPPOINT)&rcVis, 2);
GreLPtoDP(hdc, (LPPOINT)&rcSrc, 2);
//
// Since this is a mirrored DC, then the resulting
// device coord will be flowing from right to left
// (i.e. rc.right < rc.left) so they should be flipped.
// [samera]
//
if (GreGetLayout(hdc) & LAYOUT_RTL) {
int iTemp = rcVis.left;
rcVis.left = rcVis.right;
rcVis.right = iTemp;
iTemp = rcSrc.left;
rcSrc.left = rcSrc.right;
rcSrc.right = iTemp;
bMirroredDC = TRUE;
}
if (prcClip) {
GreLPtoDP(hdc, (LPPOINT)&rcClip, 2);
//
// Since this is a mirrored DC, then the resulting
// device coord will be flowing from right to left
// (i.e. rc.right < rc.left) so they should be flipped.
// [samera]
//
if (bMirroredDC) {
int iTemp = rcClip.left;
rcClip.left = rcClip.right;
rcClip.right = iTemp;
}
}
/*
* The delta values must be treated as a vector from
* the point (0, 0) to (dx, dy). Scale it as such, then
* compute the difference. This handles flipped coordinate systems.
*/
rgpt[0].x = rgpt[0].y = 0;
rgpt[1].x = dx;
rgpt[1].y = dy;
GreLPtoDP(hdc, rgpt, 2);
dx = rgpt[1].x - rgpt[0].x;
dy = rgpt[1].y - rgpt[0].y;
}
switch (wClip) {
case NULLREGION:
NullExit:
if (hrgnUpdate && !SetEmptyRgn(hrgnUpdate))
goto ErrorExit;
if (prcUpdate) {
SetRectEmpty(prcUpdate);
}
GreUnlockDisplay(gpDispInfo->hDev);
return NULLREGION;
case COMPLEXREGION:
GetTrueClipRgn(hdc, ghrgnScrlVis);
fHaveVisRgn = TRUE;
break;
}
/*
* First compute the source and destination rectangles.
*
* rcDst = Offset(rcSrc, dx, dy)
*/
rcDst.left = rcSrc.left + dx;
rcDst.right = rcSrc.right + dx;
rcDst.top = rcSrc.top + dy;
rcDst.bottom = rcSrc.bottom + dy;
/*
* If necessary, intersect with caller-supplied clip rect.
*/
if (prcClip) {
if ((wClip == SIMPLEREGION) &&
((hrgnInvalid == NULL) || (hrgnInvalid == HRGN_FULL))) {
/*
* Simple clip region: just a rect intersection
*/
if (!IntersectRect(&rcVis, &rcVis, &rcClip))
goto NullExit;
} else {
if (!fHaveVisRgn) {
if (GetTrueClipRgn(hdc, ghrgnScrlVis) == ERROR)
goto ErrorExit;
fHaveVisRgn = TRUE;
}
SetRectRgnIndirect(ghrgnScrl1, &rcClip);
wClip = IntersectRgn(ghrgnScrlVis, ghrgnScrl1, ghrgnScrlVis);
switch (wClip) {
case ERROR:
goto ErrorExit;
case NULLREGION:
goto NullExit;
case SIMPLEREGION:
/*
* If the clipped region is simple, we're back in fat
* rect city.
*/
GreGetRgnBox(ghrgnScrlVis, &rcVis);
break;
case COMPLEXREGION:
break;
}
}
}
/*
* Time for basic scrolling area calculations:
*
* Dst = Offset(Src, dx, dy) & Vis
* Src = Src & Vis
* Valid = Offset(Src, dx, dy) & Dst
* Valid = Valid & Invalid & Offset(Invalid, dx, dy)
* Update = (Src | Dst) - Valid
*
* If the vis region is simple, then we know that the valid region
* will be rectangular.
*
* The rectangular calculation case can only deal with
* ghrgnInvalid == NULL or (HRGN)1: the region case is handled the hard way.
*/
if ((wClip == SIMPLEREGION) &&
((hrgnInvalid == NULL) || (hrgnInvalid == HRGN_FULL))) {
/*
* Save a copy of this for update rect calc optimization.
*/
CopyRect(&rcUnclippedSrc, &rcSrc);
/*
* Dst = Offset(Src, dx, dy) & Vis.
*/
IntersectRect(&rcDst, &rcDst, &rcVis);
/*
* Src = Src & Vis.
*/
fSrcNotEmpty = IntersectRect(&rcSrc, &rcSrc, &rcVis);
/*
* Valid = Offset(Src, dx, dy) & Dst.
*/
if (hrgnInvalid == HRGN_FULL) {
SetRectEmpty(&rcValid);
} else {
rcValid.left = rcSrc.left + dx;
rcValid.right = rcSrc.right + dx;
rcValid.top = rcSrc.top + dy;
rcValid.bottom = rcSrc.bottom + dy;
IntersectRect(&rcValid, &rcValid, &rcDst);
}
/*
* Now calculate the update area.
*
* There are two cases where the result will be a rectangle:
*
* 1) The source rectangle lies completely within the visrgn,
* and the source and destination don't overlap. In this
* case the update region is equal to the source rect.
*
* 2) The clipped source rectangle is empty, in which case
* the update region is equal to the clipped dest rect.
*
* 3) We're scrolling in one dimension only, and the source
* and destination DO overlap. In this case we can use
* UnionRect() and SubtractRect() to do the area arithmetic.
*/
if (!fSrcNotEmpty) {
/*
* Clipped source is empty. Update area is the clipped dest.
*/
CopyRect(&rcUpdate, &rcDst);
goto RectUpdate;
} else if (IntersectRect(&rcUpdate, &rcSrc, &rcDst)) {
/*
* They overlap. If we're scrolling in one dimension only
* then we can use rect arithmetic...
*/
if (dx == 0 || dy == 0) {
UnionRect(&rcUpdate, &rcSrc, &rcDst);
SubtractRect(&rcUpdate, &rcUpdate, &rcValid);
goto RectUpdate;
}
} else if (EqualRect(&rcSrc, &rcUnclippedSrc)) {
/*
* They don't overlap, and the source lies completely
* within the visible region. Update region is the source.
*/
CopyRect(&rcUpdate, &rcSrc);
RectUpdate:
if (prcUpdate) {
CopyRect(prcUpdate, &rcUpdate);
}
if (hrgnUpdate && !SetRectRgnIndirect(hrgnUpdate, &rcUpdate)) {
goto ErrorExit;
}
wClip = SIMPLEREGION;
if (rcUpdate.left >= rcUpdate.right ||
rcUpdate.top >= rcUpdate.bottom)
wClip = NULLREGION;
goto DoRectBlt;
}
/*
* The update region isn't rectangular. Need to do our
* area calculations with region calls. Skip all this
* if the caller doesn't care about the update region.
*
* If he wants a rectangle but no region, use ghrgnScrl2 as a temp.
*/
if (hrgnUpdate == NULL && prcUpdate) {
hrgnUpdate = ghrgnScrl2;
}
if (hrgnUpdate != NULL) {
/*
* hrgnUpdateCalc = (rcSrc | rcDst) - rcBltDst
*/
SetRectRgnIndirect(ghrgnScrl1, &rcSrc);
SetRectRgnIndirect(hrgnUpdate, &rcDst);
if (UnionRgn(hrgnUpdate, hrgnUpdate, ghrgnScrl1) == ERROR)
goto ErrorExit;
SetRectRgnIndirect(ghrgnScrl1, &rcValid);
wClip = SubtractRgn(hrgnUpdate, hrgnUpdate, ghrgnScrl1);
if (wClip == ERROR)
goto ErrorExit;
if (prcUpdate) {
GreGetRgnBox(hrgnUpdate, prcUpdate);
}
}
DoRectBlt:
/*
* If the valid rectangle's not empty, then copy those bits...
*/
if (rcValid.left < rcValid.right && rcValid.top < rcValid.bottom) {
/*
* If the DC is in a funny map mode, then be sure to map from
* device to logical coordinates for BLT call...
*/
if (fLogUnits)
GreDPtoLP(hdc, (LPPOINT)&rcValid, 2);
GreBitBlt(hdc,
rcValid.left,
rcValid.top,
rcValid.right - rcValid.left,
rcValid.bottom - rcValid.top,
hdc,
rcValid.left - dxLog,
rcValid.top - dyLog,
SRCCOPY,
0);
}
} else {
/*
* Get the true visrgn if we haven't already.
*/
if (!fHaveVisRgn) {
if (GetTrueClipRgn(hdc, ghrgnScrlVis) == ERROR)
goto ErrorExit;
fHaveVisRgn = TRUE;
}
/*
* The visrgn is not empty. Need to do all our calculations
* with regions.
*
* hrgnSrc = hrgnSrc & ghrgnScrlVis
*/
SetRectRgnIndirect(ghrgnScrlSrc, &rcSrc);
if (IntersectRgn(ghrgnScrlSrc, ghrgnScrlSrc, ghrgnScrlVis) == ERROR)
goto ErrorExit;
/*
* hrgnDst = hrgnDst & ghrgnScrlVis
*/
SetRectRgnIndirect(ghrgnScrlDst, &rcDst);
if (IntersectRgn(ghrgnScrlDst, ghrgnScrlDst, ghrgnScrlVis) == ERROR)
goto ErrorExit;
/*
* Now compute the valid region:
*
* Valid = Offset(Src, dx, dy) & Dst.
* Valid = Valid & Invalid & Offset(Invalid, dx, dy)
*
* If hrgnInvalid is (HRGN)1, then the valid area is empty.
*/
wClipValid = NULLREGION;
if (hrgnInvalid != HRGN_FULL) {
/*
* Valid = Offset(Src, dx, dy) & Dst
*/
if (CopyRgn(ghrgnScrlValid, ghrgnScrlSrc) == ERROR)
goto ErrorExit;
GreOffsetRgn(ghrgnScrlValid, dx, dy);
wClipValid = IntersectRgn(ghrgnScrlValid,
ghrgnScrlValid,
ghrgnScrlDst);
/*
* Valid = Valid - Invalid - Offset(Invalid, dx, dy)
* We need bother only if hrgnInvalid is a real region.
*/
if (hrgnInvalid > HRGN_FULL) {
if (wClipValid != ERROR && wClipValid != NULLREGION) {
POINT pt;
GetDCOrgOnScreen(hdc, &pt);
/*
* hrgnInvalid is in screen coordinates: map to dc coords
*/
CopyRgn(ghrgnScrl2, hrgnInvalid);
GreOffsetRgn(ghrgnScrl2, -pt.x, -pt.y);
wClipValid = SubtractRgn(ghrgnScrlValid,
ghrgnScrlValid,
ghrgnScrl2);
}
if (wClipValid != ERROR && wClipValid != NULLREGION) {
GreOffsetRgn(ghrgnScrl2, dx, dy);
wClipValid = SubtractRgn(ghrgnScrlValid,
ghrgnScrlValid,
ghrgnScrl2);
}
}
if (wClipValid == ERROR)
goto ErrorExit;
}
/*
* If he wants a rectangle but no region, use ghrgnScrl2 as a temp.
*/
if (hrgnUpdate == NULL && prcUpdate) {
hrgnUpdate = ghrgnScrl2;
}
if (hrgnUpdate != NULL) {
/*
* Update = (Src | Dst) - Valid.
*/
wClip = UnionRgn(hrgnUpdate, ghrgnScrlDst, ghrgnScrlSrc);
if (wClip == ERROR)
goto ErrorExit;
if (wClipValid != NULLREGION) {
wClip = SubtractRgn(hrgnUpdate, hrgnUpdate, ghrgnScrlValid);
}
if (prcUpdate) {
GreGetRgnBox(hrgnUpdate, prcUpdate);
}
}
if (wClipValid != NULLREGION) {
#ifdef LATER
/*
* don't use the visrgn here
*/
HRGN hrgnSaveVis = CreateEmptyRgn();
if (hrgnSaveVis != NULL) {
BOOL fClipped;
fClipped = (GreGetRandomRgn(hdc, hrgnSaveVis, 1) == 1);
GreExtSelectClipRgn(hdc, ghrgnScrlValid, RGN_COPY);
/*
* If the DC is in a funny map mode, then be sure to
* map from device to logical coordinates for BLT call...
*/
if (fLogUnits)
GreDPtoLP(hdc, (LPPOINT)&rcDst, 2);
/*
* Gdi can take along time to process this call if
* it's a printer DC
*/
GreBitBlt(hdc,
rcDst.left,
rcDst.top,
rcDst.right - rcDst.left,
rcDst.bottom - rcDst.top,
hdc,
rcDst.left - dxLog,
rcDst.top - dyLog,
SRCCOPY,
0);
GreExtSelectClipRgn(hdc,
(fClipped ? hrgnSaveVis : NULL),
RGN_COPY);
GreDeleteObject(hrgnSaveVis);
}
#else
/*
* Visrgn is expected in DC surface coordinates: offset
* as appropriate.
*/
POINT pt;
GreGetDCOrg(hdc, &pt);
GreOffsetRgn(ghrgnScrlValid, pt.x, pt.y);
/*
* Select in the temporary vis rgn, saving the old
*/
GreSelectVisRgn(hdc, ghrgnScrlValid, SVR_SWAP);
/*
* If the DC is in a funny map mode, then be sure to map from
* device to logical coordinates for BLT call...
*/
if (fLogUnits)
GreDPtoLP(hdc, (LPPOINT)&rcDst, 2);
/*
* Gdi can take along time to process this call if it's
* a printer DC.
*/
GreBitBlt(hdc,
rcDst.left,
rcDst.top,
rcDst.right - rcDst.left,
rcDst.bottom - rcDst.top,
hdc,
rcDst.left - dxLog,
rcDst.top - dyLog,
SRCCOPY,
0);
/*
* Restore the old vis rgn, leaving ghrgnScrlValid with
* a valid rgn
*/
GreSelectVisRgn(hdc, ghrgnScrlValid, SVR_SWAP);
#endif
}
}
/*
* If necessary, convert the resultant update rect back
* to logical coordinates.
*/
if (fLogUnits && prcUpdate) {
GreDPtoLP(hdc, (LPPOINT)prcUpdate, 2);
}
GreUnlockDisplay(gpDispInfo->hDev);
return wClip;
}
/***************************************************************************\
* _ScrollDC (API)
*
*
* History:
* 18-Jul-1991 DarrinM Ported from Win 3.1 sources.
\***************************************************************************/
BOOL _ScrollDC(
HDC hdc,
int dx,
int dy,
LPRECT prcSrc,
LPRECT prcClip,
HRGN hrgnUpdate,
LPRECT prcUpdate)
{
RECT rcSrc;
RECT rcSpb;
PWND pwnd;
HRGN hrgnInvalid;
BOOL fRet;
/*
* ScrollDC does not scroll update region. Under WinNT, an app calling
* GetUpdateRgn() then ScrollDC() then InvalidateRgn() will not get
* any new update region that happened between the Get and Scroll. Under
* Win3.1, that was not a problem because no other app ran during this
* time. So pass hrgnInvalid - this will affect the hrgnUpdate and
* prcUpdate values being returned from ScrollDC with the update region.
*/
hrgnInvalid = NULL;
if ((pwnd = FastWindowFromDC(hdc)) != NULL) {
hrgnInvalid = pwnd->hrgnUpdate;
if (hrgnInvalid == HRGN_FULL) {
/*
* This is a fix for winhell, a performance testing app
* written by some guy working for a windows magazine.
* this app scrolls it's window while it is completely
* invalid. We normaly won't scroll invalid bits but
* but we make the exception here
*/
hrgnInvalid = NULL;
}
}
fRet = InternalScrollDC(hdc,
dx,
dy,
prcSrc,
prcClip,
hrgnInvalid,
hrgnUpdate,
prcUpdate,
TRUE) != ERROR;
/*
* InternalScrollDC() only scrolls those areas inside the visible region.
* This means it does no operations on parts of the window if the window
* isn't visible. This means SPBs don't get properly invalidated. This
* could be seen by starting a dir, then moving another window with the
* mouse (and keeping the mouse down until the dir finished). The
* screen is remembered with an SPB, and the dir window doesn't get
* properly invalidated because of this.
*/
if (pwnd != NULL && AnySpbs()) {
if (prcSrc) {
rcSrc = *prcSrc;
OffsetRect(&rcSrc, pwnd->rcClient.left, pwnd->rcClient.top);
rcSpb = rcSrc;
OffsetRect(&rcSpb, dx, dy);
UnionRect(&rcSpb, &rcSpb, &rcSrc);
} else {
rcSpb = pwnd->rcClient;
}
SpbCheckRect(pwnd, &rcSpb, 0);
}
return fRet;
}
/***************************************************************************\
* ScrollWindowEx (API)
*
*
* History:
* 18-Jul-1991 DarrinM Ported from Win 3.1 sources.
\***************************************************************************/
int xxxScrollWindowEx(
PWND pwnd,
int dx,
int dy,
RECT *prcScroll,
RECT *prcClip,
HRGN hrgnUpdate,
LPRECT prcUpdate,
DWORD flags)
{
INT code;
HDC hdc;
int dxDev;
int dyDev;
RECT rcSrcDev;
RECT rcSpb, rcSrc;
DWORD flagsDCX;
BOOL fHideCaret;
BOOL fRcScroll = (prcScroll != NULL);
BOOL fInvisible = FALSE;
PCARET pcaret;
POINT pt;
TL tlpwndChild;
HRGN hrgnInvalid;
PTHREADINFO ptiCurrent = PtiCurrent();
CheckLock(pwnd);
UserAssert(IsWinEventNotifyDeferredOK());
if (pwnd == NULL)
pwnd = ptiCurrent->rpdesk->pDeskInfo->spwnd; // pwndDesktop
if (TestWF(pwnd, WEFLAYOUTRTL)) {
dx = -dx;
MirrorRegion(pwnd, hrgnUpdate, TRUE);
if(prcScroll) {
MirrorClientRect(pwnd, prcScroll);
}
if (prcClip) {
MirrorClientRect(pwnd, prcClip);
}
}
/*
* If nothing's moving, nothing to do.
*/
if ((dx | dy) == 0 ) {
goto DoNothing;
} else if (!IsVisible(pwnd)) {
/* We want to offset our children if we're not minimized. IsVisible()
* will return FALSE if we're minimized, invisible, or the child of
* a minimized/invisible ancestore.
*/
if (!TestWF(pwnd, WFMINIMIZED) &&
(flags & SW_SCROLLCHILDREN) &&
!fRcScroll) {
fInvisible = TRUE;
flags &= ~SW_INVALIDATE;
}
DoNothing:
if (hrgnUpdate) {
SetEmptyRgn(hrgnUpdate);
}
if (prcUpdate) {
SetRectEmpty(prcUpdate);
}
if (!fInvisible)
return NULLREGION;
}
/*
* Hide the caret.
*/
fHideCaret = FALSE;
if (!fInvisible) {
pcaret = &ptiCurrent->pq->caret;
if (pcaret->spwnd != NULL && _IsDescendant(pcaret->spwnd, pwnd)) {
fHideCaret = TRUE;
zzzInternalHideCaret();
}
}
/*
* If scrollwindow, and window is clipchildren, use a cache entry.
* Otherwise, always use a
*
* Determine what kind of DC we'll be needing. If the DCX_CACHE bit
* isn't set, it means that we'll be operating in logical coordinates.
*/
if (flags & SW_SCROLLWINDOW) {
/*
* ScrollWindow() call: use the cache if not OWNDC or CLASSDC.
*/
flagsDCX = DCX_USESTYLE;
if (!TestCF(pwnd, CFOWNDC) && !TestCF(pwnd, CFCLASSDC))
flagsDCX |= DCX_CACHE;
/*
* If SW_SCROLLCHILDREN (i.e., lprcScroll == NULL) and CLIPCHILDREN,
* then use the cache and don't clip children.
* This is screwy, but 3.0 backward compatible.
*/
if ((flags & SW_SCROLLCHILDREN) && TestWF(pwnd, WFCLIPCHILDREN))
flagsDCX |= DCX_NOCLIPCHILDREN | DCX_CACHE;
} else {
/*
* ScrollWindowEx() call: always use the cache
*/
flagsDCX = DCX_USESTYLE | DCX_CACHE;
/*
* if SW_SCROLLCHILDREN, always use noclipchildren.
*/
if (flags & SW_SCROLLCHILDREN)
flagsDCX |= DCX_NOCLIPCHILDREN;
}
flagsDCX |= DCX_NOMIRROR;
hdc = _GetDCEx(pwnd, NULL, flagsDCX);
if (flags & SW_INVALIDATE) {
/*
* Get device origin while DC is valid, for later offsetting
*/
GetDCOrgOnScreen(hdc, &pt);
/*
* If the user didn't give us a region to use, use ghrgnSW.
*/
if (hrgnUpdate == NULL)
hrgnUpdate = ghrgnSW;
}
/*
* The DC will be in some logical coordinate system if OWNDC or CLASSDC.
*/
if (!fRcScroll) {
prcScroll = &rcSrc;
/*
* IMPORTANT:
* We have to use CopyOffsetRect() here because GetClientRect() gives
* unreliable results for minimized windows. 3.1 dudes get told that
* their client is non-empty, for compatibility reasons.
*/
GetRect(pwnd, &rcSrc, GRECT_CLIENT | GRECT_CLIENTCOORDS);
/*
* If the DC might be a screwy one, then map the
* rect to logical units.
*/
if (!(flagsDCX & DCX_CACHE))
GreDPtoLP(hdc, (LPPOINT)&rcSrc, 2);
}
/*
* If the DC is in logical coordinates, map *prcScroll and dx, dy
* to device units for use later.
*/
dxDev = dx;
dyDev = dy;
rcSrcDev = *prcScroll;
if (!(flagsDCX & DCX_CACHE)) {
POINT rgpt[2];
GreLPtoDP(hdc, (POINT FAR*)&rcSrcDev, 2);
/*
* The delta values must be treated as a vector from
* the point (0, 0) to (dx, dy). Scale it as such, then
* compute the difference. This handles flipped coordinate systems.
*/
rgpt[0].x = rgpt[0].y = 0;
rgpt[1].x = dx;
rgpt[1].y = dy;
GreLPtoDP(hdc, rgpt, 2);
dxDev = rgpt[1].x - rgpt[0].x;
dyDev = rgpt[1].y - rgpt[0].y;
}
if (fInvisible)
code = NULLREGION;
else {
hrgnInvalid = pwnd->hrgnUpdate;
if ((flags & SW_SCROLLWINDOW) && !TestWF(pwnd, WFWIN31COMPAT)) {
/*
* 3.0 Backward compatibility hack:
* The following incorrect code is what 3.0 used to do, and
* there are apps such as Finale and Scrapbook+ that have worked
* around this bug in ways that don't work with the "correct" code.
*/
if (pwnd->hrgnUpdate > HRGN_FULL) {
RECT rc;
GreGetRgnBox(pwnd->hrgnUpdate, &rc);
OffsetRect(&rc,
dxDev - pwnd->rcClient.left,
dyDev - pwnd->rcClient.top);
xxxRedrawWindow(pwnd,
&rc, NULL,
RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
}
hrgnInvalid = NULL;
}
code = InternalScrollDC(hdc,
dx,
dy,
prcScroll,
prcClip,
hrgnInvalid,
hrgnUpdate,
prcUpdate,
!(flagsDCX & DCX_CACHE));
if (prcUpdate && TestWF(pwnd, WEFLAYOUTRTL)) {
MirrorClientRect(pwnd, prcUpdate);
}
}
/*
* Release the hdc we used.
*/
_ReleaseDC(hdc);
/*
* Check the union of the src and dst rectangle against any SPBs.
* We do this because the window
* might be completely obscured by some window with an SPB, but
* since we're completely covered no BitBlt call will be made
* to accumulate bounds in that area.
*/
if (!fInvisible && AnySpbs()) {
if (fRcScroll) {
if (pwnd == PWNDDESKTOP(pwnd)) {
rcSrc = rcSrcDev;
} else {
CopyOffsetRect(
&rcSrc,
&rcSrcDev,
pwnd->rcClient.left,
pwnd->rcClient.top);
}
rcSpb = rcSrc;
OffsetRect(&rcSpb, dxDev, dyDev);
UnionRect(&rcSpb, &rcSpb, &rcSrc);
} else {
/*
* Use the entire client area.
*/
rcSpb = pwnd->rcClient;
}
SpbCheckRect(pwnd, &rcSpb, 0);
}
/*
* If this guy wants to scroll his children, go at it. Only scroll those
* children intersecting prcScroll. Then invalidate any vis rgns
* calculated for these child windows.
*/
if (flags & SW_SCROLLCHILDREN) {
RECT rc;
/*
* If this window has the caret then offset it if:
* a) The whole window is scrolling
* b) The rectangle scrolled contains the caret rectangle
*/
if (!fInvisible && (pwnd == pcaret->spwnd)) {
if (fRcScroll)
SetRect(&rc,
pcaret->x,
pcaret->y,
pcaret->x + pcaret->cx,
pcaret->y + pcaret->cy);
if (!fRcScroll || IntersectRect(&rc, &rc, &rcSrcDev)) {
pcaret->x += dxDev;
pcaret->y += dyDev;
}
}
if (fRcScroll) {
/*
* Create a copy of prcScroll and map to absolute coordinates...
*/
if (pwnd == PWNDDESKTOP(pwnd)) {
CopyRect(&rc, &rcSrcDev);
} else {
CopyOffsetRect(
&rc,
&rcSrcDev,
pwnd->rcClient.left,
pwnd->rcClient.top);
}
}
if (pwnd->spwndChild) {
OffsetChildren(pwnd,
dxDev,
dyDev,
(fRcScroll ? (LPRECT)&rc : NULL));
/*
* If we're clipchildren, then shuffling our children
* will affect our client visrgn (but not our window visrgn).
* Otherwise, only our children's
* visrgns were affected by the scroll.
* No need to DeferWinEventNotify() judging by xxxInternalInvalidate() below
*/
zzzInvalidateDCCache(pwnd,
TestWF(pwnd, WFCLIPCHILDREN) ?
IDC_CLIENTONLY : IDC_CHILDRENONLY);
}
}
if (flags & SW_INVALIDATE) {
/*
* If the caller supplied a region, invalidate using a copy,
* because InternalInvalidate may trash the passed-in region.
*/
if (hrgnUpdate != ghrgnSW)
CopyRgn(ghrgnSW, hrgnUpdate);
/*
* Make ghrgnSW screen-relative before invalidation...
*/
GreOffsetRgn(ghrgnSW, pt.x, pt.y);
xxxInternalInvalidate(
pwnd,
ghrgnSW,
(flags & SW_ERASE) ?
(RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE) :
(RDW_INVALIDATE | RDW_ALLCHILDREN));
}
/*
* Send child move messages if needed.
*/
if (flags & SW_SCROLLCHILDREN) {
PWND pwndChild;
RECT rc;
RECT rcScrolledChildren;
/*
* NOTE: the following code will send MOVE messages
* to windows that didn't move but were in the source rectangle.
* This is not a big deal, and definitely not worth fixing.
*/
if (fRcScroll) {
if (pwnd->spwndParent == PWNDDESKTOP(pwnd)) {
CopyOffsetRect(&rcScrolledChildren, &rcSrcDev, dxDev, dyDev);
} else {
CopyOffsetRect(
&rcScrolledChildren,
&rcSrcDev,
dxDev + pwnd->spwndParent->rcClient.left,
dyDev + pwnd->spwndParent->rcClient.top);
}
}
ThreadLockNever(&tlpwndChild);
pwndChild = pwnd->spwndChild;
while (pwndChild != NULL) {
if ( !fRcScroll ||
IntersectRect(&rc, &rcScrolledChildren, &pwndChild->rcWindow)) {
/*
* NOTE: Win 3.0 and below passed wParam == TRUE here.
* This was not documented or used, so it was changed
* to be consistent with the documentation.
*/
ThreadLockExchangeAlways(pwndChild, &tlpwndChild);
xxxSendMessage(
pwndChild,
WM_MOVE,
0,
(pwnd == PWNDDESKTOP(pwnd)) ?
MAKELONG(pwndChild->rcClient.left, pwndChild->rcClient.top) :
MAKELONG(pwndChild->rcClient.left - pwnd->rcClient.left,
pwndChild->rcClient.top - pwnd->rcClient.top));
}
pwndChild = pwndChild->spwndNext;
}
ThreadUnlock(&tlpwndChild);
}
if (fHideCaret) {
/*
* Show the caret again.
*/
zzzInternalShowCaret();
}
/*
* Return the region code.
*/
return code;
}