Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

3371 lines
104 KiB

#include "priv.h"
#include "sccls.h"
#include "resource.h"
#include "mshtmhst.h"
#include "desktopp.h" // DTRF_RAISE etc.
#define WANT_CBANDSITE_CLASS
#include "bandsite.h"
#include "deskbar.h"
#include "theater.h"
#include "mluisupp.h"
#define SUPERCLASS CBaseBar
#define DM_PERSIST 0 // trace IPS::Load, ::Save, etc.
#define DM_POPUI 0 // expando-UI (proto)
#define DM_MENU 0 // trace menu code
#define DM_DRAG 0 // drag move/size (terse)
#define DM_DRAG2 0 // ... (verbose)
#define DM_API 0 // trace API calls
#define DM_HIDE DM_TRACE // autohide
#define DM_HIDE2 DM_TRACE // autohide (verbose)
#define DM_APPBAR 0 // SHAppBarMessage calls
#define DM_OLECT 0 // IOleCommandTarget calls
#define DM_FOCUS 0 // focus change
#define DM_RES DM_WARNING // resolution
#define ABS(i) (((i) < 0) ? -(i) : (i))
#define RECTGETWH(uSide, prc) (ABE_HORIZ(uSide) ? RECTHEIGHT(*prc) : RECTWIDTH(*prc))
//*** CDB_INITED -- has CDockingBar::_Initialize been called
//
#define CDB_INITED() (_eInitLoaded && _fInitSited && _fInitShowed)
enum ips_e {
IPS_FALSE, // reserved, must be 0 (FALSE)
IPS_LOAD,
IPS_LOADBAG,
IPS_INITNEW,
IPS_LAST
};
CASSERT(IPS_FALSE == 0);
CASSERT(((IPS_LAST - 1) & 0x03) == (IPS_LAST - 1)); // 2-bit _eInitLoaded
//*** CXFLOAT -- distance from edge to 'float' zone
// NOTES
// pls forgive the lousy hungarian...
#define CXFLOAT() GetSystemMetrics(SM_CXICON)
#define CYFLOAT() GetSystemMetrics(SM_CYICON)
#define CXYHIDE(uSide) 2 // FEATUE: GetSystemMetrics(xxx), we need an appropriate system metric
#ifdef DEBUG
#if 0 // turn on to debug autohide boundary cases
int g_cxyHide = 8;
#undef CXYHIDE
#define CXYHIDE(uSide) g_cxyHide
#endif
#endif
#define CXSMSIZE() GetSystemMetrics(SM_CXSMSIZE)
#define CYSMSIZE() GetSystemMetrics(SM_CYSMSIZE)
#ifdef DEBUG
extern unsigned long DbStreamTell(IStream *pstm);
extern BOOL DbCheckWindow(HWND hwnd, RECT *prcExp, HWND hwndClient);
TCHAR *DbMaskToMneStr(UINT uMask, TCHAR *szMnemonics);
#else
#define DbStreamTell(pstm) 0
#define DbCheckWindow(hwnd, prcExp, hwndClient) 0
#define DbMaskToMneStr(uMask, szMnemonics) szMnemonics
#endif
//*** autohide -- design note
//
// here's an overview of how we do autohide. see the code for details.
//
// only a few routines really know about it. their behavior is driven
// by '_fHiding'. when FALSE, they behave normally. when TRUE, they
// do alternate 'fake' behavior.
//
// a 'real' or 'normal' rect is the full-size rect we display when not hidden.
// a 'fake' or 'tiny' rect is the very thin rect we display when hidden.
// (plus there's a '0-width' rect we register w/ the system when we're hidden).
//
// more specifically,
//
// when fHiding is TRUE, a few routines have alternate 'fake' behavior:
// _ProtoRect returns a 'tiny' rect rather than the 'real' rect
// _NegotiateRect is a NOOP (so we don't change the 'tiny' rect)
// _SetVRect is a NOOP (so we don't save the 'tiny' rect)
// AppBarSetPos is a NOOP (so we don't set the 'tiny' rect)
// plus, a few routines handle transitions (and setup):
// _DoHide hide/unhide helper
// _MoveSizeHelper detects and handles transitions
// _HideReg register autohide appbar w/ 0-width rect
// and finally, a few messages trigger the transitions:
// unhide WM_NCHITTEST on the 'tiny' rect starts the unhide.
// actually it starts a timer (IDT_AUTOUNHIDE) so there's a
// bit of hysteresis.
// hide WM_ACTIVATE(deact) starts a timer (IDT_AUTOHIDE)
// which we use to poll for mouse leave events. again, there
// is some hysteresis, plus some additional heuristics for hiding.
// WM_ACTIVATE(act) stops the timer.
//
// #if 0
// we also have 'manual hide'. manual hide differs from autohide as follows:
// autohide never negotiates space(*) , manual hide always does
// autohide is focus- and cursor- driven, manual hide is UI-driven
// (*) actually it negotiates space of '0'.
// e.g. 'manual hide' is used for the BrowserBar (e.g. search results).
// however for now at least 'manual hide' is simply a ShowDW(FALSE).
// #endif
void CDockingBar::_AdjustToChildSize()
{
if (_szChild.cx)
{
RECT rc, rcChild;
GetWindowRect(_hwnd, &rc);
GetClientRect(_hwndChild, &rcChild);
// we need to change rc by the delta of prc-rcChild
rc.right += _szChild.cx - RECTWIDTH(rcChild);
rc.bottom += _szChild.cy - RECTHEIGHT(rcChild);
_SetVRect(&rc);
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
_szChild.cx = 0;
}
}
void CDockingBar::_OnPostedPosRectChange()
{
if (_ptbSite) {
if (!_fDragging) {
_AdjustToChildSize();
}
}
}
HMENU CDockingBar::_GetContextMenu()
{
HMENU hmenu = LoadMenuPopup(MENU_WEBBAR);
if (hmenu) {
// _eMode
if (!ISWBM_DESKTOP())
{
EnableMenuItem(hmenu, IDM_AB_TOPMOST, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(hmenu, IDM_AB_AUTOHIDE, MF_BYCOMMAND | MF_GRAYED);
}
CheckMenuItem(hmenu, IDM_AB_TOPMOST, WBM_IS_TOPMOST() ? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
// hide
// we use _fWantHide (not _fCanHide) to reflect what user asked
// for, not what he got. o.w. you can't tell what the state is
// unless you actually get it.
CheckMenuItem(hmenu, IDM_AB_AUTOHIDE,
MF_BYCOMMAND | (_fWantHide ? MF_CHECKED : MF_UNCHECKED));
CASSERT(PARENT_XTOPMOST == HWND_DESKTOP); // for WM_ACTIVATE
CASSERT(PARENT_BTMMOST() == HWND_DESKTOP); // for WM_ACTIVATE
if (_eMode & WBM_FLOATING)
{
// (for now) only desktop btm/topmost does autohide
EnableMenuItem(hmenu, IDM_AB_AUTOHIDE, MF_BYCOMMAND | MF_GRAYED);
}
#ifdef DEBUG
// FEATURE temporary until we make browser tell us about activation
CheckMenuItem(hmenu, IDM_AB_ACTIVATE,
MF_BYCOMMAND | (_fActive ? MF_CHECKED : MF_UNCHECKED));
#endif
}
return hmenu;
}
HRESULT CDockingBar::_TrackPopupMenu(const POINT* ppt)
{
HRESULT hres = S_OK;
HMENU hmenu = _GetContextMenu();
if (hmenu)
{
TrackPopupMenu(hmenu, /*TPM_LEFTALIGN|*/TPM_RIGHTBUTTON,
ppt->x, ppt->y, 0, _hwnd, NULL);
DestroyMenu(hmenu);
}
else
{
hres = E_OUTOFMEMORY;
}
return hres;
}
void CDockingBar::_HandleWindowPosChanging(LPWINDOWPOS pwp)
{
}
/***
*/
LRESULT CDockingBar::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lres = 0;
POINT pt;
DWORD pos;
RECT rc;
switch (uMsg) {
case WM_CLOSE:
_AppBarOnCommand(IDM_AB_CLOSE); // _RemoveToolbar(0)
break;
case WM_DESTROY:
if (_fAppRegistered)
_AppBarRegister(FALSE);
break;
case APPBAR_CALLBACK:
_AppBarCallback(hwnd, uMsg, wParam, lParam);
return 0;
case WM_CONTEXTMENU:
if (_CheckForwardWinEvent(uMsg, wParam, lParam, &lres))
break;
if ((LPARAM)-1 == lParam)
{
GetClientRect(_hwnd, &rc);
MapWindowRect(_hwnd, HWND_DESKTOP, &rc);
pt.x = rc.left + (rc.right - rc.left) / 2;
pt.y = rc.top + (rc.bottom - rc.top) / 2;
}
else
{
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
}
_TrackPopupMenu(&pt);
break;
case WM_ENTERSIZEMOVE:
ASSERT(_fDragging == 0);
_fDragging = 0; // reset if busted
_xyPending = XY_NIL;
#if XXX_CANCEL
GetWindowRect(hwnd, &_rcCapture); // to detect cancel
#endif
break;
case WM_SYSCHAR:
if (wParam == TEXT(' '))
{
HMENU hmenu;
hmenu = GetSystemMenu(hwnd, FALSE);
if (hmenu) {
EnableMenuItem(hmenu, SC_RESTORE, MFS_GRAYED | MF_BYCOMMAND);
EnableMenuItem(hmenu, SC_MAXIMIZE, MFS_GRAYED | MF_BYCOMMAND);
EnableMenuItem(hmenu, SC_MINIMIZE, MFS_GRAYED | MF_BYCOMMAND);
}
}
goto DoDefault;
case WM_SIZING: // goto DoDefault? I doubt it.
case WM_MOVING:
{
LPRECT prc = (RECT*)lParam;
pos = GetMessagePos();
if (_fDragging == 0)
{
// 1st time
_DragEnter(uMsg, GET_X_LPARAM(pos), GET_Y_LPARAM(pos), prc);
ASSERT(_fDragging != 0);
}
else
{
// 2nd..Nth time
_DragTrack(uMsg, GET_X_LPARAM(pos), GET_Y_LPARAM(pos), prc, 0);
}
}
return 1;
case WM_MOVE: // xLeft , yTop
case WM_SIZE: // xWidth, yHeight
if (_fDragging)
{
RECT rcTmp;
CopyRect(&rcTmp, &_rcPending);
_DragTrack(uMsg, GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending),
&rcTmp, 1);
}
_OnSize(); // PERF: only needed for WM_SIZE? At worst this might cause a sligth flicker.
break;
case WM_EXITSIZEMOVE:
_DragLeave(-1, -1, TRUE);
ASSERT(_fDragging == 0);
break;
case WM_CHILDACTIVATE:
if (_eMode == WBM_BFLOATING)
SendMessage(_hwnd, WM_MDIACTIVATE, (WPARAM)_hwnd, 0);
goto DoDefault;
case WM_WINDOWPOSCHANGING:
_HandleWindowPosChanging((LPWINDOWPOS)lParam);
break;
case WM_WINDOWPOSCHANGED:
Lfwdappbar:
if (_fAppRegistered)
_AppBarOnWM(uMsg, wParam, lParam);
goto DoDefault; // fwd on so we'll get WM_SIZE etc.
case WM_TIMER:
switch (wParam) {
case IDT_AUTOHIDE:
{
ASSERT(_fWantHide && _fCanHide);
GetCursorPos(&pt);
GetWindowRect(hwnd, &rc);
// add a bit of fudge so we don't hide when trying to grab the edge
InflateRect(&rc, GetSystemMetrics(SM_CXEDGE) * 4,
GetSystemMetrics(SM_CYEDGE)*4);
HWND hwndAct = GetActiveWindow();
if (!PtInRect(&rc, pt) && hwndAct != hwnd &&
(hwndAct == NULL || ::GetWindowOwner(hwndAct) != hwnd))
{
// to hide, we need to be outside the inflated window,
// and we can't be active (for keyboard users).
// (heuristics stolen from tray.c)
// FEATURE: tray.c also checks TM_SYSMENUCOUNT == 0
_DoHide(AHO_KILLDO|AHO_MOVEDO);
}
}
break;
case IDT_AUTOUNHIDE: // FEATURE: share code w/ IDT_AUTOHIDE
ASSERT(_fWantHide && _fCanHide);
if (_fHiding)
{
ASSERT(_fHiding == HIDE_AUTO);
GetCursorPos(&pt);
GetWindowRect(hwnd, &rc);
if (PtInRect(&rc, pt))
_DoHide(AHO_KILLUN|AHO_MOVEUN|AHO_SETDO);
else
Lkillun:
_DoHide(AHO_KILLUN);
}
else
{
// if we mouse-over and then TAB very quickly, we can end
// up getting a WM_ACT followed by a WM_TIMER (despite the
// KillTimer inside OnAct). if so we need to be careful
// not to do an AHO_SETDO. just to be safe we do an
// AHO_KILLUN as well.
TraceMsg(DM_HIDE, "cwb.WM_T: !_fHiding (race!) => AHO_KILLUN");
goto Lkillun;
}
break;
default:
goto DoDefault;
}
break;
case WM_NCLBUTTONDOWN:
case WM_LBUTTONDOWN:
goto DoDefault;
case WM_ACTIVATE:
_OnActivate(wParam, lParam);
goto Lfwdappbar;
case WM_GETMINMAXINFO: // prevent it from getting too small
// n.b. below stuff works for scheme 'win standard large'
// but not for v. large edges. not sure why, but we'll
// have to fix it or the original bug will still manifest
// on accessibility-enabled machines.
// nt5:149535: resize/drag of v. small deskbar.
// APPCOMPAT workaround USER hittest bug for v. small windows.
// DefWndProc(WM_NCHITTEST) gives wrong result (HTLEFT) when
// window gets too small. so stop it from getting v. small.
//
// the below calc actually gives us slightly *more* than the
// min size, but what the heck. e.g. it gives 8+15+1=24,
// whereas empirical tests give 20. not sure why there's a
// diff, but we'll use the bigger # to be safe.
{
RECT rcTmp = {100,100,100,100}; // arbitrary 0-sized rect
LONG ws, wsx;
HWND hwndTmp;
_GetStyleForMode(_eMode, &ws, &wsx, &hwndTmp);
AdjustWindowRectEx(&rcTmp, ws, FALSE, wsx);
((MINMAXINFO *)lParam)->ptMinTrackSize.x = RECTWIDTH(rcTmp) + CXSMSIZE() + 1;
((MINMAXINFO *)lParam)->ptMinTrackSize.y = RECTHEIGHT(rcTmp) + CYSMSIZE() + 1;
if (ISWBM_FLOAT(_eMode))
{
// nt5:169734 'close' button on v. small floating deskbar.
// APPCOMPAT workaround USER 'close' button bug for v. small windows.
// the button on a v. small TOOLWINDOW doesn't work.
// empirically the below adjustment seems to work.
((MINMAXINFO *)lParam)->ptMinTrackSize.x += (CXSMSIZE() + 1) * 3 / 2;
((MINMAXINFO *)lParam)->ptMinTrackSize.y += (CYSMSIZE() + 1) * 3 / 2;
}
TraceMsg(DM_TRACE, "cwb.GMMI: x=%d", ((MINMAXINFO *)lParam)->ptMinTrackSize.x);
}
break;
case WM_NCHITTEST:
return _OnNCHitTest(wParam, lParam);
case WM_WININICHANGE:
// Active Desktop *broadcasts* a WM_WININICHANGE SPI_SETDESKWALLPAPER
// message when starting up. If this message gets processed during
// startup at just the right time, then the bands will notify their
// preferred state, and we lose the persisted state. Since the desktop
// wallpaper changing is really of no interest to us, we filter it out here.
//
// REVIEW CDTURNER: Would we get a perf win by punting a larger class
// of these wininichange messages? It seems like most won't affect
// the contents of a deskbar...
//
if (SPI_SETDESKWALLPAPER == wParam)
break;
goto DoDefault;
default:
DoDefault:
return SUPERCLASS::v_WndProc(hwnd, uMsg, wParam, lParam);
}
return lres;
}
LRESULT CDockingBar::_OnNCHitTest(WPARAM wParam, LPARAM lParam)
{
if (_fHiding)
_DoHide(AHO_SETUN);
// get 'pure' hittest...
LRESULT lres = _CalcHitTest(wParam, lParam);
// ... and perturb it based on where we're docked
BOOL fSizing = FALSE;
if (ISWBM_FLOAT(_eMode)) {
// standard sizing/moving behavior
return lres;
}
else {
// opposing edge sizes; any other edge moves
ASSERT(ISABE_DOCK(_uSide));
switch (_uSide) {
case ABE_LEFT:
//
// Mirror the edges (since we are dealing with screen coord)
// if the docked-window parent is mirrored. [samera]
//
if (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)))
fSizing = (lres==HTLEFT);
else
fSizing = (lres==HTRIGHT);
break;
case ABE_RIGHT:
//
// Mirror the edges (since we are dealing with screen coord)
// if the docked-window parent is mirrored.
//
if (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)))
fSizing = (lres==HTRIGHT);
else
fSizing = (lres==HTLEFT);
break;
case ABE_TOP:
fSizing = (lres==HTBOTTOM);
break;
case ABE_BOTTOM:
fSizing = (lres==HTTOP);
break;
default:
ASSERT(0);
break;
}
}
if (!fSizing) {
lres = HTCAPTION;
}
return lres;
}
//*** _OnActivate --
//
void CDockingBar::_OnActivate(WPARAM wParam, LPARAM lParam)
{
TraceMsg(DM_HIDE, "cwb.WM_ACTIVATE wParam=%x", wParam);
if (_fCanHide) {
ASSERT(_fHiding != HIDE_MANUAL);
if (LOWORD(wParam) != WA_INACTIVE) {
// activate
TraceMsg(DM_HIDE, "cdb._oa: WM_ACT(act) _fHiding=%d", _fHiding);
// turn off timers for perf
// nash:40992: unhide if hidden (e.g. TABed to hidden)
_DoHide(AHO_KILLDO|AHO_MOVEUN);
}
else {
// deactivate
_DoHide(AHO_SETDO); // restore
}
}
return;
}
/***
*/
CDockingBar::CDockingBar() : _eMode(WBM_NIL), _uSide(ABE_RIGHT)
{
ASSERT(_fIdtUnHide == FALSE);
ASSERT(_fIdtDoHide == FALSE);
_ptIdtUnHide.x = _ptIdtUnHide.y = -1;
// set up worst-case defaults. we'll end up using them for:
// - some of them for Load(bag)
// - all of them for InitNew()
// note that we might call _InitPos4 again in SetSite.
_InitPos4(TRUE);
return;
}
//*** _Initialize -- 2nd-phase ctor
// NOTES
// we need any IPS::Load settings and also a site before we can init
// ourself, so most initialization waits until here.
void CDockingBar::_Initialize()
{
ASSERT(!_fInitShowed);
ASSERT(_fInitSited && _eInitLoaded);
ASSERT(!CDB_INITED());
_fInitShowed = TRUE;
// warning: delicate phase-ordering here...
UINT eModeNew = _eMode;
_eMode = WBM_NIL;
UINT uSideNew = _uSide;
_uSide = ABE_NIL;
HMONITOR hMonNew = _hMon;
_hMon = NULL;
// 48463: beta reports fault on boot when we have deskbar+taskbar on
// same edge (non-merged). i'm guessing (no proof) that shdocvw isn't
// init'ed enough early on during boot to handle doing a MergeBS, or
// alternately that there's a race btwn the tray and desktop threads.
//
// plus in any case we shouldn't do the merge just because the guy did
// a logoff/logon!
_SetModeSide(eModeNew, uSideNew, hMonNew, /*fNoMerge*/_eInitLoaded == IPS_LOAD);
_NotifyModeChange(0);
// if we have a bar on the right and we drag a band from it to
// the top, we end up getting a sequence:
// create deskbar; AddBand; SetSite; _Initialize
// the AddBand of the (1st) band tries to do an autosize but
// there's no site yet, so nothing happens.
//
// so we need to force it here.
_AdjustToChildSize();
if (_fWantHide) {
_fWantHide = FALSE;
_AppBarOnCommand(IDM_AB_AUTOHIDE);
}
ASSERT(CDB_INITED());
return;
}
/***
*/
CDockingBar::~CDockingBar()
{
ASSERT(!_fAppRegistered); // make sure _ChangeTopMost(WBM_NIL) was called
// make sure SetSite(NULL); was called
ASSERT(!_ptbSite);
return;
}
void CDockingBar::_GetChildPos(LPRECT prc)
{
GetClientRect(_hwnd, prc);
}
//*** _OnSize -- compute size for OC, leaving room for toolbar (caption?)
//
void CDockingBar::_OnSize(void)
{
RECT rc;
if (!_hwndChild || !_eInitLoaded)
return;
ASSERT(IsWindow(_hwndChild));
// don't resize on a hide (it's temporary and we don't want things
// to jerk around or worse still do a destructive reformat)
// APPCOMPAT: should suppress resizing here in theater mode autohide
// too (see theater.cpp)
if (_fHiding)
return;
_GetChildPos(&rc);
// (used to do ISWBM_EDGELESS 'fake edge' adjustments here, someone
// nuked them, but should be o.k. now that visuals are frozen *provided*
// we don't go back to edgeless)
SetWindowPos(_hwndChild, 0,
rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc),
SWP_NOACTIVATE|SWP_NOZORDER);
//ASSERT(DbCheckWindow(_hwndChild, &rc, xxx));
}
//*** _CalcHitTest --
// NOTES
// really only has to return an int (win16?)
LRESULT CDockingBar::_CalcHitTest(WPARAM wParam, LPARAM lParam)
{
LRESULT lRet;
if (!(ISWBM_BOTTOM(_eMode) && ISWBM_EDGELESS(_eMode))) {
// For non-btmmost, we can ask USER to perform the default
// hit testing.
lRet = DefWindowProcWrap(_hwnd, WM_NCHITTEST, wParam, lParam);
} else {
// For btmmost, we need to do it.
// (possibly dead code if bottom is never edgeless)
// (if so, compiler should optimize it out)
//TraceMsg(DM_WARNING, "cdb.ro: edgeless!");
RECT rc;
GetWindowRect(_hwnd, &rc);
UINT x = GET_X_LPARAM(lParam);
UINT y = GET_Y_LPARAM(lParam);
// actually SM_C?SIZEFRAME is too big, but we get away w/ it
// since we've been initiated by a WM_NCHITTEST so we know
// we're on *some* edge
UINT cx = GetSystemMetrics(SM_CXSIZEFRAME);
UINT cy = GetSystemMetrics(SM_CYSIZEFRAME);
if (_eMode == WBM_BBOTTOMMOST)
cx *= 2;
lRet = HTCAPTION;
if (x > rc.right-cx) {
lRet = HTRIGHT;
} else if (x < rc.left+cx) {
lRet = HTLEFT;
} else if (y < rc.top+cy) {
lRet = HTTOP;
} else if (y > rc.bottom-cy) {
lRet = HTBOTTOM;
}
}
return lRet;
}
//***
//
void CDockingBar::_DragEnter(UINT uMsg, int x, int y, RECT* rcFeed)
{
ASSERT(_fDragging == 0);
if ((!(_eMode & WBM_FLOATING)) && uMsg == WM_MOVING)
{
// APPCOMPAT workaround USER non-full-drag drag rect bug
// by forcing rcFeed back to exact current location (rather than
// leaving at initial offset that USER gave us).
//
// w/o this code a drag from right to top in non-full-drag mode
// will leave drag-rect droppings at the top of the original
//
// APPCOMPAT but, this seems to make things *worse* if !ISWBM_DESKTOP(),
// so we don't do it in that case... (sigh).
_MoveSizeHelper(_eMode, _uSide, _hMon, NULL, rcFeed, FALSE, FALSE);
}
_eModePending = _eMode;
_uSidePending = _uSide;
_xyPending = MAKELPARAM(x, y);
_hMonPending = _hMon;
ASSERT(rcFeed != 0);
if (rcFeed != 0)
CopyRect(&_rcPending, rcFeed);
#if XXX_CANCEL
RECT rcTmp;
GetWindowRect(_hwnd, &rcTmp);
TraceMsg(DM_DRAG2,
"cwb.de: rcTmp=(%d,%d,%d,%d) (%dx%d) _rcCapture=(%d,%d,%d,%d) (%dx%d)",
rcTmp.left, rcTmp.top, rcTmp.right, rcTmp.bottom,
RECTWIDTH(rcTmp), RECTHEIGHT(rcTmp),
_rcCapture.left, _rcCapture.top, _rcCapture.right, _rcCapture.bottom,
RECTWIDTH(_rcCapture), RECTHEIGHT(_rcCapture));
#endif
switch (uMsg) {
case WM_MOVING: _fDragging = DRAG_MOVE; break;
case WM_SIZING: _fDragging = DRAG_SIZE; break;
default: ASSERT(0); break;
}
if (_fDragging == DRAG_MOVE) {
// turn off size negotiation to prevent horz/vert pblms.
//
// e.g. when we drag a floating guy to horz/vert, there's
// a period of time during which we have a horz/vert size,
// but still think we're floating, which screws up size
// negotiation royally.
_ExecDrag(DRAG_MOVE);
}
return;
}
//***
//
void CDockingBar::_DragTrack(UINT uMsg, int x, int y, RECT* rcFeed, int eState)
{
#if DM_API
TraceMsg(DM_DRAG2,
"cwb.dt: API s=%d xy=(%d,%d) rc=(%d,%d,%d,%d) (%dx%d)",
eState, x, y,
_PM(rcFeed,left), _PM(rcFeed,right), _PM(rcFeed,bottom), _PM(rcFeed,right),
_PX(rcFeed,RECTWIDTH(*rcFeed)), _PX(rcFeed,RECTHEIGHT(*rcFeed)));
#endif
ASSERT(_fDragging != 0);
switch (eState) {
case 0: // WM_MOVING
{
BOOL fImmediate = ((!_fDesktop) && uMsg == WM_SIZING) ? TRUE:FALSE;
// remember for eventual commit
_xyPending = MAKELPARAM(x, y);
ASSERT(rcFeed != NULL);
CopyRect(&_rcPending, rcFeed);
// snap and give feedback
_TrackSliding(x, y, rcFeed, fImmediate, fImmediate);
break;
}
case 1: // WM_MOVE
TraceMsg(DM_DRAG2,
"cwb.dt: %s _xyPend=(%d,%d) xy=(%d,%d)",
(_xyPending != MAKELPARAM(x, y)) ? "noop/cancel" : "commit",
GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending), x, y);
break;
default: ASSERT(0); break;
}
return;
}
//***
//
void CDockingBar::_DragLeave(int x, int y, BOOL fCommit)
{
#if DM_API
TraceMsg(DM_DRAG,
"cwb.dl: API xy=(%d,%d) fCommit=%d",
x, y, fCommit);
#endif
if (_fDragging == 0) {
// when we're inside a browser and you move the browser window
// we get WM_ENTERSIZEMOVE/ WM_EXITSIZEMOVE but never any
// WM_MOVING/WM_MOVE/WM_SIZING/WM_SIZE
return;
}
switch (_fDragging) {
case DRAG_MOVE:
case DRAG_SIZE:
break;
default: ASSERT(0); break;
}
#if XXX_CANCEL
RECT rcTmp;
GetWindowRect(_hwnd, &rcTmp);
TraceMsg(DM_DRAG2,
"cwb.dl: rcTmp=(%d,%d,%d,%d) (%dx%d) _rcCapture=(%d,%d,%d,%d) (%dx%d)",
rcTmp.left, rcTmp.top, rcTmp.right, rcTmp.bottom,
RECTWIDTH(rcTmp), RECTHEIGHT(rcTmp),
_rcCapture.left, _rcCapture.top, _rcCapture.right, _rcCapture.bottom,
RECTWIDTH(_rcCapture), RECTHEIGHT(_rcCapture));
TraceMsg(DM_DRAG2, "cwb.dl: %s",
EqualRect(&rcTmp, &_rcCapture) ? "noop/cancel" : "commit");
#endif
BOOL fCancel = FALSE; // FEATURE: todo: cancel NYI
if (!fCancel) {
if (_fDragging == DRAG_MOVE) {
// nt5:187720 do this *before* the final move.
// o.w. addr band ends up w/ 80-high default rather than
// snapped to correct/negotiated size.
//
// why are we able to turn this on here when in general it
// had to be off during the drag? well, the preview of the
// drag went thru MoveSizeHelper which did a NotifyModeChange
// which told our client what its orientation really is. so
// by now things should be in sync.
// size negotiation had been turned off (to prevent horz/vert
// pblms). turn it on before the final move so that we'll
// recalc correctly.
_ExecDrag(0);
}
// (we're done w/ _rcPending so o.k. to pass it in and trash it)
// fMove==TRUE even though USER has already done the move for us,
// since it's only done the move not the resize (?). if we use
// fMove==FALSE we end up in the new location but w/ the old size,
// despite the fact that rcFeed has been updated along the way.
// this is because USER sets SWP_NOSIZE when it does the move.
_TrackSliding(GET_X_LPARAM(_xyPending), GET_Y_LPARAM(_xyPending),
&_rcPending, TRUE, TRUE);
// if we got a preferred child sizewhild dragging, set ourselves to that now.
// sizing up (cx > min), _szChild.cx == 0 and call a noop.
// sizing down (cx < min), _szChild.cx != 0 and call does something.
//ASSERT(_szChild.cx == 0); // 0 => _AdjustToChildSize is nop
_AdjustToChildSize();
}
else {
_MoveSizeHelper(_eMode, _uSide, _hMon, NULL, NULL, TRUE, FALSE); // FEATURE: fMove?
}
_fDragging = 0;
return;
}
#ifdef DEBUG
int g_dbNoExecDrag = 0; // to play w/ ExecDrag w/o recompiling
#endif
void DBC_ExecDrag(IUnknown *pDBC, int eDragging)
{
VARIANTARG vaIn = {0}; // VariantInit
ASSERT(eDragging == DRAG_MOVE || eDragging == 0);
#ifdef DEBUG
if (g_dbNoExecDrag)
return;
#endif
vaIn.vt = VT_I4;
vaIn.lVal = eDragging; // n.b. currently only 0/1 is supported
IUnknown_Exec(pDBC, &CGID_DeskBarClient, DBCID_ONDRAG, OLECMDEXECOPT_DONTPROMPTUSER, &vaIn, NULL);
// VariantClear
return;
}
void CDockingBar::_ExecDrag(int eDragging)
{
DBC_ExecDrag(_pDBC, eDragging);
return;
}
//*** _Recalc -- force recalc using current settings
//
void CDockingBar::_Recalc(void)
{
_MoveSizeHelper(_eMode, _uSide, _hMon, NULL, NULL, TRUE, TRUE);
return;
}
//*** _MoveSizeHelper -- shared code for menu and dragging forms of move/size
//
void CDockingBar::_MoveSizeHelper(UINT eModeNew, UINT eSideNew, HMONITOR hMonNew,
POINT* ptTrans, RECT* rcFeed, BOOL fCommit, BOOL fMove)
{
UINT eModeOld, eSideOld;
RECT rcNew;
// only desktop guys can go to TOPMOST
ASSERT(eModeNew != WBM_TOPMOST || ISWBM_DESKTOP());
eModeOld = _eMode;
eSideOld = _uSide;
ASSERT(CHKWBM_CHANGE(eModeNew, _eMode));
_eModePending = eModeNew; // for drag feedback, before commit
_uSidePending = eSideNew;
_hMonPending = hMonNew;
if (fCommit)
{
// we need to be careful when we call _ChangeHide or we'll recurse
BOOL fChangeHide = (_fWantHide &&
(eSideNew != _uSide || eModeNew != _eMode || hMonNew != _hMon));
if (fChangeHide)
_DoHide(AHO_KILLDO|AHO_UNREG);
_SetModeSide(eModeNew, eSideNew, hMonNew, FALSE);
if (fChangeHide)
{
// don't do AHO_SETDO now, wait for WM_ACTIVATE(deactivate)
_DoHide(AHO_REG);
}
}
// negotiate (and possibly commit to negotiation)
_ProtoRect(&rcNew, eModeNew, eSideNew, hMonNew, ptTrans);
_NegotiateRect(eModeNew, eSideNew, hMonNew, &rcNew, fCommit);
// commit
if (fCommit)
_SetVRect(&rcNew);
// feedback
if (rcFeed != 0)
{
CopyRect(rcFeed, &rcNew);
}
if (fMove)
{
// If we're in theater mode, out parent manages our width and
// horizontal position, unless we're being forced to a new
// size by szChild.
if (_fTheater && !_fDragging)
{
RECT rcCur;
GetWindowRect(_hwnd, &rcCur);
rcNew.left = rcCur.left;
rcNew.right = rcCur.right;
}
// aka ScreenToClient
MapWindowPoints(HWND_DESKTOP, GetParent(_hwnd), (POINT*) &rcNew, 2);
if (_fCanHide && eModeNew == eModeOld && eSideNew == eSideOld)
{
// if we're [un]hiding to the same state, we can do SlideWindow
ASSERT(ISWBM_HIDEABLE(eModeNew));
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
SlideWindow(_hwnd, &rcNew, _hMon, !_fHiding);
DAD_ShowDragImage(TRUE); // restore the lock state.
}
else
{
MoveWindow(_hwnd, rcNew.left, rcNew.top,
RECTWIDTH(rcNew), RECTHEIGHT(rcNew), TRUE);
}
}
// WARNING: rcNew is no longer in consistent coords! (ScreenToClient)
// notify the child of changes
_NotifyModeChange(0);
}
void CDockingBar::_NotifyModeChange(DWORD dwMode)
{
UINT eMode, uSide;
eMode = ((_fDragging == DRAG_MOVE) ? _eModePending : _eMode);
uSide = ((_fDragging == DRAG_MOVE) ? _uSidePending : _uSide);
//hMon = ((_fDragging == DRAG_MOVE) ? _hMonPending : _hMon);
if (ISWBM_FLOAT(eMode))
dwMode |= DBIF_VIEWMODE_FLOATING;
else if (!ABE_HORIZ(uSide))
dwMode |= DBIF_VIEWMODE_VERTICAL;
SUPERCLASS::_NotifyModeChange(dwMode);
}
void CDockingBar::_TrackSliding(int x, int y, RECT* rcFeed,
BOOL fCommit, BOOL fMove)
{
TraceMsg(DM_DRAG2,
"cwb.ts: _TrackSliding(x=%d, y=%d, rcFeed=(%d,%d,%d,%d)(%dx%d), fCommit=%d, fMove=%d)",
x, y,
_PM(rcFeed,left), _PM(rcFeed,top), _PM(rcFeed,right), _PM(rcFeed,bottom),
_PX(rcFeed,RECTWIDTH(*rcFeed)), _PX(rcFeed,RECTHEIGHT(*rcFeed)),
fCommit, fMove);
POINT pt = { x, y };
UINT eModeNew, uSideNew;
HMONITOR hMonNew;
if (_fDragging == DRAG_MOVE) {
// moving...
if (fCommit) {
// use last feedback position.
// o.w. (if we recompute) we end up in the wrong place since
// WM_MOVE gives us the (left,top), which often is in another
// docking zone.
ASSERT(x == GET_X_LPARAM(_xyPending) && y == GET_Y_LPARAM(_xyPending));
//eModeNew = _eModePending;
//uSideNew = _uSidePending;
}
//
// figure out snap position,
// and do a few special-case hacks to fix it up if necessary
//
uSideNew = _CalcDragPlace(pt, &hMonNew);
if (uSideNew == ABE_XFLOATING) {
// dock->float or float->float
eModeNew = _eMode | WBM_FLOATING;
uSideNew = _uSide; // FEATURE: _uSidePending? This seems to work correctly as is.
}
else {
// float->dock or dock->dock
eModeNew = _eMode & ~WBM_FLOATING;
}
TraceMsg(DM_DRAG2,
"cwb.ts: (m,s) _x=(%d,%d) _xPend=(%d,%d) xNew=(%d,%d)",
_eMode, _uSide, _eModePending, _uSidePending, eModeNew, uSideNew);
// 970725: we now allow bottom->float (for the desktop, not browser)
if (ISWBM_FLOAT(eModeNew) && ISWBM_BOTTOM(_eMode) && !ISWBM_DESKTOP()) {
// special case: don't allow switch from BTMMOST to FLOATING
ASSERT(CHKWBM_CHANGE(eModeNew, _eMode));
eModeNew = _eModePending; // the dead zone...
uSideNew = _uSidePending; // QUESTION: init case?
hMonNew = _hMonPending;
TraceMsg(DM_DRAG2,
"cwb.ts: (m,s) btm->flt override xNew=(%d,%d)",
eModeNew, uSideNew);
ASSERT(!ISWBM_FLOAT(eModeNew));
}
//
// smooth things out so we don't jump around
//
_SmoothDragPlace(eModeNew, uSideNew, hMonNew, &pt, rcFeed);
//
// now do the move
//
// | with _eMode & WBMF_BROWSER because dragging around doesn't change the
// browser owned bit
_MoveSizeHelper(eModeNew | (_eMode & WBMF_BROWSER), uSideNew, hMonNew,
ISWBM_FLOAT(eModeNew) ? &pt : NULL, rcFeed, fCommit, fMove);
}
else {
ASSERT(_fDragging == DRAG_SIZE);
// truncate to max size if necessary
_SmoothDragPlace(_eMode, _uSide, _hMon, NULL, rcFeed);
if (!fCommit) {
// USER does everything for us
return;
}
ASSERT(MAKELPARAM(x, y) != XY_NIL);
// APPCOMPAT: we're gonna commit so just blast it in here...
RECT rcNew;
GetWindowRect(_hwnd, &rcNew); // PERF: already set?
_SetVRect(&rcNew);
_MoveSizeHelper(_eMode, _uSide, _hMon,
NULL, NULL, // FEATURE: &rcNew?
fCommit, fMove);
}
return;
}
/*** _CalcDragPlace -- compute where drag will end up
* NOTES
* FEATURE: prelim version
*/
UINT CDockingBar::_CalcDragPlace(POINT& pt, HMONITOR * phMon)
{
TraceMsg(DM_DRAG2,
"cwb.cdp: _CalcDragPlace(pt=(%d,%d))",
pt.x, pt.y);
SIZE screen, error;
UINT uHorzEdge, uVertEdge, uPlace;
RECT rcDisplay = {0}; // _GetBorderRect doesn't always set rect.
// Get the correct hMonitor.
ASSERT(phMon);
*phMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
// FEATURE: todo: make hwndSite and rcDisplay args, then this can be
// a generic helper func
_GetBorderRect(*phMon, &rcDisplay);
// if we're outside our 'parent' (browser or desktop), we float.
// this really only applies to the browser case, since we'll never
// be outside the desktop (what about multi-monitor?).
if (!PtInRect(&rcDisplay, pt) || !_ptbSite) {
TraceMsg(DM_DRAG2,
"cwb.cdp: pt=(%d,%d) uSideNew=%u",
pt.x, pt.y, ABE_XFLOATING);
return ABE_XFLOATING;
}
// if we're not w/in min threshhold from edge, we float
{
RECT rcFloat; // FEATURE can just use rcDisplay
int cx = CXFLOAT();
int cy = CYFLOAT();
CopyRect(&rcFloat, &rcDisplay);
InflateRect(&rcFloat, -cx, -cy);
if (PtInRect(&rcFloat, pt)) {
TraceMsg(DM_DRAG2,
"cwb.cdp: pt=(%d,%d) uSideNew=%u",
pt.x, pt.y, ABE_XFLOATING);
return ABE_XFLOATING;
}
}
//
// re-origin at zero to make calculations simpler
//
screen.cx = RECTWIDTH(rcDisplay);
screen.cy = RECTHEIGHT(rcDisplay);
pt.x -= rcDisplay.left;
pt.y -= rcDisplay.top;
//
// are we closer to the left or right side of this display?
//
if (pt.x < (screen.cx / 2)) {
uVertEdge = ABE_LEFT;
error.cx = pt.x;
}
else {
uVertEdge = ABE_RIGHT;
error.cx = screen.cx - pt.x;
}
//
// are we closer to the top or bottom side of this display?
//
if (pt.y < (screen.cy / 2)) {
uHorzEdge = ABE_TOP;
error.cy = pt.y;
}
else {
uHorzEdge = ABE_BOTTOM;
error.cy = screen.cy - pt.y;
}
//
// closer to a horizontal or vertical edge?
//
uPlace = ((error.cy * screen.cx) > (error.cx * screen.cy))?
uVertEdge : uHorzEdge;
TraceMsg(DM_DRAG2,
"cwb.cdp: pt=(%d,%d) uSideNew=%u",
pt.x, pt.y, uPlace);
return uPlace;
}
//*** _SmoothDragPlace -- do some magic to smooth out dragging
// ENTRY/EXIT
// eModeNew where we're snapping to
// eSideNew ...
// [_eModePending] where we're snapping from
// [_eSidePending] ...
// pt INOUT cursor position
// rcFeed USER's original drag feedback rect
// NOTES
// this is the place to put excel-like heuristics. e.g. when coming
// back off the right side we could put the cursor at the top right of
// the floating rect (rather than the top left) to allow us to float
// as close as possible to the other side w/o docking. hmm, but how
// would we tell USER where to put the cursor...
//
void CDockingBar::_SmoothDragPlace(UINT eModeNew, UINT eSideNew, HMONITOR hMonNew,
INOUT POINT* pt, RECT* rcFeed)
{
if (_fDragging == DRAG_MOVE) {
if (ISWBM_FLOAT(eModeNew) && ISWBM_FLOAT(_eModePending) && rcFeed != 0 && pt) {
// use the feedback rect from USER to keep things smooth.
// o.w. if we use the cursor position we'll jump at the
// beginning (to move the left-top corner to the starting
// cursor position).
pt->x = rcFeed->left;
pt->y = rcFeed->top;
}
}
else {
ASSERT(_fDragging == DRAG_SIZE);
ASSERT(eModeNew == _eMode && eSideNew == _uSide && hMonNew == _hMon);
if (!ISWBM_FLOAT(_eMode)) {
// truncate to max size (1/2 of screen) if necessary
int iWH;
RECT rcScreen;
// we'd like to use 1/2 of browser, not 1/2 of screen. however
// this causes pblms if you maximize, grow to 1/2, and restore.
// then the 1st time you resize the bar it 'jumps' down to 1/2
// of the *current* size from 1/2 of the old size. kind of a
// hack, sigh...
//
// also note that there's still a bug here: if you size down
// the browser gradually, we don't go thru this logic, so you
// end up w/ a bar width > browser width so you the right edge
// is clipped and there's no way to size it down. probably
// when the browser resize is done we should re-smooth the bar.
//_GetBorderRect(_hMon, &rcScreen);
GetMonitorRect(_hMon, &rcScreen); // aka GetSystemMetrics(SM_CXSCREEN)
iWH = RECTGETWH(_uSide, &rcScreen);
iWH /= 2;
if (RECTGETWH(_uSide, rcFeed) > iWH) {
TraceMsg(DM_TRACE, "cwb.sdp: truncate iWH'=%d", iWH);
RectXform(rcFeed, RX_OPPOSE, rcFeed, NULL, iWH, _uSide, NULL);
}
}
}
return;
}
/***
*/
LRESULT CDockingBar::_OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lres = 0;
if (_CheckForwardWinEvent(uMsg, wParam, lParam, &lres))
return lres;
if ((Command_GetID(wParam) <= IDM_AB_LAST) &&
(Command_GetID(wParam) >= IDM_AB_FIRST)) {
_AppBarOnCommand(Command_GetID(wParam));
}
return lres;
}
/*** CDockingBar::_AppBarRegister -- register/unregister AppBar
* DESCRIPTION
* updates _fAppRegistered
* does nothings if it's already regisrered or unregistered
*/
void CDockingBar::_AppBarRegister(BOOL fRegister)
{
APPBARDATA abd;
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = _hwnd;
if (fRegister && !_fAppRegistered) {
abd.uCallbackMessage = APPBAR_CALLBACK;
TraceMsg(DM_APPBAR, "cwb.abr: call ABM_NEW");
UINT_PTR bT = SHAppBarMessage(ABM_NEW, &abd);
ASSERT(bT);
if (bT) {
_fAppRegistered = TRUE;
// fake a callback to set initial state
// #if XXX_TASKMAN
TraceMsg(DM_APPBAR, "cwb.abr: fake ABN_STATECHANGE");
_AppBarCallback(_hwnd, APPBAR_CALLBACK, ABN_STATECHANGE, 0);
// #endif
}
}
else if (!fRegister && _fAppRegistered) {
TraceMsg(DM_APPBAR, "cwb.abr: call ABM_REMOVE");
// n.b. sensitive phase ordering, must set flag before send message
// since the message causes a bunch of callbacks
_fAppRegistered = FALSE;
SHAppBarMessage(ABM_REMOVE, &abd);
}
}
//*** _SetVRect -- set our 'virtual rect' to reflect window state
//
void CDockingBar::_SetVRect(RECT* rcNew)
{
UINT eModeNew, uSideNew;
//ASSERT(_fDragging == 0); // o.w. we should look at _xxxPending
eModeNew = _eMode;
uSideNew = _uSide;
if (_fHiding && ISWBM_HIDEABLE(eModeNew)) {
TraceMsg(DM_HIDE, "cwb.svr: _fHiding => suppress rcNew=(%d,%d,%d,%d)",
rcNew->left, rcNew->top, rcNew->right, rcNew->bottom);
return;
}
if (ISWBM_FLOAT(eModeNew)) {
CopyRect(&_rcFloat, rcNew);
}
else {
_adEdge[uSideNew] = ABE_HORIZ(uSideNew) ? RECTHEIGHT(*rcNew) : RECTWIDTH(*rcNew);
}
return;
}
//*** _ChangeTopMost -- switch back and forth btwn TopMost and BottomMost
// ENTRY/EXIT
// eModeNew new mode we're switching to
//
void CDockingBar::_ChangeTopMost(UINT eModeNew)
{
BOOL fShouldRegister = (eModeNew & WBM_TOPMOST) && !(eModeNew & WBM_FLOATING);
// here's what's legal...
// to...................
// from btm top float
// ---- --- --- -----
// btm(desk) - top+ y(1) (1) force to top
// top top- - 'undock'
// float y(2) 'dock' - (2) force to right
// btm(app) - x(3) y(4) (3) foster child (4) 'owned' window
#if 0
// (1,4) going from BTMMOST to FLOATING is illegal (and NYI) unless desktop
ASSERT(eModeNew != WBM_FLOATING || _eMode != WBM_BOTTOMMOST || ISWBM_DESKTOP());
#endif
// (3) only desktop guys can go to TOPMOST
ASSERT(eModeNew != WBM_TOPMOST || ISWBM_DESKTOP());
// _uSide should always be laying around (even if floating)
ASSERT(_eMode == WBM_NIL || ISABE_DOCK(_uSide));
// note the ordering here, make sure window bits are right
// before doing resume new or else new will have unexpected state
_ChangeWindowStateAndParent(eModeNew);
_eMode = eModeNew;
_ChangeZorder();
// resume new
switch (_eMode) {
case WBM_NIL:
// dummy state for termination
return;
case WBM_BOTTOMMOST:
_ResetZorder();
#if ! XXX_BROWSEROWNED
// fall through
case WBM_BBOTTOMMOST:
#endif
break;
}
_AppBarRegister(fShouldRegister);
}
//*** _ChangeZorder -- set z-order appropriately
// NOTES
// currently doesn't account for 'raised' mode (i.e. caller must call
// _ChangeZorder before _ResetZorder)
void CDockingBar::_ChangeZorder()
{
BOOL fWantTopmost = BOOLIFY(WBM_IS_TOPMOST());
BOOL fIsTopmost = BOOLIFY(GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST);
if (fWantTopmost != fIsTopmost)
SetWindowPos(_hwnd, fWantTopmost ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
return;
}
//*** _ResetZorder -- toggle DockingBars between 'normal' and 'raised' mode
// DESCRIPTION
// queries desktop state and does appropriate '_OnRaise'
//
void CDockingBar::_ResetZorder()
{
HRESULT hr;
VARIANTARG vaIn = {0}; // VariantInit
VARIANTARG vaOut = {0}; // VariantInit
vaIn.vt = VT_I4;
vaIn.lVal = DTRF_QUERY;
hr = IUnknown_Exec(_ptbSite, &CGID_ShellDocView, SHDVID_RAISE, OLECMDEXECOPT_DONTPROMPTUSER,
&vaIn, &vaOut);
if (SUCCEEDED(hr) && vaOut.vt == VT_I4)
_OnRaise(vaOut.lVal);
// VariantClear
return;
}
//*** _OnRaise -- handle desktop 'raise' command
// DESCRIPTION
// changes DockingBar z-order depending on desktop raise state:
// desktop DockingBar
// raised force on top (so visible)
// restored return to normal
// NOTES
// FEATURE: should we handle WBM_FLOATING too?
// FEATURE: should add ZORD_xxx to deskbar.h and handle non-WBM_BOTTOMMOST
void CDockingBar::_OnRaise(UINT flags)
{
HWND hwndZorder;
if (_eMode != WBM_BOTTOMMOST)
return;
switch (flags) {
case DTRF_RAISE:
hwndZorder = HWND_TOPMOST;
break;
case DTRF_LOWER:
hwndZorder = HWND_NOTOPMOST;
break;
default:
ASSERT(0);
return;
}
SetWindowPos(_hwnd, hwndZorder, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
return;
}
#if XXX_BTMFLOAT && 0 // see 'NOTES'
//*** _MayReWindow -- change/restore window state for dragging
// DESCRIPTION
// USER won't let us drag outside of the browser unless we reparent
// ourselves.
// NOTES
// need to call this *before* we enter USER's move/size loop.
// i.e. on LBUTTONDOWN and on EXITSIZEMOVE. this gets a bit
// tricky due to CANCEL etc., since the LBUTTONUP may come thru
// either before or after we're done.
//
void CDockingBar::_MayReWindow(BOOL fToFloat)
{
if (ISWBM_DESKTOP() || _eMode != WBM_BOTTOMMOST)
return;
// do style bits 1st or re-parenting breaks
SHSetWindowBits(_hwnd, GWL_STYLE, WS_CHILD | WS_POPUP, fToFloat ? WS_POPUP | WS_CHILD);
if (!fToFloat) {
// float->btm
// nuke owner
SHSetParentHwnd(_hwnd, NULL);
// parent
SetParent(_hwnd, _hwndSite);
}
if (fToFloat) {
// btm->float, set owner
// parent
SetParent(_hwnd, PARENT_FLOATING);
// set owner
ASSERT(_hwndSite != NULL);
SHSetParentHwnd(_hwnd, _hwndSite);
}
}
#endif
void CDockingBar::_GetStyleForMode(UINT eMode, LONG* plStyle, LONG* plExStyle, HWND* phwndParent)
{
switch (eMode) {
case WBM_NIL:
*plStyle = WS_NIL;
*plExStyle= WS_EX_NIL;
*phwndParent = PARENT_NIL;
break;
case WBM_BBOTTOMMOST:
*plStyle = WS_BBTMMOST;
*plExStyle= WS_EX_BBTMMOST;
*phwndParent = PARENT_BBTMMOST();
break;
case WBM_BOTTOMMOST:
*plStyle = WS_BTMMOST;
*plExStyle= WS_EX_BTMMOST;
*phwndParent = PARENT_BTMMOST();
break;
case WBM_BFLOATING:
// FEATURE: todo: FLOATING NYI
*plStyle = WS_BFLOATING;
*plExStyle = WS_EX_BFLOATING;
*phwndParent = _hwndSite;
break;
case (WBM_FLOATING | WBM_TOPMOST):
case WBM_FLOATING:
// FEATURE: todo: FLOATING NYI
*plStyle = WS_FLOATING;
*plExStyle = WS_EX_FLOATING;
*phwndParent = PARENT_FLOATING;
break;
case WBM_TOPMOST:
*plStyle = WS_XTOPMOST;
*plExStyle= WS_EX_XTOPMOST;
*phwndParent = PARENT_XTOPMOST;
break;
}
#ifdef DEBUG // {
if (_eMode == eMode) {
// style, exstyle
ASSERT(BITS_SET(GetWindowLong(_hwnd, GWL_STYLE), *plStyle));
ASSERT(BITS_SET(GetWindowLong(_hwnd, GWL_EXSTYLE), *plExStyle & ~WS_EX_TOPMOST));
// id
ASSERT(GetWindowLong(_hwnd, GWL_ID) == 0);
// parent
ASSERT(GetParent(_hwnd) == *phwndParent ||
(ISWBM_OWNED(_eMode) && GetParent(_hwnd)==_hwndSite));
}
#endif // }
}
//*** _ChangeWindowStateAndParent --
// NOTES
// todo: make table-driven (ws1, ws2, etc.)
//
void CDockingBar::_ChangeWindowStateAndParent(UINT eModeNew)
{
LONG ws1, wsx1, ws2, wsx2;
HWND hwnd;
if (eModeNew == _eMode) {
// same mode, nothing to do
return;
}
//
// nuke old bits
//
_GetStyleForMode(_eMode, &ws1, &wsx1, &hwnd);
//
// set new bits
//
_GetStyleForMode(eModeNew, &ws2, &wsx2, &hwnd);
// if it's going to be owned by the browser,
// override hwnd to our site's hwnd
if (eModeNew & WBMF_BROWSER)
hwnd = _hwndSite;
// style, exstyle
// (SWB can't do WS_EX_TOPMOST, we do it in caller w/ SWP)
SHSetWindowBits(_hwnd, GWL_STYLE, ws1|ws2 , ws2);
SHSetWindowBits(_hwnd, GWL_EXSTYLE, (wsx1|wsx2) & ~WS_EX_TOPMOST, wsx2);
// id
// (unchanged)
HWND hwndParent = GetParent(_hwnd);
if (hwndParent != hwnd) {
if (hwndParent != HWND_DESKTOP) {
// float->btm, nuke owner
SHSetParentHwnd(_hwnd, NULL);
}
// parent
SetParent(_hwnd, hwnd);
if (hwnd == _hwndSite) {
// btm->float, set owner
ASSERT(_hwndSite != NULL);
SHSetParentHwnd(_hwnd, _hwndSite);
}
}
//
// force redraw
//
SetWindowPos(_hwnd, NULL, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
return;
}
//*** _SetNewMonitor --
// When the Desktop is our Docking Site, set the new monitor I am on
// and return the old monitor
HMONITOR CDockingBar::_SetNewMonitor(HMONITOR hMonNew)
{
HMONITOR hMonOld = NULL;
if (ISWBM_DESKTOP() && _ptbSite)
{
IMultiMonitorDockingSite * pdds;
HRESULT hresT = _ptbSite->QueryInterface(IID_IMultiMonitorDockingSite, (LPVOID *)&pdds);
if (SUCCEEDED(hresT))
{
HMONITOR hMon;
ASSERT(pdds);
if (SUCCEEDED(pdds->GetMonitor(SAFECAST(this, IDockingWindow*), &hMon)))
{
if (hMon != hMonNew)
{
pdds->RequestMonitor(SAFECAST(this, IDockingWindow*), &hMonNew);
pdds->SetMonitor(SAFECAST(this, IDockingWindow*), hMonNew, &hMonOld);
// These two should be the same, otherwise something wierd is happening -- dli
ASSERT(hMonOld == hMon);
}
}
pdds->Release();
}
}
return hMonOld;
}
//*** _GetBorderRect --
// NOTES
// result in screen coordinates
//
void CDockingBar::_GetBorderRect(HMONITOR hMon, RECT* prc)
{
if (!ISWBM_BOTTOM(_eMode)) {
// FEATURE: todo: should use:
// floating: _hwndSite (not strictly correct, but good enough)
// topmost: UnionRect of:
// GetWindowRect(_hwndSite); // non-appbar rect
// GetWindowRect(self) // plus my personal appbar
ASSERT(IsWindow(_hwndSite));
if (ISWBM_DESKTOP())
GetMonitorRect(hMon, prc);
else
GetWindowRect(_hwndSite, prc);
#ifdef DEBUG
#if 0
RECT rcTmp;
// these asserts often fail. e.g. when dragging topmost right->top.
// weird: _hwndSite ends up being PROGMAN's hwnd.
// weird: also, the GetWindowRect fails.
ASSERT(_hwndSite == PARENT_XTOPMOST);
// _hwndSite is PROGMAN
GetWindowRect(PARENT_XTOPMOST, &rcTmp);
ASSERT(EqualRect(prc, &rcTmp));
#endif
#endif
}
else if (_ptbSite) {
HMONITOR hMonOld = _SetNewMonitor(hMon);
_ptbSite->GetBorderDW(SAFECAST(this, IDockingWindow*), prc);
if (hMonOld)
_SetNewMonitor(hMonOld);
ASSERT(_hwndSite != NULL);
//ASSERT(GetParent(_hwnd) == _hwndSite); // FEATURE ISWBM_OWNED?
// convert if necessary
// aka ClientToScreen
MapWindowPoints(_hwndSite, HWND_DESKTOP, (POINT*) prc, 2);
}
return;
}
//*** _HideRegister -- (un)register auto-hide w/ edge
// ENTRY/EXIT
// fToHide TRUE if turning AutoHide on, FALSE if turning off
// _fCanHide [OUT] TRUE if successfully set autohide on; o.w. FALSE
// other pops up dialog if operation fails
//
void CDockingBar::_HideRegister(BOOL fToHide)
{
BOOL fSuccess;
APPBARDATA abd;
if (! ISWBM_HIDEABLE(_eMode))
return;
// (try to) register or unregister it
// n.b. we're allowed to do this even if we're not an AppBar
// that's good, because we want at most one autohide deskbar
// on an edge regardless of mode
abd.cbSize = SIZEOF(abd);
abd.hWnd = _hwnd;
abd.uEdge = _uSide;
abd.lParam = fToHide;
// FEATURE should we do a ABM_GETAUTOHIDEBAR at some point?
// (tray.c does, and so does the AB sample code...)
//ASSERT(_fAppRegistered);
fSuccess = (BOOL) SHAppBarMessage(ABM_SETAUTOHIDEBAR, &abd);
// set our state
_fCanHide = BOOLIFY(fSuccess);
// FEATURE: how handle failure?
// init some stuff
if (fToHide)
{
if (_fCanHide)
{
RECT rc;
ASSERT(_fCanHide); // so we won't SetVRect
ASSERT(!_fHiding); // (paranoia)
// force a '0-width' rectangle so we don't take up any space
RectXform(&rc, RX_EDGE|RX_OPPOSE|RX_ADJACENT, &rc, NULL,
0, _uSide, _hMon);
switch (_eMode) {
case WBM_TOPMOST:
// negotiate/commit it
APPBARDATA abd;
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = _hwnd;
ASSERT(_fCanHide);
// we used to do:
// _fCanHide = FALSE; // hack: so we surrender AppBar's space
// AppBarQuerySetPos(&rc, _uSide, &rc, &abd, TRUE);
// _fCanHide = TRUE; // hack: restore
// but the instant we do the ABSetPos the shell does a recalc
// by doing a ShowDW of all toolbars, which does a _Recalc,
// which does a MSH, which ends up doing ProtoRect w/ our
// 'temporary' _fCanHide=0, which ends up taking space (oops!).
//
// so instead we call the low-level ABQueryPos/ABSetPos guys
// directly.
AppBarQueryPos(&rc, _uSide, _hMon, &rc, &abd, TRUE);
AppBarSetPos0(_uSide, &rc, &abd);
break;
}
// do *not* start the hide here
// it's up to the caller, since a) might want delay or
// immediate and b) recursion pblms w/ _MoveSizeHelper
}
else
{
// FEATURE: do PostMessage a la tray.c?
MLShellMessageBox(_hwnd,
MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
MAKEINTRESOURCE(IDS_WEBBARTITLE),
MB_OK | MB_ICONINFORMATION);
ASSERT(!_fCanHide);
}
}
else
{
// do *not* start the unhide here
// it's up to the caller, since a) might want delay or
// immediate and b) recursion pblms w/ _MoveSizeHelper
_fCanHide = FALSE;
}
return;
}
//*** IsNearPoint -- am i currently near specified point?
// ENTRY/EXIT
// pptBase (INOUT) IN previous cursor pos, OUT updated to current if !fNear
// fNear (ret) TRUE if near, o.w. FALSE
// NOTES
// heuristic stolen from explorer/tray.c!TraySetUnhideTimer
//
BOOL IsNearPoint(/*INOUT*/ POINT *pptBase)
{
POINT ptCur;
int dx, dy, dOff, dNear;
GetCursorPos(&ptCur);
dx = pptBase->x - ptCur.x;
dy = pptBase->y - ptCur.y;
dOff = dx * dx + dy * dy;
dNear = GetSystemMetrics(SM_CXDOUBLECLK) * GetSystemMetrics(SM_CYDOUBLECLK);
if (dOff <= dNear)
return TRUE;
TraceMsg(DM_HIDE2, "cwb.inp: ret=0 dOff=%d dNear=%d", dOff, dNear);
*pptBase = ptCur;
return FALSE;
}
//*** _DoHide --
// DESCRIPTION
// AHO_KILLDO kill timer for 'do' operation
// AHO_SETDO set timer for 'do' operation
// AHO_KILLUN kill timer for 'undo' operation
// AHO_SETUN set timer for 'undo' operation
// AHO_REG register
// AHO_UNREG unregister
// AHO_MOVEDO do the actual hide
// AHO_MOVEUN do the actual unhide
// NOTES
// the _fIdtXxHide stuff stops us from doing a 2nd SetTimer before the
// 1st one comes in, which makes us never get the 'earlier' ticks.
// this fixes nt5:142686: drag-over doesn't unhide. it was caused by us
// getting a bunch of WM_NCHITTESTs in rapid succession (OLE asking us on
// a fast timer?).
// REARCHITECT: i think there's a tiny race window on _fIdtXxHide (between the
// call to Set/Kill and the shadowing in _fIdtXxHide). not sure we can
// even hit it, but if we do, i think the worst that happens is somebody
// doesn't hide or unhide for a while.
//
void CDockingBar::_DoHide(UINT uOpMask)
{
TraceMsg(DM_HIDE, "cwb.dh enter(uOpMask=0x%x(%s))",
uOpMask, DbMaskToMneStr(uOpMask, AHO_MNE));
if (!ISWBM_HIDEABLE(_eMode)) {
TraceMsg(DM_HIDE, "cwb.dh !ISWBM_HIDEABLE(_eMode) => suppress");
return;
}
// nuke old timer
if (uOpMask & AHO_KILLDO) {
TraceMsg(DM_HIDE, "cwb.dh: KillTimer(idt_autohide)");
KillTimer(_hwnd, IDT_AUTOHIDE);
_fIdtDoHide = FALSE;
}
if (uOpMask & AHO_KILLUN) {
TraceMsg(DM_HIDE, "cwb.dh: KillTimer(idt_autoUNhide)");
KillTimer(_hwnd, IDT_AUTOUNHIDE);
_fIdtUnHide = FALSE;
_ptIdtUnHide.x = _ptIdtUnHide.y = -1;
}
if (uOpMask & (AHO_REG|AHO_UNREG)) {
_HideRegister(uOpMask & AHO_REG);
}
if (uOpMask & (AHO_MOVEDO|AHO_MOVEUN)) {
// tricky, tricky...
// all the smarts are in _MoveSizeHelper, driven by _fHiding (and _fCanHide)
// use correct one of (tiny,real)
_fHiding = (uOpMask & AHO_MOVEDO) ? HIDE_AUTO : FALSE;
TraceMsg(DM_HIDE, "cwb.dh: move _fHiding=%d", _fHiding);
ASSERT(_fCanHide); // suppress SetVRect
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
}
// start new timer
if (_fCanHide) {
if (uOpMask & AHO_SETDO) {
TraceMsg(DM_HIDE, "cwb.dh: SetTimer(idt_autohide) fAlready=%d", _fIdtDoHide);
if (!_fIdtDoHide) {
_fIdtDoHide = TRUE;
SetTimer(_hwnd, IDT_AUTOHIDE, DLY_AUTOHIDE, NULL);
}
}
if (uOpMask & AHO_SETUN) {
TraceMsg(DM_HIDE, "cwb.dh: SetTimer(idt_autoUNhide) fAlready=%d", _fIdtUnHide);
// IsNearPoint hysteresis prevents us from unhiding when we happen
// to be passed over on the way to something unrelated
if (!IsNearPoint(&_ptIdtUnHide) || !_fIdtUnHide) {
_fIdtUnHide = TRUE;
SetTimer(_hwnd, IDT_AUTOUNHIDE, DLY_AUTOUNHIDE, NULL);
}
}
}
else {
#ifdef DEBUG
if ((uOpMask & (AHO_SETDO|AHO_SETUN))) {
TraceMsg(DM_HIDE, "cwb.dh: !_fCanHide => suppress AHO_SET*");
}
#endif
}
return;
}
//*** SlideWindow -- sexy slide effect
// NOTES
// stolen from tray.c
void SlideWindow(HWND hwnd, RECT *prc, HMONITOR hMonClip, BOOL fShow)
{
RECT rcMonitor, rcClip;
BOOL fRegionSet = FALSE;
SetRectEmpty(&rcMonitor);
if (GetNumberOfMonitors() > 1)
{
GetMonitorRect(hMonClip, &rcMonitor);
// aka ScreenToClient
MapWindowPoints(HWND_DESKTOP, GetParent(hwnd), (LPPOINT)&rcMonitor, 2); }
// Future: We could loop on the following code for the slide effect
IntersectRect(&rcClip, &rcMonitor, prc);
if (!IsRectEmpty(&rcClip))
{
HRGN hrgnClip;
// Change the clip region to be relative to the upper left corner of prc
// NOTE: this is not converting rcClip to prc client coordinate
OffsetRect(&rcClip, -prc->left, -prc->top);
hrgnClip = CreateRectRgnIndirect(&rcClip);
// LINTASSERT(hrgnClip || !hgnClip); // 0 semi-ok for SetWindowRgn
// nt5:149630: always repaint, o.w. auto-unhide BitBlt's junk
// from hide position
fRegionSet = SetWindowRgn(hwnd, hrgnClip, /*fRepaint*/TRUE);
}
MoveWindow(hwnd, prc->left, prc->top, RECTWIDTH(*prc), RECTHEIGHT(*prc), TRUE);
// Turn off the region stuff if we don't hide any more
if (fRegionSet && fShow)
SetWindowRgn(hwnd, NULL, TRUE);
return;
}
/*** AppBarQueryPos -- negotiate position
* ENTRY/EXIT
* return width (height) from docked edge to opposing edge
*/
int CDockingBar::AppBarQueryPos(RECT* prcOut, UINT uEdge, HMONITOR hMon, const RECT* prcReq,
PAPPBARDATA pabd, BOOL fCommit)
{
int iWH;
ASSERT(ISWBM_DESKTOP());
// snap to edge (in case another AppBar disappeared w/o us knowing),
// readjust opposing side to reflect that snap,
// and max out adjacent sides to fill up full strip.
iWH = RectGetWH(prcReq, uEdge);
RectXform(&(pabd->rc), RX_EDGE|RX_OPPOSE|RX_ADJACENT|(_fHiding ? RX_HIDE : 0), prcReq, NULL, iWH, uEdge, hMon);
ASSERT(EqualRect(&(pabd->rc), prcReq)); // caller guarantees?
// negotiate
// if we're dragging we might not be registered yet (floating->docked)
// in that case we'll just use the requested size (w/o negotiating).
// ditto for if we're in the middle of a top/non-top mode switch.
if (_fAppRegistered) {
pabd->uEdge = uEdge;
TraceMsg(DM_APPBAR, "cwb.abqp: call ABM_QUERYPOS");
SHAppBarMessage(ABM_QUERYPOS, pabd);
}
// readjust opposing side to reflect the negotiation (which only
// adjusts the moved edge-most side, not the opposing edge).
// FEATURE: (dli) need to find the right hmonitor to pass in
RectXform(prcOut, RX_OPPOSE, &(pabd->rc), NULL, iWH, uEdge, hMon);
return RectGetWH(prcOut, uEdge);
}
//*** AppBarSetPos --
// NOTES
// does *not* do _SetVRect and MoveWindow, that's up to caller
//
void CDockingBar::AppBarSetPos(UINT uEdge, const RECT* prcReq, PAPPBARDATA pabd)
{
ASSERT(_eMode == WBM_TOPMOST);
if (!_fCanHide && _fAppRegistered)
AppBarSetPos0(uEdge, prcReq, pabd);
return;
}
void CDockingBar::AppBarSetPos0(UINT uEdge, const RECT* prcReq, PAPPBARDATA pabd)
{
CopyRect(&(pabd->rc), prcReq);
pabd->uEdge = uEdge;
TraceMsg(DM_APPBAR, "cwb.absp: call ABM_SETPOS");
ASSERT(_fAppRegistered);
SHAppBarMessage(ABM_SETPOS, pabd);
// APPCOMPAT workaround explorer bug: during dragging we get:
// querypos*; wm_winposchanged; querypos; setpos
// the lack of a wm_winposchanged at the end screws up the
// autohide bring-to-top code.
ASSERT(pabd->cbSize == sizeof(APPBARDATA));
ASSERT(pabd->hWnd == _hwnd);
TraceMsg(DM_APPBAR, "cwb.absp: call ABM_WINPOSCHGED");
SHAppBarMessage(ABM_WINDOWPOSCHANGED, pabd);
// n.b. _SetVRect and MoveWindow done by caller
return;
}
//*** AppBarQuerySetPos --
//
void CDockingBar::AppBarQuerySetPos(RECT* prcOut, UINT uEdge, HMONITOR hMon, const RECT* prcReq,
PAPPBARDATA pabd, BOOL fCommit)
{
RECT rcTmp;
if (prcOut == NULL)
prcOut = &rcTmp;
AppBarQueryPos(prcOut, uEdge, hMon, prcReq, pabd, fCommit);
if (fCommit) {
AppBarSetPos(uEdge, prcOut, pabd);
ASSERT(EqualRect(prcOut, &(pabd->rc))); // callers assume prcOut correct
}
return;
}
void CDockingBar::_AppBarOnSize()
{
RECT rc;
APPBARDATA abd;
ASSERT(_eMode == WBM_TOPMOST);
ASSERT(ISABE_DOCK(_uSide));
if (!_fAppRegistered)
return;
// don't commit until done
if (_fDragging)
return;
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = _hwnd;
GetWindowRect(_hwnd, &rc);
AppBarQuerySetPos(NULL, _uSide, _hMon, &rc, &abd, TRUE);
return;
}
void CDockingBar::_RemoveToolbar(DWORD dwFlags)
{
if (_ptbSite) {
// WM_DESTROY will do _ChangeTopMost(WBM_NIL) for us
IDockingWindowFrame* ptbframe;
HRESULT hresT=_ptbSite->QueryInterface(IID_IDockingWindowFrame, (LPVOID*)&ptbframe);
if (SUCCEEDED(hresT)) {
AddRef(); // guard against self destruction
ptbframe->RemoveToolbar(SAFECAST(this, IDockingWindow*), dwFlags);
ptbframe->Release();
Release();
}
} else {
CloseDW(0);
}
}
void CDockingBar::_AppBarOnCommand(UINT idCmd)
{
UINT eModeNew;
switch (idCmd) {
case IDM_AB_TOPMOST:
eModeNew = _eMode ^ WBM_TOPMOST;
_MoveSizeHelper(eModeNew, _uSide, _hMon, NULL, NULL, TRUE, TRUE);
break;
case IDM_AB_AUTOHIDE:
if (_fWantHide)
{
// on->off
_DoHide(AHO_KILLDO|AHO_UNREG); // _ChangeHide
_fWantHide = FALSE;
}
else
{
// off->on
_fWantHide = TRUE;
// don't do AHO_SETDO now, wait for WM_ACTIVATE(deactivate)
_DoHide(AHO_REG); // _ChangeHide
}
// force it to happen *now*
// REARCHITECT potential race condition w/ the AHO_SETDO above,
// but worst case that should cause a 2nd redraw (?).
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
if (SHIsChildOrSelf(GetActiveWindow(), _hwnd) != S_OK)
{
// nt5:148444: if we're already deactive, we need to kick off
// the hide now. this is needed e.g. for login when we load
// persisted auto-hide deskbars. they come up inactive so we
// never get the initial deact to hide them.
_OnActivate(MAKEWPARAM(WA_INACTIVE, FALSE), (LPARAM)(HWND)0);
}
break;
#ifdef DEBUG
case IDM_AB_ACTIVATE:
// REARCHITECT temporary until we make browser tell us about activation
// note that since we're faking this w/ a menu our (normal) assumption
// in WM_ENTERMENU is bogus so make sure you keep the mouse over
// the BrowserBar during activation or it will hide away out from under
// you and the Activate won't work...
_OnActivate(MAKEWPARAM(_fActive ? WA_INACTIVE : WA_ACTIVE, FALSE),
(LPARAM) (HWND) 0);
_fActive = !_fActive;
break;
#endif
case IDM_AB_CLOSE:
_OnCloseBar(TRUE);
break;
default:
MessageBeep(0);
break;
}
}
BOOL CDockingBar::_OnCloseBar(BOOL fConfirm)
{
_RemoveToolbar(0);
return TRUE;
}
void CDockingBar::_AppBarOnWM(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_WINDOWPOSCHANGED:
case WM_ACTIVATE:
{
APPBARDATA abd;
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = _hwnd;
abd.lParam = (long) NULL;
if (uMsg == WM_WINDOWPOSCHANGED) {
TraceMsg(DM_APPBAR, "cwb.WM_WPC: call ABM_WINPOSCHGED");
SHAppBarMessage(ABM_WINDOWPOSCHANGED, &abd);
}
else {
//if (LOWORD(wParam) != WA_INACTIVE)
// just do it always, doesn't hurt...
TraceMsg(DM_APPBAR, "cwb.WM_ACT: call ABM_ACTIVATE");
SHAppBarMessage(ABM_ACTIVATE, &abd);
}
}
break;
default:
ASSERT(0);
break;
}
return;
}
// try to preserve our thinkness
void CDockingBar::_AppBarOnPosChanged(PAPPBARDATA pabd)
{
RECT rcWindow;
ASSERT(_eMode == WBM_TOPMOST);
GetWindowRect(pabd->hWnd, &rcWindow);
RectXform(&rcWindow, RX_EDGE|RX_OPPOSE, &rcWindow, NULL, RectGetWH(&rcWindow, _uSide), _uSide, _hMon);
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
return;
}
/*** _InitPos4 -- initialize edge positions
* ENTRY/EXIT
* fCtor TRUE if called from constructor; o.w. FALSE
*/
void CDockingBar::_InitPos4(BOOL fCtor)
{
RECT rcSite;
TraceMsg(DM_PERSIST, "cdb.ip4(fCtor=%d) enter", fCtor);
if (fCtor)
{
// set some worst-case defaults for the Load(bag) case
_adEdge[ABE_TOP] = 80;
_adEdge[ABE_BOTTOM] = 80;
_adEdge[ABE_LEFT] = 80;
_adEdge[ABE_RIGHT] = 80;
SetRect(&_rcFloat, 10, 10, 310, 310); // FEATURE: todo: NYI
_hMon = GetPrimaryMonitor();
}
else
{
// set up semi-reasonable defaults for the InitNew case
ASSERT(_eInitLoaded == IPS_INITNEW); // not req'd, but expected
ASSERT(IsWindow(_hwndSite));
GetWindowRect(_hwndSite, &rcSite);
_adEdge[ABE_TOP] = AB_THEIGHT(rcSite);
_adEdge[ABE_BOTTOM] = AB_BHEIGHT(rcSite);
_adEdge[ABE_LEFT] = AB_LWIDTH(rcSite);
_adEdge[ABE_RIGHT] = AB_RWIDTH(rcSite);
// FEATURE: (dli) should we ask _hwndSite for it's hmonitor?
// This current implementation already seems acceptable -justmann
_hMon = MonitorFromRect(&rcSite, MONITOR_DEFAULTTONULL);
if (!_hMon)
{
POINT ptCenter;
ptCenter.x = (rcSite.left + rcSite.right) / 2;
ptCenter.y = (rcSite.top + rcSite.bottom) / 2;
_hMon = MonitorFromPoint(ptCenter, MONITOR_DEFAULTTONEAREST);
}
}
return;
}
/*** RectXform -- transform RECT
* ENTRY/EXIT
* prcOut
* uRxMask
* prcIn initial rect
* prcBound bounding rect specifying min/max dimensions
* iWH
* uSide
* DESCRIPTION
* RX_EDGE set edgemost side to extreme (0 or max)
* RX_OPPOSE set opposing side to edge + width
* RX_ADJACENT set adjacent sides to extremes (0 and max)
* RX_GETWH get distance to opposing side
*
* Two common calls are:
* ...
* NOTES
* Note that rcOut, rcIn, and rcSize can all be the same.
*/
int CDockingBar::RectXform(RECT* prcOut, UINT uRxMask,
const RECT* prcIn, RECT* prcBound, int iWH, UINT uSide, HMONITOR hMon)
{
RECT rcDef;
int iRet = 0;
BOOL bMirroredWnd=FALSE;
if (prcOut != prcIn && prcOut != NULL) {
ASSERT(prcIn != NULL); // used to do SetRect(prcOut,0,0,0,0)
CopyRect(prcOut, prcIn);
}
#ifdef DEBUG
if (! (uRxMask & (RX_OPPOSE|RX_GETWH))) {
ASSERT(iWH == -1);
iWH = -1; // try to force something to go wrong...
}
#endif
if (uRxMask & (RX_EDGE|RX_ADJACENT)) {
if (prcBound == NULL) {
prcBound = &rcDef;
ASSERT(hMon);
GetMonitorRect(hMon, prcBound); // aka GetSystemMetrics(SM_CXSCREEN)
}
#define iXMin (prcBound->left)
#define iYMin (prcBound->top)
#define iXMax (prcBound->right);
#define iYMax (prcBound->bottom);
}
if (uRxMask & (RX_EDGE|RX_OPPOSE|RX_HIDE|RX_GETWH)) {
//
// If docking is happening on a horizontal size, then...
//
if ((ABE_LEFT == uSide) || (ABE_RIGHT == uSide)) {
bMirroredWnd = (IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd)));
}
switch (uSide) {
case ABE_TOP:
if (prcOut)
{
if (uRxMask & RX_EDGE)
prcOut->top = iYMin;
if (uRxMask & RX_OPPOSE)
prcOut->bottom = prcOut->top + iWH;
if (uRxMask & RX_HIDE)
MoveRect(prcOut, prcOut->left, prcOut->top - iWH + CXYHIDE(uSide));
}
if (uRxMask & RX_GETWH)
iRet = RECTHEIGHT(*prcIn);
break;
case ABE_BOTTOM:
if (prcOut)
{
if (uRxMask & RX_EDGE)
prcOut->bottom = iYMax;
if (uRxMask & RX_OPPOSE)
prcOut->top = prcOut->bottom - iWH;
if (uRxMask & RX_HIDE)
MoveRect(prcOut, prcOut->left, prcOut->bottom - CXYHIDE(uSide));
}
if (uRxMask & RX_GETWH)
iRet = RECTHEIGHT(*prcIn);
break;
case ABE_LEFT:
if (prcOut)
{
if (uRxMask & RX_EDGE)
prcOut->left = iXMin;
if (uRxMask & RX_OPPOSE) {
//
// If the parent of this docked window is mirrored, then it is placed and
// aligned to the right. [samera]
//
if (bMirroredWnd)
prcOut->left = prcOut->right - iWH;
else
prcOut->right = prcOut->left + iWH;
}
if (uRxMask & RX_HIDE)
MoveRect(prcOut, prcOut->left - iWH + CXYHIDE(uSide), prcOut->top);
}
if (uRxMask & RX_GETWH)
iRet = RECTWIDTH(*prcIn);
break;
case ABE_RIGHT:
if (prcOut)
{
if (uRxMask & RX_EDGE)
prcOut->right = iXMax;
if (uRxMask & RX_OPPOSE) {
//
// If the parent of this docked window is mirrored, then it is placed and
// aligned to the left
//
if (bMirroredWnd)
prcOut->right = prcOut->left + iWH;
else
prcOut->left = prcOut->right - iWH;
}
if (uRxMask & RX_HIDE)
MoveRect(prcOut, prcOut->right - CXYHIDE(uSide), prcOut->top);
}
if (uRxMask & RX_GETWH)
iRet = RECTWIDTH(*prcIn);
break;
}
}
if ((uRxMask & RX_ADJACENT) && prcOut)
{
if (uSide == ABE_LEFT || uSide == ABE_RIGHT) {
prcOut->top = iYMin;
prcOut->bottom = iYMax;
}
else {
prcOut->left = iXMin;
prcOut->right = iXMax;
}
}
return iRet;
}
//*** _ProtoRect -- create best-guess proto rect for specified location
//
void CDockingBar::_ProtoRect(RECT* prcOut, UINT eModeNew, UINT uSideNew, HMONITOR hMonNew, POINT* ptXY)
{
if (ISWBM_FLOAT(eModeNew))
{
// start at last position/size, and move to new left-top if requested
CopyRect(prcOut, &_rcFloat);
if (ptXY != NULL)
MoveRect(prcOut, ptXY->x, ptXY->y);
// if we're (e.g.) floating on the far right and the display shrinks,
// we need to reposition ourselves
// PERF: wish we could do this at resolution-change time but
// WM_DISPLAYCHANGE comes in too early (before our [pseudo] parent
// has changed).
if (eModeNew == WBM_FLOATING)
{
// make sure we're still visible
// FEATURE todo: multi-mon
RECT rcTmp;
_GetBorderRect(hMonNew, &rcTmp);
if (prcOut->left > rcTmp.right || prcOut->top > rcTmp.bottom)
{
// WARNING note we don't explicitly account for other toolbars
// this may be a bug (though other apps seem to behave the
// same way)
MoveRect(prcOut,
prcOut->left <= rcTmp.right ? prcOut->left :
rcTmp.right - CXFLOAT(),
prcOut->top <= rcTmp.bottom ? prcOut->top :
rcTmp.bottom - CYFLOAT()
);
}
}
}
else
{
ASSERT(ISABE_DOCK(uSideNew));
if (_fCanHide && ISWBM_HIDEABLE(eModeNew))
{
// force a 'tiny' rectangle
// (WARNING prcBound==NULL bogus for XXX_HIDEALL && XXX_BROWSEROWNED)
RectXform(prcOut, RX_EDGE|RX_OPPOSE|RX_ADJACENT|(_fHiding ? RX_HIDE : 0),
prcOut, NULL, _adEdge[uSideNew], uSideNew, hMonNew);
}
else
{
// get current rect, adjust opposing side per request
_GetBorderRect(hMonNew, prcOut);
RectXform(prcOut, RX_OPPOSE, prcOut, NULL, _adEdge[uSideNew], uSideNew, hMonNew);
}
}
return;
}
//*** _NegotiateRect --
// NOTES
// will only return an approximate result in the non-commit case.
//
void CDockingBar::_NegotiateRect(UINT eModeNew, UINT uSideNew, HMONITOR hMonNew,
RECT* rcReq, BOOL fCommit)
{
switch (eModeNew) {
case WBM_TOPMOST:
APPBARDATA abd;
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = _hwnd;
AppBarQuerySetPos(rcReq, uSideNew, hMonNew, rcReq, &abd, fCommit);
if (_fCanHide)
{
// we did a query to adjust the adjacent sides (e.g. so we don't
// cover up the 'start' menu when we unhide). however that may
// have also moved us in from the edge, which we don't want.
// so snap back to edge.
int iWH;
iWH = RectGetWH(rcReq, uSideNew);
RectXform(rcReq, RX_EDGE|RX_OPPOSE|(_fHiding ? RX_HIDE : 0), rcReq, NULL, iWH, uSideNew, hMonNew);
}
goto Ldefault;
default:
Ldefault:
// everyone else just gives us what we want
// but, we need to free up border
_NegotiateBorderRect(NULL, NULL, fCommit); // free up space
break;
case WBM_BOTTOMMOST:
case WBM_BBOTTOMMOST:
_NegotiateBorderRect(rcReq, rcReq, fCommit);
break;
}
return;
}
void CDockingBar::_AppBarCallback(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
APPBARDATA abd;
ASSERT(_eMode == WBM_TOPMOST);
abd.cbSize = sizeof(abd);
abd.hWnd = hwnd;
switch (wParam) {
case ABN_FULLSCREENAPP:
// when 1st app goes full-screen, move ourselves to BOTTOM;
// when last app leaves full-screen, move ourselves back
// todo: FullScreen(flg)
{
BOOL fIsTopmost = BOOLIFY(GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST);
if (!lParam != fIsTopmost)
{
SetWindowPos(hwnd,
lParam ? HWND_BOTTOM : HWND_TOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
}
break;
case ABN_POSCHANGED:
TraceMsg(DM_APPBAR, "cwb.abcb: ABN_POSCHANGED");
// note that we do this even if _fHiding. while we want
// to stay snapped to the edge as a 'tiny' rect, a change
// in someone else *should* effect our adjacent edges.
//
// FEATURE: unfortunately this currently causes 'jiggle' of a hidden
// guy when another appbar moves (due to a SlideWindow of a 0-width
// hidden guy and a rounded-up 8-pixel wide guy). when we switch
// to explorer's new offscreen hide that should go away.
_AppBarOnPosChanged(&abd);
break;
}
return;
}
HRESULT CDockingBar::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
static const QITAB qit[] = {
QITABENT(CDockingBar, IDockingWindow), // IID_IDockingWindow
QITABENT(CDockingBar, IObjectWithSite), // IID_IObjectWithSite
QITABENT(CDockingBar, IPersistStreamInit), // IID_IPersistStreamInit
QITABENTMULTI(CDockingBar, IPersistStream, IPersistStreamInit), // IID_IPersistStream
QITABENTMULTI(CDockingBar, IPersist, IPersistStreamInit), // IID_IPersist
QITABENT(CDockingBar, IPersistPropertyBag), // IID_IPersistPropertyBag
{ 0 },
};
HRESULT hres = QISearch(this, qit, riid, ppvObj);
if (FAILED(hres))
hres = SUPERCLASS::QueryInterface(riid, ppvObj);
return hres;
}
HRESULT CDockingBar::QueryService(REFGUID guidService,
REFIID riid, void **ppvObj)
{
HRESULT hres = E_FAIL;
*ppvObj = NULL; // assume error
// Block IID_ITargetFrame, so we don't look like a frame of the
// window we are attached to
if (IsEqualGUID(guidService, IID_ITargetFrame)
||IsEqualGUID(guidService, IID_ITargetFrame2)) {
return hres;
}
hres = SUPERCLASS::QueryService(guidService, riid, ppvObj);
if (FAILED(hres))
{
const GUID* pguidService = &guidService;
if (IsEqualGUID(guidService, SID_SProxyBrowser)) {
pguidService = &SID_STopLevelBrowser;
}
if (_ptbSite) {
hres = IUnknown_QueryService(_ptbSite, *pguidService, riid, ppvObj);
}
}
return hres;
}
void CDockingBar::_GrowShrinkBar(DWORD dwDirection)
{
RECT rcNew, rcOld;
int iMin;
iMin = GetSystemMetrics(SM_CXVSCROLL) * 4;
GetWindowRect(_hwnd, &rcNew);
rcOld = rcNew;
switch(_uSide)
{
case ABE_TOP:
if (VK_DOWN == dwDirection)
rcNew.bottom += GetSystemMetrics(SM_CYFRAME);
if (VK_UP == dwDirection)
rcNew.bottom -= GetSystemMetrics(SM_CYFRAME);
if ((rcNew.bottom - rcNew.top) < iMin)
rcNew.bottom = rcNew.top + iMin;
break;
case ABE_BOTTOM:
if (VK_UP == dwDirection)
rcNew.top -= GetSystemMetrics(SM_CYFRAME);
if (VK_DOWN == dwDirection)
rcNew.top += GetSystemMetrics(SM_CYFRAME);
if ((rcNew.bottom - rcNew.top) < iMin)
rcNew.top = rcNew.bottom - iMin;
break;
case ABE_LEFT:
if (VK_RIGHT == dwDirection)
rcNew.right += GetSystemMetrics(SM_CXFRAME);
if (VK_LEFT == dwDirection)
rcNew.right -= GetSystemMetrics(SM_CXFRAME);
if ((rcNew.right - rcNew.left) < iMin)
rcNew.right = rcNew.left + iMin;
break;
case ABE_RIGHT:
if (VK_LEFT == dwDirection)
rcNew.left -= GetSystemMetrics(SM_CXFRAME);
if (VK_RIGHT == dwDirection)
rcNew.left += GetSystemMetrics(SM_CXFRAME);
if ((rcNew.right - rcNew.left) < iMin)
rcNew.left = rcNew.right - iMin;
break;
}
if (!EqualRect(&rcOld, &rcNew))
{
int iWH;
RECT rcScreen;
// don't let the new size get > MonitorRect/2
GetMonitorRect(_hMon, &rcScreen); // aka GetSystemMetrics(SM_CXSCREEN)
iWH = RECTGETWH(_uSide, &rcScreen);
iWH /= 2;
if (RECTGETWH(_uSide, &rcNew) > iWH)
{
RectXform(&rcNew, RX_OPPOSE, &rcNew, NULL, iWH, _uSide, NULL);
}
_SetVRect(&rcNew);
_Recalc();
}
}
//*** CDockingBar::IOleCommandTarget::* {
HRESULT CDockingBar::Exec(const GUID *pguidCmdGroup,
DWORD nCmdID, DWORD nCmdexecopt,
VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
if (pguidCmdGroup == NULL) {
/*NOTHING*/
}
else if (IsEqualGUID(CGID_ShellDocView, *pguidCmdGroup)) {
switch (nCmdID) {
case SHDVID_RAISE:
ASSERT(pvarargIn && pvarargIn->vt == VT_I4);
if (pvarargIn->vt == VT_I4 && pvarargIn->lVal != DTRF_QUERY) {
_OnRaise(pvarargIn->lVal);
return S_OK;
}
break; // e.g. DTRF_QUERY
default:
// note that this means we may get OLECMDERR_E_UNKNOWNGROUP
// rather than OLECMDERR_E_NOTSUPPORTED for unhandled guys...
break;
}
}
else if (IsEqualGUID(CGID_DeskBarClient, *pguidCmdGroup))
{
if (DBCID_RESIZE == nCmdID)
{
_GrowShrinkBar(nCmdexecopt);
return S_OK;
}
}
return SUPERCLASS::Exec(pguidCmdGroup, nCmdID, nCmdexecopt,
pvarargIn, pvarargOut);
}
// }
//*** CDockingBar::IDockingWindow::* {
//
HRESULT CDockingBar::SetSite(IUnknown* punkSite)
{
ATOMICRELEASE(_ptbSite);
if (punkSite)
{
HRESULT hresT;
hresT = punkSite->QueryInterface(IID_IDockingWindowSite, (LPVOID*)&_ptbSite);
IUnknown_GetWindow(punkSite, &_hwndSite);
//
// Check if we are under the desktop browser or not and set
// the initial state correctly. (Always on top for Desktop)
//
IUnknown* punkT;
hresT = punkSite->QueryInterface(SID_SShellDesktop, (LPVOID*)&punkT);
if (SUCCEEDED(hresT))
{
_fDesktop = TRUE;
punkT->Release();
}
if (!_fInitSited)
{
if (!_eInitLoaded)
{
// if we haven't initialized, do it now.
InitNew();
_eMode = WBM_BOTTOMMOST;
}
ASSERT(_eInitLoaded);
if (_eInitLoaded == IPS_INITNEW)
{
_InitPos4(FALSE);
_eMode = _fDesktop ? WBM_TOPMOST : WBM_BBOTTOMMOST;
}
}
ASSERT(_eMode != WBM_NIL);
// WARNING actually we could also be owned floating...
ASSERT(ISWBM_DESKTOP() == _fDesktop);
ASSERT(_fDesktop || _eMode == WBM_BBOTTOMMOST);
ASSERT(ISWBM_DESKTOP() == _fDesktop);
ASSERT(ISWBM_DESKTOP() || _eMode == WBM_BBOTTOMMOST);
}
_fInitSited = TRUE; // done w/ 1st-time init
return S_OK;
}
HRESULT CDockingBar::ShowDW(BOOL fShow)
{
fShow = BOOLIFY(fShow); // so comparisons and assigns to bitfields work
// we used to early out if BOOLIFY(_fShow) == fShow.
// however we now count on ShowDW(TRUE) to force a refresh
// (e.g. when screen resolution changes CBB::v_ShowHideChildWindows
// calls us)
if (BOOLIFY(_fShow) == fShow)
return S_OK;
_fShow = fShow;
if (!_fInitShowed)
{
ASSERT(_fInitSited && _eInitLoaded);
_Initialize();
ASSERT(_fInitShowed);
}
if (_fShow)
{
// FEATURE: switch to using _ChangeTopMost, it already does this...
// Tell itself to resize.
// use _MoveSizeHelper (not just _NegotiateBorderRect) since we might
// actually be moving to a new position...
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
// _NegotiateBorderRect(NULL, NULL, FALSE)
if (_pDBC)
_pDBC->UIActivateDBC(DBC_SHOW);
// nt5:148444: SW_SHOWNA (vs. SW_SHOW) so we don't unhide on create
// this fix will cause a new bug -- newly created bars don't have
// focus (e.g. drag a band to floating, the new floating bar won't
// have focus) -- but that should be the lesser of evils.
//ShowWindow(_hwnd, ISWBM_FLOAT(_eMode) ? SW_SHOWNORMAL : SW_SHOWNA);
ShowWindow(_hwnd, SW_SHOWNA);
_OnSize();
}
else
{
ShowWindow(_hwnd, SW_HIDE);
if (EVAL(_pDBC))
_pDBC->UIActivateDBC(DBC_SHOWOBSCURE);
UIActivateIO(FALSE, NULL);
// Tell itself to resize.
// don't call MoveSizeHelper here since it will do (e.g.)
// negotiation, which will cause flicker and do destructive stuff.
//_Recalc(); //_MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
_NegotiateBorderRect(NULL, NULL, TRUE); // hide=>0 border space
}
return S_OK;
}
HRESULT CDockingBar::ResizeBorderDW(LPCRECT prcBorder,
IUnknown* punkToolbarSite, BOOL fReserved)
{
_Recalc(); // _MoveSizeHelper(_eMode, _uSide, NULL, NULL, TRUE, TRUE);
return S_OK; // FEATURE _NegotiateBorderRect()?
}
HRESULT CDockingBar::_NegotiateBorderRect(RECT* prcOut, RECT* prcReq, BOOL fCommit)
{
UINT eMode, uSide;
HMONITOR hMon;
int iWH;
// FEATURE: should be params like MSH etc.
eMode = ((_fDragging == DRAG_MOVE) ? _eModePending : _eMode);
uSide = ((_fDragging == DRAG_MOVE) ? _uSidePending : _uSide);
hMon = ((_fDragging == DRAG_MOVE) ? _hMonPending : _hMon);
if (prcOut != prcReq && prcOut != NULL && prcReq != NULL)
CopyRect(prcOut, prcReq);
if (_ptbSite) {
RECT rcRequest = { 0, 0, 0, 0 };
if (_fShow && ISWBM_BOTTOM(eMode)) {
if (prcReq)
{
iWH = RectGetWH(prcReq, uSide);
ASSERT(iWH == _adEdge[uSide]);
if ((!_fCanHide) && uSide != ABE_NIL)
((int*)&rcRequest)[uSide] = iWH;
}
if (_fTheater) {
// MOVE TO CBROWSERBAR
// we override the left that we request from the browser, but
// we need to notify theater what the user has requested for the expaneded width
VARIANTARG v = { 0 };
v.vt = VT_I4;
v.lVal = rcRequest.left;
IUnknown_Exec(_ptbSite, &CGID_Theater, THID_SETBROWSERBARWIDTH, 0, &v, NULL);
_iTheaterWidth = v.lVal;
// if we're in theater mode, we can only be on the left and we only grab left border
ASSERT(uSide == ABE_LEFT);
// if we're in autohide mode, we request no space
if (!_fNoAutoHide)
rcRequest.left = 0;
// END MOVE TO CBROWSERBAR
}
}
// FEATURE: leave alone (at 0 from HideRegister?) if _fHiding==HIDE_AUTO
HMONITOR hMonOld = _SetNewMonitor(hMon);
_ptbSite->RequestBorderSpaceDW(SAFECAST(this, IDockingWindow*), &rcRequest);
if (fCommit) {
RECT rcMirRequest;
LPRECT lprcRequest = &rcRequest;
if (IS_WINDOW_RTL_MIRRORED(_hwnd) &&
!IS_WINDOW_RTL_MIRRORED(GetParent(_hwnd))) {
// Swap left and right.
rcMirRequest.left = rcRequest.right;
rcMirRequest.right = rcRequest.left;
rcMirRequest.top = rcRequest.top;
rcMirRequest.bottom = rcRequest.bottom;
lprcRequest = &rcMirRequest;
}
_ptbSite->SetBorderSpaceDW(SAFECAST(this, IDockingWindow*), lprcRequest);
}
if (_fShow && ISWBM_BOTTOM(eMode) && !_fTheater) {
// were'd we end up (as a real rect not just a size)?
// start w/ our full border area, then apply negotiated width.
// however that may have also moved us in from the edge, which
// we don't want if we're autohide, so snap back to edge if so.
_ptbSite->GetBorderDW(SAFECAST(this, IDockingWindow*), prcOut);
// aka ClientToScreen
if (prcOut)
MapWindowPoints(_hwndSite, HWND_DESKTOP, (POINT*) prcOut, 2);
if ((!_fCanHide) && uSide != ABE_NIL)
iWH = ((int*)&rcRequest)[uSide];
RectXform(prcOut, (_fCanHide ? RX_EDGE : 0)|RX_OPPOSE|(_fHiding ? RX_HIDE : 0), prcOut, NULL, iWH, uSide, hMon);
}
if (hMonOld)
_SetNewMonitor(hMonOld);
}
return S_OK;
}
// }
//*** CDockingBar::IPersistStream*::* {
//
HRESULT CDockingBar::IsDirty(void)
{
return S_FALSE; // Never be dirty
}
//
// Persisted CDockingBar
//
struct SWebBar
{
DWORD cbSize;
DWORD cbVersion;
UINT uSide : 3;
UINT fWantHide :1;
INT adEdge[4]; // FEATURE: wordsize dependent
RECT rcFloat;
POINT ptSiteCenter; // Center of the docking site -- in case of multiple docking sites
UINT eMode;
UINT fAlwaysOnTop;
RECT rcChild;
};
#define SWB_VERSION 8
HRESULT CDockingBar::Load(IStream *pstm)
{
SWebBar swb = {0};
ULONG cbRead;
TraceMsg(DM_PERSIST, "cwb.l enter(this=%x pstm=%x) tell()=%x", this, pstm, DbStreamTell(pstm));
ASSERT(!_eInitLoaded);
HRESULT hres = pstm->Read(&swb, SIZEOF(swb), &cbRead);
#ifdef DEBUG
// just in case we toast ourselves (offscreen or something)...
static BOOL fNoPersist = FALSE;
if (fNoPersist)
hres = E_FAIL;
#endif
if (hres==S_OK && cbRead==SIZEOF(swb)) {
// REARCHITECT: this is not forward compatible!
if (swb.cbSize==SIZEOF(SWebBar) && swb.cbVersion==SWB_VERSION) {
_eMode = swb.eMode;
_uSide = swb.uSide;
_hMon = MonitorFromPoint(swb.ptSiteCenter, MONITOR_DEFAULTTONEAREST);
// don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize
_fWantHide = swb.fWantHide;
memcpy(_adEdge, swb.adEdge, SIZEOF(_adEdge));
_rcFloat = swb.rcFloat;
_NotifyModeChange(0);
// child (e.g. bandsite)
ASSERT(_pDBC != NULL);
if (_pDBC != NULL) {
// require IPersistStreamInit?
IPersistStream *ppstm;
hres = _pDBC->QueryInterface(IID_IPersistStream, (LPVOID*)&ppstm);
if (SUCCEEDED(hres)) {
// set the child size first because initialization layout might depend on it
SetWindowPos(_hwndChild, 0,
swb.rcChild.left, swb.rcChild.top, RECTWIDTH(swb.rcChild), RECTHEIGHT(swb.rcChild),
SWP_NOACTIVATE|SWP_NOZORDER);
ppstm->Load(pstm);
ppstm->Release();
}
}
_eInitLoaded = IPS_LOAD; // what if OLFS of bands fails?
TraceMsg(DM_PERSIST, "CDockingBar::Load succeeded");
} else {
TraceMsg(DM_ERROR, "CWB::Load failed swb.cbSize==SIZEOF(SWebBar) && swb.cbVersion==SWB_VERSION");
hres = E_FAIL;
}
} else {
TraceMsg(DM_ERROR, "CWB::Load failed (hres==S_OK && cbRead==SIZEOF(_adEdge)");
hres = E_FAIL;
}
TraceMsg(DM_PERSIST, "cwb.l leave tell()=%x", DbStreamTell(pstm));
return hres;
}
HRESULT CDockingBar::Save(IStream *pstm, BOOL fClearDirty)
{
HRESULT hres;
SWebBar swb = {0};
RECT rcMonitor;
swb.cbSize = SIZEOF(SWebBar);
swb.cbVersion = SWB_VERSION;
swb.uSide = _uSide;
swb.eMode = _eMode;
swb.fWantHide = _fWantHide;
memcpy(swb.adEdge, _adEdge, SIZEOF(_adEdge));
swb.rcFloat = _rcFloat;
GetWindowRect(_hwndChild, &swb.rcChild);
MapWindowRect(HWND_DESKTOP, _hwnd, &swb.rcChild);
ASSERT(_hMon);
GetMonitorRect(_hMon, &rcMonitor);
swb.ptSiteCenter.x = (rcMonitor.left + rcMonitor.right) / 2;
swb.ptSiteCenter.y = (rcMonitor.top + rcMonitor.bottom) / 2;
hres = pstm->Write(&swb, SIZEOF(swb), NULL);
if (SUCCEEDED(hres))
{
IPersistStream* ppstm;
hres = _pDBC->QueryInterface(IID_IPersistStream, (LPVOID*)&ppstm);
if (SUCCEEDED(hres))
{
hres = ppstm->Save(pstm, TRUE);
ppstm->Release();
}
}
return hres;
}
HRESULT CDockingBar::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
ULARGE_INTEGER cbMax = { SIZEOF(SWebBar), 0 };
*pcbSize = cbMax;
return S_OK;
}
HRESULT CDockingBar::InitNew(void)
{
ASSERT(!_eInitLoaded);
_eInitLoaded = IPS_INITNEW;
TraceMsg(DM_PERSIST, "CDockingBar::InitNew called");
// can't call _InitPos4 until set site in SetSite
// don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize
// derived class (e.g. CBrowserBarApp) does the _Populate...
// on first creation, before bands are added, but the bandsite IS created, we need to notify the bandsite of the new position
_NotifyModeChange(0);
return S_OK;
}
HRESULT CDockingBar::Load(IPropertyBag *pPropBag, IErrorLog *pErrorLog)
{
ASSERT(!_eInitLoaded);
_eInitLoaded = IPS_LOADBAG;
// TODO: We'll read following properties.
//
// URL = "..."
// Mode = 0 - TopMost, 1 - Bottom, 2 - Undocked
// Side = 0 - Right, 1 - Top, 2 - Left, 3 - Bottom
// Left/Right/Top/Bottom = Initial docked size
//
UINT uSide;
UINT eMode = _eMode;
if (WBM_NIL == eMode)
eMode = WBM_BOTTOMMOST;
eMode = PropBag_ReadInt4(pPropBag, L"Mode", eMode);
uSide = PropBag_ReadInt4(pPropBag, L"Side", _uSide);
_adEdge[ABE_LEFT] = PropBag_ReadInt4(pPropBag, L"Left", _adEdge[ABE_LEFT]);
_adEdge[ABE_RIGHT] = PropBag_ReadInt4(pPropBag, L"Right", _adEdge[ABE_RIGHT]);
_adEdge[ABE_TOP] = PropBag_ReadInt4(pPropBag, L"Top", _adEdge[ABE_TOP]);
_adEdge[ABE_BOTTOM] = PropBag_ReadInt4(pPropBag, L"Bottom", _adEdge[ABE_BOTTOM]);
int x = PropBag_ReadInt4(pPropBag, L"X", _rcFloat.left);
int y = PropBag_ReadInt4(pPropBag, L"Y", _rcFloat.top);
OffsetRect(&_rcFloat, x - _rcFloat.left, y - _rcFloat.top);
int cx = PropBag_ReadInt4(pPropBag, L"CX", RECTWIDTH(_rcFloat));
int cy = PropBag_ReadInt4(pPropBag, L"CY", RECTHEIGHT(_rcFloat));
_rcFloat.right = _rcFloat.left + cx;
_rcFloat.bottom = _rcFloat.top + cy;
// set up vars for eventual CDockingBar::_Initialize call
ASSERT(!CDB_INITED());
_eMode = eMode;
_uSide = uSide;
POINT pt = {x, y};
// (dli) compute the new hMonitor
_hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
// don't call _SetModeSide, _MoveSizeHelper, etc. until *after* _Initialize
// derived class (e.g. CBrowserBarApp) does the _Populate...
// on first creation, before bands are added, but the bandsite IS created, we need to notify the bandsite of the new position
_NotifyModeChange(0);
return S_OK;
}
HRESULT CDockingBar::Save(IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
{
// We don't need to support this for now.
return E_NOTIMPL;
}
// }
//*** CDockingBar::IDocHostUIHandler::* {
//
HRESULT CDockingBar::ShowContextMenu(DWORD dwID,
POINT* ppt,
IUnknown* pcmdtReserved,
IDispatch* pdispReserved)
{
if (dwID==0) {
TraceMsg(DM_MENU, "cdb.scm: intercept");
return _TrackPopupMenu(ppt);
}
return S_FALSE;
}
// }
void CDockingBar::_SetModeSide(UINT eMode, UINT uSide, HMONITOR hMonNew, BOOL fNoMerge)
{
_ChangeTopMost(eMode);
_uSide = uSide;
_hMon = hMonNew;
_SetNewMonitor(hMonNew);
}
// *** IInputObjectSite methods ***
HRESULT CDockingBar::OnFocusChangeIS(IUnknown *punk, BOOL fSetFocus)
{
return IUnknown_OnFocusChangeIS(_ptbSite, SAFECAST(this, IInputObject*), fSetFocus);
}
////////////////////////////////////////////////////////////////
//
// A deskbar property bag
//////
HRESULT CDockingBarPropertyBag_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
CDockingBarPropertyBag* p = new CDockingBarPropertyBag();
if (p != NULL)
{
*ppunk = SAFECAST(p, IPropertyBag*);
return S_OK;
}
*ppunk = NULL;
return E_OUTOFMEMORY;
}
ULONG CDockingBarPropertyBag::AddRef()
{
_cRef++;
return _cRef;
}
ULONG CDockingBarPropertyBag::Release()
{
ASSERT(_cRef > 0);
_cRef--;
if (_cRef > 0)
return _cRef;
delete this;
return 0;
}
HRESULT CDockingBarPropertyBag::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
static const QITAB qit[] = {
QITABENT(CDockingBarPropertyBag, IPropertyBag), // IID_IPropertyBag
QITABENT(CDockingBarPropertyBag, IDockingBarPropertyBagInit), // IID_IDockingBarPropertyBagInit
{ 0 },
};
return QISearch(this, qit, riid, ppvObj);
}
const WCHAR * const c_szPropNames[] = {
L"Side",
L"Mode",
L"Left",
L"Top",
L"Right",
L"Bottom",
L"Deleteable",
L"X",
L"Y",
L"CX",
L"CY"
};
HRESULT CDockingBarPropertyBag::Read(
/* [in] */ LPCOLESTR pszPropName,
/* [out][in] */ VARIANT *pVar,
/* [in] */ IErrorLog *pErrorLog)
{
int epropdata;
for (epropdata = 0; epropdata < (int)PROPDATA_COUNT; epropdata++) {
if (!StrCmpW(pszPropName, c_szPropNames[epropdata])) {
break;
}
}
if (epropdata < PROPDATA_COUNT &&
_props[epropdata]._fSet) {
pVar->lVal = _props[epropdata]._dwData;
pVar->vt = VT_I4;
return S_OK;
}
return E_FAIL;
}
#ifdef DEBUG
//*** DbCheckWindow --
// NOTES
// FEATURE: Its a bad idea, why break working code, but here is the suggestion:
// nuke the 'hwndClient' param and just use GetParent (but what
// about 'owned' windows, does GetParent give the correct answer?)
BOOL DbCheckWindow(HWND hwnd, RECT *prcExp, HWND hwndClient)
{
RECT rcAct;
GetWindowRect(hwnd, &rcAct);
hwndClient = GetParent(hwnd); // nuke this param
if (hwndClient != NULL) {
// aka ClientToScreen
MapWindowPoints(HWND_DESKTOP, hwndClient, (POINT*) &rcAct, 2);
}
if (!EqualRect(&rcAct, prcExp)) {
TraceMsg(DM_TRACE,
"cwb.dbcw: !EqualRect rcAct=(%d,%d,%d,%d) (%dx%d) rcExp=(%d,%d,%d,%d) (%dx%d) hwndClient=0x%x",
rcAct.left, rcAct.top, rcAct.right, rcAct.bottom,
RECTWIDTH(rcAct), RECTHEIGHT(rcAct),
prcExp->left, prcExp->top, prcExp->right, prcExp->bottom,
RECTWIDTH(*prcExp), RECTHEIGHT(*prcExp),
hwndClient);
return FALSE;
}
return TRUE;
}
//*** DbStreamTell -- get position in stream (low part only)
//
unsigned long DbStreamTell(IStream *pstm)
{
if (pstm == 0)
return (unsigned long) -1;
ULARGE_INTEGER liEnd;
pstm->Seek(c_li0, STREAM_SEEK_CUR, &liEnd);
if (liEnd.HighPart != 0)
TraceMsg(DM_TRACE, "DbStreamTell: hi!=0");
return liEnd.LowPart;
}
//*** DbMaskToMneStr -- pretty-print a bit mask in mnemonic form
// ENTRY/EXIT
// uMask bit mask
// szMne mnemonics, sz[0] for bit 0 .. sz[N] for highest bit
// return ptr to *static* buffer
// NOTES
// n.b.: non-reentrant!!!
TCHAR *DbMaskToMneStr(UINT uMask, TCHAR *szMnemonics)
{
static TCHAR buf[33]; // FEATURE: non-reentrant!!!
TCHAR *p;
p = &buf[ARRAYSIZE(buf) - 1]; // point at EOS
ASSERT(*p == '\0');
for (;;) {
if (*szMnemonics == 0) {
ASSERT(uMask == 0);
break;
}
--p;
*p = (uMask & 1) ? *szMnemonics : TEXT('-');
++szMnemonics;
uMask >>= 1;
}
return p;
}
#endif