|
|
/****************************** Module Header ******************************\
* Module Name: minmax.c** Copyright (c) 1985 - 1999, Microsoft Corporation** Window Minimize/Maximize Routines*\***************************************************************************/
#include "precomp.h"
#pragma hdrstop
/*
* How long we want animation to last, in milliseconds */#define CMS_ANIMATION 250
#define DX_GAP (SYSMET(CXMINSPACING) - SYSMET(CXMINIMIZED))
#define DY_GAP (SYSMET(CYMINSPACING) - SYSMET(CYMINIMIZED))
/***************************************************************************\
* xxxInitSendValidateMinMaxInfo()** Routine which initializes the minmax array, sends WM_GETMINMAXINFO to* the caller, and validates the results.** Returns FALSE is the window went away in the middle.*\***************************************************************************/
voidxxxInitSendValidateMinMaxInfo(PWND pwnd, LPMINMAXINFO lpmmi){ PTHREADINFO ptiCurrent; PMONITOR pMonitorReal; PMONITOR pMonitorPrimary; TL tlpMonitorReal; TL tlpMonitorPrimary; CHECKPOINT * pcp; RECT rcParent; int cBorders; int xMin, yMin; BOOL bTopLevel;
CheckLock(pwnd);
ptiCurrent = PtiCurrent();
/*
* FILL IN THE MINMAXINFO WE THINK IS APPROPRIATE */
/*
* Minimized Size */ lpmmi->ptReserved.x = SYSMET(CXMINIMIZED); lpmmi->ptReserved.y = SYSMET(CYMINIMIZED);
/*
* Maximized Position and Size * Figure out where the window would be maximized within its parent. */ pMonitorPrimary = GetPrimaryMonitor();
/*
* [msadek], #31003 * Cache window parent status in case some code reparents * the window during WM_GETMINMAXINFO */ if (bTopLevel = (pwnd->spwndParent == PWNDDESKTOP(pwnd))) { /* What monitor is the window really going to maximize to? */ pMonitorReal = _MonitorFromWindow(pwnd, MONITOR_DEFAULTTOPRIMARY);
/* Send dimensions based on the primary only. */ rcParent = pMonitorPrimary->rcMonitor; } else { pMonitorReal = NULL; _GetClientRect(pwnd->spwndParent, &rcParent); }
cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE);
InflateRect(&rcParent, cBorders * SYSMET(CXBORDER), cBorders * SYSMET(CYBORDER));
rcParent.right -= rcParent.left; rcParent.bottom -= rcParent.top;
/* rcParent.right, bottom are width and height now. */ lpmmi->ptMaxSize.x = rcParent.right; lpmmi->ptMaxSize.y = rcParent.bottom;
pcp = (CHECKPOINT *)_GetProp(pwnd, PROP_CHECKPOINT, PROPF_INTERNAL); if (pcp && pcp->fMaxInitialized) { /*
* Note: For top level windows, we will fix this point up after * the fact if it has gotten out of date because the size border * changed. */ lpmmi->ptMaxPosition = pcp->ptMax; } else { lpmmi->ptMaxPosition = *((LPPOINT)&rcParent.left); }
/*
* Normal minimum tracking size * Only enforce min tracking size for windows with captions */ xMin = cBorders*SYSMET(CXEDGE); yMin = cBorders*SYSMET(CYEDGE);
if (TestWF(pwnd, WFCAPTION) && !TestWF(pwnd, WEFTOOLWINDOW)) { lpmmi->ptMinTrackSize.x = SYSMET(CXMINTRACK); lpmmi->ptMinTrackSize.y = SYSMET(CYMINTRACK); } else { lpmmi->ptMinTrackSize.x = max(SYSMET(CXEDGE), xMin); lpmmi->ptMinTrackSize.y = max(SYSMET(CYEDGE), yMin); }
/*
* Normal maximum tracking size */ lpmmi->ptMaxTrackSize.x = SYSMET(CXMAXTRACK); lpmmi->ptMaxTrackSize.y = SYSMET(CYMAXTRACK);
/*
* SEND THE WM_GETMINMAXINFO MESSAGE */
ThreadLockWithPti(ptiCurrent, pMonitorReal, &tlpMonitorReal); ThreadLockAlwaysWithPti(ptiCurrent, pMonitorPrimary, &tlpMonitorPrimary); xxxSendMessage(pwnd, WM_GETMINMAXINFO, 0, (LPARAM)lpmmi);
/*
* VALIDATE THE MINMAXINFO */
/*
* Minimized Size (this is read only) */ lpmmi->ptReserved.x = SYSMET(CXMINIMIZED); lpmmi->ptReserved.y = SYSMET(CYMINIMIZED);
/*
* Maximized Postion and Size (only for top level windows) */ if (bTopLevel) { LPRECT lprcRealMax;
GetMonitorMaxArea(pwnd, pMonitorReal, &lprcRealMax);
/*
* Is the window a TRUE maximized dude, or somebody like the DOS box * who can maximize but not take up the entire screen? * * Is the window really maximizeable? */ if ((lpmmi->ptMaxSize.x >= (pMonitorPrimary->rcMonitor.right - pMonitorPrimary->rcMonitor.left)) && (lpmmi->ptMaxSize.y >= (pMonitorPrimary->rcMonitor.bottom - pMonitorPrimary->rcMonitor.top))) {
SetWF(pwnd, WFREALLYMAXIMIZABLE);
/*
* Need to reload the checkpoint here, since it might have gotten * blown away while we were in the xxxSendMessage call above. */ pcp = (CHECKPOINT *)_GetProp(pwnd, PROP_CHECKPOINT, PROPF_INTERNAL);
if ( pcp && pcp->fMaxInitialized && TestWF(pwnd, WFSIZEBOX) && (lpmmi->ptMaxPosition.x != rcParent.left) && (pcp->ptMax.x == lpmmi->ptMaxPosition.x)) {
/*
* If this window has a weird maximize point that doesn't jibe * with what we'd expect and it has a checkpoint, fix up the * checkpoint. It means that somebody's WINDOWPLACEMENT * got out of date when the size border changed dimensions. */ pcp->fMaxInitialized = FALSE;
lpmmi->ptMaxPosition.y += (rcParent.left - lpmmi->ptMaxPosition.x); lpmmi->ptMaxPosition.x = rcParent.left; }
/*
* Transfer the maximum size over to the monitor we are REALLY * moving to. And fix up guys going fullscreen. A whole bunch * of Consumer titles + Word '95 and XL '95 move their caption * above the top of the monitor when going fullscreen. Detect * these guys now, and let them take up the monitor. */ if ( lpmmi->ptMaxPosition.y + SYSMET(CYCAPTION) <= pMonitorPrimary->rcMonitor.top && lpmmi->ptMaxPosition.y + lpmmi->ptMaxSize.y >= pMonitorPrimary->rcMonitor.bottom) {
lprcRealMax = &pMonitorReal->rcMonitor; }
/*
* Compensate for the difference between the primary monitor * and the monitor we are actually on. */ lpmmi->ptMaxSize.x = lpmmi->ptMaxSize.x - (pMonitorPrimary->rcMonitor.right - pMonitorPrimary->rcMonitor.left) + (lprcRealMax->right - lprcRealMax->left);
lpmmi->ptMaxSize.y = lpmmi->ptMaxSize.y - (pMonitorPrimary->rcMonitor.bottom - pMonitorPrimary->rcMonitor.top) + (lprcRealMax->bottom - lprcRealMax->top); } else { ClrWF(pwnd, WFREALLYMAXIMIZABLE); }
/*
* Now transfer the max position over to the monitor we are REALLY * moving to. */ lpmmi->ptMaxPosition.x += lprcRealMax->left; lpmmi->ptMaxPosition.y += lprcRealMax->top; }
ThreadUnlock(&tlpMonitorPrimary); ThreadUnlock(&tlpMonitorReal);
/*
* Normal minimum tracking size. */
/*
* WFCAPTION == WFBORDER | WFDLGFRAME; So, when we want to test for the * presence of CAPTION, we must test for both the bits. Otherwise we * might mistake WFBORDER or WFDLGFRAME to be a CAPTION. * * * We must not allow a window to be sized smaller than the border * thickness -- SANKAR -- 06/12/91 -- */ if (TestWF(pwnd, WFCPRESENT)) {
/*
* NOTE THAT IF YOU CHANGE THE SPACING OF STUFF IN THE CAPTION, * YOU NEED TO KEEP THE FOLLOWING IN SSYNC: * (1) Default CXMINTRACK, CYMINTRACK in inctlpan.c * (2) The default minimum right below * (3) Hit testing * * The minimum size should be space for: * * The borders * * The buttons * * Margins * * 4 chars of text * * Caption icon */ yMin = SYSMET(CYMINTRACK);
/*
* Min track size is determined by the number of buttons in * the caption. */ if (TestWF(pwnd, WEFTOOLWINDOW)) {
/*
* Add in space for close button. */ if (TestWF(pwnd, WFSYSMENU)) xMin += SYSMET(CXSMSIZE);
/*
* DON'T add in space for 2 characters--breaks * MFC toolbar stuff. They want to make vertical undocked * toolbars narrower than what that would produce. */ xMin += (2 * SYSMET(CXEDGE));
} else {
if (TestWF(pwnd, WFSYSMENU)) {
/*
* Add in space for min/max/close buttons. Otherwise, * if it's a contexthelp window, then add in space * for help/close buttons. */ if (TestWF(pwnd, (WFMINBOX | WFMAXBOX))) xMin += 3 * SYSMET(CXSIZE); else if (TestWF(pwnd, WEFCONTEXTHELP)) xMin += 2 * SYSMET(CXSIZE);
/*
* Add in space for system menu icon. */ if (_HasCaptionIcon(pwnd)) xMin += SYSMET(CYSIZE); }
/*
* Add in space for 4 characters and margins. */ xMin += 4 * gcxCaptionFontChar + 2 * SYSMET(CXEDGE); } }
lpmmi->ptMinTrackSize.x = max(lpmmi->ptMinTrackSize.x, xMin); lpmmi->ptMinTrackSize.y = max(lpmmi->ptMinTrackSize.y, yMin);}
/***************************************************************************\
* ParkIcon** Called when minimizing a window. This parks the minwnd in the position* given in the checkpoint or calculates a new position for it.** LauraBu 10/15/92* We now let the user specify two things that affect parking and arranging:* (1) The corner to start arranging from* (2) The direction to move in first* MCostea 11/13/98 #246397* Add sanity check for the number of tries. If the metrics are messed up* and pwnd has a lot of siblings, the for-ever loop would make us timeout*\***************************************************************************/
VOID ParkIcon( PWND pwnd, PCHECKPOINT pcp){ RECT rcTest; RECT rcT; UINT xIconPositions; UINT xIconT; PWND pwndTest; PWND pwndParent; int xOrg; int yOrg; int dx; int dy; int dxSlot; int dySlot; int iteration; BOOL fHorizontal; PCHECKPOINT pncp;
/*
* Put these into local vars immediately. The compiler is too dumb to * know that we're using a constant offset into a constant address, and * thus a resulting constant address. */ dxSlot = SYSMET(CXMINSPACING); dySlot = SYSMET(CYMINSPACING);
if (IsTrayWindow(pwnd)) {
pcp->fMinInitialized = TRUE; pcp->ptMin.x = WHERE_NOONE_CAN_SEE_ME; pcp->ptMin.y = WHERE_NOONE_CAN_SEE_ME;
return; }
/* We need to adjust the client rectangle for scrollbars, just like we
* do in ArrangeIconicWindows(). If one thing is clear, it is that * parking and arranging must follow the same principles. This is to * avoid the user arranging some windows, creating a new one, and parking * it in a place not consistent with the arrangement of the others. */ pwndParent = pwnd->spwndParent; GetRealClientRect(pwndParent, &rcT, GRC_SCROLLS, NULL);
/*
* Get gravity & move vars. We want gaps to start on the sides that * we begin arranging from. * * Horizontal gravity */ if (SYSMET(ARRANGE) & ARW_STARTRIGHT) {
/*
* Starting on right side */ rcTest.left = xOrg = rcT.right - dxSlot; dx = -dxSlot;
} else {
/*
* Starting on left */ rcTest.left = xOrg = rcT.left + DX_GAP; dx = dxSlot; }
/*
* Vertical gravity */ if (SYSMET(ARRANGE) & ARW_STARTTOP) {
/*
* Starting on top side */ rcTest.top = yOrg = rcT.top + DY_GAP; dy = dySlot;
} else {
/*
* Starting on bottom */ rcTest.top = yOrg = rcT.bottom - dySlot; dy = -dySlot; }
/*
* Get arrangement direction. Note that ARW_HORIZONTAL is 0, so we * can't test for it. */ fHorizontal = ((SYSMET(ARRANGE) & ARW_DOWN) ? FALSE : TRUE);
if (fHorizontal) xIconPositions = xIconT = max(1, (rcT.right / dxSlot)); else xIconPositions = xIconT = max(1, (rcT.bottom / dySlot));
/*
* BOGUS * LauraBu 10/15/92 * What happens if the parent is scrolled over horizontally or * vertically? Just like when you drop an object... */ iteration = 0; while (iteration < 5000) {
/*
* Make a rectangle representing this position, in screen coords */ rcTest.right = rcTest.left + dxSlot; rcTest.bottom = rcTest.top + dySlot;
/*
* Look for intersections with existing iconic windows */ for (pwndTest = pwndParent->spwndChild; pwndTest; pwndTest = pwndTest->spwndNext) {
if (!TestWF(pwndTest, WFVISIBLE)) continue;
if (pwndTest == pwnd) continue;
if (!TestWF(pwndTest, WFMINIMIZED)) {
/*
* This is a non-minimized window. See if it has a checkpoint * and find out where it would be if it were minimized. We * will try not to park an icon in this spot. */ pncp = (PCHECKPOINT)_GetProp(pwndTest, PROP_CHECKPOINT, PROPF_INTERNAL);
if (!pncp || !pncp->fDragged || !pncp->fMinInitialized) continue;
/*
* Get parent coordinates of minimized window pos. */ rcT.right = rcT.left = pncp->ptMin.x; rcT.right += dxSlot; rcT.bottom = rcT.top = pncp->ptMin.y; rcT.bottom += dySlot;
} else {
/*
* Get parent coordinates of currently minimized window */ GetRect(pwndTest, &rcT, GRECT_WINDOW | GRECT_PARENTCOORDS); }
iteration++; /*
* Get out of loop if they overlap */ if (IntersectRect(&rcT, &rcT, &rcTest)) break; }
/*
* Found a position that doesn't overlap, so get out of search loop */ if (!pwndTest) break;
/*
* Else setup to process the next position */ if (--xIconT == 0) {
/*
* Setup next pass */ xIconT = xIconPositions;
if (fHorizontal) { rcTest.left = xOrg; rcTest.top += dy; } else { rcTest.left += dx; rcTest.top = yOrg; }
} else {
/*
* Same pass. */ if (fHorizontal) rcTest.left += dx; else rcTest.top += dy; } }
/*
* Note that rcTest is in parent coordinates already. */ pcp->fMinInitialized = TRUE; pcp->ptMin.x = rcTest.left; pcp->ptMin.y = rcTest.top;}
/***************************************************************************\
* xxxAnimateCaption**\***************************************************************************/
ULONG_PTR SaveScreen(PWND pwnd, ULONG iMode, ULONG_PTR iSave, int x, int y, int cx, int cy){ RECT rc;
/*
* x and y are in the DC coordinates, make the screen in the * (meta hdev) coordinates for the call to Gre/driver. */ rc.left = x + pwnd->rcWindow.left; rc.right = x + cx; rc.top = y + pwnd->rcWindow.top; rc.bottom = y + cy;
if (IntersectRect(&rc, &rc, &gpDispInfo->rcScreen)) { return GreSaveScreenBits(gpDispInfo->hDev, iMode, iSave, (RECTL*)&rc); } else { return 0; }}
VOID xxxAnimateCaption( PWND pwnd, HDC hdc, LPRECT lprcStart, LPRECT lprcEnd){ DWORD dwTimeStart; DWORD iTimeElapsed; int iLeftStart; int iTopStart; int cxStart; int dLeft; int dTop; int dcx; int iLeft; int iTop; int cx; int iLeftNew; int iTopNew; int cxNew; int cBorders; HBITMAP hbmpOld; RECT rc; int cy; HDC hdcMem; ULONG_PTR uSave; PWND pwndOrg;
CheckLock(pwnd);
if ((pwndOrg = _WindowFromDC(hdc)) == NULL) { RIPMSG0(RIP_WARNING, "SaveScreen: invalid DC passed in"); return; }
cy = SYSMET(CYCAPTION) - 1;
/*
* kurtp: 29-Jan-1997 * * We don't do anything when animating the caption, * because we couldn't get the desired effect at the * client. If we do use it then the * cache gets a bunch of bitmaps (size: 2xCaption by CXScreen) * that are never re-used. This slows down clients * because the GreBitBlts always generate new bitmaps * and the cache is displaced by the new bitmaps (yuk!). */ if (IsRemoteConnection() || SYSMETBOOL2(SM_REMOTECONTROL)) return;
if ((hdcMem = GreCreateCompatibleDC(ghdcMem)) == NULL) return;
/*
* If the caption strip doesn't exist, then attempt to recreate it. This * might be necessary if the user does a mode-switch during low memory * and is not able to recreate the surface. When the memory becomes * available, we'll attempt to recreate it here. */ if (ghbmCaption == NULL) { ghbmCaption = CreateCaptionStrip(); }
hbmpOld = GreSelectBitmap(hdcMem, ghbmCaption);
/*
* initialize start values */ iTopStart = lprcStart->top; iLeftStart = lprcStart->left; cxStart = lprcStart->right - iLeftStart;
/*
* initialize delta values to the destination dimensions */ dLeft = lprcEnd->left; dTop = lprcEnd->top; dcx = lprcEnd->right - dLeft;
/*
* adjust for window borders as appropriate */ cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE);
if ((lprcStart->bottom - iTopStart) > SYSMET(CYCAPTION)) {
iLeftStart += cBorders; iTopStart += cBorders; cxStart -= 2*cBorders; }
if ((lprcEnd->bottom - dTop) > SYSMET(CYCAPTION)) {
dLeft += cBorders; dTop += cBorders; dcx -= 2*cBorders; }
/*
* initialize step values */ iLeft = iLeftStart; iTop = iTopStart; cx = cxStart;
/*
* initialize off screen bitmap with caption drawing and first saved rect */ rc.left = 0; rc.top = cy; rc.right = max(cxStart, dcx); rc.bottom = cy * 2;
xxxDrawCaptionTemp(pwnd, hdcMem, &rc, NULL, NULL, NULL, DC_ACTIVE | DC_ICON | DC_TEXT | (TestALPHA(GRADIENTCAPTIONS) ? DC_GRADIENT : 0));
if ((uSave = SaveScreen(pwndOrg, SS_SAVE, 0,iLeft, iTop, cx, cy)) == 0) { if (!GreBitBlt(hdcMem, 0, 0, cx, cy, hdc, iLeft, iTop, SRCCOPY, 0)) { goto Cleanup; } }
/*
* compute delta values by subtracting source dimensions */ dLeft -= iLeftStart; dTop -= iTopStart; dcx -= cxStart;
/*
* blt and time first caption on screen * WARNING: If you use *lpSystemTickCount here, * the compiler may not generate code to do a DWORD fetch; */ dwTimeStart = NtGetTickCount(); GreBitBlt(hdc, iLeft, iTop, cx, cy, hdcMem, 0, cy, SRCCOPY, 0);
iTimeElapsed = (NtGetTickCount() - dwTimeStart);
while (LOWORD(iTimeElapsed) <= CMS_ANIMATION) {
iLeftNew = iLeftStart + MultDiv(dLeft, LOWORD(iTimeElapsed), CMS_ANIMATION); iTopNew = iTopStart + MultDiv(dTop, LOWORD(iTimeElapsed), CMS_ANIMATION); cxNew = cxStart + MultDiv(dcx, LOWORD(iTimeElapsed), CMS_ANIMATION);
/*
* Delay before next frame */ UserSleep(1);
/*
* restore saved rect */ if (uSave != 0) { SaveScreen(pwndOrg, SS_RESTORE, uSave, iLeft, iTop, cx, cy); } else { GreBitBlt(hdc, iLeft, iTop, cx, cy, hdcMem, 0, 0, SRCCOPY, 0); }
iLeft = iLeftNew; iTop = iTopNew; cx = cxNew;
/*
* save new rect offscreen and then draw over it onscreen. */ if (uSave != 0) { uSave = SaveScreen(pwndOrg, SS_SAVE, 0, iLeft, iTop, cx, cy); } else { GreBitBlt(hdcMem, 0, 0, cx, cy, hdc, iLeft, iTop, SRCCOPY, 0); } GreBitBlt(hdc, iLeft, iTop, cx, cy, hdcMem, 0, cy, SRCCOPY, 0);
/*
* update elapsed time * WARNING: If you use *lpSystemTickCount here, * the compiler may not generate code to do a DWORD fetch; */ iTimeElapsed = (NtGetTickCount() - dwTimeStart); }
/*
* restore saved rect */ if (uSave != 0) { SaveScreen(pwndOrg, SS_RESTORE, uSave, iLeft, iTop, cx, cy); } else { GreBitBlt(hdc, iLeft, iTop, cx, cy, hdcMem, 0, 0, SRCCOPY, 0); }
Cleanup: GreSelectBitmap(hdcMem, hbmpOld); GreDeleteDC(hdcMem);}
#if 0 // DISABLE OLD ANIMATION FOR M7
/***************************************************************************\
* DrawWireFrame** Draws wire frame trapezoid**\***************************************************************************/
VOID DrawWireFrame( HDC hdc, LPRECT prcFront, LPRECT prcBack){ RECT rcFront; RECT rcBack; RECT rcT; HRGN hrgnSave; BOOL fClip;
/*
* Save these locally */ CopyRect(&rcFront, prcFront); CopyRect(&rcBack, prcBack);
/*
* Front face */ GreMoveTo(hdc, rcFront.left, rcFront.top); GreLineTo(hdc, rcFront.left, rcFront.bottom); GreLineTo(hdc, rcFront.right, rcFront.bottom); GreLineTo(hdc, rcFront.right, rcFront.top); GreLineTo(hdc, rcFront.left, rcFront.top);
/*
* Exclude front face from clipping area, only if back face isn't * entirely within interior. We need variable because SaveClipRgn() * can return NULL. */ fClip = (EqualRect(&rcFront, &rcBack) || !IntersectRect(&rcT, &rcFront, &rcBack) || !EqualRect(&rcT, &rcBack));
if (fClip) {
hrgnSave = GreSaveClipRgn(hdc);
GreExcludeClipRect(hdc, rcFront.left, rcFront.top, rcFront.right, rcFront.bottom); }
/*
* Edges */ GreMoveTo(hdc, rcBack.left, rcBack.top); LineTo(hdc, rcFront.left, rcFront.top);
GreMoveTo(hdc, rcBack.right, rcBack.top); GreLineTo(hdc, rcFront.right, rcFront.top);
GreMoveTo(hdc, rcBack.right, rcBack.bottom); GreLineTo(hdc, rcFront.right, rcFront.bottom);
GreMoveTo(hdc, rcBack.left, rcBack.bottom); GreLineTo(hdc, rcFront.left, rcFront.bottom);
/*
* Back face */ MoveTo(hdc, rcBack.left, rcBack.top); LineTo(hdc, rcBack.left, rcBack.bottom); LineTo(hdc, rcBack.right, rcBack.bottom); LineTo(hdc, rcBack.right, rcBack.top); LineTo(hdc, rcBack.left, rcBack.top);
if (fClip) GreRestoreClipRgn(hdc, hrgnSave);}
/***************************************************************************\
* AnimateFrame** Draws wire frame 3D trapezoid**\***************************************************************************/
VOID AnimateFrame( HDC hdc, LPRECT prcStart, LPRECT prcEnd, BOOL fGrowing){ RECT rcBack; RECT rcFront; RECT rcT; HPEN hpen; int nMode; int iTrans; int nTrans; DWORD dwTimeStart; DWORD dwTimeCur;
/*
* Get pen for drawing lines */ hpen = GreSelectPen(hdc, GetStockObject(WHITE_PEN)); nMode = GreSetROP2(hdc, R2_XORPEN);
/*
* Save these locally */ if (fGrowing) {
CopyRect(&rcBack, prcStart); CopyRect(&rcFront, prcStart);
} else {
/*
* Initial is trapezoid entire way from small to big. We're going * to shrink it from the front face. */ CopyRect(&rcFront, prcStart); CopyRect(&rcBack, prcEnd); }
/*
* Offset left & top edges of rects, due to way that lines work. */ rcFront.left -= 1; rcFront.top -= 1; rcBack.left -= 1; rcBack.top -= 1;
/*
* Get tick count. We'll draw then check how much time elapsed. From * that we can calculate how many more transitions to draw. For the first * We basically want whole animation to last 3/4 of a second, or 750 * milliseconds. * * WARNING: If you use *lpSystemTickCount here, * the compiler may not generate code to do a DWORD fetch; */ dwTimeStart = GetSystemMsecCount();
DrawWireFrame(hdc, &rcFront, &rcBack);
/*
* WARNING: If you use *lpSystemTickCount here, * the compiler may not generate code to do a DWORD fetch; */ dwTimeCur = GetSystemMsecCount();
/*
* Get rough estimate for how much time it took. */ if (dwTimeCur == dwTimeStart) nTrans = CMS_ANIMATION / 55; else nTrans = CMS_ANIMATION / ((int)(dwTimeCur - dwTimeStart));
iTrans = 1; while (iTrans <= nTrans) {
/*
* Grow the trapezoid out or shrink it in. Fortunately, prcStart * and prcEnd are already set up for us. */ rcT.left = prcStart->left + MultDiv(prcEnd->left - prcStart->left, iTrans, nTrans); rcT.top = prcStart->top + MultDiv(prcEnd->top - prcStart->top, iTrans, nTrans); rcT.right = prcStart->right + MultDiv(prcEnd->right - prcStart->right, iTrans, nTrans); rcT.bottom = prcStart->bottom + MultDiv(prcEnd->bottom - prcStart->bottom, iTrans, nTrans);
/*
* Undraw old and draw new */ DrawWireFrame(hdc, &rcFront, &rcBack); CopyRect(&rcFront, &rcT); DrawWireFrame(hdc, &rcFront, &rcBack);
/*
* Check the time. How many more transitions left? * iTrans / nTrans AS (dwTimeCur-dwTimeStart) / 750 * * WARNING: If you use *lpSystemTickCount here, * the compiler may not generate code to do a DWORD fetch; */ dwTimeCur = GetSystemMsecCount(); iTrans = MultDiv(nTrans, (int)(dwTimeCur - dwTimeStart), CMS_ANIMATION); }
/*
* Undraw wire frame */ DrawWireFrame(hdc, &rcFront, &rcBack);
/*
* Clean up */ GreSetROP2(hdc, nMode); hpen = GreSelectPen(hdc, hpen);}#endif // END DISABLE OLD ANIMATION FOR M7
/***************************************************************************\
* xxxDrawAnimatedRects** General routine, like PlaySoundEvent(), that calls other routines for* various animation effects. Currently used for changing state from/to* minimized.*\***************************************************************************/
BOOL xxxDrawAnimatedRects( PWND pwndClip, int idAnimation, LPRECT lprcStart, LPRECT lprcEnd){ HDC hdc; POINT rgPt[4]; RECT rcClip; HRGN hrgn; PWND pwndAnimate = NULL; int iPt;
CheckLock(pwndClip);
/*
* Get rects into variables */ CopyRect((LPRECT)&rgPt[0], lprcStart); CopyRect((LPRECT)&rgPt[2], lprcEnd);
/*
* DISABLE OLD ANIMATION FOR M7 */ if (idAnimation != IDANI_CAPTION) return TRUE;
pwndAnimate = pwndClip; if (!pwndAnimate || pwndAnimate == PWNDDESKTOP(pwndAnimate)) return FALSE;
pwndClip = pwndClip->spwndParent; if (!pwndClip) { RIPMSG0(RIP_WARNING, "xxxDrawAnimatedRects: pwndClip->spwndParent is NULL"); } else if (pwndClip == PWNDDESKTOP(pwndClip)) { pwndClip = NULL; }
/*
* NOTE: * We do NOT need to do LockWindowUpdate(). We never yield within this * function! Anything that was invalid will stay invalid, etc. So our * XOR drawing won't leave remnants around. * * WIN32NT may need to take display critical section or do LWU(). * * Get clipping area * Neat feature: * NULL window means whole screen, don't clip out children * hwndDesktop means working area, don't clip out children */ if (pwndClip == NULL) { pwndClip = _GetDesktopWindow(); CopyRect(&rcClip, &pwndClip->rcClient); if ((hrgn = GreCreateRectRgnIndirect(&rcClip)) == NULL) { hrgn = HRGN_FULL; }
/*
* Get drawing DC */ hdc = _GetDCEx(pwndClip, hrgn, DCX_WINDOW | DCX_CACHE | DCX_INTERSECTRGN | DCX_LOCKWINDOWUPDATE); } else {
hdc = _GetDCEx(pwndClip, HRGN_FULL, DCX_WINDOW | DCX_USESTYLE | DCX_INTERSECTRGN);
/*
* We now have a window DC. We need to convert client coords * to window coords. */ for (iPt = 0; iPt < 4; iPt++) {
rgPt[iPt].x += (pwndClip->rcClient.left - pwndClip->rcWindow.left); rgPt[iPt].y += (pwndClip->rcClient.top - pwndClip->rcWindow.top); } }
/*
* Get drawing DC: * Unclipped if desktop, clipped otherwise. * Note that ReleaseDC() will free the region if needed. */ if (idAnimation == IDANI_CAPTION) { CheckLock(pwndAnimate); xxxAnimateCaption(pwndAnimate, hdc, (LPRECT)&rgPt[0], (LPRECT)&rgPt[2]); }
/*
* DISABLE OLD ANIMATION FOR M7 */#if 0
else { AnimateFrame(hdc, (LPRECT)&rgPt[0], (LPRECT)&rgPt[2], (idAnimation == IDANI_OPEN)); }#endif
/*
* END DISABLE OLD ANIMATION FOR M7 */
/*
* Clean up */ _ReleaseDC(hdc);
return TRUE;}
/***************************************************************************\
* CalcMinZOrder*** Compute the Z-order of a window to be minimized.** The strategy is to find the bottom-most sibling of pwndMinimize that* shares the same owner, and insert ourself behind that. We must also* take into account that a TOPMOST window should stay among other TOPMOST,* and vice versa.** We must make sure never to insert after a bottom-most window.** This code works for child windows too, since they don't have owners* and never have WEFTOPMOST set.** If NULL is returned, the window shouldn't be Z-ordered.*\***************************************************************************/
PWND CalcMinZOrder( PWND pwndMinimize){ BYTE bTopmost; PWND pwndAfter; PWND pwnd;
bTopmost = TestWF(pwndMinimize, WEFTOPMOST); pwndAfter = NULL;
for (pwnd = pwndMinimize->spwndNext; pwnd && !TestWF(pwnd, WFBOTTOMMOST); pwnd = pwnd->spwndNext) {
/*
* If we've enumerated a window that isn't the same topmost-wise * as pwndMinimize, we've gone as far as we can. */ if (TestWF(pwnd, WEFTOPMOST) != bTopmost) break;
if (pwnd->spwndOwner == pwndMinimize->spwndOwner) pwndAfter = pwnd; }
return pwndAfter;}
/***************************************************************************\
* xxxActivateOnMinimize** Activate the previously active window, provided that window still exists* and is a NORMAL window (not bottomost, minimized, disabled, or invisible).* If it's not NORMAL, then activate the first non WS_EX_TOPMOST window* that's normal. Return TRUE when no activation is needed or the activation* has been done in this function. Return FALSE if failed to find a window* to activate.*\***************************************************************************/
BOOL xxxActivateOnMinimize(PWND pwnd){ PTHREADINFO ptiCurrent = PtiCurrent(); PWND pwndStart, pwndFirstTool, pwndT; BOOL fTryTopmost = TRUE; BOOL fPrevCheck = (ptiCurrent->pq->spwndActivePrev != NULL); TL tlpwndT;
/*
* We should always have a last-topmost window. */ pwndStart = GetLastTopMostWindow(); if (pwndStart) { pwndStart = pwndStart->spwndNext; } else { pwndStart = pwnd->spwndParent->spwndChild; }
UserAssert(HIBYTE(WFMINIMIZED) == HIBYTE(WFVISIBLE)); UserAssert(HIBYTE(WFVISIBLE) == HIBYTE(WFDISABLED));
SearchAgain:
pwndT = (fPrevCheck ? ptiCurrent->pq->spwndActivePrev : pwndStart); pwndFirstTool = NULL;
/*
* TryThisWindow must be outside the beginning of the for loop such * that pwndT is checked for NULL before being dereferenced. */TryThisWindow:
for ( ; pwndT ; pwndT = pwndT->spwndNext) { /*
* Use the first nonminimized, visible, nondisabled, and * nonbottommost window */ if (!HMIsMarkDestroy(pwndT) && !TestWF(pwndT, WEFNOACTIVATE) && (TestWF(pwndT, WFVISIBLE | WFDISABLED) == LOBYTE(WFVISIBLE)) && (!TestWF(pwndT, WFMINIMIZED) || GetFullScreen(pwndT) == FULLSCREEN)) {
if (TestWF(pwndT, WEFTOOLWINDOW)) { if (!pwndFirstTool) { pwndFirstTool = pwndT; } } else { break; } }
if (fPrevCheck) { fPrevCheck = FALSE; pwndT = pwndStart; goto TryThisWindow; } }
if (!pwndT) {
if (fTryTopmost) {
fTryTopmost = FALSE; if (pwndStart != NULL) { pwndStart = pwndStart->spwndParent->spwndChild; } else { PWND pwndDesktop = _GetDesktopWindow(); pwndStart = (pwndDesktop != NULL) ? pwndDesktop->spwndChild : NULL; } goto SearchAgain; }
pwndT = pwndFirstTool; }
if (pwndT) { ThreadLockAlwaysWithPti(ptiCurrent, pwndT, &tlpwndT); xxxSetForegroundWindow(pwndT, FALSE); ThreadUnlock(&tlpwndT); } else { return FALSE; }
return TRUE;}
/***************************************************************************\
* xxxMinMaximize** cmd = SW_MINIMIZE, SW_SHOWMINNOACTIVE, SW_SHOWMINIZED,* SW_SHOWMAXIMIZED, SW_SHOWNOACTIVE, SW_NORMAL** If MINMAX_KEEPHIDDEN is set in dwFlags, keep it hidden, otherwise show it.* This is always cleared, except in the case we call it from* createwindow(), where the wnd is iconic, but hidden. we* need to call this func, to set it up correctly so that when* the app shows the wnd, it is displayed correctly.** When changing state, we always add on SWP_STATECHANGE. This lets* SetWindowPos() know to always send WM_WINDOWPOSCHANGING/CHANGED messages* even if the new size is the same as the old size. This is because* apps watch the WM_SIZE wParam field to see when they are changing state.* If SWP doesn't send WM_WINDOWPOSCHANGED, then they won't get a WM_SIZE* message at all.** Furthermore, when changing state to/from maximized, if we are really* maximizing and are in multiple monitor mode, we want to set the window's* region so that it can't draw outside of the monitor. Otherwise, it* will spill over onto another. The borders are really annoying.*\***************************************************************************/
PWND xxxMinMaximize( PWND pwnd, UINT cmd, DWORD dwFlags){ RECT rc; RECT rcWindow; RECT rcRestore; BOOL fShow = FALSE; BOOL fSetFocus = FALSE; BOOL fShowOwned = FALSE; BOOL fSendActivate = FALSE; BOOL fMaxStateChanging = FALSE; int idAnimation = 0; BOOL fFlushPalette = FALSE; UINT swpFlags = 0; HWND hwndAfter = NULL; PWND pwndT; PCHECKPOINT pcp; PTHREADINFO ptiCurrent; TL tlpwndParent; TL tlpwndT; PSMWP psmwp; BOOL fIsTrayWindowNow = FALSE; NTSTATUS Status; MINMAXINFO mmi; UINT uEvent = 0; PWND pwndParent = pwnd->spwndParent; BOOL bMirroredParent=FALSE;
CheckLock(pwnd);
/*
* Get window rect, in parent client coordinates. */ GetRect(pwnd, &rcWindow, GRECT_WINDOW | GRECT_PARENTCOORDS);
/*
* If this is NULL, we're out of memory, so punt now. */ pcp = CkptRestore(pwnd, &rcWindow); if (!pcp) goto Exit;
/*
* If this top-level window is placed in a mirrored desktop, * its coordinates should be mirrored here so that xxxAnimateCaptions * works properly, however we shouldn't change the actual screen coordinates * of the window. This is why I do it after CkptRestore(...). [samera] */ if (TestWF(pwndParent,WEFLAYOUTRTL) && (!TestWF(pwnd,WFCHILD))) { int iLeft = rcWindow.left; rcWindow.left = pwndParent->rcWindow.right - rcWindow.right; rcWindow.right = pwndParent->rcWindow.right - iLeft; bMirroredParent = TRUE; }
/*
* Save the previous restore size. */ CopyRect(&rcRestore, &pcp->rcNormal);
/*
* First ask the CBT hook if we can do this operation. */ if ( IsHooked(PtiCurrent(), WHF_CBT) && xxxCallHook(HCBT_MINMAX, (WPARAM)HWq(pwnd), (DWORD)cmd, WH_CBT)) {
goto Exit; }
/*
* If another MDI window is being maximized, and we want to restore this * one to its previous state, we can't change the zorder or the * activation. We'd mess things up that way. BTW, this SW_ value is * internal. */ if (cmd == SW_MDIRESTORE) {
swpFlags |= SWP_NOZORDER | SWP_NOACTIVATE;
cmd = (pcp->fWasMinimizedBeforeMaximized ? SW_SHOWMINIMIZED : SW_SHOWNORMAL); }
ptiCurrent = PtiCurrent();
switch (cmd) { case SW_MINIMIZE: // Bottom of zorder, make top-level active
case SW_SHOWMINNOACTIVE: // Bottom of zorder, don't change activation
if (gpqForeground && gpqForeground->spwndActive) swpFlags |= SWP_NOACTIVATE;
if ((pwndT = CalcMinZOrder(pwnd)) == NULL) { swpFlags |= SWP_NOZORDER; } else { hwndAfter = PtoHq(pwndT); }
/*
* FALL THRU */
case SW_SHOWMINIMIZED: // Top of zorder, make active
/*
* Force a show. */ fShow = TRUE;
/*
* If already minimized, then don't change the existing * parking spot. */ if (TestWF(pwnd, WFMINIMIZED)) {
/*
* If we're already minimized and we're properly visible * or not visible, don't do anything */ if (TestWF(pwnd, WFVISIBLE)) return NULL;
swpFlags |= SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE;
goto Showit; }
/*
* We're becoming minimized although we currently are not. So * we want to draw the transition animation, and ALWAYS send * sizing messages. */ idAnimation = IDANI_CLOSE;
if (!pcp->fDragged) pcp->fMinInitialized = FALSE;
if (!pcp->fMinInitialized) ParkIcon(pwnd, pcp);
rc.left = pcp->ptMin.x; rc.top = pcp->ptMin.y; rc.right = pcp->ptMin.x + SYSMET(CXMINIMIZED); rc.bottom = pcp->ptMin.y + SYSMET(CYMINIMIZED);
xxxShowOwnedWindows(pwnd, SW_PARENTCLOSING, NULL);
pwndT = ptiCurrent->pq->spwndFocus;
while (pwndT) {
/*
* if we or any child has the focus, punt it away */ if (pwndT != pwnd) { pwndT = pwndT->spwndParent; continue; }
ThreadLockAlwaysWithPti(ptiCurrent, pwndT, &tlpwndT);
if (TestwndChild(pwnd)) {
ThreadLockWithPti(ptiCurrent, pwnd->spwndParent, &tlpwndParent); xxxSetFocus(pwnd->spwndParent); ThreadUnlock(&tlpwndParent);
} else { xxxSetFocus(NULL); }
ThreadUnlock(&tlpwndT); break; }
/*
* Save the maximized state so that we can restore the window maxed */ if (TestWF(pwnd, WFMAXIMIZED)) { pcp->fWasMaximizedBeforeMinimized = TRUE; fMaxStateChanging = TRUE; } else{ pcp->fWasMaximizedBeforeMinimized = FALSE; }
if (!TestWF(pwnd, WFWIN40COMPAT)) fIsTrayWindowNow = IsTrayWindow(pwnd);
/*
* Decrement the visible-windows count only if the * window is visible. If the window is marked for * destruction, we will not decrement for that as * well. Let SetMinimize take care of this. */ SetMinimize(pwnd, SMIN_SET); ClrWF(pwnd, WFMAXIMIZED);
uEvent = EVENT_SYSTEM_MINIMIZESTART;
if (!TestWF(pwnd, WFWIN40COMPAT)) fIsTrayWindowNow = (fIsTrayWindowNow != IsTrayWindow(pwnd));
/*
* The children of this window are now no longer visible. * Ensure that they no longer have any update regions... */ for (pwndT = pwnd->spwndChild; pwndT; pwndT = pwndT->spwndNext) ClrFTrueVis(pwndT);
/*
* B#2919 * Ensure that the client area gets recomputed, and make * sure that no bits are copied when the size is changed. And * make sure that WM_SIZE messages get sent, even if our client * size is staying the same. */ swpFlags |= (SWP_DRAWFRAME | SWP_NOCOPYBITS | SWP_STATECHANGE);
/*
* We are going minimized, so we want to give palette focus to * another app. */ if (pwnd->spwndParent == PWNDDESKTOP(pwnd)) { fFlushPalette = (BOOL)TestWF(pwnd, WFHASPALETTE); }
break;
case SW_SHOWNOACTIVATE: if (gpqForeground && gpqForeground->spwndActive) swpFlags |= SWP_NOACTIVATE;
/*
* FALL THRU */
case SW_RESTORE:
/*
* If restoring a minimized window that was maximized before * being minimized, go back to being maximized. */ if (TestWF(pwnd, WFMINIMIZED) && pcp->fWasMaximizedBeforeMinimized) cmd = SW_SHOWMAXIMIZED; else cmd = SW_NORMAL;
/*
* FALL THRU */
case SW_NORMAL: case SW_SHOWMAXIMIZED:
if (cmd == SW_SHOWMAXIMIZED) {
/*
* If already maximized and visible, we have nothing to do * Otherwise, for the DOSbox, still set fMaxStateChanging * to TRUE so we recalc the monitor region if need be. * That way WinOldAp can change its "changing from maxed to * maxed with new bigger font" code to work right. */ if (TestWF(pwnd, WFMAXIMIZED)) { if (TestWF(pwnd, WFVISIBLE)) { return NULL; } } else { /*
* We're changing from normal to maximized, so always * send WM_SIZE. */ swpFlags |= SWP_STATECHANGE; } fMaxStateChanging = TRUE;
/*
* If calling from CreateWindow, don't let the thing become * activated by the SWP call below. Acitvation will happen * on the ShowWindow done by CreateWindow or the app. */ if (dwFlags & MINMAX_KEEPHIDDEN) swpFlags |= SWP_NOACTIVATE;
/*
* This is for MDI's auto-restore behaviour (craigc) */ if (TestWF(pwnd, WFMINIMIZED)) pcp->fWasMinimizedBeforeMaximized = TRUE;
xxxInitSendValidateMinMaxInfo(pwnd, &mmi);
} else {
/*
* We're changing state from non-normal to normal. Make * sure WM_SIZE gets sents. */ UserAssert(HIBYTE(WFMINIMIZED) == HIBYTE(WFMAXIMIZED)); if (TestWF(pwnd, WFMINIMIZED | WFMAXIMIZED)) { swpFlags |= SWP_STATECHANGE; } if (TestWF(pwnd, WFMAXIMIZED)) { fMaxStateChanging = TRUE; } }
/*
* If currently minimized, show windows' popups */ if (TestWF(pwnd, WFMINIMIZED)) {
/*
* Send WM_QUERYOPEN to make sure this guy should unminimize */ if (!xxxSendMessage(pwnd, WM_QUERYOPEN, 0, 0L)) return NULL;
idAnimation = IDANI_OPEN; fShowOwned = TRUE; fSetFocus = TRUE;
/*
* JEFFBOG B#2868 * Condition added before setting fSendActivate prevents * WM_ACTIVATE message from reaching a child window. Might * be backwards compatibility problems if a pre 3.1 app * relies on WM_ACTIVATE reaching a child. */ if (!TestWF(pwnd, WFCHILD)) fSendActivate = TRUE;
swpFlags |= SWP_NOCOPYBITS; } else { idAnimation = IDANI_CAPTION; }
if (cmd == SW_SHOWMAXIMIZED) { rc.left = mmi.ptMaxPosition.x; rc.top = mmi.ptMaxPosition.y; rc.right = rc.left + mmi.ptMaxSize.x; rc.bottom = rc.top + mmi.ptMaxSize.y;
SetWF(pwnd, WFMAXIMIZED);
} else { CopyRect(&rc, &rcRestore); ClrWF(pwnd, WFMAXIMIZED); }
/*
* We do this TestWF again since we left the critical section * above and someone might have already 'un-minimized us'. */ if (TestWF(pwnd, WFMINIMIZED)) {
if (!TestWF(pwnd, WFWIN40COMPAT)) fIsTrayWindowNow = IsTrayWindow(pwnd);
/*
* Mark it as minimized and adjust cVisWindows. */ SetMinimize(pwnd, SMIN_CLEAR);
uEvent = EVENT_SYSTEM_MINIMIZEEND;
/*
* if we're unminimizing a window that is now * not seen in maximized/restore mode then remove him * from the tray */ if (!TestWF(pwnd, WFWIN40COMPAT) && (fIsTrayWindowNow != IsTrayWindow(pwnd)) && FDoTray()) {
HWND hw = HWq(pwnd);
if (FCallHookTray()) { xxxCallHook(HSHELL_WINDOWDESTROYED, (WPARAM)hw, (LPARAM)0, WH_SHELL); }
/*
* NT specific code. Post the window-destroyed message * to the shell. */ if (FPostTray(pwnd->head.rpdesk)) PostShellHookMessages(HSHELL_WINDOWDESTROYED, (LPARAM)hw); }
fIsTrayWindowNow = FALSE;
/*
* If we're un-minimizing a visible top-level window, cVisWindows * was zero, and we're either activating a window or showing * the currently active window, set ourselves into the * foreground. If the window isn't currently visible * then we can rely on SetWindowPos() to do the right * thing for us. */ if (!TestwndChild(pwnd) && TestWF(pwnd, WFVISIBLE) && (GETPTI(pwnd)->cVisWindows == 1) && (GETPTI(pwnd)->pq != gpqForeground) && (!(swpFlags & SWP_NOACTIVATE) || (GETPTI(pwnd)->pq->spwndActive == pwnd))) {
xxxSetForegroundWindow2(pwnd, GETPTI(pwnd), SFW_STARTUP); } }
/*
* Ensure that client area gets recomputed, and that * the frame gets redrawn to reflect the new state. */ swpFlags |= SWP_DRAWFRAME; break; }
/*
* For the iconic case, we need to also show the window because it * might not be visible yet. */
Showit:
if (!(dwFlags & MINMAX_KEEPHIDDEN)) {
if (TestWF(pwnd, WFVISIBLE)) {
if (fShow) swpFlags |= SWP_SHOWWINDOW;
/* if we're full screening a DOS BOX then don't draw
* the animation 'cause it looks bad. * overloaded WFFULLSCREEN bit for MDI child windows -- * use it to indicate to not animate size change. */ if (IsVisible(pwnd) && (dwFlags & MINMAX_ANIMATE) && idAnimation && (!TestWF(pwnd, WFCHILD) || !TestWF(pwnd, WFNOANIMATE))) {
/*
* If this top-level window is placed in a mirrored desktop, * its coordinates should be mirrored here so that xxxAnimateCaptions * works properly, however we shouldn't change the actual screen coordinates * of the window. This is why I do it here and restore it afterwards before * doing the _DeferWindowPos(...). [samera] */ RECT rcT; if (bMirroredParent) { int iLeft = rc.left; rcT = rc; rc.left = pwndParent->rcWindow.right - rc.right; rc.right = pwndParent->rcWindow.right - iLeft; }
if ((idAnimation != IDANI_CAPTION) && IsTrayWindow(pwnd)) {
RECT rcMin;
SetRectEmpty(&rcMin);#if 0 // Win95 call.
CallHook(HSHELL_GETMINRECT, (WPARAM)HW16(hwnd), (LPARAM)(LPRECT)&rcMin, WH_SHELL);#else
xxxSendMinRectMessages(pwnd, &rcMin);#endif
if (!IsRectEmpty(&rcMin)) {
if (idAnimation == IDANI_CLOSE) {
xxxDrawAnimatedRects(pwnd, IDANI_CAPTION, &rcWindow, &rcMin);
} else {
xxxDrawAnimatedRects(pwnd, IDANI_CAPTION, &rcMin, &rc); } }
} else { xxxDrawAnimatedRects(pwnd, IDANI_CAPTION, &rcWindow, &rc); } /*
* Restore the original rect, after doing the animation */ if (bMirroredParent) { rc = rcT; } }
} else { swpFlags |= SWP_SHOWWINDOW; } }
/*
* hack for VB - we add their window in when their minimizing. */ if (!TestWF(pwnd, WFWIN40COMPAT) && fIsTrayWindowNow && FDoTray()) {
HWND hw = HWq(pwnd);
if (FCallHookTray()) { xxxCallHook(HSHELL_WINDOWCREATED, (WPARAM)hw, (LPARAM)0, WH_SHELL); }
/*
* NT specific code. Post the window-created message * to the shell. */ if (FPostTray(pwnd->head.rpdesk)) PostShellHookMessages(HSHELL_WINDOWCREATED, (LPARAM)hw); }
/*
* BACKWARD COMPATIBILITY HACK: * * Because SetWindowPos() won't honor sizing, moving and SWP_SHOWWINDOW * at the same time in version 3.0 or below, we call DeferWindowPos() * directly here. */ if (psmwp = InternalBeginDeferWindowPos(1)) {
psmwp = _DeferWindowPos(psmwp, pwnd, ((hwndAfter != NULL) ? RevalidateHwnd(hwndAfter) : NULL), rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, swpFlags);
if (psmwp) {
/*
* HACK FOR MULTIPLE MONITOR TRUE MAXIMIZATION CLIPPING * On a multiple monitor system, we would like the * borders not to spill over onto another monitor when a * window 'really' maximizes. The only way to get this * to work right is to set a rectangular region, namely * a copy of the monitor region, on the window. We can * only do this if the window isn't currently regional. * * Going to maximized: Add the monitor region * Coming from maximized: Remove the monitor region */ if (fMaxStateChanging && gpDispInfo->cMonitors > 1) { if ( TestWF(pwnd, WFMAXIMIZED) && pwnd->spwndParent == PWNDDESKTOP(pwnd)) {
psmwp->acvr[0].hrgnClip = HRGN_MONITOR;
} else if (TestWF(pwnd, WFMAXFAKEREGIONAL)) { UserAssert(pwnd->hrgnClip); psmwp->acvr[0].hrgnClip = HRGN_FULL; } }
xxxEndDeferWindowPosEx(psmwp, FALSE); } }
if (uEvent) { xxxWindowEvent(uEvent, pwnd, OBJID_WINDOW, 0, WEF_USEPWNDTHREAD); }
/*
* COMPATIBILITY HACK: * Borland's OBEX expects a WM_PAINT message when it starts running * minimized and initializes all it's data during that message. * So, we generate a bogus WM_PAINT message here. * Also, Visionware's XServer can not handle getting a WM_PAINT msg, as it * would always get a WM_PAINTICON msg in 3.1, so make sure the logic is here * to generate the correct message. */ if((cmd == SW_SHOWMINIMIZED) && (!TestWF(pwnd, WFWIN40COMPAT)) && TestWF(pwnd, WFVISIBLE) && TestWF(pwnd, WFTOPLEVEL)) {
if (pwnd->pcls->spicn) _PostMessage(pwnd, WM_PAINTICON, (WPARAM)TRUE, 0L); else _PostMessage(pwnd, WM_PAINT, 0, 0L); }
if (fShowOwned) xxxShowOwnedWindows(pwnd, SW_PARENTOPENING, NULL);
if ((cmd == SW_MINIMIZE) && (pwnd->spwndParent == PWNDDESKTOP(pwnd))) { if (!xxxActivateOnMinimize(pwnd)) { xxxActivateWindow(pwnd, AW_SKIP); }
{ PEPROCESS p;
if (gptiForeground && ptiCurrent->ppi != gptiForeground->ppi && !(ptiCurrent->TIF_flags & TIF_SYSTEMTHREAD)) {
p = PsGetThreadProcess(ptiCurrent->pEThread); KeAttachProcess(PsGetProcessPcb(p)); Status = MmAdjustWorkingSetSize((SIZE_T)-1, (SIZE_T)-1, FALSE, TRUE); KeDetachProcess();
if (!NT_SUCCESS(Status)) { RIPMSG1(RIP_ERROR, "Error adjusting working set, status = %x\n", Status); } } }
/*
* If any app is starting, restore its right to foreground activate * (activate and come on top of everything else) because we just * minimized what we were working on. */ RestoreForegroundActivate(); }
/*
* If going from iconic, insure the focus is in the window. */ if (fSetFocus) xxxSetFocus(pwnd);
/*
* This was added for 1.03 compatibility reasons. If apps watch * WM_ACTIVATE to set their focus, sending this message will appear * as if the window just got activated (like in 1.03). Before this * was added, opening an iconic window never sent this message since * it was already active (but HIWORD(lParam) != 0). */ if (fSendActivate) xxxSendMessage(pwnd, WM_ACTIVATE, WA_ACTIVE, 0);
/*
* Flush the palette. We do this on a minimize of a palette app. */ if (fFlushPalette) xxxFlushPalette(pwnd);
Exit: return NULL;}
/***************************************************************************\
* xxxMinimizeHungWindow** 10/31/96 vadimg created\***************************************************************************/
void xxxMinimizeHungWindow(PWND pwnd){ RECT rcMin; HRGN hrgnHung;
CheckLock(pwnd);
/*
* If the window is already minimized or not visible don't do anything. */ if (TestWF(pwnd, WFMINIMIZED) || !TestWF(pwnd, WFVISIBLE)) return;
/*
* Animate the caption to the minimized state. */ if (TEST_PUDF(PUDF_ANIMATE)) { SetRectEmpty(&rcMin); xxxSendMinRectMessages(pwnd, &rcMin); if (!IsRectEmpty(&rcMin)) { xxxDrawAnimatedRects(pwnd, IDANI_CAPTION, &pwnd->rcWindow, &rcMin); } }
/*
* Reset the visible bit on the window itself and ownees. At the same * time calculate how much needs to be repainted. We must invalidate * the DC cache to make sure that the visible regions get recalculated. */ SetVisible(pwnd, SV_UNSET); hrgnHung = GreCreateRectRgnIndirect(&pwnd->rcWindow); xxxShowOwnedWindows(pwnd, SW_PARENTCLOSING, hrgnHung); zzzInvalidateDCCache(pwnd, IDC_DEFAULT); xxxRedrawWindow(NULL, NULL, hrgnHung, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN); GreDeleteObject(hrgnHung);
/*
* Deal with activating some other window for top-level windows. */ if (pwnd->spwndParent == PWNDDESKTOP(pwnd)) { xxxActivateOnMinimize(pwnd); } PostEventMessage(GETPTI(pwnd), GETPTI(pwnd)->pq, QEVENT_HUNGTHREAD, pwnd, 0, 0, 0);}
|
