void
xxxInvalidateDesktopOnPaletteChange(PWND pwnd)
{
PDESKTOP pdesk;
PWND pwndShell;
TL tlpwndShell;
RECT rc;
BOOL fRedrawDesktop;
CheckLock(pwnd);
/*
* Invalidate the shell window.
*/
pdesk = PtiCurrent()->rpdesk;
pwndShell = (pdesk) ? pdesk->pDeskInfo->spwndShell : NULL;
if (!pwndShell) {
fRedrawDesktop = TRUE;
rc = gpsi->rcScreen;
} else {
ThreadLockAlways(pwndShell, &tlpwndShell);
xxxRedrawWindow(
pwndShell,
NULL,
NULL,
RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
/*
* The shell window may not cover all of the desktop.
* Invalidate the part of the desktop wallpaper it
* doesn't sit over.
*/
fRedrawDesktop = SubtractRect(&rc, &pwnd->rcWindow, &pwndShell->rcWindow);
ThreadUnlock(&tlpwndShell);
}
/*
* Invalidate the desktop window.
*/
if (fRedrawDesktop) {
xxxRedrawWindow(
pwnd,
&rc,
NULL,
RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
}
}
/***************************************************************************\
* xxxCancelMouseMoveTracking
*
* History
* 12/07/96 GerardoB Created
\***************************************************************************/
void xxxCancelMouseMoveTracking (DWORD dwDTFlags, PWND pwndTrack, int htEx, DWORD dwDTCancel)
{
CheckLock(pwndTrack);
/*
* Hottracking
*/
if ((dwDTFlags & DF_HOTTRACKING) && (dwDTCancel & DF_HOTTRACKING)) {
/*
* The current state must be owned by the current queue.
* Otherwise, we're about to do an inter-queue cancelation.
*/
UserAssert(PtiCurrent()->pq == GETPTI(pwndTrack)->pq);
xxxHotTrack(pwndTrack, htEx, FALSE);
}
/*
* Tooltips
*/
if ((dwDTFlags & DF_TOOLTIPSHOWING) && (dwDTCancel & DF_TOOLTIP)) {
PTOOLTIPWND pttwnd = (PTOOLTIPWND)PWNDTOOLTIP(pwndTrack);
TL tlpwnd;
ThreadLockAlways(pttwnd, &tlpwnd);
xxxResetTooltip(pttwnd);
ThreadUnlock(&tlpwnd);
}
/*
* Mouse Leave
*/
if ((dwDTFlags & DF_TRACKMOUSELEAVE) && (dwDTCancel & DF_TRACKMOUSELEAVE)) {
_PostMessage(pwndTrack,
((htEx == HTCLIENT) ? WM_MOUSELEAVE : WM_NCMOUSELEAVE),
0, 0);
}
/*
* Mouse Hover
*/
if ((dwDTFlags & DF_TRACKMOUSEHOVER) && (dwDTCancel & DF_TRACKMOUSEHOVER)) {
_KillSystemTimer(pwndTrack, IDSYS_MOUSEHOVER);
}
}
VOID UserRedrawDesktop(VOID)
{
TL tlpwnd;
PWND pwndDesk;
EnterCrit();
pwndDesk = PtiCurrent()->rpdesk->pDeskInfo->spwnd;
ThreadLockAlways(pwndDesk, &tlpwnd);
xxxInternalInvalidate(pwndDesk,
HRGN_FULL,
RDW_INVALIDATE |
RDW_ERASE |
RDW_FRAME |
RDW_ALLCHILDREN);
ThreadUnlock(&tlpwnd);
LeaveCrit();
}
void xxxResetTooltip(PTOOLTIPWND pttwnd)
{
KillTooltipTimer(pttwnd);
CheckLock(pttwnd);
if (TestWF(pttwnd, WFVISIBLE)) {
PWND spwndMessage;
TL tlpwnd;
xxxSetWindowPos((PWND)pttwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE |
SWP_NOMOVE | SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOZORDER);
spwndMessage = PWNDMESSAGE(pttwnd);
ThreadLockAlways(spwndMessage, &tlpwnd);
xxxSetParent((PWND)pttwnd, spwndMessage);
ThreadUnlock(&tlpwnd);
}
ZeroTooltip(pttwnd);
pttwnd->head.rpdesk->dwDTFlags &= ~DF_TOOLTIP;
}
int DlgDirSelectComboBoxExW(
HWND hwndDlg,
LPWSTR pwszOut,
int cchOut,
int idComboBox)
{
BOOL fRet;
TL tlpwndComboBox;
TL tlpwndList;
PWND pwndDlg;
PWND pwndComboBox;
PCBOX pcbox;
pwndDlg = ValidateHwnd(hwndDlg);
if (pwndDlg == NULL)
return FALSE;
pwndComboBox = _GetDlgItem(pwndDlg, idComboBox);
if (pwndComboBox == NULL) {
RIPERR0(ERROR_CONTROL_ID_NOT_FOUND, RIP_VERBOSE, "");
return 0;
}
pcbox = ((PCOMBOWND)pwndComboBox)->pcbox;
if (pcbox == NULL) {
RIPERR0(ERROR_WINDOW_NOT_COMBOBOX, RIP_VERBOSE, "");
return 0;
}
ThreadLockAlways(pwndComboBox, &tlpwndComboBox);
ThreadLock(pcbox->spwndList, &tlpwndList);
fRet = xxxDlgDirSelectHelper(pwndComboBox, pwszOut, cchOut, pcbox->spwndList);
ThreadUnlock(&tlpwndList);
ThreadUnlock(&tlpwndComboBox);
return fRet;
}
void xxxTooltipHandleTimer(PTOOLTIPWND pttwnd, UINT uTID)
{
switch(uTID) {
case TTT_SHOW: {
/*
* Move the tooltip window to the desktop so it can
* be shown. Then show it.
*/
PWND pwndDesktop = PWNDDESKTOP(pttwnd);
TL tlpwnd;
ThreadLockAlways(pwndDesktop, &tlpwnd);
xxxSetParent((PWND)pttwnd, pwndDesktop);
ThreadUnlock(&tlpwnd);
xxxShowTooltip(pttwnd);
break;
}
case TTT_ANIMATE:
/*
* If animation is completed, set timer to hide
*/
if (TooltipAnimate(pttwnd)) {
SetTooltipTimer(pttwnd, TTT_HIDE, pttwnd->dwHideDelay);
}
break;
case TTT_HIDE:
/*
* Hide it
*/
xxxResetTooltip(pttwnd);
break;
}
}
void xxxShowOwnedWindows(
PWND pwndOwner,
UINT cmdShow)
{
BOOL fShow;
int cmdZoom;
HWND *phwnd;
PBWL pbwl;
PWND pwnd, pwndTopOwner;
TL tlpwnd;
CheckLock(pwndOwner);
/*
* Not interested in child windows
*/
if (TestwndChild(pwndOwner))
return;
if ((pbwl = BuildHwndList(PWNDDESKTOP(pwndOwner)->spwndChild, BWL_ENUMLIST, NULL)) == NULL)
return;
/*
* NOTE: The following code assumes the values of SW_* are 1, 2, 3, and 4
*/
fShow = (cmdShow >= SW_PARENTOPENING);
cmdZoom = 0;
if (cmdShow == SW_OTHERZOOM)
cmdZoom = SIZEZOOMHIDE;
if (cmdShow == SW_OTHERUNZOOM)
cmdZoom = SIZEZOOMSHOW;
/*
* If zoom/unzoom, then open/close all popups owned by all other
* windows. Otherwise, open/close popups owned by pwndOwner.
*/
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
/*
* Lock the window before we play with it.
* If the window handle is invalid, skip it
*/
if ((pwnd = RevalidateHwnd(*phwnd)) == NULL)
continue;
/*
* Kanji windows can't be owned, so skip it.
*/
if (TestCF(pwnd, CFKANJIWINDOW))
continue;
/*
* If same as window passed in, skip it.
*/
if (pwnd == pwndOwner)
continue;
/*
* Find ultimate owner of popup, but only go up as far as pwndOwner.
*/
if ((pwndTopOwner = pwnd->spwndOwner) != NULL) {
/*
* The TestwndHI is needed since if it has an icon, pwndOwner
* is invalid.
*/
while (!TestwndHI(pwndTopOwner) && pwndTopOwner != pwndOwner &&
pwndTopOwner->spwndOwner != NULL)
pwndTopOwner = pwndTopOwner->spwndOwner;
}
/*
* Zoom/Unzoom case.
*/
if (cmdZoom != 0) {
/*
* If no parent, or parents are the same, skip.
*/
if (pwndTopOwner == NULL || pwndTopOwner == pwndOwner)
continue;
/*
* If owner is iconic, then this window should stay hidden,
* UNLESS the minimized window is disabled, in which case we'd
* better show the window.
*/
if ( cmdShow == SW_OTHERUNZOOM
&& pwndTopOwner != NULL
&& TestWF(pwndTopOwner, WFMINIMIZED)
&& !TestWF(pwndTopOwner, WFDISABLED)
)
continue;
} else {
/*
* Hide/Iconize/Show/Open case.
*/
/*
* If parents aren't the same, skip.
*/
if (pwndTopOwner != pwndOwner)
continue;
}
/*
* Hide or show if:
* Showing & this is a hidden popup
* OR
* Hiding & this is a visible window
*/
if ((fShow && TestWF(pwnd, WFHIDDENPOPUP)) ||
(!fShow && TestWF(pwnd, WFVISIBLE))) {
ThreadLockAlways(pwnd, &tlpwnd);
xxxSendMessage(pwnd, WM_SHOWWINDOW, fShow, (LONG)cmdShow);
ThreadUnlock(&tlpwnd);
}
}
/*
* Free the window list.
*/
FreeHwndList(pbwl);
}
void xxxTrackMouseMove(PWND pwnd, int htEx, UINT message)
{
BOOL fNewpwndTrack;
DWORD dwDTCancel = 0;
TL tlpwnd;
LPWSTR pstr;
PDESKTOP pdesk = PtiCurrent()->rpdesk;
PTHREADINFO ptiTrack;
#if DBG
/*
* Let's warn if this function gets reenterd so we can make sure
* nothing bad will follow. This should be a rare situation.
* Look in gptiReEntered to find out who is already here.
*/
static UINT gcReEntered = 0;
static PTHREADINFO gptiReEntered;
if(gcReEntered++ != 0){
RIPMSG2(RIP_WARNING, "Reentered xxxTrackMouseMove; previous thread was %#p, current thread is %#p", gptiReEntered, PtiCurrent());
}
gptiReEntered = PtiCurrent();
CheckLock(pwnd);
/*
* We must be on an interactive window station.
*/
if (pdesk->rpwinstaParent != NULL &&
pdesk->rpwinstaParent->dwWSF_Flags & WSF_NOIO) {
RIPMSG0(RIP_ERROR, "Can't use tooltips on non-interactive winsta");
}
{
static POINT pt = {0, 0};
#ifdef UNDONE
/*
* We might have taken a guess on the hit test (see FindNCHitEx)
* so if we're at the same point and same window, something
* might be fishy
*/
if ((pt.x == gpsi->ptCursor.x)
&& (pt.y == gpsi->ptCursor.y)
&& (pdesk->spwndTrack == pwnd)) {
RIPMSG1(RIP_WARNING, "xxxTrackMouseMove: Same point & window. %#p", pwnd);
}
#endif
/*
* Something is supposed to have changed or we're wasting time
*/
UserAssert((pt.x != gpsi->ptCursor.x)
|| (pt.y != gpsi->ptCursor.y)
|| (pdesk->spwndTrack != pwnd)
|| (pdesk->htEx != htEx)
|| (message != WM_MOUSEMOVE));
/*
* Remember last tracked point
*/
pt = gpsi->ptCursor;
}
/*
* pwnd is supposed to be on the current thread and queue
*/
UserAssert(PtiCurrent() == GETPTI(pwnd));
UserAssert(PtiCurrent()->pq == GETPTI(pwnd)->pq);
#endif
/*
* Have we switched windows?
*/
fNewpwndTrack = (pdesk->spwndTrack != pwnd);
/*
* If no tracking is taking place, just go set the new
* tracking state
*/
if (!(pdesk->dwDTFlags & DF_MOUSEMOVETRK)) {
goto SetNewState;
}
/*
* Potentially while we leave the critical section below in
* xxxCancelMouseMoveTracking, spwndTrack could be destroyed and unlocked
* and then we go and create the tooltip. This would mean that
* DF_TOOLTIPACTIVE (part of DF_MOUSEMOVETRK test above) would be set,
* but pdesk->spwndTrack would be NULL and we can AV dereferencing
* pdesk->spwndTrack below. Prevent this by making the check here.
*/
if (pdesk->spwndTrack == NULL) {
goto SetNewState;
}
/*
* Nuke hottracking and deactivate tooltip state, if any.
* Do it sychronously if we're tracking on the current queue;
* Otherwise, post an event and let it happen later.
*/
ptiTrack = GETPTI(pdesk->spwndTrack);
if (PtiCurrent()->pq == ptiTrack->pq) {
dwDTCancel |= DF_HOTTRACKING;
} else if (pdesk->dwDTFlags & (DF_HOTTRACKING | DF_TOOLTIPACTIVE)) {
PostEventMessage(ptiTrack, ptiTrack->pq,
QEVENT_CANCELMOUSEMOVETRK,
pdesk->spwndTrack,
pdesk->dwDTFlags,
pdesk->htEx, DF_HOTTRACKING);
/*
* Paranoid assertion. If we're switching queues, we must
* be switching windows. Did we just go through
* ReattachThreads?
*/
UserAssert(pwnd != pdesk->spwndTrack);
pdesk->dwDTFlags &= ~(DF_HOTTRACKING | DF_TOOLTIPACTIVE);
}
/*
* If we're on the client area or the user clicked,
* nuke the tooltip (if any).
* Since we might want to re-show the tooltip, we don't nuke it
* now if we swichted windows (we'll nuke it later if needed)
*/
if ((htEx == HTCLIENT) || (message != WM_MOUSEMOVE)) {
dwDTCancel |= DF_TOOLTIPACTIVE;
}
/*
* If we switched windows or crossed client/nonclinet boundaries,
* end track mouse leave/hover.
*/
if (fNewpwndTrack || ((pdesk->htEx == HTCLIENT) ^ (htEx == HTCLIENT))) {
dwDTCancel |= DF_TRACKMOUSEEVENT;
}
/*
* Cancel whatever is active and needs to go away
*/
ThreadLockAlways(pdesk->spwndTrack, &tlpwnd);
xxxCancelMouseMoveTracking(pdesk->dwDTFlags,
pdesk->spwndTrack,
pdesk->htEx,
dwDTCancel);
ThreadUnlock(&tlpwnd);
pdesk->dwDTFlags &= ~dwDTCancel;
SetNewState:
/*
* Hottracking/tooltip on mouse move if on NC hitest and enabled
*/
if ((htEx != HTCLIENT) && (message == WM_MOUSEMOVE) && TestEffectUP(HOTTRACKING)) {
/*
* Hottrack the new hit test area
*/
if (xxxHotTrack(pwnd, htEx, TRUE)) {
pdesk->dwDTFlags |= DF_HOTTRACKING;
}
/*
* Remove/set the tool tip.
* We always do this synchronously because it doesn't mess
* with pwnd's or spwnTrack's queue
*/
if ((pstr = IsTooltipHittest(pwnd, LOWORD(htEx))) != NULL) {
PTOOLTIPWND pttwnd = (PTOOLTIPWND)pdesk->spwndTooltip;
ThreadLockAlways(pttwnd, &tlpwnd);
xxxCreateTooltip(pttwnd, pstr);
ThreadUnlock(&tlpwnd);
pdesk->dwDTFlags |= DF_TOOLTIP;
} else {
PTOOLTIPWND pttwnd = (PTOOLTIPWND)pdesk->spwndTooltip;
ThreadLockAlways(pttwnd, &tlpwnd);
xxxResetTooltip(pttwnd);
ThreadUnlock(&tlpwnd);
}
} /* if (htEx != HTCLIENT) */
ValidateThreadLocks(NULL, PtiCurrent()->ptl, (ULONG_PTR)&pwnd, TRUE);
/*
* Update new track window if needed.
*/
if (fNewpwndTrack) {
PWND pwndActivate;
Lock(&pdesk->spwndTrack, pwnd);
/*
* Active window tracking.
* If there is non-zero timeout, get the window we're supposed to activate
* and set the timer. Otherwise, set the queue flag so
* xxxActiveWindowTracking can do its thing.
*/
if ((message == WM_MOUSEMOVE) && TestUP(ACTIVEWINDOWTRACKING)) {
if (UP(ACTIVEWNDTRKTIMEOUT) != 0) {
pwndActivate = GetActiveTrackPwnd(pwnd, NULL);
if (pwndActivate != NULL) {
InternalSetTimer(pwndActivate, IDSYS_WNDTRACKING,
UP(ACTIVEWNDTRKTIMEOUT),
xxxSystemTimerProc, TMRF_SYSTEM);
}
} else {
PtiCurrent()->pq->QF_flags |= QF_ACTIVEWNDTRACKING;
} /* if (TestUP(ACTIVEWNDTRKZORDER)) */
} /* if (TestUP(ACTIVEWINDOWTRACKING)) */
}
/*
* Save new hit test code
*/
pdesk->htEx = htEx;
#if DBG
--gcReEntered;
#endif
}
/*
* Modal loop for when the user has selected the help icon from the titlebar
*
*/
VOID xxxHelpLoop(PWND pwnd)
{
HWND hwndChild;
PWND pwndChild;
PWND pwndControl;
MSG msg;
RECT rc;
int cBorders;
PTHREADINFO ptiCurrent = PtiCurrent();
DLGENUMDATA DlgEnumData;
TL tlpwndChild;
CheckLock(pwnd);
UserAssert(IsWinEventNotifyDeferredOK());
if (FWINABLE()) {
xxxWindowEvent(EVENT_SYSTEM_CONTEXTHELPSTART, pwnd, OBJID_WINDOW,
INDEXID_CONTAINER, 0);
}
zzzSetCursor(SYSCUR(HELP));
xxxCapture(ptiCurrent, pwnd, SCREEN_CAPTURE);
cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE);
CopyInflateRect(&rc, &pwnd->rcWindow, -cBorders * SYSMET(CXBORDER), -cBorders * SYSMET(CYBORDER));
while (ptiCurrent->pq->spwndCapture == pwnd) {
if (!xxxPeekMessage(&msg, NULL, 0, 0, PM_NOYIELD | PM_NOREMOVE)) {
xxxWaitMessage();
continue;
}
if (msg.message == WM_NCLBUTTONDOWN) {
break;
} else if (msg.message == WM_LBUTTONDOWN) {
/*
* If user clicked outside of window client, bail out now.
*/
if (!PtInRect(&rc, msg.pt))
break;
/*
* WindowHitTest() won't return a static control's handle
*/
hwndChild = xxxWindowHitTest(pwnd, msg.pt, NULL, 0);
pwndChild = ValidateHwnd( hwndChild );
ThreadLock(pwndChild, &tlpwndChild);
if (pwndChild && FIsParentDude(pwndChild))
{
/*
* If this is a dialog class, then one of three things has
* happened:
*
* o This is a static text control
* o This is the background of the dialog box.
*
* What we do is enumerate the child windows and see if
* any of them contain the current cursor point. If they do,
* change our window handle and continue on. Otherwise,
* return doing nothing -- we don't want context-sensitive
* help for a dialog background.
*
* If this is a group box, then we might have clicked on a
* disabled control, so we enumerate child windows to see
* if we get another control.
*/
/*
* We're enumerating a dialog's children. So, if we don't
* find any matches, hwndChild will be NULL and the check
* below will drop out.
*/
DlgEnumData.pwndDialog = pwndChild;
DlgEnumData.pwndControl = NULL;
DlgEnumData.ptCurHelp = msg.pt;
xxxInternalEnumWindow(pwndChild, EnumPwndDlgChildProc, (LPARAM)&DlgEnumData, BWL_ENUMCHILDREN);
pwndControl = DlgEnumData.pwndControl;
} else {
pwndControl = pwndChild;
}
/*
* If we click on nothing, just exit.
*/
if (pwndControl == pwnd) {
pwndControl = NULL;
}
/*
* HACK ALERT (Visual Basic 4.0) - they have their own non-window
* based controls that draw directly on the main dialog. In order
* to provide help for these controls, we pass along the WM_HELP
* message iff the main dialog has a context id assigned.
*
* If the top level window has its own context help ID,
* then pass it in the context help message.
*/
if (!pwndControl) {
if (_GetProp(pwnd, MAKEINTATOM(gpsi->atomContextHelpIdProp), TRUE))
pwndControl = pwnd;
}
if (pwndControl) {
PWND pwndSend;
int id;
TL tlpwndSend;
TL tlpwndControl;
ThreadLockAlways(pwndControl, &tlpwndControl);
zzzSetCursor(SYSCUR(ARROW));
xxxReleaseCapture();
xxxRedrawTitle(pwnd, DC_BUTTONS);
ClrWF(pwnd, WFHELPBUTTONDOWN);
xxxGetMessage(&msg, NULL, 0, 0);
if (FWINABLE()) {
xxxWindowEvent(EVENT_OBJECT_STATECHANGE, pwnd, OBJID_TITLEBAR,
INDEX_TITLEBAR_HELPBUTTON, FALSE);
xxxWindowEvent(EVENT_SYSTEM_CONTEXTHELPEND, pwnd, OBJID_WINDOW,
INDEXID_CONTAINER, FALSE);
}
/*
* Determine the ID of the control
* We used to always sign extend, but Win98 doesn't do that
* so we only sign extend 0xffff. MCostea #218711
*/
if (TestwndChild(pwndControl)) {
id = PTR_TO_ID(pwndControl->spmenu);
if (id == 0xffff) {
id = -1;
}
} else {
id = -1;
}
/*
* Disabled controls and static controls won't pass this
* on to their parent, so instead, we send the message to
* their parent.
*/
if (TestWF(pwndControl, WFDISABLED)) {
PWND pwndParent = _GetParent(pwndControl);
if (!pwndParent)
{
ThreadUnlock( &tlpwndControl );
ThreadUnlock( &tlpwndChild );
return;
}
pwndSend = pwndParent;
} else {
pwndSend = pwndControl;
}
ThreadLockAlways(pwndSend, &tlpwndSend);
xxxSendHelpMessage( pwndSend, HELPINFO_WINDOW, id,
(HANDLE)HWq(pwndControl), GetContextHelpId(pwndControl));
ThreadUnlock(&tlpwndSend);
ThreadUnlock(&tlpwndControl);
ThreadUnlock(&tlpwndChild);
return;
}
ThreadUnlock(&tlpwndChild);
break;
}
else if ((msg.message == WM_RBUTTONDOWN) ||
(msg.message == WM_MBUTTONDOWN) ||
(msg.message == WM_XBUTTONDOWN)) {
/*
* fix bug 29852; break the loop for right and middle buttons
* and pass along the messages to the control
*/
break;
}
else if (msg.message == WM_MOUSEMOVE) {
if (PtInRect(&rc, msg.pt))
zzzSetCursor(SYSCUR(HELP));
else
zzzSetCursor(SYSCUR(ARROW));
}
else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE)
{
xxxGetMessage( &msg, NULL, 0, 0 );
break;
}
xxxGetMessage(&msg, NULL, 0, 0);
xxxTranslateMessage(&msg, 0);
xxxDispatchMessage(&msg);
}
xxxReleaseCapture();
zzzSetCursor(SYSCUR(ARROW));
xxxRedrawTitle(pwnd, DC_BUTTONS);
ClrWF(pwnd, WFHELPBUTTONDOWN);
if (FWINABLE()) {
xxxWindowEvent(EVENT_OBJECT_STATECHANGE, pwnd, OBJID_TITLEBAR,
INDEX_TITLEBAR_HELPBUTTON, 0);
xxxWindowEvent(EVENT_SYSTEM_CONTEXTHELPEND, pwnd, OBJID_WINDOW,
INDEXID_CONTAINER, 0);
}
}
void xxxCalcClientRect(
PWND pwnd,
LPRECT lprc,
BOOL fHungRedraw)
{
int cxFrame, yTopOld;
RECT rcTemp;
PMENU pMenu;
TL tlpmenu;
int cBorders;
BOOL fEmptyClient;
CheckLock(pwnd);
/*
* Clear all the frame bits. NOTE: The HIBYTE of all these #defines
* must stay the same for this line to work.
*/
ClrWF(pwnd, (WFHPRESENT | WFVPRESENT | WFCPRESENT | WFMPRESENT));
//
// We need to clear the client border bits also. Otherwise, when the
// window gets really small, the client border will draw over the menu
// and caption.
//
ClrWF(pwnd, WFCEPRESENT);
/*
* If the window is iconic, the client area is empty.
*/
if (TestWF(pwnd, WFMINIMIZED)) {
// SetRectEmpty(lprc);
// We must make it an empty rectangle.
// But, that empty rectangle should be at the top left corner of the
// window rect. Else, ScreenToClient() will return bad values.
lprc->right = lprc->left;
lprc->bottom = lprc->top;
return;
}
// Save rect into rcTemp for easy local calculations.
CopyRect(&rcTemp, lprc);
// Save the top so we'll know how tall the caption was
yTopOld = rcTemp.top;
// Adjustment for the caption
if (TestWF(pwnd, WFBORDERMASK) == LOBYTE(WFCAPTION))
{
SetWF(pwnd, WFCPRESENT);
rcTemp.top += TestWF(pwnd, WEFTOOLWINDOW) ? SYSMET(CYSMCAPTION) : SYSMET(CYCAPTION);
}
// Subtract out window borders
cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE);
cxFrame = cBorders * SYSMET(CXBORDER);
InflateRect(&rcTemp, -cxFrame, -cBorders*SYSMET(CYBORDER));
if (!TestwndChild(pwnd) && (pMenu = pwnd->spmenu)) {
SetWF(pwnd, WFMPRESENT);
if (!fHungRedraw) {
ThreadLockAlways(pMenu, &tlpmenu);
rcTemp.top += xxxMenuBarCompute(pMenu, pwnd, rcTemp.top - yTopOld,
cxFrame, rcTemp.right - rcTemp.left);
ThreadUnlock(&tlpmenu);
}
}
//
// Fix for B#1425 -- Sizing window really small used to move children's
// rects because the client calculations were wrong. So we make the
// bottom of the client match up with the top (the bottom of the menu
// bar).
//
fEmptyClient = FALSE;
if (rcTemp.top >= rcTemp.bottom) {
rcTemp.bottom = rcTemp.top;
fEmptyClient = TRUE;
}
//
// BOGUS BOGUS BOGUS
// Hack for Central Point PC Tools.
// Possibly for M5 only.
// B#8445
//
// They check for div-by-zero all over, but they jump to the wrong place
// if a zero divisor is encountered, and end up faulting anyway. So this
// code path was never tested basically. There's a period when starting
// up where the window rect of their drives ribbon is empty. In Win3.x,
// the client would be shrunk to account for the border it had, and it
// would look like it wasn't empty because the width would be negative,
// signed! So we version-switch this code, since other apps have
// reported the non-emptiness as an annoying bug.
//
if (TestWF(pwnd, WFWIN40COMPAT) && (rcTemp.left >= rcTemp.right)) {
rcTemp.right = rcTemp.left;
fEmptyClient = TRUE;
}
if (fEmptyClient)
goto ClientCalcEnd;
//
// Subtract client edge if we have space
//
if (TestWF(pwnd, WEFCLIENTEDGE) &&
(rcTemp.right - rcTemp.left >= (2 * SYSMET(CXEDGE))) &&
(rcTemp.bottom - rcTemp.top >= (2 * SYSMET(CYEDGE))) ) {
SetWF(pwnd, WFCEPRESENT);
InflateRect(&rcTemp, -SYSMET(CXEDGE), -SYSMET(CYEDGE));
}
//
// Subtract scrollbars
// Note compatibility with 3.1:
// * You don't get a horizontal scrollbar unless you have MORE
// space (> ) in your client than you need for one.
// * You get a vertical scrollbar if you have AT LEAST ENOUGH
// space (>=) in your client for one.
//
if (TestWF(pwnd, WFHSCROLL) && (rcTemp.bottom - rcTemp.top > SYSMET(CYHSCROLL))) {
SetWF(pwnd, WFHPRESENT);
if (!fHungRedraw)
rcTemp.bottom -= SYSMET(CYHSCROLL);
}
if (TestWF(pwnd, WFVSCROLL) && (rcTemp.right - rcTemp.left >= SYSMET(CXVSCROLL))) {
SetWF(pwnd, WFVPRESENT);
if (!fHungRedraw)
rcTemp.right -= SYSMET(CXVSCROLL);
}
ClientCalcEnd:
CopyRect(lprc, &rcTemp);
}
/***************************************************************************\
* xxxMNStartMenuState
*
* This function is called when the menu bar is about to be activated (the
* app's main menu). It makes sure that the threads involved are not in
* menu mode already, finds the owner/notification window, initializes
* pMenuState and sends the WM_ENTERMENULOOP message.
* It successful, it returns a pointer to a pMenuState. If so, the caller
* must call MNEndMenuState when done.
*
* History:
* 4-25-91 Mikehar Port for 3.1 merge
* 5-20-96 GerardoB Renamed and changed (Old name: xxxMNGetPopup)
\***************************************************************************/
PMENUSTATE xxxMNStartMenuState(PWND pwnd)
{
PPOPUPMENU ppopupmenu;
PTHREADINFO ptiCurrent, ptiNotify;
PMENUSTATE pMenuState;
TL tlpwnd;
CheckLock(pwnd);
/*
* Bail if the current thread is already in menu mode
*/
ptiCurrent = PtiCurrent();
if (ptiCurrent->pMenuState != NULL) {
return NULL;
}
/*
* If the window doesn't have any children, return pwndActive.
*/
if (!TestwndChild(pwnd)) {
pwnd = GETPTI(pwnd)->pq->spwndActive;
} else {
/*
* Search up the parents for a window with a System Menu.
*/
while (TestwndChild(pwnd)) {
if (TestWF(pwnd, WFSYSMENU))
break;
pwnd = pwnd->spwndParent;
}
}
if (pwnd == NULL) {
return NULL;
}
if (!TestwndChild(pwnd) && (pwnd->spmenu != NULL)) {
goto hasmenu;
}
if (!TestWF(pwnd, WFSYSMENU)) {
return NULL;
}
hasmenu:
/*
* If the owner/notification window was created by another thread,
* make sure that it's not in menu mode already
* This can happen if PtiCurrent() is attached to other threads, one of
* which created pwnd.
*/
ptiNotify = GETPTI(pwnd);
if (ptiNotify->pMenuState != NULL) {
return NULL;
}
/*
* Allocate ppoupmenu and pMenuState
*/
ppopupmenu = MNAllocPopup(FALSE);
if (ppopupmenu == NULL) {
return NULL;
}
pMenuState = MNAllocMenuState(ptiCurrent, ptiNotify, ppopupmenu);
if (pMenuState == NULL) {
MNFreePopup(ppopupmenu);
return NULL;
}
ppopupmenu->fIsMenuBar = TRUE;
ppopupmenu->fHasMenuBar = TRUE;
Lock(&(ppopupmenu->spwndNotify), pwnd);
ppopupmenu->posSelectedItem = MFMWFP_NOITEM;
Lock(&(ppopupmenu->spwndPopupMenu), pwnd);
ppopupmenu->ppopupmenuRoot = ppopupmenu;
/*
* Notify the app we are entering menu mode. wParam is always 0 since this
* procedure will only be called for menu bar menus not TrackPopupMenu
* menus.
*/
ThreadLockAlways(pwnd, &tlpwnd);
xxxSendMessage(pwnd, WM_ENTERMENULOOP, 0, 0L);
ThreadUnlock(&tlpwnd);
return pMenuState;
}
HBITMAP xxxExpandBitmap(
HBITMAP hbm)
{
int nx;
int ny;
BITMAP bm;
HBITMAP hbmNew;
HBITMAP hbmD;
LPRECT lprc;
RECT rc;
PMONITOR pMonitor;
TL tlpMonitor;
/*
* Get the dimensions of the screen and bitmap we'll
* be dealing with. We'll adjust the xScreen/yScreen
* to reflect the new surface size. The default adjustment
* is to stretch the image to fit the screen.
*/
GreExtGetObjectW(hbm, sizeof(bm), (PBITMAP)&bm);
pMonitor = GetPrimaryMonitor();
lprc = &pMonitor->rcMonitor;
nx = (lprc->right / TILE_XMINSIZE) / bm.bmWidth;
ny = (lprc->bottom / TILE_YMINSIZE) / bm.bmHeight;
if (nx == 0)
nx++;
if (ny == 0)
ny++;
if ((nx + ny) <= 2)
return hbm;
/*
* Create the surface for the new-bitmap.
*/
rc.left = rc.top = 0;
rc.right = nx * bm.bmWidth;
rc.bottom = ny * bm.bmHeight;
hbmD = GreSelectBitmap(ghdcMem, hbm);
hbmNew = GreCreateCompatibleBitmap(ghdcMem, rc.right, rc.bottom);
GreSelectBitmap(ghdcMem, hbmD);
if (hbmNew == NULL)
return hbm;
if (hbmD = GreSelectBitmap(ghdcMem2, hbmNew)) {
/*
* Expand the bitmap to the new surface.
*/
ThreadLockAlways(pMonitor, &tlpMonitor);
xxxDrawWallpaper(NULL, ghdcMem2, pMonitor, &rc);
ThreadUnlock(&tlpMonitor);
GreSelectBitmap(ghdcMem2, hbmD);
}
GreDeleteObject(hbm);
GreSetBitmapOwner(hbmNew, OBJECT_OWNER_PUBLIC);
return hbmNew;
}
BOOL xxxSetDeskWallpaper(PUNICODE_STRING pProfileUserName,
LPWSTR lpszFile)
{
BITMAP bm;
UINT WallpaperStyle2;
PWND pwndShell;
TL tl;
PTHREADINFO ptiCurrent = PtiCurrent();
PDESKTOP pdesk;
BOOL fRet = FALSE;
HBITMAP hbmOld;
PROFINTINFO apsi[] = {
{PMAP_DESKTOP, (LPWSTR)STR_TILEWALL , 0, &gwWPStyle },
{PMAP_DESKTOP, (LPWSTR)STR_DTSTYLE , 0, &WallpaperStyle2 },
{PMAP_DESKTOP, (LPWSTR)STR_DTORIGINX, 0, &gsrcWallpaper.x },
{PMAP_DESKTOP, (LPWSTR)STR_DTORIGINY, 0, &gsrcWallpaper.y },
{0, NULL, 0, NULL }
};
pdesk = ptiCurrent->rpdesk;
hbmOld = ghbmWallpaper;
/*
* Get the shell-window. This could be NULL on system
* initialization. We will use this to do palette realization.
*/
pwndShell = (pdesk ? pdesk->pDeskInfo->spwndShell : NULL);
if ((lpszFile == SETWALLPAPER_METRICS) && !(gwWPStyle & DTF_STRETCH)) {
gsrcWallpaper.x = 0;
gsrcWallpaper.y = 0;
if (ghbmWallpaper)
goto CreateNewWallpaper;
goto Metric_Change;
}
CreateNewWallpaper:
/*
* Delete the old wallpaper and palette if the exist.
*/
if (ghpalWallpaper) {
GreDeleteObject(ghpalWallpaper);
ghpalWallpaper = NULL;
}
if (ghbmWallpaper) {
GreDeleteObject(ghbmWallpaper);
ghbmWallpaper = NULL;
}
/*
* Kill any SPBs no matter what.
* Works if we're switching from/to palettized wallpaper.
* Fixes a lot of problems because palette doesn't change, shell
* paints funny on desktop, etc.
*/
FreeAllSpbs();
/*
* If this is a metric-change (and stretched), then we need to
* reload it. However, since we are called from the winlogon process
* during a desktop-switch, we would be mapped to the wrong Luid
* when we attempt to grab the name from GetDeskWallpaperName. This
* would use the Luid from the DEFAULT user rather than the current
* logged on user. In order to avoid this, we cache the wallpaer
* name so that on METRIC-CHANGES we use the current-user's wallpaper.
*
* NOTE: we assume that prior to any METRIC change, we have already
* setup the ghbmWallpaper and lpszCached. This is usually done
* either on logon or during user desktop-changes through conrol-Panel.
*/
if (lpszFile == SETWALLPAPER_METRICS) {
UserAssert(gpszWall != NULL);
goto LoadWallpaper;
}
/*
* Free the cached handle.
*/
if (gpszWall) {
UserFreePool(gpszWall);
gpszWall = NULL;
}
/*
* Load the wallpaper-name. If this returns FALSE, then
* the user specified (None). We will return true to force
* the repainting of the desktop.
*/
gpszWall = GetDeskWallpaperName(pProfileUserName,lpszFile);
if (!gpszWall) {
fRet = TRUE;
goto SDW_Exit;
}
/*
* Retrieve the default settings from the registry.
*
* If tile is indicated, then normalize style to not include
* FIT/STRETCH which are center-only styles. Likewise, if
* we are centered, then normalize out the TILE bit.
*/
FastGetProfileIntsW(pProfileUserName, apsi);
gwWPStyle &= DTF_TILE;
if (!(gwWPStyle & DTF_TILE)) {
gwWPStyle = WallpaperStyle2 & DTF_STRETCH;
}
/*
* Load the wallpaper. This makes a callback to the client to
* perform the bitmap-creation.
*/
LoadWallpaper:
if (xxxLoadDesktopWallpaper(gpszWall) == FALSE) {
gwWPStyle = 0;
goto SDW_Exit;
}
/*
* If we have a palette, then we need to do the correct realization and
* notification.
*/
if (ghpalWallpaper != NULL) {
PWND pwndSend;
if (pwndShell) {
pwndSend = pwndShell;
} else {
pwndSend = (pdesk ? pdesk->pDeskInfo->spwnd : NULL);
}
/*
* Update the desktop with the new bitmap. This cleans
* out the system-palette so colors can be realized.
*/
GreRealizeDefaultPalette(gpDispInfo->hdcScreen, TRUE);
/*
* Don't broadcast if system initialization is occuring. Otherwise
* this gives the shell first-crack at realizing its colors
* correctly.
*/
if (pwndSend) {
HWND hwnd = HW(pwndSend);
ThreadLockAlways(pwndSend, &tl);
xxxSendNotifyMessage(pwndSend, WM_PALETTECHANGED, (WPARAM)hwnd, 0);
ThreadUnlock(&tl);
}
}
Metric_Change:
if (fRet = GreExtGetObjectW(ghbmWallpaper, sizeof(bm), (PBITMAP)&bm)) {
gsrcWallpaper.cx = bm.bmWidth;
gsrcWallpaper.cy = bm.bmHeight;
}
// fall-through
SDW_Exit:
/*
* Notify the shell-window that the wallpaper changed.
*/
if ((pwndShell != NULL) &&
((hbmOld && !ghbmWallpaper) || (!hbmOld && ghbmWallpaper))) {
ThreadLockAlways(pwndShell, &tl);
xxxSendNotifyMessage(pwndShell,
WM_SHELLNOTIFY,
SHELLNOTIFY_WALLPAPERCHANGED,
(LPARAM)ghbmWallpaper);
ThreadUnlock(&tl);
}
return fRet;
}
BOOL xxxClientShutdown2(
PBWL pbwl,
UINT msg,
DWORD wParam)
{
HWND *phwnd;
PWND pwnd;
TL tlpwnd;
BOOL fEnd;
PTHREADINFO ptiCurrent;
BOOL fDestroyTimers;
LPARAM lParam;
ptiCurrent = PtiCurrent();
/*
* Make sure we don't send this window any more WM_TIMER
* messages if the session is ending. This was causing
* AfterDark to fault when it freed some memory on the
* WM_ENDSESSION and then tried to reference it on the
* WM_TIMER.
* LATER GerardoB: Do we still need to do this??
* Do this horrible thing only if the process is in the
* context being logged off.
* Perhaps someday we should post a WM_CLOSE so the app
* gets a better chance to clean up (if this process is in
* the context being logged off, winsrv is going to call
* TerminateProcess soon after this).
*/
fDestroyTimers = (wParam & WMCS_EXIT) && (wParam & WMCS_CONTEXTLOGOFF);
/*
* fLogOff and fEndSession parameters (WM_ENDSESSION only)
*/
lParam = wParam & ENDSESSION_LOGOFF;
wParam &= WMCS_EXIT;
/*
* Now enumerate these windows and send the WM_QUERYENDSESSION or
* WM_ENDSESSION messages.
*/
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
if ((pwnd = RevalidateHwnd(*phwnd)) == NULL)
continue;
ThreadLockAlways(pwnd, &tlpwnd);
/*
* Send the message.
*/
switch (msg) {
case WM_QUERYENDSESSION:
/*
* Windows does not send the WM_QUERYENDSESSION to the app
* that called ExitWindows
*/
if (ptiCurrent == gptiShutdownNotify) {
fEnd = TRUE;
} else {
fEnd = xxxSendMessage(pwnd, WM_QUERYENDSESSION, FALSE, lParam);
}
break;
case WM_ENDSESSION:
xxxSendMessage(pwnd, WM_ENDSESSION, wParam, lParam);
fEnd = TRUE;
if (fDestroyTimers) {
DestroyWindowsTimers(pwnd);
}
break;
}
ThreadUnlock(&tlpwnd);
if (!fEnd)
return FALSE;
}
return TRUE;
}
UINT xxxArrangeIconicWindows(
PWND pwnd)
{
PBWL pbwl;
PSMWP psmwp;
PWND pwndTest, pwndSort, pwndSwitch;
HWND *phwnd, *phwndSort;
CHECKPOINT *pcp, *pcpSort;
POINT ptSort, ptSrc;
WORD nIcons = 0;
RECT rc;
POINT ptMin;
int xOrg, yOrg;
int dx, dy;
int dxSlot, dySlot;
int cIconsPerPass, iIconPass;
BOOL fHorizontal, fBreak;
TL tlpwndTest;
BOOL fHideMe;
CheckLock(pwnd);
/*
* Create a window list of all children of pwnd
*/
if ((pbwl = BuildHwndList(pwnd->spwndChild, BWL_ENUMLIST, NULL)) == NULL)
return 0;
fHideMe = IsTrayWindow(pwnd->spwndChild);
//
// Put these into local vars for efficiency (see ParkIcon())
//
dxSlot = SYSMET(CXMINSPACING);
dySlot = SYSMET(CYMINSPACING);
//
// We need to adjust the client rectangle if the parent has scrollbars.
//
GetRealClientRect(pwnd, &rc, GRC_SCROLLS);
/*
* find all icons
*/
pwndSwitch = RevalidateHwnd(ghwndSwitch);
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
if (((pwndTest = RevalidateHwnd(*phwnd)) == NULL) ||
!TestWF(pwndTest , WFVISIBLE) ||
pwndTest == pwndSwitch ||
(pcp = (CHECKPOINT *)_GetProp(pwndTest, PROP_CHECKPOINT,
PROPF_INTERNAL)) == NULL) {
*phwnd = NULL;
continue;
}
if (!TestWF(pwndTest, WFMINIMIZED)) {
pcp->fMinInitialized = FALSE;
pcp->ptMin.x = pcp->ptMin.y = -1;
*phwnd = NULL;
continue;
}
/*
* inc count of icons
*/
nIcons++;
/*
* we will park in default position again...
*/
pcp->fDragged = FALSE;
/*
* ensure the original position is up to date
*/
pcp->ptMin.x = pwndTest->rcWindow.left - pwnd->rcClient.left;
pcp->ptMin.y = pwndTest->rcWindow.top - pwnd->rcClient.top;
// Slide into the nearest row or column
switch (SYSMET(ARRANGE) & ~ARW_HIDE) {
case ARW_TOPLEFT | ARW_RIGHT:
case ARW_TOPRIGHT | ARW_LEFT:
// Slide into top row
pcp->ptMin.y += dySlot / 2;
pcp->ptMin.y -= pcp->ptMin.y % dySlot;
break;
case ARW_TOPLEFT | ARW_DOWN:
case ARW_BOTTOMLEFT | ARW_UP:
// Slide into left column
pcp->ptMin.x += dxSlot / 2;
pcp->ptMin.x -= pcp->ptMin.x % dxSlot;
break;
case ARW_BOTTOMLEFT | ARW_RIGHT:
case ARW_BOTTOMRIGHT | ARW_LEFT:
// Slide into bottom row
pcp->ptMin.y = rc.bottom - pcp->ptMin.y;
pcp->ptMin.y += dySlot / 2;
pcp->ptMin.y -= pcp->ptMin.y % dySlot;
pcp->ptMin.y = rc.bottom - pcp->ptMin.y;
break;
case ARW_BOTTOMRIGHT | ARW_UP:
case ARW_TOPRIGHT | ARW_DOWN:
// Slide into right column
pcp->ptMin.x = rc.right - pcp->ptMin.x;
pcp->ptMin.x += dxSlot / 2;
pcp->ptMin.x -= pcp->ptMin.x % dxSlot;
pcp->ptMin.x = rc.right - pcp->ptMin.x;
break;
}
}
if (nIcons == 0) {
/*
* no icons were found... break out
*/
FreeHwndList(pbwl);
return 0;
}
if (fHideMe) {
ptMin.x = WHERE_NOONE_CAN_SEE_ME;
ptMin.y = WHERE_NOONE_CAN_SEE_ME;
goto JustParkEm;
}
//
// Get gravity && move vars
//
if (SYSMET(ARRANGE) & ARW_STARTRIGHT) {
// Starting on right side
ptMin.x = xOrg = rc.right - dxSlot;
dx = -dxSlot;
} else {
// Starting on left
ptMin.x = xOrg = rc.left + DX_GAP;
dx = dxSlot;
}
if (SYSMET(ARRANGE) & ARW_STARTTOP) {
// Starting on top
ptMin.y = yOrg = rc.top + DY_GAP;
dy = dySlot;
} else {
// Starting on bottom
ptMin.y = yOrg = rc.bottom - dySlot;
dy = -dySlot;
}
//
// Get arrange dir
//
fHorizontal = ( (SYSMET(ARRANGE) & ARW_DOWN) ? FALSE : TRUE );
iIconPass = fHorizontal ? (rc.right / dxSlot) : (rc.bottom / dySlot);
cIconsPerPass = iIconPass = max(1, iIconPass);
/*
* insertion sort of windows by y, and by x within a row.
*/
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
/*
* Check for 0 (window was not icon) and
* Check for invalid HWND (window has been destroyed)
*/
if (*phwnd == NULL || (pwndTest = RevalidateHwnd(*phwnd)) == NULL)
continue;
pcp = (CHECKPOINT *)_GetProp(pwndTest, PROP_CHECKPOINT,
PROPF_INTERNAL);
ptSrc = pcp->ptMin;
fBreak = FALSE;
for (phwndSort = pbwl->rghwnd; phwndSort < phwnd; phwndSort++) {
if (*phwndSort == NULL ||
(pwndSort = RevalidateHwnd(*phwndSort)) == NULL)
continue;
pcpSort = (CHECKPOINT*)_GetProp(pwndSort, PROP_CHECKPOINT,
PROPF_INTERNAL);
ptSort = pcpSort->ptMin;
//
// Is this the position in which to sort this min window?
//
switch (SYSMET(ARRANGE) & ~ARW_HIDE) {
case ARW_BOTTOMLEFT | ARW_RIGHT:
// Lower left, moving horizontally
if (((ptSort.y == ptSrc.y) && (ptSort.x > ptSrc.x)) ||
(ptSort.y < ptSrc.y))
fBreak = TRUE;
break;
case ARW_BOTTOMLEFT | ARW_UP:
// Lower left, moving vertically
if (((ptSort.x == ptSrc.x) && (ptSort.y < ptSrc.y)) ||
(ptSort.x > ptSrc.x))
fBreak = TRUE;
break;
case ARW_BOTTOMRIGHT | ARW_LEFT:
// Lower right, moving horizontally
if (((ptSort.y == ptSrc.y) && (ptSort.x < ptSrc.x)) ||
(ptSort.y < ptSrc.y))
fBreak = TRUE;
break;
case ARW_BOTTOMRIGHT | ARW_UP:
// Lower right, moving vertically
if (((ptSort.x == ptSrc.x) && (ptSort.y < ptSrc.y)) ||
(ptSort.x < ptSrc.x))
fBreak = TRUE;
break;
case ARW_TOPLEFT | ARW_RIGHT:
// Top left, moving horizontally
if (((ptSort.y == ptSrc.y) && (ptSort.x > ptSrc.x)) ||
(ptSort.y > ptSrc.y))
fBreak = TRUE;
break;
case ARW_TOPLEFT | ARW_DOWN:
// Top left, moving vertically
if (((ptSort.x == ptSrc.x) && (ptSort.y > ptSrc.y)) ||
(ptSort.x > ptSrc.x))
fBreak = TRUE;
break;
case ARW_TOPRIGHT | ARW_LEFT:
// Top right, moving horizontally
if (((ptSort.y == ptSrc.y) && (ptSort.x < ptSrc.x)) ||
(ptSort.y > ptSrc.y))
fBreak = TRUE;
break;
case ARW_TOPRIGHT | ARW_DOWN:
// Top right, moving vertically
if (((ptSort.x == ptSrc.x) && (ptSort.y > ptSrc.y)) ||
(ptSort.x < ptSrc.x))
fBreak = TRUE;
break;
}
if (fBreak)
break;
}
/*
* insert the window at this position by sliding the rest up.
* LATER IanJa, use hwnd intermediate variables, avoid PW() & HW()
*/
while (phwndSort < phwnd) {
pwndSort = PW(*phwndSort);
*phwndSort = HW(pwndTest);
pwndTest = pwndSort;
phwndSort++;
}
/*
* replace the window handle in the original position
*/
*phwnd = HW(pwndTest);
}
//
// Now park the icons.
//
JustParkEm:
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
if (*phwnd == NULL || (pwndTest = RevalidateHwnd(*phwnd)) == NULL)
continue;
if (fHideMe) {
pcp = (CHECKPOINT *)_GetProp(pwndTest, PROP_CHECKPOINT,
PROPF_INTERNAL);
if (pcp != NULL) {
pcp->fMinInitialized = TRUE;
pcp->ptMin.x = ptMin.x;
pcp->ptMin.y = ptMin.y;
}
continue;
}
pcp = (CHECKPOINT *)_GetProp(pwndTest, PROP_CHECKPOINT,
PROPF_INTERNAL);
if (pcp != NULL) {
pcp->fMinInitialized = TRUE;
pcp->ptMin.x = ptMin.x;
pcp->ptMin.y = ptMin.y;
}
// Setup to process the next position
if (--iIconPass <= 0) {
// Need to setup next pass
iIconPass = cIconsPerPass;
if (fHorizontal) {
ptMin.x = xOrg;
ptMin.y += dy;
} else {
ptMin.x += dx;
ptMin.y = yOrg;
}
} else {
// Same pass
if (fHorizontal)
ptMin.x += dx;
else
ptMin.y += dy;
}
}
psmwp = _BeginDeferWindowPos(2 * nIcons);
if (psmwp == NULL)
goto ParkExit;
for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) {
/*
* Check for a NULL (window has gone away)
*/
if (*phwnd == NULL || (pwndTest = RevalidateHwnd(*phwnd)) == NULL)
continue;
pcp = (CHECKPOINT *)_GetProp(pwndTest, PROP_CHECKPOINT,
PROPF_INTERNAL);
ThreadLockAlways(pwndTest, &tlpwndTest);
psmwp = _DeferWindowPos(psmwp, pwndTest, NULL,
pcp->ptMin.x, pcp->ptMin.y, rgptMinMaxWnd[MMI_MINSIZE].x, rgptMinMaxWnd[MMI_MINSIZE].y,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS);
ThreadUnlock(&tlpwndTest);
if (psmwp == NULL)
break;
}
if (psmwp != NULL) {
/*
* Make the swp async so we don't hang waiting for hung apps.
*/
xxxEndDeferWindowPosEx(psmwp, TRUE);
}
ParkExit:
FreeHwndList(pbwl);
return nIcons;
}
