void xxxShowTooltip(PTOOLTIPWND pttwnd)
{
SIZE size;
POINT pt;
DWORD dwFlags;
CheckLock(pttwnd);
if (pttwnd->pstr == NULL)
return;
if (pttwnd->pstr == gszCAPTIONTOOLTIP) {
PWND pwnd = PtiCurrent()->rpdesk->spwndTrack;
/*
* The window text might have changed in callbacks, retrieve it now
*/
if (TestWF(pwnd, WEFTRUNCATEDCAPTION) && pwnd->strName.Length) {
wcsncpycch(gszCAPTIONTOOLTIP, pwnd->strName.Buffer, CAPTIONTOOLTIPLEN-1);
gszCAPTIONTOOLTIP[CAPTIONTOOLTIPLEN-1] = 0;
} else {
return;
}
}
TooltipGetSize(pttwnd, &size);
TooltipGetPosition(pttwnd, &size, &pt);
dwFlags = SWP_CREATESPB | SWP_SHOWWINDOW | SWP_NOACTIVATE;
if (TestEffectUP(TOOLTIPANIMATION)) {
dwFlags |= SWP_NOREDRAW;
}
xxxSetWindowPos((PWND)pttwnd, PWND_TOP, pt.x, pt.y, size.cx, size.cy,
dwFlags);
}
void xxxCreateTooltip(PTOOLTIPWND pttwnd, LPWSTR pstr)
{
CheckLock(pttwnd);
/*
* Store new text
*/
pttwnd->pstr = pstr;
/*
* If already visible, hide it and show it in new place.
* Otherwise, set timer to show.
*/
if (TestWF(pttwnd, WFVISIBLE)) {
xxxSetWindowPos((PWND)pttwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE |
SWP_NOMOVE | SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
xxxShowTooltip(pttwnd);
} else {
SetTooltipTimer(pttwnd, TTT_SHOW, pttwnd->dwShowDelay);
}
}
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;
}
BOOL xxxShowWindow(
PWND pwnd,
DWORD cmdShowAnimate)
{
BOOL fVisOld, fVisNew;
UINT swpFlags = SWP_NOMOVE | SWP_NOSIZE;
PTHREADINFO pti;
BOOL bFirstMain = FALSE;
int cmdShow = LOWORD(cmdShowAnimate);
CheckLock(pwnd);
fVisOld = TestWF(pwnd, WFVISIBLE);
pti = PtiCurrent();
/*
* See if this is the first "main" top level
* window being created by this application - if show, assume it
* is showing with the SW_SHOWDEFAULT command.
*
* Checks for:
* - cmdShow is a "default" show command
* - we haven't done startupinfo yet (we only use it once)
* - this is not a child (it is a top level window)
* - this has a titlebar (indicator of the main window)
* - it isn't owned (indicator of the main window)
*/
if ((pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW) &&
!TestwndChild(pwnd) &&
(TestWF(pwnd, WFBORDERMASK) == (BYTE)LOBYTE(WFCAPTION)) &&
(pwnd->spwndOwner == NULL)) {
bFirstMain = TRUE;
switch (cmdShow) {
case SW_SHOWNORMAL:
case SW_SHOW:
/*
* Then assume default!
*/
cmdShow = SW_SHOWDEFAULT;
break;
}
}
/*
* If this application specified SW_SHOWDEFAULT, then we get the
* real SW_* command from the application's STARTUPINFO structure
* (STARTUPINFO is passed to CreateProcess() when this application
* was launched).
*/
if (cmdShow == SW_SHOWDEFAULT) {
/*
* Call the client to get the SW_* command from the STARTUPINFO
* for this process.
*/
if (pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW) {
bFirstMain = TRUE;
cmdShow = pti->ppi->usi.wShowWindow;
#if 0
switch (cmdShow) {
case SW_SHOWMINIMIZED:
case SW_MINIMIZE:
/*
* If the default show was "minimized", then make sure it doesn't
* become active. Minimized is effectively "background".
*/
cmdShow = SW_SHOWMINNOACTIVE;
break;
}
#endif
}
}
//
// This is in case someone said SW_SHOWDEFAULT but has no startupinfo.
// Or in case cmdShow inside of STARTUPINFO is SW_SHOWDEFAULT.
//
if (cmdShow == SW_SHOWDEFAULT)
cmdShow = SW_SHOWNORMAL;
/*
* Turn off startup info. We turn this off after the first call to
* ShowWindow. If we don't apps can be started by progman with
* the start info being minimized and then be restored and then
* call ShowWindow(SW_SHOW) and the app would minimize again.
* Notepad had that problem 2985.
*/
if (bFirstMain) {
pti->ppi->usi.dwFlags &= ~(STARTF_USESHOWWINDOW|STARTF_USESIZE \
| STARTF_USEPOSITION);
}
/*
* Take care of all the OLD show commands with columns & iconslot.
*/
if (cmdShow & 0xFF00) {
if ((cmdShow & 0xFF80) == (int)0xFF80)
cmdShow = SW_SHOWMINNOACTIVE;
else
cmdShow = SW_SHOW;
}
/*
* Change to new fullscreen if needed and in same desktop
*/
if ((pwnd->bFullScreen != WINDOWED)
&& (pwnd->head.rpdesk == grpdeskRitInput)) {
if ((cmdShow == SW_SHOWNORMAL) ||
(cmdShow == SW_RESTORE) ||
(cmdShow == SW_MAXIMIZE) ||
(cmdShow == SW_SHOWMAXIMIZED)) {
cmdShow = SW_SHOWMINIMIZED;
if (pwnd->bFullScreen == FULLSCREENMIN) {
pwnd->bFullScreen = FULLSCREEN;
}
if (gpqForeground != NULL &&
gpqForeground->spwndActive == pwnd) {
xxxMakeWindowForegroundWithState(NULL, 0);
}
}
}
switch (cmdShow) {
case SW_SHOWNOACTIVATE:
case SW_SHOWNORMAL:
case SW_RESTORE:
/*
* If min/max, let xxxMinMaximize() do all the work.
*/
if (TestWF(pwnd, WFMINIMIZED) || TestWF(pwnd, WFMAXIMIZED)) {
xxxMinMaximize(pwnd, (UINT)cmdShow, cmdShowAnimate & MINMAX_ANIMATE);
return fVisOld;
} else {
/*
* Ignore if the window is already visible.
*/
if (fVisOld) {
return fVisOld;
}
swpFlags |= SWP_SHOWWINDOW;
if ( cmdShow == SW_SHOWNOACTIVATE) {
swpFlags |= SWP_NOZORDER;
#ifdef NEVER
/*
* This is what win3.1 does. On NT, since each "queue" has
* its own active window, there is often no active window.
* In this case, win3.1 turns a SHOWNOACTIVATE into a "SHOW
* with activate". Since win3.1 almost always has an active
* window, this almost never happens. So on NT, we're not
* going to do this check - that way we'll be more compatible
* with win3.1 because we'll usally not activate (like win3.1).
* With this check, this causes FoxPro 2.5 for Windows to not
* properly activate its command window when first coming up.
*/
if (pti->pq->spwndActive != NULL)
swpFlags |= SWP_NOACTIVATE;
#else
swpFlags |= SWP_NOACTIVATE;
#endif
}
}
break;
case SW_SHOWMINNOACTIVE:
case SW_SHOWMINIMIZED:
case SW_SHOWMAXIMIZED:
case SW_MINIMIZE:
xxxMinMaximize(pwnd, (UINT)cmdShow, cmdShowAnimate & MINMAX_ANIMATE);
return fVisOld;
case SW_SHOWNA:
swpFlags |= SWP_SHOWWINDOW | SWP_NOACTIVATE;
// LATER removed this to be compatible with SHOWNOACTIVATE
//if (pti->pq->spwndActive != NULL)
// swpFlags |= SWP_NOACTIVATE;
break;
case SW_SHOW:
/*
* Don't bother if it is already visible.
*/
if (fVisOld)
return fVisOld;
swpFlags |= SWP_SHOWWINDOW;
if (cmdShow == SW_SHOWNOACTIVATE)
{
swpFlags |= SWP_NOZORDER | SWP_NOACTIVATE;
}
break;
case SW_HIDE:
/*
* Don't bother if it is already hidden.
*/
if (!fVisOld)
return fVisOld;
swpFlags |= SWP_HIDEWINDOW;
if (pwnd != pti->pq->spwndActive)
swpFlags |= (SWP_NOACTIVATE | SWP_NOZORDER);
break;
default:
RIPERR0(ERROR_INVALID_SHOWWIN_COMMAND, RIP_VERBOSE, "");
return fVisOld;
}
/*
* If we're changing from visible to hidden or vise-versa, send
* WM_SHOWWINDOW.
*/
fVisNew = !(cmdShow == SW_HIDE);
if (fVisNew != fVisOld) {
xxxSendMessage(pwnd, WM_SHOWWINDOW, fVisNew, 0L);
if (!TestWF(pwnd, WFWIN31COMPAT)) {
xxxSendMessage(pwnd, WM_SETVISIBLE, fVisNew, 0L);
}
}
if (!TestwndChild(pwnd)) {
if (TestCF(pwnd, CFSAVEBITS)) {
/*
* Activate to prevent discarding saved bits???
*/
if (cmdShow == SW_SHOW || cmdShow == SW_SHOWNORMAL) {
xxxActivateWindow(pwnd, AW_USE);
swpFlags |= SWP_NOZORDER | SWP_NOACTIVATE;
}
}
} else {
/*
* Children can't get activation...
*/
swpFlags |= (SWP_NOACTIVATE | SWP_NOZORDER);
}
/*
* If our parent is hidden, don't bother to call xxxSetWindowPos.
*/
if (_FChildVisible(pwnd)) {
xxxSetWindowPos(pwnd, (PWND)NULL, 0, 0, 0, 0, swpFlags);
} else {
if (cmdShow == SW_HIDE)
ClrWF(pwnd, WFVISIBLE);
else
SetWF(pwnd, WFVISIBLE);
}
/*
* Send size and move messages AFTER repainting
*/
if (TestWF(pwnd, WFSENDSIZEMOVE)) {
ClrWF(pwnd, WFSENDSIZEMOVE);
if (TestWF(pwnd, WFMINIMIZED)) {
xxxSendSizeMessage(pwnd, SIZEICONIC);
} else if (TestWF(pwnd, WFMAXIMIZED)) {
xxxSendSizeMessage(pwnd, SIZEFULLSCREEN);
} else {
xxxSendSizeMessage(pwnd, SIZENORMAL);
}
if (pwnd->spwndParent) {
xxxSendMessage(pwnd, WM_MOVE, 0, MAKELONG(
pwnd->rcClient.left - pwnd->spwndParent->rcClient.left,
pwnd->rcClient.top - pwnd->spwndParent->rcClient. top));
} else {
/*
* NULL parent implies this window is a zombie
*/
xxxSendMessage(pwnd, WM_MOVE, 0, MAKELONG(
pwnd->rcClient.left, pwnd->rcClient.top));
}
}
/*
* If hiding and is active-foreground window, activate someone else.
* If hiding a active window make someone active.
*/
if (cmdShow == SW_HIDE) {
if ((pwnd == pti->pq->spwndActive) && (pti->pq == gpqForeground)) {
xxxActivateWindow(pwnd, AW_SKIP);
} else {
xxxCheckFocus(pwnd);
}
}
return fVisOld;
}
/***************************************************************************\
*
* SetShellWindow()
*
* Returns true if shell window is successfully set. Note that we return
* FALSE if a shell window already exists. I.E., this works on a first
* come, first serve basis.
*
* We also do NOT allow child windows to be shell windows. Other than that,
* it's up to the caller to size her window appropriately.
*
* The pwndBkGnd is provided for the explorer shell. Since the shellwnd
* and the window which does the drawing of background wallpapers are
* different, we need to provide means by which we can draw directly on
* the background window during hung-app drawing. The pwnd and pwndBkGnd
* will be identical if called through the SetShellWindow() api.
*
*
\***************************************************************************/
BOOL xxxSetShellWindow(PWND pwnd, PWND pwndBkGnd)
{
PTHREADINFO ptiCurrent = PtiCurrent();
PDESKTOPINFO pdeskinfo = GETDESKINFO(ptiCurrent);
PPROCESSINFO ppiShellProcess;
UserAssert(pwnd);
/*
* Fail the call if another shell window exists
*/
if (pdeskinfo->spwndShell != NULL)
return(FALSE);
/*
* The shell window must be
* (1) Top-level
* (2) Unowned
* (3) Not topmost
*/
if (TestwndChild(pwnd) ||
(pwnd->spwndOwner != NULL) ||
TestWF(pwnd, WEFTOPMOST)) {
RIPMSG0(RIP_WARNING, "xxxSetShellWindow: Invalid type of window");
return(FALSE);
}
/*
* Chicago has a totally different input model which has special code
* that checks for Ctrl-Esc and sends it to the shell. We can get
* the same functionality, without totally re-writing our input model
* by just automatically installing the Ctrl-Esc as a hotkey for the
* shell window. The hotkey delivery code has a special case which
* turns this into a WM_SYSCOMMAND message instead of a WM_HOTKEY
* message.
*
* We don't both checking for failure. Somebody could already have
* a Ctrl-Esc handler installed.
*/
_RegisterHotKey(pwnd,SC_TASKLIST,MOD_CONTROL,VK_ESCAPE);
/*
* This is the shell window wright.
* So get the process id for the shell.
*/
ppiShellProcess = GETPTI(pwnd)->ppi;
/*
* Set the shell process id to the desktop only if it's the first instance
*/
if ((ppiShellProcess != NULL) && (pdeskinfo->ppiShellProcess == NULL)) {
pdeskinfo->ppiShellProcess = ppiShellProcess;
}
Lock(&pdeskinfo->spwndShell, pwnd);
Lock(&pdeskinfo->spwndBkGnd, pwndBkGnd);
/*
* Push window to bottom of stack.
*/
SetWF(pdeskinfo->spwndShell, WFBOTTOMMOST);
xxxSetWindowPos(pdeskinfo->spwndShell,
PWND_BOTTOM,
0,
0,
0,
0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
return(TRUE);
}
