9280 lines
274 KiB
C++
9280 lines
274 KiB
C++
#include "cabinet.h"
|
|
|
|
#include <wtsapi32.h> // for NOTIFY_FOR_THIS_SESSION
|
|
#include <winsta.h> // for disconnect and reconnect messages from terminal server
|
|
#include "mmsysp.h"
|
|
|
|
#include "rcids.h"
|
|
#include "dlg.h"
|
|
|
|
#include <atlstuff.h>
|
|
|
|
#include <shlapip.h>
|
|
#include "trayclok.h"
|
|
#include <help.h> // help ids
|
|
#include <desktray.h>
|
|
|
|
#include "util.h"
|
|
#include "tray.h"
|
|
|
|
#if defined(FE_IME)
|
|
#include <immp.h>
|
|
#endif
|
|
|
|
#include <regstr.h>
|
|
|
|
#include "bandsite.h"
|
|
|
|
#include "startmnu.h"
|
|
#include "uemapp.h"
|
|
#include <uxthemep.h>
|
|
|
|
#define NO_NOTIFYSUBCLASSWNDPROC
|
|
#include "cwndproc.cpp"
|
|
|
|
#include "desktop2.h"
|
|
#include "mixer.h"
|
|
|
|
#include "winbrand.h"
|
|
|
|
#define DM_FOCUS 0 // focus
|
|
#define DM_SHUTDOWN TF_TRAY // shutdown
|
|
#define DM_UEMTRACE TF_TRAY // timer service, other UEM stuff
|
|
#define DM_MISC 0 // miscellany
|
|
|
|
const GUID CLSID_MSUTBDeskBand = {0x540d8a8b, 0x1c3f, 0x4e32, 0x81, 0x32, 0x53, 0x0f, 0x6a, 0x50, 0x20, 0x90};
|
|
|
|
// From Desktop2\proglist.cpp
|
|
HRESULT AddMenuItemsCacheTask(IShellTaskScheduler* pSystemScheduler, BOOL fKeepCacheWhenFinished);
|
|
|
|
// import the WIN31 Compatibility HACKs from the shell32.dll
|
|
STDAPI_(void) CheckWinIniForAssocs(void);
|
|
|
|
// hooks to Shell32.dll
|
|
STDAPI CheckDiskSpace();
|
|
STDAPI CheckStagingArea();
|
|
|
|
// startmnu.cpp
|
|
void HandleFirstTime();
|
|
|
|
HWND v_hwndDesktop = NULL;
|
|
HWND v_hwndTray = NULL;
|
|
HWND v_hwndStartPane = NULL;
|
|
|
|
BOOL g_fDesktopRaised = FALSE;
|
|
BOOL g_fInSizeMove = FALSE;
|
|
|
|
UINT _uMsgEnableUserTrackedBalloonTips = 0;
|
|
|
|
void ClearRecentDocumentsAndMRUStuff(BOOL fBroadcastChange);
|
|
void DoTaskBarProperties(HWND hwnd, DWORD dwFlags);
|
|
|
|
void ClassFactory_Start();
|
|
void ClassFactory_Stop();
|
|
|
|
//
|
|
// Settings UI entry point types.
|
|
//
|
|
typedef void (WINAPI *PTRAYPROPSHEETCALLBACK)(DWORD nStartPage);
|
|
typedef void (WINAPI *PSETTINGSUIENTRY)(PTRAYPROPSHEETCALLBACK);
|
|
|
|
// Shell perf automation
|
|
extern DWORD g_dwShellStartTime;
|
|
extern DWORD g_dwShellStopTime;
|
|
extern DWORD g_dwStopWatchMode;
|
|
|
|
CTray c_tray;
|
|
|
|
// from explorer\desktop2
|
|
STDAPI DesktopV2_Create(
|
|
IMenuPopup **ppmp, IMenuBand **ppmb, void **ppvStartPane);
|
|
STDAPI DesktopV2_Build(void *pvStartPane);
|
|
|
|
// dyna-res change for multi-config hot/warm-doc
|
|
void HandleDisplayChange(int x, int y, BOOL fCritical);
|
|
DWORD GetMinDisplayRes(void);
|
|
|
|
// timer IDs
|
|
#define IDT_AUTOHIDE 2
|
|
#define IDT_AUTOUNHIDE 3
|
|
#ifdef DELAYWININICHANGE
|
|
#define IDT_DELAYWININICHANGE 5
|
|
#endif
|
|
#define IDT_DESKTOP 6
|
|
#define IDT_PROGRAMS IDM_PROGRAMS
|
|
#define IDT_RECENT IDM_RECENT
|
|
#define IDT_REBUILDMENU 7
|
|
#define IDT_HANDLEDELAYBOOTSTUFF 8
|
|
#define IDT_REVERTPROGRAMS 9
|
|
#define IDT_REVERTRECENT 10
|
|
#define IDT_REVERTFAVORITES 11
|
|
|
|
#define IDT_STARTMENU 12
|
|
|
|
#define IDT_ENDUNHIDEONTRAYNOTIFY 13
|
|
|
|
#define IDT_SERVICE0 14
|
|
#define IDT_SERVICE1 15
|
|
#define IDT_SERVICELAST IDT_SERVICE1
|
|
#define IDT_SAVESETTINGS 17
|
|
#define IDT_ENABLEUNDO 18
|
|
#define IDT_STARTUPFAILED 19
|
|
#define IDT_CHECKDISKSPACE 21
|
|
#define IDT_STARTBUTTONBALLOON 22
|
|
#define IDT_CHANGENOTIFY 23
|
|
#define IDT_COFREEUNUSED 24
|
|
#define IDT_DESKTOPCLEANUP 25
|
|
|
|
#define FADEINDELAY 100
|
|
#define BALLOONTIPDELAY 10000 // default balloon time copied from traynot.cpp
|
|
|
|
|
|
// INSTRUMENTATION WARNING: If you change anything here, make sure to update instrument.c
|
|
// we need to start at 500 because we're now sharing the hotkey handler
|
|
// with shortcuts.. they use an index array so they need to be 0 based
|
|
// NOTE, this constant is also in desktop.cpp, so that we can forward hotkeys from the desktop for
|
|
// NOTE, app compatibility.
|
|
#define GHID_FIRST 500
|
|
enum
|
|
{
|
|
GHID_RUN = GHID_FIRST,
|
|
GHID_MINIMIZEALL,
|
|
GHID_UNMINIMIZEALL,
|
|
GHID_HELP,
|
|
GHID_EXPLORER,
|
|
GHID_FINDFILES,
|
|
GHID_FINDCOMPUTER,
|
|
GHID_TASKTAB,
|
|
GHID_TASKSHIFTTAB,
|
|
GHID_SYSPROPERTIES,
|
|
GHID_DESKTOP,
|
|
GHID_TRAYNOTIFY,
|
|
GHID_MAX
|
|
};
|
|
|
|
const DWORD GlobalKeylist[] =
|
|
{
|
|
MAKELONG(TEXT('R'), MOD_WIN),
|
|
MAKELONG(TEXT('M'), MOD_WIN),
|
|
MAKELONG(TEXT('M'), MOD_SHIFT|MOD_WIN),
|
|
MAKELONG(VK_F1,MOD_WIN),
|
|
MAKELONG(TEXT('E'),MOD_WIN),
|
|
MAKELONG(TEXT('F'),MOD_WIN),
|
|
MAKELONG(TEXT('F'), MOD_CONTROL|MOD_WIN),
|
|
MAKELONG(VK_TAB, MOD_WIN),
|
|
MAKELONG(VK_TAB, MOD_WIN|MOD_SHIFT),
|
|
MAKELONG(VK_PAUSE,MOD_WIN),
|
|
MAKELONG(TEXT('D'),MOD_WIN),
|
|
MAKELONG(TEXT('B'),MOD_WIN),
|
|
};
|
|
|
|
CTray::CTray() : _fCanSizeMove(TRUE), _fIsLogoff(FALSE), _fIsDesktopConnected(TRUE), _fBandSiteInitialized(FALSE)
|
|
{
|
|
}
|
|
|
|
void CTray::ClosePopupMenus()
|
|
{
|
|
if (_pmpStartMenu)
|
|
_pmpStartMenu->OnSelect(MPOS_FULLCANCEL);
|
|
if (_pmpStartPane)
|
|
_pmpStartPane->OnSelect(MPOS_FULLCANCEL);
|
|
}
|
|
|
|
BOOL Tray_StartPanelEnabled()
|
|
{
|
|
SHELLSTATE ss = {0};
|
|
SHGetSetSettings(&ss, SSF_STARTPANELON, FALSE);
|
|
return ss.fStartPanelOn;
|
|
}
|
|
|
|
#ifdef FEATURE_STARTPAGE
|
|
BOOL Tray_ShowStartPageEnabled()
|
|
{
|
|
#if 0
|
|
SHELLSTATE ss = {0};
|
|
SHGetSetSettings(&ss, SSF_SHOWSTARTPAGE, FALSE);
|
|
return ss.fShowStartPage;
|
|
#endif
|
|
static BOOL s_fEnabled = -1;
|
|
|
|
if (s_fEnabled == -1)
|
|
{
|
|
DWORD dwType = REG_DWORD;
|
|
DWORD dwData;
|
|
DWORD cbData = sizeof(DWORD);
|
|
DWORD dwDefault = 0;
|
|
// FaultID is a decoy so that hackers won't think of trying to enable this feature.
|
|
LONG lRet = SHRegGetUSValue(REGSTR_PATH_EXPLORER, TEXT("FaultID"), &dwType, &dwData, &cbData, FALSE, &dwDefault, sizeof(dwDefault));
|
|
if (lRet == ERROR_SUCCESS && dwData == 101) // Some random value not easily guessed
|
|
s_fEnabled = TRUE;
|
|
else
|
|
s_fEnabled = FALSE;
|
|
}
|
|
return s_fEnabled;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// The StartButtonBalloonTip registry value can have one of these values:
|
|
//
|
|
// 0 (or nonexistent): User has never clicked the Start Button.
|
|
// 1: User has clicked the Start Button on a pre-Whistler system.
|
|
// 2: User has clicked the Start Button on a Whistler system.
|
|
//
|
|
// In case 0, we always want to show the balloon tip regardless of whether
|
|
// the user is running Classic or Personal.
|
|
//
|
|
// In case 1, we want to show the balloon tip if the user is using the
|
|
// Personal Start Menu, but not if using Classic (since he's already
|
|
// seen the Classic Start Menu). In the Classic case, upgrade the counter
|
|
// to 2 so the user won't be annoyed when they switch from Classic to
|
|
// Personal.
|
|
//
|
|
// In case 2, we don't want to show the balloon tip at all since the
|
|
// user has seen all we have to offer.
|
|
//
|
|
BOOL CTray::_ShouldWeShowTheStartButtonBalloon()
|
|
{
|
|
DWORD dwType;
|
|
DWORD dwData = 0;
|
|
DWORD cbSize = sizeof(DWORD);
|
|
SHGetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED,
|
|
TEXT("StartButtonBalloonTip"), &dwType, (BYTE*)&dwData, &cbSize);
|
|
|
|
if (Tray_StartPanelEnabled())
|
|
{
|
|
// Personal Start Menu is enabled, so show the balloon if the
|
|
// user has never logged on to a Whistler machine before.
|
|
return dwData < 2;
|
|
}
|
|
else
|
|
{
|
|
// Classic Start Menu is enabled.
|
|
switch (dwData)
|
|
{
|
|
case 0:
|
|
// User has never seen the Start Menu before, not even the
|
|
// classic one. So show the tip.
|
|
return TRUE;
|
|
|
|
case 1:
|
|
// User has already seen the Classic Start Menu, so don't
|
|
// prompt them again. Note that this means that they aren't
|
|
// prompted when they turn on the Personal Start Menu, but
|
|
// that's okay, because by the time they switch to Personal,
|
|
// they clearly have demonstrated that they know how the
|
|
// Start Button works and don't need a tip.
|
|
_DontShowTheStartButtonBalloonAnyMore();
|
|
return FALSE;
|
|
|
|
default:
|
|
// User has seen Whistler Start menu before, so don't show tip.
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the value to 2 to indicate that the user has seen a Whistler
|
|
// Start Menu (either Classic or Personal).
|
|
//
|
|
void CTray::_DontShowTheStartButtonBalloonAnyMore()
|
|
{
|
|
DWORD dwData = 2;
|
|
SHSetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED,
|
|
TEXT("StartButtonBalloonTip"), REG_DWORD, (BYTE*)&dwData, sizeof(dwData));
|
|
}
|
|
|
|
void CTray::_DestroyStartButtonBalloon()
|
|
{
|
|
if (_hwndStartBalloon)
|
|
{
|
|
DestroyWindow(_hwndStartBalloon);
|
|
_hwndStartBalloon = NULL;
|
|
}
|
|
KillTimer(_hwnd, IDT_STARTBUTTONBALLOON);
|
|
}
|
|
|
|
void CTray::CreateStartButtonBalloon(UINT idsTitle, UINT idsMessage)
|
|
{
|
|
if (!_hwndStartBalloon)
|
|
{
|
|
|
|
_hwndStartBalloon = CreateWindow(TOOLTIPS_CLASS, NULL,
|
|
WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP | TTS_BALLOON,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
_hwnd, NULL, hinstCabinet,
|
|
NULL);
|
|
|
|
if (_hwndStartBalloon)
|
|
{
|
|
// set the version so we can have non buggy mouse event forwarding
|
|
SendMessage(_hwndStartBalloon, CCM_SETVERSION, COMCTL32_VERSION, 0);
|
|
SendMessage(_hwndStartBalloon, TTM_SETMAXTIPWIDTH, 0, (LPARAM)300);
|
|
|
|
// taskbar windows are themed under Taskbar subapp name
|
|
SendMessage(_hwndStartBalloon, TTM_SETWINDOWTHEME, 0, (LPARAM)c_wzTaskbarTheme);
|
|
|
|
// Tell the Start Menu that this is a special balloon tip
|
|
SetProp(_hwndStartBalloon, PROP_DV2_BALLOONTIP, DV2_BALLOONTIP_STARTBUTTON);
|
|
}
|
|
}
|
|
|
|
if (_hwndStartBalloon)
|
|
{
|
|
TCHAR szTip[MAX_PATH];
|
|
szTip[0] = TEXT('\0');
|
|
LoadString(hinstCabinet, idsMessage, szTip, ARRAYSIZE(szTip));
|
|
if (szTip[0])
|
|
{
|
|
RECT rc;
|
|
TOOLINFO ti = {0};
|
|
|
|
ti.cbSize = sizeof(ti);
|
|
ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT;
|
|
ti.hwnd = _hwnd;
|
|
ti.uId = (UINT_PTR)_hwndStart;
|
|
//ti.lpszText = NULL;
|
|
SendMessage(_hwndStartBalloon, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
|
|
SendMessage(_hwndStartBalloon, TTM_TRACKACTIVATE, (WPARAM)FALSE, (LPARAM)0);
|
|
|
|
ti.lpszText = szTip;
|
|
SendMessage(_hwndStartBalloon, TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);
|
|
|
|
LoadString(hinstCabinet, idsTitle, szTip, ARRAYSIZE(szTip));
|
|
if (szTip[0])
|
|
{
|
|
SendMessage(_hwndStartBalloon, TTM_SETTITLE, TTI_INFO, (LPARAM)szTip);
|
|
}
|
|
|
|
GetWindowRect(_hwndStart, &rc);
|
|
|
|
SendMessage(_hwndStartBalloon, TTM_TRACKPOSITION, 0, MAKELONG((rc.left + rc.right)/2, rc.top));
|
|
|
|
SetWindowZorder(_hwndStartBalloon, HWND_TOPMOST);
|
|
|
|
SendMessage(_hwndStartBalloon, TTM_TRACKACTIVATE, (WPARAM)TRUE, (LPARAM)&ti);
|
|
|
|
SetTimer(_hwnd, IDT_STARTBUTTONBALLOON, BALLOONTIPDELAY, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_ShowStartButtonToolTip()
|
|
{
|
|
if (!_ShouldWeShowTheStartButtonBalloon() || SHRestricted(REST_NOSMBALLOONTIP))
|
|
{
|
|
PostMessage(_hwnd, TM_SHOWTRAYBALLOON, TRUE, 0);
|
|
return;
|
|
}
|
|
|
|
if (Tray_StartPanelEnabled())
|
|
{
|
|
// In order to display the Start Menu, we need foreground activation
|
|
// so keyboard focus will work properly.
|
|
if (SetForegroundWindow(_hwnd))
|
|
{
|
|
LockSetForegroundWindow(LSFW_LOCK);
|
|
_fForegroundLocked = TRUE;
|
|
|
|
// Inform the tray that start button is auto-popping, so the tray
|
|
// can hold off on showing balloons.
|
|
PostMessage(_hwnd, TM_SHOWTRAYBALLOON, FALSE, 0);
|
|
|
|
// This pushes the start button and causes the start menu to popup.
|
|
SendMessage(GetDlgItem(_hwnd, IDC_START), BM_SETSTATE, TRUE, 0);
|
|
|
|
// Once successfully done once, don't do it again.
|
|
_DontShowTheStartButtonBalloonAnyMore();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PostMessage(_hwnd, TM_SHOWTRAYBALLOON, TRUE, 0);
|
|
CreateStartButtonBalloon(IDS_STARTMENUBALLOON_TITLE, IDS_STARTMENUBALLOON_TIP);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CTray::_CreateClockWindow()
|
|
{
|
|
_hwndNotify = _trayNotify.TrayNotifyCreate(_hwnd, IDC_CLOCK, hinstCabinet);
|
|
SendMessage(_hwndNotify, TNM_UPDATEVERTICAL, 0, !STUCK_HORIZONTAL(_uStuckPlace));
|
|
|
|
return BOOLFROMPTR(_hwndNotify);
|
|
}
|
|
|
|
BOOL CTray::_InitTrayClass()
|
|
{
|
|
WNDCLASS wc = {0};
|
|
|
|
wc.lpszClassName = TEXT(WNDCLASS_TRAYNOTIFY);
|
|
wc.style = CS_DBLCLKS;
|
|
wc.lpfnWndProc = s_WndProc;
|
|
wc.hInstance = hinstCabinet;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
|
|
wc.cbWndExtra = sizeof(LONG_PTR);
|
|
|
|
return RegisterClass(&wc);
|
|
}
|
|
|
|
|
|
HFONT CTray::_CreateStartFont(HWND hwndTray)
|
|
{
|
|
HFONT hfontStart = NULL;
|
|
NONCLIENTMETRICS ncm;
|
|
|
|
ncm.cbSize = sizeof(ncm);
|
|
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, FALSE))
|
|
{
|
|
WORD wLang = GetUserDefaultLangID();
|
|
|
|
// Select normal weight font for chinese language.
|
|
if (PRIMARYLANGID(wLang) == LANG_CHINESE &&
|
|
((SUBLANGID(wLang) == SUBLANG_CHINESE_TRADITIONAL) ||
|
|
(SUBLANGID(wLang) == SUBLANG_CHINESE_SIMPLIFIED)))
|
|
ncm.lfCaptionFont.lfWeight = FW_NORMAL;
|
|
else
|
|
ncm.lfCaptionFont.lfWeight = FW_BOLD;
|
|
|
|
hfontStart = CreateFontIndirect(&ncm.lfCaptionFont);
|
|
}
|
|
|
|
return hfontStart;
|
|
}
|
|
|
|
// Set the stuck monitor for the tray window
|
|
void CTray::_SetStuckMonitor()
|
|
{
|
|
// use STICK_LEFT because most of the multi-monitors systems are set up
|
|
// side by side. use DEFAULTTONULL because we don't want to get the wrong one
|
|
// use the center point to call again in case we failed the first time.
|
|
_hmonStuck = MonitorFromRect(&_arStuckRects[STICK_LEFT],
|
|
MONITOR_DEFAULTTONULL);
|
|
if (!_hmonStuck)
|
|
{
|
|
POINT pt;
|
|
pt.x = (_arStuckRects[STICK_LEFT].left + _arStuckRects[STICK_LEFT].right)/2;
|
|
pt.y = (_arStuckRects[STICK_LEFT].top + _arStuckRects[STICK_LEFT].bottom)/2;
|
|
_hmonStuck = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
|
|
}
|
|
|
|
_hmonOld = _hmonStuck;
|
|
}
|
|
|
|
DWORD _GetDefaultTVSDFlags()
|
|
{
|
|
DWORD dwFlags = TVSD_TOPMOST;
|
|
|
|
// if we are on a remote hydra session and if there is no previous saved value,
|
|
// do not display the clock.
|
|
if (SHGetMachineInfo(GMI_TSCLIENT))
|
|
{
|
|
dwFlags |= TVSD_HIDECLOCK;
|
|
}
|
|
return dwFlags;
|
|
}
|
|
|
|
void CTray::_GetSaveStateAndInitRects()
|
|
{
|
|
TVSDCOMPAT tvsd;
|
|
RECT rcDisplay;
|
|
DWORD dwTrayFlags;
|
|
UINT uStick;
|
|
SIZE size;
|
|
|
|
// first fill in the defaults
|
|
SetRect(&rcDisplay, 0, 0, g_cxPrimaryDisplay, g_cyPrimaryDisplay);
|
|
|
|
// size gets defaults
|
|
size.cx = _sizeStart.cx + 2 * (g_cxDlgFrame + g_cxBorder);
|
|
size.cy = _sizeStart.cy + 2 * (g_cyDlgFrame + g_cyBorder);
|
|
|
|
// sStuckWidths gets minimum
|
|
_sStuckWidths.cx = 2 * (g_cxDlgFrame + g_cxBorder);
|
|
_sStuckWidths.cy = _sizeStart.cy + 2 * (g_cyDlgFrame + g_cyBorder);
|
|
|
|
_uStuckPlace = STICK_BOTTOM;
|
|
dwTrayFlags = _GetDefaultTVSDFlags();
|
|
|
|
_uAutoHide = 0;
|
|
|
|
// now try to load saved vaules
|
|
|
|
// BUG : 231077
|
|
// Since Tasbar properties don't roam from NT5 to NT4, (NT4 -> NT5 yes)
|
|
// Allow roaming from NT4 to NT5 only for the first time the User logs
|
|
// on to NT5, so that future changes to NT5 are not lost when the user
|
|
// logs on to NT4 after customizing the taskbar properties on NT5.
|
|
|
|
DWORD cbData1 = sizeof(tvsd);
|
|
DWORD cbData2 = sizeof(tvsd);
|
|
if (Reg_GetStruct(g_hkeyExplorer, TEXT("StuckRects2"), TEXT("Settings"),
|
|
&tvsd, &cbData1)
|
|
||
|
|
Reg_GetStruct(g_hkeyExplorer, TEXT("StuckRects"), TEXT("Settings"),
|
|
&tvsd, &cbData2))
|
|
{
|
|
if (IS_CURRENT_TVSD(tvsd.t) && IsValidSTUCKPLACE(tvsd.t.uStuckPlace))
|
|
{
|
|
_GetDisplayRectFromRect(&rcDisplay, &tvsd.t.rcLastStuck,
|
|
MONITOR_DEFAULTTONEAREST);
|
|
|
|
size = tvsd.t.sStuckWidths;
|
|
_uStuckPlace = tvsd.t.uStuckPlace;
|
|
|
|
dwTrayFlags = tvsd.t.dwFlags;
|
|
}
|
|
else if (MAYBE_WIN95_TVSD(tvsd.w95) &&
|
|
IsValidSTUCKPLACE(tvsd.w95.uStuckPlace))
|
|
{
|
|
_uStuckPlace = tvsd.w95.uStuckPlace;
|
|
dwTrayFlags = tvsd.w95.dwFlags;
|
|
if (tvsd.w95.uAutoHide & AH_ON)
|
|
dwTrayFlags |= TVSD_AUTOHIDE;
|
|
|
|
switch (_uStuckPlace)
|
|
{
|
|
case STICK_LEFT:
|
|
size.cx = tvsd.w95.dxLeft;
|
|
break;
|
|
|
|
case STICK_RIGHT:
|
|
size.cx = tvsd.w95.dxRight;
|
|
break;
|
|
|
|
case STICK_BOTTOM:
|
|
size.cy = tvsd.w95.dyBottom;
|
|
break;
|
|
|
|
case STICK_TOP:
|
|
size.cy = tvsd.w95.dyTop;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
ASSERT(IsValidSTUCKPLACE(_uStuckPlace));
|
|
|
|
//
|
|
// use the size only if it is not bogus
|
|
//
|
|
if (_sStuckWidths.cx < size.cx)
|
|
_sStuckWidths.cx = size.cx;
|
|
|
|
if (_sStuckWidths.cy < size.cy)
|
|
_sStuckWidths.cy = size.cy;
|
|
|
|
//
|
|
// set the tray flags
|
|
//
|
|
_fAlwaysOnTop = BOOLIFY(dwTrayFlags & TVSD_TOPMOST);
|
|
_fSMSmallIcons = BOOLIFY(dwTrayFlags & TVSD_SMSMALLICONS);
|
|
_fHideClock = SHRestricted(REST_HIDECLOCK) || BOOLIFY(dwTrayFlags & TVSD_HIDECLOCK);
|
|
_uAutoHide = (dwTrayFlags & TVSD_AUTOHIDE) ? AH_ON | AH_HIDING : 0;
|
|
_RefreshSettings();
|
|
|
|
//
|
|
// initialize stuck rects
|
|
//
|
|
for (uStick = STICK_LEFT; uStick <= STICK_BOTTOM; uStick++)
|
|
_MakeStuckRect(&_arStuckRects[uStick], &rcDisplay, _sStuckWidths, uStick);
|
|
|
|
_UpdateVertical(_uStuckPlace);
|
|
// Determine which monitor the tray is on using its stuck rectangles
|
|
_SetStuckMonitor();
|
|
}
|
|
|
|
IBandSite * BandSite_CreateView();
|
|
HRESULT BandSite_SaveView(IUnknown *pbs);
|
|
LRESULT BandSite_OnMarshallBS(WPARAM wParam, LPARAM lParam);
|
|
|
|
void CTray::_SaveTrayStuff(void)
|
|
{
|
|
TVSD tvsd;
|
|
|
|
tvsd.dwSize = sizeof(tvsd);
|
|
tvsd.lSignature = TVSDSIG_CURRENT;
|
|
|
|
// position
|
|
CopyRect(&tvsd.rcLastStuck, &_arStuckRects[_uStuckPlace]);
|
|
tvsd.sStuckWidths = _sStuckWidths;
|
|
tvsd.uStuckPlace = _uStuckPlace;
|
|
|
|
tvsd.dwFlags = 0;
|
|
if (_fAlwaysOnTop) tvsd.dwFlags |= TVSD_TOPMOST;
|
|
if (_fSMSmallIcons) tvsd.dwFlags |= TVSD_SMSMALLICONS;
|
|
if (_fHideClock && !SHRestricted(REST_HIDECLOCK)) tvsd.dwFlags |= TVSD_HIDECLOCK;
|
|
if (_uAutoHide & AH_ON) tvsd.dwFlags |= TVSD_AUTOHIDE;
|
|
|
|
// Save in Stuck rects.
|
|
Reg_SetStruct(g_hkeyExplorer, TEXT("StuckRects2"), TEXT("Settings"), &tvsd, sizeof(tvsd));
|
|
|
|
BandSite_SaveView(_ptbs);
|
|
|
|
return;
|
|
}
|
|
|
|
// align toolbar so that buttons are flush with client area
|
|
// and make toolbar's buttons to be MENU style
|
|
void CTray::_AlignStartButton()
|
|
{
|
|
HWND hwndStart = _hwndStart;
|
|
if (hwndStart)
|
|
{
|
|
TCHAR szStart[50];
|
|
LoadString(hinstCabinet, _hTheme ? IDS_START : IDS_STARTCLASSIC, szStart, ARRAYSIZE(szStart));
|
|
SetWindowText(_hwndStart, szStart);
|
|
|
|
RECT rcClient;
|
|
if (!_sizeStart.cx)
|
|
{
|
|
Button_GetIdealSize(hwndStart, &_sizeStart);
|
|
}
|
|
GetClientRect(_hwnd, &rcClient);
|
|
|
|
if (rcClient.right < _sizeStart.cx)
|
|
{
|
|
SetWindowText(_hwndStart, L"");
|
|
}
|
|
|
|
int cyStart = _sizeStart.cy;
|
|
|
|
if (_hwndTasks)
|
|
{
|
|
if (_hTheme)
|
|
{
|
|
cyStart = max(cyStart, SendMessage(_hwndTasks, TBC_BUTTONHEIGHT, 0, 0));
|
|
}
|
|
else
|
|
{
|
|
cyStart = SendMessage(_hwndTasks, TBC_BUTTONHEIGHT, 0, 0);
|
|
}
|
|
}
|
|
|
|
SetWindowPos(hwndStart, NULL, 0, 0, min(rcClient.right, _sizeStart.cx),
|
|
cyStart, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
}
|
|
|
|
// Helper function for CDesktopHost so clicking twice on the Start Button
|
|
// treats the second click as a dismiss rather than a redisplay.
|
|
//
|
|
// The crazy state machine goes like this:
|
|
//
|
|
// SBSM_NORMAL - normal state, nothing exciting
|
|
//
|
|
// When user opens Start Pane, we become
|
|
//
|
|
// SBSM_SPACTIVE - start pane is active
|
|
//
|
|
// If user clicks Start Button while SBSM_SPACTIVE, then we become
|
|
//
|
|
// SBSM_EATING - eat mouse clicks
|
|
//
|
|
// Until we receive a WM_MOUSEFIRST/WM_MOUSELAST message, and then
|
|
// we return to SBSM_NORMAL.
|
|
//
|
|
// If user dismisses Start Pane, we go straight to SBSM_NORMAL.
|
|
//
|
|
//
|
|
// We eat the mouse clicks so that the click that the user made
|
|
// to "unclick" the start button doesn't cause it to get pushed down
|
|
// again (and cause the Start Menu to reopen).
|
|
//
|
|
#define SBSM_NORMAL 0
|
|
#define SBSM_SPACTIVE 1
|
|
#define SBSM_EATING 2
|
|
|
|
void Tray_UnlockStartPane()
|
|
{
|
|
// If we had locked out foreground window changes (first-boot),
|
|
// then release the lock.
|
|
if (c_tray._fForegroundLocked)
|
|
{
|
|
c_tray._fForegroundLocked = FALSE;
|
|
LockSetForegroundWindow(LSFW_UNLOCK);
|
|
}
|
|
}
|
|
|
|
void Tray_SetStartPaneActive(BOOL fActive)
|
|
{
|
|
if (fActive)
|
|
{ // Start Pane appearing
|
|
c_tray._uStartButtonState = SBSM_SPACTIVE;
|
|
}
|
|
else if (c_tray._uStartButtonState != SBSM_EATING)
|
|
{ // Start Pane dismissing, not eating messages -> return to normal
|
|
c_tray._uStartButtonState = SBSM_NORMAL;
|
|
Tray_UnlockStartPane();
|
|
}
|
|
}
|
|
|
|
// Allow us to do stuff on a "button-down".
|
|
|
|
LRESULT WINAPI CTray::StartButtonSubclassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return c_tray._StartButtonSubclassWndProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
LRESULT CTray::_StartButtonSubclassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lRet;
|
|
|
|
ASSERT(_pfnButtonProc)
|
|
|
|
// Is the button going down?
|
|
if (uMsg == BM_SETSTATE)
|
|
{
|
|
// Is it going Down?
|
|
if (wParam)
|
|
{
|
|
// DebugMsg(DM_TRACE, "c.stswp: Set state %d", wParam);
|
|
// Yes - proceed if it's currently up and it's allowed to be down
|
|
if (!_uDown)
|
|
{
|
|
// Nope.
|
|
INSTRUMENT_STATECHANGE(SHCNFI_STATE_START_DOWN);
|
|
_uDown = 1;
|
|
|
|
// If we are going down, then we do not want to popup again until the Start Menu is collapsed
|
|
_fAllowUp = FALSE;
|
|
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
|
|
|
|
// Show the button down.
|
|
lRet = CallWindowProc(_pfnButtonProc, hwnd, uMsg, wParam, lParam);
|
|
// Notify the parent.
|
|
SendMessage(GetParent(hwnd), WM_COMMAND, (WPARAM)LOWORD(GetDlgCtrlID(hwnd)), (LPARAM)hwnd);
|
|
_tmOpen = GetTickCount();
|
|
return lRet;
|
|
}
|
|
else
|
|
{
|
|
// Yep. Do nothing.
|
|
// fDown = FALSE;
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// DebugMsg(DM_TRACE, "c.stswp: Set state %d", wParam);
|
|
// Nope, buttons coming up.
|
|
|
|
// Is it supposed to be down? Is it not allowed to be up?
|
|
if (_uDown == 1 || !_fAllowUp)
|
|
{
|
|
INSTRUMENT_STATECHANGE(SHCNFI_STATE_START_UP);
|
|
|
|
// Yep, do nothing.
|
|
_uDown = 2;
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
else
|
|
{
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
|
|
// Nope, Forward it on.
|
|
_uDown = 0;
|
|
return CallWindowProc(_pfnButtonProc, hwnd, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_uStartButtonState == SBSM_EATING &&
|
|
uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST)
|
|
{
|
|
_uStartButtonState = SBSM_NORMAL;
|
|
|
|
// Explicitly dismiss the Start Panel because it might be
|
|
// stuck in this limbo state where it is open but not the
|
|
// foreground window (_ShowStartButtonToolTip does this)
|
|
// so it doesn't know that it needs to go away.
|
|
ClosePopupMenus();
|
|
}
|
|
|
|
switch (uMsg) {
|
|
case WM_LBUTTONDOWN:
|
|
// The button was clicked on, then we don't need no stink'n focus rect.
|
|
SendMessage(GetParent(hwnd), WM_UPDATEUISTATE, MAKEWPARAM(UIS_SET,
|
|
UISF_HIDEFOCUS), 0);
|
|
|
|
goto ProcessCapture;
|
|
break;
|
|
|
|
|
|
case WM_KEYDOWN:
|
|
// The user pressed enter or return or some other bogus key combination when
|
|
// the start button had keyboard focus, so show the rect....
|
|
SendMessage(GetParent(hwnd), WM_UPDATEUISTATE, MAKEWPARAM(UIS_CLEAR,
|
|
UISF_HIDEFOCUS), 0);
|
|
|
|
if (wParam == VK_RETURN)
|
|
PostMessage(_hwnd, WM_COMMAND, IDC_KBSTART, 0);
|
|
|
|
// We do not need the capture, because we do all of our button processing
|
|
// on the button down. In fact taking capture for no good reason screws with
|
|
// drag and drop into the menus. We're overriding user.
|
|
ProcessCapture:
|
|
lRet = CallWindowProc(_pfnButtonProc, hwnd, uMsg, wParam, lParam);
|
|
SetCapture(NULL);
|
|
return lRet;
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
MSG msg;
|
|
|
|
msg.lParam = lParam;
|
|
msg.wParam = wParam;
|
|
msg.message = uMsg;
|
|
msg.hwnd = hwnd;
|
|
SendMessage(_hwndTrayTips, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)& msg);
|
|
|
|
break;
|
|
}
|
|
|
|
case WM_MOUSEACTIVATE:
|
|
if (_uStartButtonState != SBSM_NORMAL)
|
|
{
|
|
_uStartButtonState = SBSM_EATING;
|
|
return MA_ACTIVATEANDEAT;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// Debounce the Start Button. Usability shows that lots of people
|
|
// double-click the Start Button, resulting in the menu opening
|
|
// and then immediately closing...
|
|
//
|
|
case WM_NCHITTEST:
|
|
if (GetTickCount() - _tmOpen < GetDoubleClickTime())
|
|
{
|
|
return HTNOWHERE;
|
|
}
|
|
break;
|
|
|
|
|
|
case WM_NULL:
|
|
break;
|
|
}
|
|
|
|
return CallWindowProc(_pfnButtonProc, hwnd, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
EXTERN_C const WCHAR c_wzTaskbarTheme[] = L"Taskbar";
|
|
EXTERN_C const WCHAR c_wzTaskbarVertTheme[] = L"TaskbarVert";
|
|
|
|
// create the toolbar with the three buttons and align windows
|
|
|
|
HWND CTray::_CreateStartButton()
|
|
{
|
|
DWORD dwStyle = 0;//BS_BITMAP;
|
|
|
|
_uStartButtonBalloonTip = RegisterWindowMessage(TEXT("Welcome Finished"));
|
|
|
|
_uLogoffUser = RegisterWindowMessage(TEXT("Logoff User"));
|
|
|
|
// Register for MM device changes
|
|
_uWinMM_DeviceChange = RegisterWindowMessage(WINMMDEVICECHANGEMSGSTRING);
|
|
|
|
|
|
HWND hwnd = CreateWindowEx(0, WC_BUTTON, TEXT("Start"),
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS |
|
|
BS_PUSHBUTTON | BS_LEFT | BS_VCENTER | dwStyle,
|
|
0, 0, 0, 0, _hwnd, (HMENU)IDC_START, hinstCabinet, NULL);
|
|
if (hwnd)
|
|
{
|
|
// taskbar windows are themed under Taskbar subapp name
|
|
SetWindowTheme(hwnd, L"Start", NULL);
|
|
|
|
SendMessage(hwnd, CCM_DPISCALE, TRUE, 0);
|
|
|
|
// Subclass it.
|
|
_hwndStart = hwnd;
|
|
_pfnButtonProc = SubclassWindow(hwnd, StartButtonSubclassWndProc);
|
|
|
|
_StartButtonReset();
|
|
}
|
|
return hwnd;
|
|
}
|
|
|
|
void CTray::_GetWindowSizes(UINT uStuckPlace, PRECT prcClient, PRECT prcView, PRECT prcNotify)
|
|
{
|
|
prcView->top = 0;
|
|
prcView->left = 0;
|
|
prcView->bottom = prcClient->bottom;
|
|
prcView->right = prcClient->right;
|
|
|
|
if (STUCK_HORIZONTAL(uStuckPlace))
|
|
{
|
|
DWORD_PTR dwNotifySize = SendMessage(_hwndNotify, WM_CALCMINSIZE, prcClient->right / 2, prcClient->bottom);
|
|
prcNotify->top = 0;
|
|
prcNotify->left = prcClient->right - LOWORD(dwNotifySize);
|
|
prcNotify->bottom = HIWORD(dwNotifySize);
|
|
prcNotify->right = prcClient->right;
|
|
|
|
prcView->left = _sizeStart.cx + g_cxFrame + 1;
|
|
prcView->right = prcNotify->left;
|
|
}
|
|
else
|
|
{
|
|
DWORD_PTR dwNotifySize = SendMessage(_hwndNotify, WM_CALCMINSIZE, prcClient->right, prcClient->bottom / 2);
|
|
prcNotify->top = prcClient->bottom - HIWORD(dwNotifySize);
|
|
prcNotify->left = 0;
|
|
prcNotify->bottom = prcClient->bottom;
|
|
prcNotify->right = LOWORD(dwNotifySize);
|
|
|
|
prcView->top = _sizeStart.cy + g_cyTabSpace;
|
|
prcView->bottom = prcNotify->top;
|
|
}
|
|
}
|
|
|
|
void CTray::_RestoreWindowPos()
|
|
{
|
|
WINDOWPLACEMENT wp;
|
|
|
|
//first restore the stuck postitions
|
|
_GetSaveStateAndInitRects();
|
|
|
|
wp.length = sizeof(wp);
|
|
wp.showCmd = SW_HIDE;
|
|
|
|
_uMoveStuckPlace = (UINT)-1;
|
|
_GetDockedRect(&wp.rcNormalPosition, FALSE);
|
|
|
|
SendMessage(_hwndNotify, TNM_TRAYHIDE, 0, _fHideClock);
|
|
SetWindowPlacement(_hwnd, &wp);
|
|
}
|
|
|
|
// Get the display (monitor) rectangle from the given arbitrary point
|
|
HMONITOR CTray::_GetDisplayRectFromPoint(LPRECT prcDisplay, POINT pt, UINT uFlags)
|
|
{
|
|
RECT rcEmpty = {0};
|
|
HMONITOR hmon = MonitorFromPoint(pt, uFlags);
|
|
if (hmon && prcDisplay)
|
|
GetMonitorRect(hmon, prcDisplay);
|
|
else if (prcDisplay)
|
|
*prcDisplay = rcEmpty;
|
|
|
|
return hmon;
|
|
}
|
|
|
|
// Get the display (monitor) rectangle from the given arbitrary rectangle
|
|
HMONITOR CTray::_GetDisplayRectFromRect(LPRECT prcDisplay, LPCRECT prcIn, UINT uFlags)
|
|
{
|
|
RECT rcEmpty = {0};
|
|
HMONITOR hmon = MonitorFromRect(prcIn, uFlags);
|
|
if (hmon && prcDisplay)
|
|
GetMonitorRect(hmon, prcDisplay);
|
|
else if (prcDisplay)
|
|
*prcDisplay = rcEmpty;
|
|
|
|
return hmon;
|
|
}
|
|
|
|
// Get the display (monitor) rectangle where the taskbar is currently on,
|
|
// if that monitor is invalid, get the nearest one.
|
|
void CTray::_GetStuckDisplayRect(UINT uStuckPlace, LPRECT prcDisplay)
|
|
{
|
|
ASSERT(prcDisplay);
|
|
BOOL fValid = GetMonitorRect(_hmonStuck, prcDisplay);
|
|
|
|
if (!fValid)
|
|
_GetDisplayRectFromRect(prcDisplay, &_arStuckRects[uStuckPlace], MONITOR_DEFAULTTONEAREST);
|
|
}
|
|
|
|
void CTray::_AdjustRectForSizingBar(UINT uStuckPlace, LPRECT prc, int iIncrement)
|
|
{
|
|
if (iIncrement != 0)
|
|
{
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_BOTTOM: prc->top -= iIncrement * _sizeSizingBar.cy; break;
|
|
case STICK_TOP: prc->bottom += iIncrement * _sizeSizingBar.cy; break;
|
|
case STICK_LEFT: prc->right += iIncrement * _sizeSizingBar.cx; break;
|
|
case STICK_RIGHT: prc->left -= iIncrement * _sizeSizingBar.cx; break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (IS_BIDI_LOCALIZED_SYSTEM())
|
|
{
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_BOTTOM: prc->bottom = prc->top + _sizeSizingBar.cy; break;
|
|
case STICK_TOP: prc->top = prc->bottom - _sizeSizingBar.cy; break;
|
|
case STICK_LEFT: prc->right = prc->left + _sizeSizingBar.cx; break;
|
|
case STICK_RIGHT: prc->left = prc->right - _sizeSizingBar.cx; break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_BOTTOM: prc->bottom = prc->top + _sizeSizingBar.cy; break;
|
|
case STICK_TOP: prc->top = prc->bottom - _sizeSizingBar.cy; break;
|
|
case STICK_LEFT: prc->left = prc->right - _sizeSizingBar.cx; break;
|
|
case STICK_RIGHT: prc->right = prc->left + _sizeSizingBar.cx; break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Snap a StuckRect to the edge of a containing rectangle
|
|
// fClip determines whether to clip the rectangle if it's off the display or move it onto the screen
|
|
void CTray::_MakeStuckRect(LPRECT prcStick, LPCRECT prcBound, SIZE size, UINT uStick)
|
|
{
|
|
CopyRect(prcStick, prcBound);
|
|
|
|
if (_hTheme && (_fCanSizeMove || _fShowSizingBarAlways))
|
|
{
|
|
_AdjustRectForSizingBar(uStick, prcStick, 1);
|
|
}
|
|
|
|
if (!_hTheme)
|
|
{
|
|
InflateRect(prcStick, g_cxEdge, g_cyEdge);
|
|
}
|
|
|
|
if (size.cx < 0) size.cx *= -1;
|
|
if (size.cy < 0) size.cy *= -1;
|
|
|
|
switch (uStick)
|
|
{
|
|
case STICK_LEFT: prcStick->right = (prcStick->left + size.cx); break;
|
|
case STICK_TOP: prcStick->bottom = (prcStick->top + size.cy); break;
|
|
case STICK_RIGHT: prcStick->left = (prcStick->right - size.cx); break;
|
|
case STICK_BOTTOM: prcStick->top = (prcStick->bottom - size.cy); break;
|
|
}
|
|
}
|
|
|
|
// the screen size has changed, so the docked rectangles need to be
|
|
// adjusted to the new screen.
|
|
void CTray::_ResizeStuckRects(RECT *arStuckRects)
|
|
{
|
|
RECT rcDisplay;
|
|
_GetStuckDisplayRect(_uStuckPlace, &rcDisplay);
|
|
for (UINT uStick = STICK_LEFT; uStick <= STICK_BOTTOM; uStick++)
|
|
{
|
|
_MakeStuckRect(&arStuckRects[uStick], &rcDisplay, _sStuckWidths, uStick);
|
|
}
|
|
}
|
|
|
|
|
|
//*** CTray::InvisibleUnhide -- temporary 'invisible' un-autohide
|
|
// DESCRIPTION
|
|
// various tray resize routines need the tray to be un-autohide'd for
|
|
// stuff to be calculated correctly. so we un-autohide it (invisibly...)
|
|
// here. note the WM_SETREDRAW to prevent flicker (nt5:182340).
|
|
// note that this is kind of a hack -- ideally the tray code would do
|
|
// stuff correctly even if hidden.
|
|
//
|
|
void CTray::InvisibleUnhide(BOOL fShowWindow)
|
|
{
|
|
if (fShowWindow == FALSE)
|
|
{
|
|
if (_cHided++ == 0)
|
|
{
|
|
SendMessage(_hwnd, WM_SETREDRAW, FALSE, 0);
|
|
ShowWindow(_hwnd, SW_HIDE);
|
|
Unhide();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(_cHided > 0); // must be push/pop
|
|
if (--_cHided == 0)
|
|
{
|
|
_Hide();
|
|
ShowWindow(_hwnd, SW_SHOWNA);
|
|
SendMessage(_hwnd, WM_SETREDRAW, TRUE, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::VerifySize(BOOL fWinIni, BOOL fRoundUp /* = FALSE */)
|
|
{
|
|
RECT rc;
|
|
BOOL fHiding;
|
|
|
|
fHiding = (_uAutoHide & AH_HIDING);
|
|
if (fHiding)
|
|
{
|
|
// force it visible so various calculations will happen relative
|
|
// to unhidden size/position.
|
|
//
|
|
// fixes (e.g.) ie5:154536, where dropping a large-icon ISFBand
|
|
// onto hidden tray didn't do size negotiation.
|
|
//
|
|
InvisibleUnhide(FALSE);
|
|
}
|
|
|
|
rc = _arStuckRects[_uStuckPlace];
|
|
_HandleSizing(0, NULL, _uStuckPlace);
|
|
|
|
if (!EqualRect(&rc, &_arStuckRects[_uStuckPlace]))
|
|
{
|
|
if (fWinIni)
|
|
{
|
|
// if we're changing size or position, we need to be unhidden
|
|
Unhide();
|
|
SizeWindows();
|
|
}
|
|
rc = _arStuckRects[_uStuckPlace];
|
|
|
|
if (EVAL((_uAutoHide & (AH_ON | AH_HIDING)) != (AH_ON | AH_HIDING)))
|
|
{
|
|
_fSelfSizing = TRUE;
|
|
SetWindowPos(_hwnd, NULL,
|
|
rc.left, rc.top,
|
|
RECTWIDTH(rc),RECTHEIGHT(rc),
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS);
|
|
|
|
_fSelfSizing = FALSE;
|
|
}
|
|
|
|
_StuckTrayChange();
|
|
}
|
|
|
|
if (fWinIni)
|
|
SizeWindows();
|
|
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(TRUE);
|
|
}
|
|
}
|
|
|
|
HWND CTray::_GetClockWindow(void)
|
|
{
|
|
return (HWND)SendMessage(_hwndNotify, TNM_GETCLOCK, 0, 0L);
|
|
}
|
|
|
|
UINT _GetStartIDB()
|
|
{
|
|
UINT id;
|
|
|
|
#ifdef _WIN64
|
|
|
|
if (IsOS(OS_ANYSERVER))
|
|
{
|
|
id = IDB_WIN64ADVSERSTART;
|
|
}
|
|
else
|
|
{
|
|
id = IDB_WIN64PROSTART;
|
|
}
|
|
|
|
#else
|
|
|
|
if (IsOS(OS_TERMINALCLIENT))
|
|
{
|
|
id = IDB_TERMINALSERVICESBKG;
|
|
}
|
|
else if (IsOS(OS_DATACENTER))
|
|
{
|
|
id = IDB_DCSERVERSTARTBKG;
|
|
}
|
|
else if (IsOS(OS_ADVSERVER))
|
|
{
|
|
id = IDB_ADVSERVERSTARTBKG;
|
|
}
|
|
else if (IsOS(OS_SERVER))
|
|
{
|
|
id = IDB_SERVERSTARTBKG;
|
|
}
|
|
else if (IsOS(OS_EMBEDDED))
|
|
{
|
|
id = IDB_EMBEDDED;
|
|
}
|
|
else if (IsOS(OS_PERSONAL))
|
|
{
|
|
id = IDB_PERSONALSTARTBKG;
|
|
}
|
|
else if (IsOS(OS_MEDIACENTER))
|
|
{
|
|
id = IDB_MEDIACENTER_STARTBKG;
|
|
}
|
|
else if (IsOS(OS_TABLETPC))
|
|
{
|
|
id = IDB_TABLETPC_STARTBKG;
|
|
}
|
|
else
|
|
{
|
|
id = IDB_PROFESSIONALSTARTBKG;
|
|
}
|
|
|
|
#endif // _WIN64
|
|
|
|
return id;
|
|
}
|
|
|
|
void CTray::_CreateTrayTips()
|
|
{
|
|
_hwndTrayTips = CreateWindowEx(WS_EX_TRANSPARENT, TOOLTIPS_CLASS, NULL,
|
|
WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
_hwnd, NULL, hinstCabinet,
|
|
NULL);
|
|
|
|
if (_hwndTrayTips)
|
|
{
|
|
// taskbar windows are themed under Taskbar subapp name
|
|
SendMessage(_hwndTrayTips, TTM_SETWINDOWTHEME, 0, (LPARAM)c_wzTaskbarTheme);
|
|
|
|
SetWindowZorder(_hwndTrayTips, HWND_TOPMOST);
|
|
|
|
TOOLINFO ti;
|
|
|
|
ti.cbSize = sizeof(ti);
|
|
ti.uFlags = TTF_IDISHWND | TTF_EXCLUDETOOLAREA;
|
|
ti.hwnd = _hwnd;
|
|
ti.uId = (UINT_PTR)_hwndStart;
|
|
ti.lpszText = (LPTSTR)MAKEINTRESOURCE(IDS_STARTBUTTONTIP);
|
|
ti.hinst = hinstCabinet;
|
|
SendMessage(_hwndTrayTips, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
|
|
|
|
HWND hwndClock = _GetClockWindow();
|
|
if (hwndClock)
|
|
{
|
|
ti.uFlags = TTF_EXCLUDETOOLAREA;
|
|
ti.uId = (UINT_PTR)hwndClock;
|
|
ti.lpszText = LPSTR_TEXTCALLBACK;
|
|
ti.rect.left = ti.rect.top = ti.rect.bottom = ti.rect.right = 0;
|
|
SendMessage(_hwndTrayTips, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define SHCNE_STAGINGAREANOTIFICATIONS (SHCNE_CREATE | SHCNE_MKDIR | SHCNE_UPDATEDIR | SHCNE_UPDATEITEM)
|
|
LRESULT CTray::_CreateWindows()
|
|
{
|
|
if (_CreateStartButton() && _CreateClockWindow())
|
|
{
|
|
//
|
|
// We need to set the tray position, before creating
|
|
// the view window, because it will call back our
|
|
// GetWindowRect member functions.
|
|
//
|
|
_RestoreWindowPos();
|
|
|
|
_CreateTrayTips();
|
|
|
|
SendMessage(_hwndNotify, TNM_HIDECLOCK, 0, _fHideClock);
|
|
|
|
_ptbs = BandSite_CreateView();
|
|
if (_ptbs)
|
|
{
|
|
IUnknown_GetWindow(_ptbs, &_hwndRebar);
|
|
SetWindowStyle(_hwndRebar, RBS_BANDBORDERS, FALSE);
|
|
|
|
// No need to check the disk space thing for non-privileged users, this reduces activity in the TS case
|
|
// and only admins can properly free disk space anyways.
|
|
if (IsUserAnAdmin() && !SHRestricted(REST_NOLOWDISKSPACECHECKS))
|
|
{
|
|
SetTimer(_hwnd, IDT_CHECKDISKSPACE, 60 * 1000, NULL); // 60 seconds poll
|
|
}
|
|
|
|
if (IsOS(OS_PERSONAL) || IsOS(OS_PROFESSIONAL))
|
|
{
|
|
SetTimer(_hwnd, IDT_DESKTOPCLEANUP, 24 * 60 * 60 * 1000, NULL); // 24 hour poll
|
|
}
|
|
|
|
if (!SHRestricted(REST_NOCDBURNING))
|
|
{
|
|
LPITEMIDLIST pidlStaging;
|
|
if (SUCCEEDED(SHGetFolderLocation(NULL, CSIDL_CDBURN_AREA | CSIDL_FLAG_CREATE, NULL, 0, &pidlStaging)))
|
|
{
|
|
SHChangeNotifyEntry fsne;
|
|
fsne.fRecursive = FALSE;
|
|
fsne.pidl = pidlStaging;
|
|
_uNotify = SHChangeNotifyRegister(_hwnd, SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel,
|
|
SHCNE_STAGINGAREANOTIFICATIONS, TM_CHANGENOTIFY, 1, &fsne);
|
|
|
|
// start off by checking the first time.
|
|
_CheckStagingAreaOnTimer();
|
|
|
|
ILFree(pidlStaging);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
LRESULT CTray::_InitStartButtonEtc()
|
|
{
|
|
UINT uID = _GetStartIDB();
|
|
// NOTE: This bitmap is used as a flag in CTaskBar::OnPosRectChangeDB to
|
|
// tell when we are done initializing, so we don't resize prematurely
|
|
|
|
#ifndef _WIN64
|
|
if (uID == IDB_MEDIACENTER_STARTBKG || uID == IDB_TABLETPC_STARTBKG) // SP1 Only!
|
|
{
|
|
HMODULE hmod = LoadLibraryEx(TEXT("winbrand.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE);
|
|
if (hmod)
|
|
{
|
|
_hbmpStartBkg = LoadBitmap(hmod, MAKEINTRESOURCE(uID));
|
|
FreeLibrary(hmod);
|
|
}
|
|
else
|
|
{
|
|
_hbmpStartBkg = LoadBitmap(hinstCabinet, MAKEINTRESOURCE(IDB_PROFESSIONALSTARTBKG));
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
_hbmpStartBkg = LoadBitmap(hinstCabinet, MAKEINTRESOURCE(uID));
|
|
}
|
|
|
|
if (_hbmpStartBkg)
|
|
{
|
|
UpdateWindow(_hwnd);
|
|
_BuildStartMenu();
|
|
_RegisterDropTargets();
|
|
|
|
if (_CheckAssociations())
|
|
CheckWinIniForAssocs();
|
|
|
|
SendNotifyMessage(HWND_BROADCAST,
|
|
RegisterWindowMessage(TEXT("TaskbarCreated")), 0, 0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void CTray::_AdjustMinimizedMetrics()
|
|
{
|
|
MINIMIZEDMETRICS mm;
|
|
|
|
mm.cbSize = sizeof(mm);
|
|
SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, sizeof(mm), &mm, FALSE);
|
|
mm.iArrange |= ARW_HIDE;
|
|
SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, sizeof(mm), &mm, FALSE);
|
|
}
|
|
|
|
void CTray::_UpdateBandSiteStyle()
|
|
{
|
|
if (_ptbs)
|
|
{
|
|
BANDSITEINFO bsi;
|
|
bsi.dwMask = BSIM_STYLE;
|
|
_ptbs->GetBandSiteInfo(&bsi);
|
|
|
|
BOOL fCanMoveBands = _fCanSizeMove && !SHRestricted(REST_NOMOVINGBAND);
|
|
|
|
DWORD dwStyleNew;
|
|
if (fCanMoveBands)
|
|
{
|
|
dwStyleNew = (bsi.dwStyle & ~(BSIS_NOGRIPPER | BSIS_LOCKED)) | BSIS_AUTOGRIPPER
|
|
| BSIS_PREFERNOLINEBREAK;
|
|
}
|
|
else
|
|
{
|
|
dwStyleNew = (bsi.dwStyle & ~BSIS_AUTOGRIPPER) | BSIS_NOGRIPPER | BSIS_LOCKED
|
|
| BSIS_PREFERNOLINEBREAK;
|
|
}
|
|
|
|
// only bother with refresh if something's changed
|
|
if (bsi.dwStyle ^ dwStyleNew)
|
|
{
|
|
bsi.dwStyle = dwStyleNew;
|
|
_ptbs->SetBandSiteInfo(&bsi);
|
|
IUnknown_Exec(_ptbs, &CGID_DeskBand, DBID_BANDINFOCHANGED, 0, NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL _IsSizeMoveRestricted()
|
|
{
|
|
return SHRegGetBoolUSValue(REGSTR_POLICIES_EXPLORER, TEXT("LockTaskbar"), FALSE, FALSE);
|
|
}
|
|
|
|
BOOL _IsSizeMoveEnabled()
|
|
{
|
|
BOOL fCanSizeMove;
|
|
|
|
if (_IsSizeMoveRestricted())
|
|
{
|
|
fCanSizeMove = FALSE;
|
|
}
|
|
else
|
|
{
|
|
fCanSizeMove = SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarSizeMove"), FALSE, TRUE);
|
|
}
|
|
|
|
return fCanSizeMove;
|
|
}
|
|
|
|
void CTray::_RefreshSettings()
|
|
{
|
|
BOOL fOldCanSizeMove = _fCanSizeMove;
|
|
_fCanSizeMove = _IsSizeMoveEnabled();
|
|
BOOL fOldShowSizingBarAlways = _fShowSizingBarAlways;
|
|
_fShowSizingBarAlways = (_uAutoHide & AH_ON) ? TRUE : FALSE;
|
|
|
|
if ((fOldCanSizeMove != _fCanSizeMove) || (_fShowSizingBarAlways != fOldShowSizingBarAlways))
|
|
{
|
|
BOOL fHiding = (_uAutoHide & AH_HIDING);
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(FALSE);
|
|
}
|
|
|
|
RECT rc;
|
|
GetWindowRect(_hwnd, &rc);
|
|
|
|
if (_hTheme && !_fShowSizingBarAlways)
|
|
{
|
|
if (_fCanSizeMove)
|
|
{
|
|
_AdjustRectForSizingBar(_uStuckPlace, &rc, 1);
|
|
}
|
|
else
|
|
{
|
|
_AdjustRectForSizingBar(_uStuckPlace, &rc, -1);
|
|
}
|
|
}
|
|
|
|
_ClipWindow(FALSE);
|
|
_fSelfSizing = TRUE;
|
|
SetWindowPos(_hwnd, NULL, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc), SWP_NOZORDER | SWP_FRAMECHANGED);
|
|
_fSelfSizing = FALSE;
|
|
_ClipWindow(TRUE);
|
|
|
|
_arStuckRects[_uStuckPlace] = rc;
|
|
_StuckTrayChange();
|
|
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(TRUE);
|
|
}
|
|
|
|
if (!_fCanSizeMove)
|
|
{
|
|
SetWindowPos(_hwnd, NULL, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc), SWP_NOZORDER);
|
|
}
|
|
}
|
|
}
|
|
|
|
LRESULT CTray::_OnCreateAsync()
|
|
{
|
|
LRESULT lres;
|
|
|
|
if (g_dwProfileCAP & 0x00000004)
|
|
{
|
|
StartCAP();
|
|
}
|
|
|
|
lres = _InitStartButtonEtc();
|
|
|
|
if (g_dwProfileCAP & 0x00000004)
|
|
{
|
|
StopCAP();
|
|
}
|
|
|
|
_hMainAccel = LoadAccelerators(hinstCabinet, MAKEINTRESOURCE(ACCEL_TRAY));
|
|
|
|
_RegisterGlobalHotkeys();
|
|
|
|
// We spin a thread that will process "Load=", "Run=", CU\Run, and CU\RunOnce
|
|
RunStartupApps();
|
|
|
|
// If there were any startup failures that occurred before we were
|
|
// ready to handle them, re-raise the failure now that we're ready.
|
|
if (_fEarlyStartupFailure)
|
|
LogFailedStartupApp();
|
|
|
|
// we run the tray thread that handles Ctrl-Esc with a high priority
|
|
// class so that it can respond even on a stressed system.
|
|
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
|
|
|
|
return lres;
|
|
}
|
|
|
|
LRESULT CTray::_OnCreate(HWND hwnd)
|
|
{
|
|
LRESULT lres = -1;
|
|
v_hwndTray = hwnd;
|
|
|
|
Mixer_SetCallbackWindow(hwnd);
|
|
SendMessage(_hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0);
|
|
|
|
_AdjustMinimizedMetrics();
|
|
|
|
_hTheme = OpenThemeData(hwnd, c_wzTaskbarTheme);
|
|
|
|
_fShowSizingBarAlways = (_uAutoHide & AH_ON) ? TRUE : FALSE;
|
|
if (_hTheme)
|
|
{
|
|
GetThemeBool(_hTheme, 0, 0, TMT_ALWAYSSHOWSIZINGBAR, &_fShowSizingBarAlways);
|
|
}
|
|
|
|
SetWindowStyle(_hwnd, WS_BORDER | WS_THICKFRAME, !_hTheme);
|
|
|
|
// Force Refresh of frame
|
|
SetWindowPos(_hwnd, NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE);
|
|
|
|
if (_HotkeyCreate())
|
|
{
|
|
lres = _CreateWindows();
|
|
}
|
|
return lres;
|
|
}
|
|
|
|
typedef struct tagFSEPDATA
|
|
{
|
|
LPRECT prc;
|
|
HMONITOR hmon;
|
|
CTray* ptray;
|
|
}
|
|
FSEPDATA, *PFSEPDATA;
|
|
|
|
BOOL WINAPI CTray::FullScreenEnumProc(HMONITOR hmon, HDC hdc, LPRECT prc, LPARAM dwData)
|
|
{
|
|
BOOL fFullScreen; // Is there a rude app on this monitor?
|
|
|
|
PFSEPDATA pd = (PFSEPDATA)dwData;
|
|
if (pd->hmon == hmon)
|
|
{
|
|
fFullScreen = TRUE;
|
|
}
|
|
else if (pd->prc)
|
|
{
|
|
RECT rc, rcMon;
|
|
GetMonitorRect(hmon, &rcMon);
|
|
IntersectRect(&rc, &rcMon, pd->prc);
|
|
fFullScreen = EqualRect(&rc, &rcMon);
|
|
}
|
|
else
|
|
{
|
|
fFullScreen = FALSE;
|
|
}
|
|
|
|
if (hmon == pd->ptray->_hmonStuck)
|
|
{
|
|
pd->ptray->_fStuckRudeApp = fFullScreen;
|
|
}
|
|
|
|
//
|
|
// Tell all the appbars on the same display to get out of the way too
|
|
//
|
|
pd->ptray->_AppBarNotifyAll(hmon, ABN_FULLSCREENAPP, NULL, fFullScreen);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::HandleFullScreenApp(HWND hwnd)
|
|
{
|
|
//
|
|
// First check to see if something has actually changed
|
|
//
|
|
_hwndRude = hwnd;
|
|
|
|
//
|
|
// Enumerate all the monitors, see if the app is rude on each, adjust
|
|
// app bars and _fStuckRudeApp as necessary. (Some rude apps, such
|
|
// as the NT Logon Screen Saver, span multiple monitors.)
|
|
//
|
|
FSEPDATA d = {0};
|
|
RECT rc;
|
|
if (hwnd && GetWindowRect(hwnd, &rc))
|
|
{
|
|
d.prc = &rc;
|
|
d.hmon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONULL);
|
|
}
|
|
d.ptray = this;
|
|
|
|
EnumDisplayMonitors(NULL, NULL, FullScreenEnumProc, (LPARAM)&d);
|
|
|
|
//
|
|
// Now that we've set _fStuckRudeApp, update the tray's z-order position
|
|
//
|
|
_ResetZorder();
|
|
|
|
//
|
|
// stop the clock so we don't eat cycles and keep tons of code paged in
|
|
//
|
|
SendMessage(_hwndNotify, TNM_TRAYHIDE, 0, _fStuckRudeApp);
|
|
|
|
//
|
|
// Finally, let traynot know about whether the tray is hiding
|
|
//
|
|
SendMessage(_hwndNotify, TNM_RUDEAPP, _fStuckRudeApp, 0);
|
|
}
|
|
|
|
BOOL CTray::_IsTopmost()
|
|
{
|
|
return BOOLIFY(GetWindowLong(_hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST);
|
|
}
|
|
|
|
BOOL CTray::_IsPopupMenuVisible()
|
|
{
|
|
HWND hwnd;
|
|
return ((SUCCEEDED(IUnknown_GetWindow(_pmpStartMenu, &hwnd)) && IsWindowVisible(hwnd)) ||
|
|
(SUCCEEDED(IUnknown_GetWindow(_pmpStartPane, &hwnd)) && IsWindowVisible(hwnd)) ||
|
|
(SUCCEEDED(IUnknown_GetWindow(_pmpTasks, &hwnd)) && IsWindowVisible(hwnd)));
|
|
}
|
|
|
|
BOOL CTray::_IsActive()
|
|
{
|
|
//
|
|
// We say the tray is "active" iff:
|
|
//
|
|
// (a) the foreground window is the tray or a window owned by the tray, or
|
|
// (b) the start menu is showing
|
|
//
|
|
|
|
BOOL fActive = FALSE;
|
|
HWND hwnd = GetForegroundWindow();
|
|
|
|
if (hwnd != NULL &&
|
|
(hwnd == _hwnd || (GetWindowOwner(hwnd) == _hwnd)))
|
|
{
|
|
fActive = TRUE;
|
|
}
|
|
else if (_IsPopupMenuVisible())
|
|
{
|
|
fActive = TRUE;
|
|
}
|
|
|
|
return fActive;
|
|
}
|
|
|
|
void CTray::_ResetZorder()
|
|
{
|
|
HWND hwndZorder, hwndZorderCurrent;
|
|
|
|
if (g_fDesktopRaised || _fProcessingDesktopRaise || (_fAlwaysOnTop && !_fStuckRudeApp))
|
|
{
|
|
hwndZorder = HWND_TOPMOST;
|
|
}
|
|
else if (_IsActive())
|
|
{
|
|
hwndZorder = HWND_TOP;
|
|
}
|
|
else if (_fStuckRudeApp)
|
|
{
|
|
hwndZorder = HWND_BOTTOM;
|
|
}
|
|
else
|
|
{
|
|
hwndZorder = HWND_NOTOPMOST;
|
|
}
|
|
|
|
//
|
|
// We don't have to worry about the HWND_BOTTOM current case -- it's ok
|
|
// to keep moving ourselves down to the bottom when there's a rude app.
|
|
//
|
|
// Nor do we have to worry about the HWND_TOP current case -- it's ok
|
|
// to keep moving ourselves up to the top when we're active.
|
|
//
|
|
hwndZorderCurrent = _IsTopmost() ? HWND_TOPMOST : HWND_NOTOPMOST;
|
|
|
|
if (hwndZorder != hwndZorderCurrent)
|
|
{
|
|
// only do this if somehting has changed.
|
|
// this keeps us from popping up over menus as desktop async
|
|
// notifies us of it's state
|
|
|
|
SHForceWindowZorder(_hwnd, hwndZorder);
|
|
}
|
|
}
|
|
|
|
void CTray::_MessageLoop()
|
|
{
|
|
for (;;)
|
|
{
|
|
MSG msg;
|
|
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (msg.message == WM_QUIT)
|
|
{
|
|
if (_hwnd && IsWindow(_hwnd))
|
|
{
|
|
// Tell the tray to save everything off if we got here
|
|
// without it being destroyed.
|
|
SendMessage(_hwnd, WM_ENDSESSION, 1, 0);
|
|
}
|
|
return; // break all the way out of the main loop
|
|
}
|
|
|
|
if (_pmbTasks)
|
|
{
|
|
HRESULT hr = _pmbTasks->IsMenuMessage(&msg);
|
|
if (hr == E_FAIL)
|
|
{
|
|
if (_hwndTasks)
|
|
SendMessage(_hwndTasks, TBC_FREEPOPUPMENUS, 0, 0);
|
|
}
|
|
else if (hr == S_OK)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Note that this needs to come before _pmbStartMenu since
|
|
// the start pane sometimes hosts the start menu and it needs
|
|
// to handle the start menu messages in that case.
|
|
if (_pmbStartPane &&
|
|
_pmbStartPane->IsMenuMessage(&msg) == S_OK)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (_pmbStartMenu &&
|
|
_pmbStartMenu->IsMenuMessage(&msg) == S_OK)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (_hMainAccel && TranslateAccelerator(_hwnd, _hMainAccel, &msg))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
else
|
|
{
|
|
WaitMessage();
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CTray::Init()
|
|
{
|
|
// use _COINIT to make sure COM is inited disabling the OLE1 support
|
|
return SHCreateThread(MainThreadProc, this, CTF_COINIT, SyncThreadProc) && (_hwnd != NULL);
|
|
}
|
|
|
|
int CTray::_GetPart(BOOL fSizingBar, UINT uStuckPlace)
|
|
{
|
|
if (fSizingBar)
|
|
{
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_BOTTOM: return TBP_SIZINGBARBOTTOM;
|
|
case STICK_LEFT: return TBP_SIZINGBARLEFT;
|
|
case STICK_TOP: return TBP_SIZINGBARTOP;
|
|
case STICK_RIGHT: return TBP_SIZINGBARRIGHT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_BOTTOM: return TBP_BACKGROUNDBOTTOM;
|
|
case STICK_LEFT: return TBP_BACKGROUNDLEFT;
|
|
case STICK_TOP: return TBP_BACKGROUNDTOP;
|
|
case STICK_RIGHT: return TBP_BACKGROUNDRIGHT;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CTray::_UpdateVertical(UINT uStuckPlace, BOOL fForce)
|
|
{
|
|
static UINT _uOldStuckPlace = STICK_MAX + 1;
|
|
|
|
if ((_uOldStuckPlace != uStuckPlace) || fForce)
|
|
{
|
|
_uOldStuckPlace = uStuckPlace;
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_uv tray is now %s"), STUCK_HORIZONTAL(uStuckPlace) ? TEXT("HORIZONTAL") : TEXT("VERTICAL"));
|
|
|
|
if (_ptbs)
|
|
{
|
|
// This following function will cause a WINDOWPOSCHANGING which will call DoneMoving
|
|
// DoneMoving will then go a screw up all of the window sizing
|
|
_fIgnoreDoneMoving = TRUE;
|
|
BandSite_SetMode(_ptbs, STUCK_HORIZONTAL(uStuckPlace) ? 0 : DBIF_VIEWMODE_VERTICAL);
|
|
BandSite_SetWindowTheme(_ptbs, (LPWSTR)(STUCK_HORIZONTAL(uStuckPlace) ? c_wzTaskbarTheme : c_wzTaskbarVertTheme));
|
|
_fIgnoreDoneMoving = FALSE;
|
|
}
|
|
|
|
SendMessage(_hwndNotify, TNM_UPDATEVERTICAL, 0, !STUCK_HORIZONTAL(uStuckPlace));
|
|
|
|
if (_hTheme)
|
|
{
|
|
HDC hdc = GetDC(_hwnd);
|
|
GetThemePartSize(_hTheme, hdc, _GetPart(TRUE, uStuckPlace), 0, NULL, TS_TRUE, &_sizeSizingBar);
|
|
ReleaseDC(_hwnd, hdc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_InitBandsite()
|
|
{
|
|
ASSERT(_hwnd);
|
|
|
|
// we initilize the contents after all the infrastructure is created and sized properly
|
|
// need to notify which side we're on.
|
|
// nt5:211881: set mode *before* load, o.w. Update->RBAutoSize messed up
|
|
_UpdateBandSiteStyle();
|
|
|
|
BandSite_Load();
|
|
// now that the mode is set, we need to force an update because we
|
|
// explicitly avoided the update during BandSite_Load
|
|
_UpdateVertical(_uStuckPlace, TRUE);
|
|
BandSite_Update(_ptbs);
|
|
BandSite_UIActivateDBC(_ptbs, DBC_SHOW);
|
|
|
|
BandSite_FindBand(_ptbs, CLSID_TaskBand, IID_PPV_ARG(IDeskBand, &_pdbTasks), NULL, NULL);
|
|
IUnknown_GetWindow(_pdbTasks, &_hwndTasks);
|
|
|
|
// Now that bandsite is ready, set the correct size
|
|
// BUG: 606284 was caused by the tray do _HandleSizing before the BandSite's band were ready to go
|
|
// they all had their default band size of 0,0 so the tray became 0 px height
|
|
_fBandSiteInitialized = TRUE;
|
|
VerifySize(FALSE, TRUE);
|
|
}
|
|
|
|
void CTray::_KickStartAutohide()
|
|
{
|
|
if (_uAutoHide & AH_ON)
|
|
{
|
|
// tray always starts out hidden on autohide
|
|
_uAutoHide = AH_ON | AH_HIDING;
|
|
|
|
// we and many apps rely upon us having calculated the size correctly
|
|
Unhide();
|
|
|
|
// register it
|
|
if (!_AppBarSetAutoHideBar2(_hwnd, TRUE, _uStuckPlace))
|
|
{
|
|
// don't bother putting up UI in this case
|
|
// if someone is there just silently convert to normal
|
|
// (the shell is booting who would be there anyway?)
|
|
_SetAutoHideState(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_InitNonzeroGlobals()
|
|
{
|
|
// initalize globals that need to be non-zero
|
|
|
|
if (GetSystemMetrics(SM_SLOWMACHINE))
|
|
{
|
|
_dtSlideHide = 0; // dont slide the tray out
|
|
_dtSlideShow = 0;
|
|
}
|
|
else
|
|
{
|
|
_dtSlideHide = 400;
|
|
_dtSlideShow = 200;
|
|
}
|
|
|
|
_RefreshSettings();
|
|
}
|
|
|
|
void CTray::_CreateTrayWindow()
|
|
{
|
|
_InitTrayClass();
|
|
|
|
_uMsgEnableUserTrackedBalloonTips = RegisterWindowMessage(ENABLE_BALLOONTIP_MESSAGE);
|
|
|
|
_fNoToolbarsOnTaskbarPolicyEnabled = (SHRestricted(REST_NOTOOLBARSONTASKBAR) != 0);
|
|
|
|
DWORD dwExStyle = WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW;
|
|
// Don't fadein because layered windows suck
|
|
// If you create a layered window on a non-active desktop then the window goes black
|
|
dwExStyle |= IS_BIDI_LOCALIZED_SYSTEM() ? dwExStyleRTLMirrorWnd : 0L;
|
|
|
|
CreateWindowEx(dwExStyle, TEXT(WNDCLASS_TRAYNOTIFY), NULL,
|
|
WS_CLIPCHILDREN | WS_POPUP,
|
|
0, 0, 0, 0, NULL, NULL, hinstCabinet, (void*)this);
|
|
|
|
}
|
|
|
|
DWORD WINAPI CTray::SyncThreadProc(void *pv)
|
|
{
|
|
CTray* ptray = (CTray*)pv;
|
|
return ptray->_SyncThreadProc();
|
|
}
|
|
|
|
DWORD CTray::_SyncThreadProc()
|
|
{
|
|
if (g_dwStopWatchMode)
|
|
StopWatch_StartTimed(SWID_STARTUP, TEXT("_SyncThreadProc"), SPMODE_SHELL | SPMODE_DEBUGOUT, GetPerfTime());
|
|
|
|
if (g_dwProfileCAP & 0x00000002)
|
|
StartCAP();
|
|
|
|
|
|
InitializeCriticalSection(&_csHotkey);
|
|
|
|
OleInitialize(NULL); // matched in MainThreadProc()
|
|
ClassFactory_Start();
|
|
|
|
_InitNonzeroGlobals();
|
|
_ssomgr.Init();
|
|
|
|
//
|
|
// Watch the registry key that tells us which app is the default
|
|
// web browser, so we can track it in
|
|
// HKLM\Software\Clients\StartMenuInternet. We have to track it
|
|
// ourselves because downlevel browsers won't know about it.
|
|
//
|
|
// We need to do this only if we have write access to the key.
|
|
// (If we don't have write access, then we can't change it,
|
|
// so there's no point watching for it to change...)
|
|
//
|
|
// Well, okay, even if we only have read access, we have to do
|
|
// it once in case it changed while we were logged off.
|
|
//
|
|
// The order of these operations is important...
|
|
//
|
|
// 1. Migrate browser settings.
|
|
// 2. Build default MFU. (Depends on browser settings.)
|
|
// 3. Create tray window. (Relies on value MFU.)
|
|
//
|
|
|
|
_hHTTPEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
|
|
if (_hHTTPEvent)
|
|
{
|
|
// Make one migration pass immediately so HandleFirstTime
|
|
// sees good information. This also kick-starts the
|
|
// registry change notification process if the current user
|
|
// has write permission.
|
|
_MigrateOldBrowserSettings();
|
|
|
|
if (RegisterWaitForSingleObject(&_hHTTPWait, _hHTTPEvent,
|
|
_MigrateOldBrowserSettingsCB, this,
|
|
INFINITE, WT_EXECUTEDEFAULT))
|
|
{
|
|
// Yay, everything is fine.
|
|
}
|
|
}
|
|
|
|
// Build the default MFU if necessary
|
|
HandleFirstTime();
|
|
|
|
_CreateTrayWindow();
|
|
|
|
if (_hwnd && _ptbs)
|
|
{
|
|
_ResetZorder(); // obey the "always on top" flag
|
|
_KickStartAutohide();
|
|
|
|
_InitBandsite();
|
|
|
|
_ClipWindow(TRUE); // make sure we clip the taskbar to the current monitor before showing it
|
|
|
|
// it looks really strange for the tray to pop up and rehide at logon
|
|
// if we are autohide don't activate the tray when we show it
|
|
// if we aren't autohide do what Win95 did (tray is active by default)
|
|
ShowWindow(_hwnd, (_uAutoHide & AH_HIDING) ? SW_SHOWNA : SW_SHOW);
|
|
|
|
UpdateWindow(_hwnd);
|
|
_StuckTrayChange();
|
|
|
|
// get the system background scheduler thread
|
|
IShellTaskScheduler* pScheduler;
|
|
if (SUCCEEDED(CoCreateInstance(CLSID_SharedTaskScheduler, NULL, CLSCTX_INPROC,
|
|
IID_PPV_ARG(IShellTaskScheduler, &pScheduler))))
|
|
{
|
|
AddMenuItemsCacheTask(pScheduler, Tray_StartPanelEnabled());
|
|
pScheduler->Release();
|
|
}
|
|
|
|
SetTimer(_hwnd, IDT_HANDLEDELAYBOOTSTUFF, 5 * 1000, NULL);
|
|
}
|
|
|
|
if (g_dwProfileCAP & 0x00020000)
|
|
StopCAP();
|
|
|
|
if (g_dwStopWatchMode)
|
|
StopWatch_StopTimed(SWID_STARTUP, TEXT("_SyncThreadProc"), SPMODE_SHELL | SPMODE_DEBUGOUT, GetPerfTime());
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// the rest of the thread proc that includes the message loop
|
|
DWORD WINAPI CTray::MainThreadProc(void *pv)
|
|
{
|
|
CTray* ptray = (CTray*)pv;
|
|
|
|
if (!ptray->_hwnd)
|
|
return FALSE;
|
|
|
|
ptray->_OnCreateAsync();
|
|
|
|
PERFSETMARK("ExplorerStartMenuReady");
|
|
|
|
ptray->_MessageLoop();
|
|
|
|
ClassFactory_Stop();
|
|
OleUninitialize(); // matched in _SyncThreadProc()
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#define DM_IANELHK 0
|
|
|
|
#define HKIF_NULL 0
|
|
#define HKIF_CACHED 1
|
|
#define HKIF_FREEPIDLS 2
|
|
|
|
typedef struct
|
|
{
|
|
LPITEMIDLIST pidlFolder;
|
|
LPITEMIDLIST pidlItem;
|
|
WORD wGHotkey;
|
|
WORD wFlags;
|
|
} HOTKEYITEM;
|
|
|
|
|
|
UINT CTray::_HotkeyGetFreeItemIndex(void)
|
|
{
|
|
int i, cItems;
|
|
HOTKEYITEM *phki;
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
cItems = DSA_GetItemCount(_hdsaHKI);
|
|
for (i=0; i<cItems; i++)
|
|
{
|
|
phki = (HOTKEYITEM *)DSA_GetItemPtr(_hdsaHKI, i);
|
|
if (!phki->wGHotkey)
|
|
{
|
|
ASSERT(!phki->pidlFolder);
|
|
ASSERT(!phki->pidlItem);
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// Weird, Global hotkeys use different flags for modifiers than window hotkeys
|
|
// (and hotkeys returned by the hotkey control)
|
|
WORD _MapHotkeyToGlobalHotkey(WORD wHotkey)
|
|
{
|
|
UINT nMod = 0;
|
|
|
|
// Map the modifiers.
|
|
if (HIBYTE(wHotkey) & HOTKEYF_SHIFT)
|
|
nMod |= MOD_SHIFT;
|
|
if (HIBYTE(wHotkey) & HOTKEYF_CONTROL)
|
|
nMod |= MOD_CONTROL;
|
|
if (HIBYTE(wHotkey) & HOTKEYF_ALT)
|
|
nMod |= MOD_ALT;
|
|
UINT nVirtKey = LOBYTE(wHotkey);
|
|
return (WORD)((nMod*256) + nVirtKey);
|
|
}
|
|
|
|
// NB This takes a regular window hotkey not a global hotkey (it does
|
|
// the convertion for you).
|
|
int CTray::HotkeyAdd(WORD wHotkey, LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlItem, BOOL fClone)
|
|
{
|
|
if (wHotkey)
|
|
{
|
|
LPCITEMIDLIST pidl1, pidl2;
|
|
|
|
HOTKEYITEM hki;
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
int i = _HotkeyGetFreeItemIndex();
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
// DebugMsg(DM_IANELHK, "c.hl_a: Hotkey %x with id %d.", wHotkey, i);
|
|
|
|
if (fClone)
|
|
{
|
|
pidl1 = ILClone(pidlFolder);
|
|
pidl2 = ILClone(pidlItem);
|
|
hki.wFlags = HKIF_FREEPIDLS;
|
|
}
|
|
else
|
|
{
|
|
pidl1 = pidlFolder;
|
|
pidl2 = pidlItem;
|
|
hki.wFlags = HKIF_NULL;
|
|
}
|
|
|
|
hki.pidlFolder = (LPITEMIDLIST)pidl1;
|
|
hki.pidlItem = (LPITEMIDLIST)pidl2;
|
|
hki.wGHotkey = _MapHotkeyToGlobalHotkey(wHotkey);
|
|
DSA_SetItem(_hdsaHKI, i, &hki);
|
|
|
|
LeaveCriticalSection(&_csHotkey);
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// NB Cached hotkeys have their own pidls that need to be free but
|
|
// regular hotkeys just keep a pointer to pidls used by the startmenu and
|
|
// so don't.
|
|
int CTray::_HotkeyAddCached(WORD wGHotkey, LPITEMIDLIST pidl)
|
|
{
|
|
int i = -1;
|
|
|
|
if (wGHotkey)
|
|
{
|
|
LPITEMIDLIST pidlItem = ILClone(ILFindLastID(pidl));
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
if (pidlItem)
|
|
{
|
|
if (ILRemoveLastID(pidl))
|
|
{
|
|
HOTKEYITEM hki;
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
i = _HotkeyGetFreeItemIndex();
|
|
|
|
// DebugMsg(DM_IANELHK, "c.hl_ac: Hotkey %x with id %d.", wGHotkey, i);
|
|
|
|
hki.pidlFolder = pidl;
|
|
hki.pidlItem = pidlItem;
|
|
hki.wGHotkey = wGHotkey;
|
|
hki.wFlags = HKIF_CACHED | HKIF_FREEPIDLS;
|
|
DSA_SetItem(_hdsaHKI, i, &hki);
|
|
|
|
LeaveCriticalSection(&_csHotkey);
|
|
}
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
// NB Again, this takes window hotkey not a Global one.
|
|
// NB This doesn't delete cached hotkeys.
|
|
int CTray::_HotkeyRemove(WORD wHotkey)
|
|
{
|
|
int iRet = -1;
|
|
if (EVAL(_hdsaHKI))
|
|
{
|
|
int i, cItems;
|
|
HOTKEYITEM *phki;
|
|
WORD wGHotkey;
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
// DebugMsg(DM_IANELHK, "c.hl_r: Remove hotkey for %x" , wHotkey);
|
|
|
|
// Unmap the modifiers.
|
|
wGHotkey = _MapHotkeyToGlobalHotkey(wHotkey);
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
cItems = DSA_GetItemCount(_hdsaHKI);
|
|
for (i=0; i<cItems; i++)
|
|
{
|
|
phki = (HOTKEYITEM *)DSA_GetItemPtr(_hdsaHKI, i);
|
|
if (phki && !(phki->wFlags & HKIF_CACHED) && (phki->wGHotkey == wGHotkey))
|
|
{
|
|
// DebugMsg(DM_IANELHK, "c.hl_r: Invalidating %d", i);
|
|
if (phki->wFlags & HKIF_FREEPIDLS)
|
|
{
|
|
if (phki->pidlFolder)
|
|
ILFree(phki->pidlFolder);
|
|
if (phki->pidlItem)
|
|
ILFree(phki->pidlItem);
|
|
}
|
|
phki->wGHotkey = 0;
|
|
phki->pidlFolder = NULL;
|
|
phki->pidlItem = NULL;
|
|
phki->wFlags &= ~HKIF_FREEPIDLS;
|
|
iRet = i;
|
|
break;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&_csHotkey);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
// NB This takes a global hotkey.
|
|
int CTray::_HotkeyRemoveCached(WORD wGHotkey)
|
|
{
|
|
int iRet = -1;
|
|
int i, cItems;
|
|
HOTKEYITEM *phki;
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
// DebugMsg(DM_IANELHK, "c.hl_rc: Remove hotkey for %x" , wGHotkey);
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
cItems = DSA_GetItemCount(_hdsaHKI);
|
|
for (i=0; i<cItems; i++)
|
|
{
|
|
phki = (HOTKEYITEM *)DSA_GetItemPtr(_hdsaHKI, i);
|
|
if (phki && (phki->wFlags & HKIF_CACHED) && (phki->wGHotkey == wGHotkey))
|
|
{
|
|
// DebugMsg(DM_IANELHK, "c.hl_r: Invalidating %d", i);
|
|
if (phki->wFlags & HKIF_FREEPIDLS)
|
|
{
|
|
if (phki->pidlFolder)
|
|
ILFree(phki->pidlFolder);
|
|
if (phki->pidlItem)
|
|
ILFree(phki->pidlItem);
|
|
}
|
|
phki->pidlFolder = NULL;
|
|
phki->pidlItem = NULL;
|
|
phki->wGHotkey = 0;
|
|
phki->wFlags &= ~(HKIF_CACHED | HKIF_FREEPIDLS);
|
|
iRet = i;
|
|
break;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&_csHotkey);
|
|
|
|
return iRet;
|
|
}
|
|
|
|
// NB Some (the ones not marked HKIF_FREEPIDLS) of the items in the list of hotkeys
|
|
// have pointers to idlists used by the filemenu so they are only valid for
|
|
// the lifetime of the filemenu.
|
|
BOOL CTray::_HotkeyCreate(void)
|
|
{
|
|
if (!_hdsaHKI)
|
|
{
|
|
// DebugMsg(DM_TRACE, "c.hkl_c: Creating global hotkey list.");
|
|
_hdsaHKI = DSA_Create(sizeof(HOTKEYITEM), 0);
|
|
}
|
|
|
|
if (_hdsaHKI)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CTray::_BuildStartMenu()
|
|
{
|
|
HRESULT hr;
|
|
|
|
ClosePopupMenus();
|
|
|
|
//
|
|
// Avoid redundant rebuilds: Peek out any pending SBM_REBUILDMENU messages
|
|
// since the rebuild we're about to do will take care of it. Do this
|
|
// before destroying the Start Menu so we never yield while there isn't
|
|
// a Start Menu.
|
|
//
|
|
MSG msg;
|
|
while (PeekMessage(&msg, _hwnd, SBM_REBUILDMENU, SBM_REBUILDMENU, PM_REMOVE | PM_NOYIELD))
|
|
{
|
|
// Keep sucking them out
|
|
}
|
|
|
|
|
|
_DestroyStartMenu();
|
|
|
|
if (Tray_StartPanelEnabled())
|
|
{
|
|
hr = DesktopV2_Create(&_pmpStartPane, &_pmbStartPane, &_pvStartPane);
|
|
DesktopV2_Build(_pvStartPane);
|
|
}
|
|
else
|
|
{
|
|
hr = StartMenuHost_Create(&_pmpStartMenu, &_pmbStartMenu);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IBanneredBar* pbb;
|
|
|
|
hr = _pmpStartMenu->QueryInterface(IID_PPV_ARG(IBanneredBar, &pbb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pbb->SetBitmap(_hbmpStartBkg);
|
|
if (_fSMSmallIcons)
|
|
pbb->SetIconSize(BMICON_SMALL);
|
|
else
|
|
pbb->SetIconSize(BMICON_LARGE);
|
|
|
|
pbb->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
TraceMsg(TF_ERROR, "Could not create StartMenu");
|
|
}
|
|
}
|
|
|
|
void CTray::_DestroyStartMenu()
|
|
{
|
|
IUnknown_SetSite(_pmpStartMenu, NULL);
|
|
ATOMICRELEASET(_pmpStartMenu, IMenuPopup);
|
|
ATOMICRELEASET(_pmbStartMenu, IMenuBand);
|
|
IUnknown_SetSite(_pmpStartPane, NULL);
|
|
ATOMICRELEASET(_pmpStartPane, IMenuPopup);
|
|
ATOMICRELEASET(_pmbStartPane, IMenuBand);
|
|
ATOMICRELEASET(_pmpTasks, IMenuPopup);
|
|
ATOMICRELEASET(_pmbTasks, IMenuBand);
|
|
}
|
|
|
|
void CTray::ForceStartButtonUp()
|
|
{
|
|
MSG msg;
|
|
// don't do that check message pos because it gets screwy with
|
|
// keyboard cancel. and besides, we always want it cleared after
|
|
// track menu popup is done.
|
|
// do it twice to be sure it's up due to the _uDown cycling twice in
|
|
// the subclassing stuff
|
|
// pull off any button downs
|
|
PeekMessage(&msg, _hwndStart, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE);
|
|
SendMessage(_hwndStart, BM_SETSTATE, FALSE, 0);
|
|
SendMessage(_hwndStart, BM_SETSTATE, FALSE, 0);
|
|
|
|
if (_hwndTasks)
|
|
SendMessage(_hwndTasks, TBC_SETPREVFOCUS, 0, NULL);
|
|
|
|
PostMessage(_hwnd, TM_STARTMENUDISMISSED, 0, 0);
|
|
}
|
|
|
|
void Tray_OnStartMenuDismissed()
|
|
{
|
|
c_tray._bMainMenuInit = FALSE;
|
|
// Tell the Start Button that it's allowed to be in the up position now. This
|
|
// prevents the problem where the start menu is displayed but the button is
|
|
// in the up position... This happens when dialog boxes are displayed
|
|
c_tray._fAllowUp = TRUE;
|
|
|
|
// Now tell it to be in the up position
|
|
c_tray.ForceStartButtonUp();
|
|
|
|
PostMessage(v_hwndTray, TM_SHOWTRAYBALLOON, TRUE, 0);
|
|
}
|
|
|
|
#ifdef FEATURE_STARTPAGE
|
|
void Tray_OnStartPageDismissed()
|
|
{
|
|
if (g_fDesktopRaised)
|
|
c_tray._RaiseDesktop(!g_fDesktopRaised, TRUE);
|
|
|
|
Tray_OnStartMenuDismissed();
|
|
}
|
|
void Tray_MenuInvoke(int idCmd)
|
|
{
|
|
c_tray.ContextMenuInvoke(idCmd);
|
|
}
|
|
#endif
|
|
|
|
int CTray::_TrackMenu(HMENU hmenu)
|
|
{
|
|
TPMPARAMS tpm;
|
|
int iret;
|
|
|
|
tpm.cbSize = sizeof(tpm);
|
|
GetClientRect(_hwndStart, &tpm.rcExclude);
|
|
|
|
RECT rcClient;
|
|
GetClientRect(_hwnd, &rcClient);
|
|
tpm.rcExclude.bottom = min(tpm.rcExclude.bottom, rcClient.bottom);
|
|
|
|
MapWindowPoints(_hwndStart, NULL, (LPPOINT)&tpm.rcExclude, 2);
|
|
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
|
|
iret = TrackPopupMenuEx(hmenu, TPM_VERTICAL | TPM_BOTTOMALIGN | TPM_RETURNCMD,
|
|
tpm.rcExclude.left, tpm.rcExclude.bottom, _hwnd, &tpm);
|
|
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
|
|
return iret;
|
|
}
|
|
|
|
/*------------------------------------------------------------------
|
|
** Respond to a button's pressing by bringing up the appropriate menu.
|
|
** Clean up the button depression when the menu is dismissed.
|
|
**------------------------------------------------------------------*/
|
|
void CTray::_ToolbarMenu()
|
|
{
|
|
RECTL rcExclude;
|
|
POINTL ptPop;
|
|
DWORD dwFlags = MPPF_KEYBOARD; // Assume that we're popuping
|
|
// up because of the keyboard
|
|
// This is for the underlines on NT5
|
|
|
|
if (_hwndTasks)
|
|
SendMessage(_hwndTasks, TBC_FREEPOPUPMENUS, 0, 0);
|
|
|
|
if (_hwndStartBalloon)
|
|
{
|
|
_DontShowTheStartButtonBalloonAnyMore();
|
|
ShowWindow(_hwndStartBalloon, SW_HIDE);
|
|
_DestroyStartButtonBalloon();
|
|
}
|
|
|
|
SetActiveWindow(_hwnd);
|
|
_bMainMenuInit = TRUE;
|
|
|
|
// Exclude rect is the VISIBLE portion of the Start Button.
|
|
{
|
|
RECT rcParent;
|
|
GetClientRect(_hwndStart, (RECT *)&rcExclude);
|
|
MapWindowRect(_hwndStart, HWND_DESKTOP, &rcExclude);
|
|
|
|
GetClientRect(_hwnd, &rcParent);
|
|
MapWindowRect(_hwnd, HWND_DESKTOP, &rcParent);
|
|
|
|
IntersectRect((RECT*)&rcExclude, (RECT*)&rcExclude, &rcParent);
|
|
}
|
|
ptPop.x = rcExclude.left;
|
|
ptPop.y = rcExclude.top;
|
|
|
|
// Close any Context Menus
|
|
SendMessage(_hwnd, WM_CANCELMODE, 0, 0);
|
|
|
|
// Is the "Activate" button down (If the buttons are swapped, then it's the
|
|
// right button, otherwise the left button)
|
|
if (GetKeyState(GetSystemMetrics(SM_SWAPBUTTON)?VK_RBUTTON:VK_LBUTTON) < 0)
|
|
{
|
|
dwFlags = 0; // Then set to the default
|
|
}
|
|
|
|
#ifdef FEATURE_STARTPAGE
|
|
if(!(GetAsyncKeyState(VK_SHIFT) < 0) && Tray_ShowStartPageEnabled()) //If the start page is on, then just raise the desktop!
|
|
{
|
|
_hwndFocusBeforeRaise = GetForegroundWindow();
|
|
_RaiseDesktop(TRUE, TRUE);
|
|
Tray_SetStartPaneActive(TRUE);
|
|
}
|
|
else
|
|
#endif //FEATURE_STARTPAGE
|
|
{
|
|
IMenuPopup **ppmpToDisplay = &_pmpStartMenu;
|
|
|
|
if (_pmpStartPane)
|
|
{
|
|
ppmpToDisplay = &_pmpStartPane;
|
|
}
|
|
|
|
// Close race window: The user can click on the Start Button
|
|
// before we get a chance to rebuild the Start Menu in its new
|
|
// form. In such case, rebuild it now.
|
|
if (!*ppmpToDisplay)
|
|
{
|
|
TraceMsg(TF_WARNING, "e.tbm: Rebuilding Start Menu");
|
|
_BuildStartMenu();
|
|
}
|
|
|
|
|
|
if (*ppmpToDisplay && SUCCEEDED((*ppmpToDisplay)->Popup(&ptPop, &rcExclude, dwFlags)))
|
|
{
|
|
// All is well - the menu is up
|
|
TraceMsg(DM_MISC, "e.tbm: dwFlags=%x (0=mouse 1=key)", dwFlags);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_WARNING, "e.tbm: %08x->Popup failed", *ppmpToDisplay);
|
|
// Start Menu failed to display -- reset the Start Button
|
|
// so the user can click it again to try again
|
|
Tray_OnStartMenuDismissed();
|
|
}
|
|
|
|
if (dwFlags == MPPF_KEYBOARD)
|
|
{
|
|
// Since the user has launched the start button by Ctrl-Esc, or some other worldly
|
|
// means, then turn the rect on.
|
|
SendMessage(_hwndStart, WM_UPDATEUISTATE, MAKEWPARAM(UIS_CLEAR,
|
|
UISF_HIDEFOCUS), 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT CTray::_AppBarSetState(UINT uFlags)
|
|
{
|
|
if (uFlags & ~(ABS_AUTOHIDE | ABS_ALWAYSONTOP))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
_SetAutoHideState(uFlags & ABS_AUTOHIDE);
|
|
_UpdateAlwaysOnTop(uFlags & ABS_ALWAYSONTOP);
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
//
|
|
// can't use SubtractRect sometimes because of inclusion limitations
|
|
//
|
|
void CTray::_AppBarSubtractRect(PAPPBAR pab, LPRECT lprc)
|
|
{
|
|
switch (pab->uEdge) {
|
|
case ABE_TOP:
|
|
if (pab->rc.bottom > lprc->top)
|
|
lprc->top = pab->rc.bottom;
|
|
break;
|
|
|
|
case ABE_LEFT:
|
|
if (pab->rc.right > lprc->left)
|
|
lprc->left = pab->rc.right;
|
|
break;
|
|
|
|
case ABE_BOTTOM:
|
|
if (pab->rc.top < lprc->bottom)
|
|
lprc->bottom = pab->rc.top;
|
|
break;
|
|
|
|
case ABE_RIGHT:
|
|
if (pab->rc.left < lprc->right)
|
|
lprc->right = pab->rc.left;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CTray::_AppBarSubtractRects(HMONITOR hmon, LPRECT lprc)
|
|
{
|
|
int i;
|
|
|
|
if (!_hdpaAppBars)
|
|
return;
|
|
|
|
i = DPA_GetPtrCount(_hdpaAppBars);
|
|
|
|
while (i--)
|
|
{
|
|
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(_hdpaAppBars, i);
|
|
|
|
//
|
|
// autohide bars are not in our DPA or live on the edge
|
|
// don't subtract the appbar if it's on a different display
|
|
// don't subtract the appbar if we are in a locked desktop
|
|
//
|
|
// if (hmon == MonitorFromRect(&pab->rc, MONITOR_DEFAULTTONULL))
|
|
if (hmon == MonitorFromRect(&pab->rc, MONITOR_DEFAULTTONULL) && !_fIsDesktopLocked)
|
|
_AppBarSubtractRect(pab, lprc);
|
|
}
|
|
}
|
|
|
|
#define RWA_NOCHANGE 0
|
|
#define RWA_CHANGED 1
|
|
#define RWA_BOTTOMMOSTTRAY 2
|
|
|
|
// (dli) This is a hack put in because bottommost tray is wierd, once
|
|
// it becomes a toolbar, this code should go away.
|
|
// In the bottommost tray case, even though the work area has not changed,
|
|
// we should notify the desktop.
|
|
int CTray::_RecomputeWorkArea(HWND hwndCause, HMONITOR hmon, LPRECT prcWork)
|
|
{
|
|
int iRet = RWA_NOCHANGE;
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof(mi);
|
|
|
|
if (_fIsLogoff)
|
|
{
|
|
if (GetMonitorInfo(hmon, &mi))
|
|
{
|
|
*prcWork = mi.rcMonitor;
|
|
iRet = RWA_CHANGED;
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
ASSERT(!_fIsLogoff);
|
|
|
|
//
|
|
// tell everybody that this window changed positions _on_this_monitor_
|
|
// note that this notify happens even if we don't change the work area
|
|
// since it may cause another app to change the work area...
|
|
//
|
|
PostMessage(_hwnd, TM_RELAYPOSCHANGED, (WPARAM)hwndCause, (LPARAM)hmon);
|
|
|
|
//
|
|
// get the current info for this monitor
|
|
// we subtract down from the display rectangle to build the work area
|
|
//
|
|
if (GetMonitorInfo(hmon, &mi))
|
|
{
|
|
//
|
|
// don't subtract the tray if it is autohide
|
|
// don't subtract the tray if it is not always on top
|
|
// don't subtract the tray if it's on a different display
|
|
// don't subtract the tray if it is on a different desktop
|
|
//
|
|
if (!(_uAutoHide & AH_ON) && _fAlwaysOnTop &&
|
|
(hmon == _hmonStuck) && !_fIsDesktopLocked)
|
|
{
|
|
SubtractRect(prcWork, &mi.rcMonitor,
|
|
&_arStuckRects[_uStuckPlace]);
|
|
}
|
|
else
|
|
*prcWork = mi.rcMonitor;
|
|
|
|
//
|
|
// now subtract off all the appbars on this display
|
|
//
|
|
_AppBarSubtractRects(hmon, prcWork);
|
|
|
|
//
|
|
// return whether we changed anything
|
|
//
|
|
if (!EqualRect(prcWork, &mi.rcWork))
|
|
iRet = RWA_CHANGED;
|
|
else if (!(_uAutoHide & AH_ON) && (!_fAlwaysOnTop) &&
|
|
(!IsRectEmpty(&_arStuckRects[_uStuckPlace])))
|
|
// NOTE: This is the bottommost case, it only applies for the tray.
|
|
// this should be taken out when bottommost tray becomes toolbar
|
|
iRet = RWA_BOTTOMMOSTTRAY;
|
|
}
|
|
else
|
|
{
|
|
iRet = RWA_NOCHANGE;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
void RedrawDesktop(RECT *prcWork)
|
|
{
|
|
// This rect point should always be valid (dli)
|
|
RIP(prcWork);
|
|
|
|
if (v_hwndDesktop && g_fCleanBoot)
|
|
{
|
|
MapWindowRect(NULL, v_hwndDesktop, prcWork);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac invalidating desktop rect {%d,%d,%d,%d}"), prcWork->left, prcWork->top, prcWork->right, prcWork->bottom);
|
|
RedrawWindow(v_hwndDesktop, prcWork, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
|
|
}
|
|
}
|
|
|
|
void CTray::_StuckAppChange(HWND hwndCause, LPCRECT prcOld, LPCRECT prcNew, BOOL bTray)
|
|
{
|
|
RECT rcWork1, rcWork2;
|
|
HMONITOR hmon1, hmon2 = 0;
|
|
int iChange = 0;
|
|
|
|
//
|
|
// PERF FEATURE:
|
|
// there are cases where we end up setting the work area multiple times
|
|
// we need to keep a static array of displays that have changed and a
|
|
// reenter count so we can avoid pain of sending notifies to the whole
|
|
// planet...
|
|
//
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac from_AppBar %08X"), hwndCause);
|
|
|
|
//
|
|
// see if the work area changed on the display containing prcOld
|
|
//
|
|
if (prcOld)
|
|
{
|
|
if (bTray)
|
|
hmon1 = _hmonOld;
|
|
else
|
|
hmon1 = MonitorFromRect(prcOld, MONITOR_DEFAULTTONEAREST);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac old pos {%d,%d,%d,%d} on monitor %08X"), prcOld->left, prcOld->top, prcOld->right, prcOld->bottom, hmon1);
|
|
|
|
if (hmon1)
|
|
{
|
|
int iret = _RecomputeWorkArea(hwndCause, hmon1, &rcWork1);
|
|
if (iret == RWA_CHANGED)
|
|
iChange = 1;
|
|
if (iret == RWA_BOTTOMMOSTTRAY)
|
|
iChange = 4;
|
|
}
|
|
}
|
|
else
|
|
hmon1 = NULL;
|
|
|
|
//
|
|
// see if the work area changed on the display containing prcNew
|
|
//
|
|
if (prcNew)
|
|
{
|
|
hmon2 = MonitorFromRect(prcNew, MONITOR_DEFAULTTONULL);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac new pos {%d,%d,%d,%d} on monitor %08X"), prcNew->left, prcNew->top, prcNew->right, prcNew->bottom, hmon2);
|
|
|
|
if (hmon2 && (hmon2 != hmon1))
|
|
{
|
|
int iret = _RecomputeWorkArea(hwndCause, hmon2, &rcWork2);
|
|
if (iret == RWA_CHANGED)
|
|
iChange |= 2;
|
|
else if (iret == RWA_BOTTOMMOSTTRAY && (!iChange))
|
|
iChange = 4;
|
|
}
|
|
}
|
|
|
|
//
|
|
// did the prcOld's display's work area change?
|
|
//
|
|
if (iChange & 1)
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac changing work area for monitor %08X"), hmon1);
|
|
|
|
// only send SENDWININICHANGE if the desktop has been created (otherwise
|
|
// we will hang the explorer because the main thread is currently blocked)
|
|
SystemParametersInfo(SPI_SETWORKAREA, TRUE, &rcWork1,
|
|
(iChange == 1 && v_hwndDesktop)? SPIF_SENDWININICHANGE : 0);
|
|
|
|
RedrawDesktop(&rcWork1);
|
|
}
|
|
|
|
//
|
|
// did the prcOld's display's work area change?
|
|
//
|
|
if (iChange & 2)
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sac changing work area for monitor %08X"), hmon2);
|
|
|
|
// only send SENDWININICHANGE if the desktop has been created (otherwise
|
|
// we will hang the explorer because the main thread is currently blocked)
|
|
SystemParametersInfo(SPI_SETWORKAREA, TRUE, &rcWork2,
|
|
v_hwndDesktop ? SPIF_SENDWININICHANGE : 0);
|
|
|
|
RedrawDesktop(&rcWork2);
|
|
}
|
|
|
|
// only send if the desktop has been created...
|
|
// need to send if it's from the tray or any outside app that causes size change
|
|
// from the tray because autohideness will affect desktop size even if it's not always on top
|
|
if ((bTray || iChange == 4) && v_hwndDesktop)
|
|
SendMessage(v_hwndDesktop, WM_SIZE, 0, 0);
|
|
}
|
|
|
|
void CTray::_StuckTrayChange()
|
|
{
|
|
// We used to blow off the _StuckAppChange when the tray was in autohide
|
|
// mode, since moving or resizing an autohid tray doesn't change the
|
|
// work area. Now we go ahead with the _StuckAppChange in this case
|
|
// too. The reason is that we can get into a state where the work area
|
|
// size is incorrect, and we want the taskbar to always be self-repairing
|
|
// in this case (so that resizing or moving the taskbar will correct the
|
|
// work area size).
|
|
|
|
//
|
|
// pass a NULL window here since we don't want to hand out our window and
|
|
// the tray doesn't get these anyway (nobody cares as long as its not them)
|
|
//
|
|
_StuckAppChange(NULL, &_rcOldTray,
|
|
&_arStuckRects[_uStuckPlace], TRUE);
|
|
|
|
//
|
|
// save off the new tray position...
|
|
//
|
|
_rcOldTray = _arStuckRects[_uStuckPlace];
|
|
}
|
|
|
|
UINT CTray::_RecalcStuckPos(LPRECT prc)
|
|
{
|
|
RECT rcDummy;
|
|
POINT pt;
|
|
|
|
if (!prc)
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_rsp no rect supplied, using window rect"));
|
|
|
|
prc = &rcDummy;
|
|
GetWindowRect(_hwnd, prc);
|
|
}
|
|
|
|
// use the center of the original drag rect as a staring point
|
|
pt.x = prc->left + RECTWIDTH(*prc) / 2;
|
|
pt.y = prc->top + RECTHEIGHT(*prc) / 2;
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_rsp rect is {%d, %d, %d, %d} point is {%d, %d}"), prc->left, prc->top, prc->right, prc->bottom, pt.x, pt.y);
|
|
|
|
// reset this so the drag code won't give it preference
|
|
_uMoveStuckPlace = (UINT)-1;
|
|
|
|
// simulate a drag back to figure out where we originated from
|
|
// you may be tempted to remove this. before you do think about dragging
|
|
// the tray across monitors and then hitting ESC...
|
|
return _CalcDragPlace(pt);
|
|
}
|
|
|
|
/*------------------------------------------------------------------
|
|
** the position is changing in response to a move operation.
|
|
**
|
|
** if the docking status changed, we need to get a new size and
|
|
** maybe a new frame style. change the WINDOWPOS to reflect
|
|
** these changes accordingly.
|
|
**------------------------------------------------------------------*/
|
|
void CTray::_DoneMoving(LPWINDOWPOS lpwp)
|
|
{
|
|
RECT rc, *prc;
|
|
|
|
if ((_uMoveStuckPlace == (UINT)-1) || (_fIgnoreDoneMoving))
|
|
return;
|
|
|
|
if (_fSysSizing)
|
|
_fDeferedPosRectChange = TRUE;
|
|
|
|
rc.left = lpwp->x;
|
|
rc.top = lpwp->y;
|
|
rc.right = lpwp->x + lpwp->cx;
|
|
rc.bottom = lpwp->y + lpwp->cy;
|
|
|
|
prc = &_arStuckRects[_uMoveStuckPlace];
|
|
|
|
if (!EqualRect(prc, &rc))
|
|
{
|
|
_uMoveStuckPlace = _RecalcStuckPos(&rc);
|
|
prc = &_arStuckRects[_uMoveStuckPlace];
|
|
}
|
|
|
|
// Get the new hmonitor
|
|
_hmonStuck = MonitorFromRect(prc, MONITOR_DEFAULTTONEAREST);
|
|
|
|
lpwp->x = prc->left;
|
|
lpwp->y = prc->top;
|
|
lpwp->cx = RECTWIDTH(*prc);
|
|
lpwp->cy = RECTHEIGHT(*prc);
|
|
|
|
lpwp->flags &= ~(SWP_NOMOVE | SWP_NOSIZE);
|
|
|
|
// if we were autohiding, we need to update our appbar autohide rect
|
|
if (_uAutoHide & AH_ON)
|
|
{
|
|
// unregister us from the old side
|
|
_AppBarSetAutoHideBar2(_hwnd, FALSE, _uStuckPlace);
|
|
}
|
|
|
|
// All that work might've changed _uMoveStuckPlace (since there
|
|
// was a lot of message traffic), so check one more time.
|
|
// Somehow, NT Stress manages to get us in here with an invalid
|
|
// uMoveStuckPlace.
|
|
if (IsValidSTUCKPLACE(_uMoveStuckPlace))
|
|
{
|
|
// remember the new state
|
|
_uStuckPlace = _uMoveStuckPlace;
|
|
}
|
|
_uMoveStuckPlace = (UINT)-1;
|
|
_UpdateVertical(_uStuckPlace);
|
|
|
|
_HandleSizing(0, prc, _uStuckPlace);
|
|
if ((_uAutoHide & AH_ON) &&
|
|
!_AppBarSetAutoHideBar2(_hwnd, TRUE, _uStuckPlace))
|
|
{
|
|
_AutoHideCollision();
|
|
}
|
|
}
|
|
|
|
UINT CTray::_CalcDragPlace(POINT pt)
|
|
{
|
|
UINT uPlace = _uMoveStuckPlace;
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_cdp starting point is {%d, %d}"), pt.x, pt.y);
|
|
|
|
//
|
|
// if the mouse is currently over the tray position leave it alone
|
|
//
|
|
if ((uPlace == (UINT)-1) || !PtInRect(&_arStuckRects[uPlace], pt))
|
|
{
|
|
HMONITOR hmonDrag;
|
|
SIZE screen, error;
|
|
UINT uHorzEdge, uVertEdge;
|
|
RECT rcDisplay, *prcStick;
|
|
|
|
//
|
|
// which display is the mouse on?
|
|
//
|
|
hmonDrag = _GetDisplayRectFromPoint(&rcDisplay, pt,
|
|
MONITOR_DEFAULTTOPRIMARY);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_cdp monitor is %08X"), hmonDrag);
|
|
|
|
//
|
|
// 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 = STICK_LEFT;
|
|
error.cx = pt.x;
|
|
}
|
|
else
|
|
{
|
|
uVertEdge = STICK_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 = STICK_TOP;
|
|
error.cy = pt.y;
|
|
}
|
|
else
|
|
{
|
|
uHorzEdge = STICK_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;
|
|
|
|
// which StuckRect should we use?
|
|
prcStick = &_arStuckRects[uPlace];
|
|
|
|
//
|
|
// need to recalc stuck rect for new monitor?
|
|
//
|
|
if ((hmonDrag != _GetDisplayRectFromRect(NULL, prcStick,
|
|
MONITOR_DEFAULTTONULL)))
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_cdp re-snapping rect for new display"));
|
|
_MakeStuckRect(prcStick, &rcDisplay, _sStuckWidths, uPlace);
|
|
}
|
|
}
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_cdp edge is %d, rect is {%d, %d, %d, %d}"), uPlace, _arStuckRects[uPlace].left, _arStuckRects[uPlace].top, _arStuckRects[uPlace].right, _arStuckRects[uPlace].bottom);
|
|
ASSERT(IsValidSTUCKPLACE(uPlace));
|
|
return uPlace;
|
|
}
|
|
|
|
void CTray::_HandleMoving(WPARAM wParam, LPRECT lprc)
|
|
{
|
|
POINT ptCursor;
|
|
GetCursorPos(&ptCursor);
|
|
|
|
// If the cursor is not far from its starting point, then ignore it.
|
|
// A very common problem is the user clicks near the corner of the clock,
|
|
// twitches the mouse 5 pixels, and BLAM, their taskbar is now vertical
|
|
// and they don't know what they did or how to get it back.
|
|
|
|
if (g_fInSizeMove && PtInRect(&_rcSizeMoveIgnore, ptCursor))
|
|
{
|
|
// Ignore -- user is merely twitching
|
|
_uMoveStuckPlace = _uStuckPlace;
|
|
}
|
|
else
|
|
{
|
|
_uMoveStuckPlace = _CalcDragPlace(ptCursor);
|
|
}
|
|
|
|
*lprc = _arStuckRects[_uMoveStuckPlace];
|
|
_HandleSizing(wParam, lprc, _uMoveStuckPlace);
|
|
}
|
|
|
|
// store the tray size when dragging is finished
|
|
void CTray::_SnapshotStuckRectSize(UINT uPlace)
|
|
{
|
|
RECT rcDisplay, *prc = &_arStuckRects[uPlace];
|
|
|
|
//
|
|
// record the width of this stuck rect
|
|
//
|
|
if (STUCK_HORIZONTAL(uPlace))
|
|
_sStuckWidths.cy = RECTHEIGHT(*prc);
|
|
else
|
|
_sStuckWidths.cx = RECTWIDTH(*prc);
|
|
|
|
//
|
|
// we only present a horizontal or vertical size to the end user
|
|
// so update the StuckRect on the other side of the screen to match
|
|
//
|
|
_GetStuckDisplayRect(uPlace, &rcDisplay);
|
|
|
|
uPlace += 2;
|
|
uPlace %= 4;
|
|
prc = &_arStuckRects[uPlace];
|
|
|
|
_MakeStuckRect(prc, &rcDisplay, _sStuckWidths, uPlace);
|
|
}
|
|
|
|
|
|
// Size the icon area to fill as much of the tray window as it can.
|
|
|
|
void CTray::SizeWindows()
|
|
{
|
|
RECT rcView, rcNotify, rcClient;
|
|
int fHiding;
|
|
|
|
if (!_hwndRebar || !_hwnd || !_hwndNotify)
|
|
return;
|
|
|
|
fHiding = (_uAutoHide & AH_HIDING);
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(FALSE);
|
|
}
|
|
|
|
// remember our current size
|
|
_SnapshotStuckRectSize(_uStuckPlace);
|
|
|
|
GetClientRect(_hwnd, &rcClient);
|
|
_AlignStartButton();
|
|
|
|
_GetWindowSizes(_uStuckPlace, &rcClient, &rcView, &rcNotify);
|
|
|
|
InvalidateRect(_hwndStart, NULL, TRUE);
|
|
InvalidateRect(_hwnd, NULL, TRUE);
|
|
|
|
// position the view
|
|
SetWindowPos(_hwndRebar, NULL, rcView.left, rcView.top,
|
|
RECTWIDTH(rcView), RECTHEIGHT(rcView),
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS);
|
|
UpdateWindow(_hwndRebar);
|
|
|
|
// And the clock
|
|
SetWindowPos(_hwndNotify, NULL, rcNotify.left, rcNotify.top,
|
|
RECTWIDTH(rcNotify), RECTHEIGHT(rcNotify),
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS);
|
|
|
|
{
|
|
TOOLINFO ti;
|
|
HWND hwndClock = _GetClockWindow();
|
|
|
|
ti.cbSize = sizeof(ti);
|
|
ti.uFlags = 0;
|
|
ti.hwnd = _hwnd;
|
|
ti.lpszText = LPSTR_TEXTCALLBACK;
|
|
ti.uId = (UINT_PTR)hwndClock;
|
|
GetWindowRect(hwndClock, &ti.rect);
|
|
MapWindowPoints(HWND_DESKTOP, _hwnd, (LPPOINT)&ti.rect, 2);
|
|
SendMessage(_hwndTrayTips, TTM_NEWTOOLRECT, 0, (LPARAM)((LPTOOLINFO)&ti));
|
|
}
|
|
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
void CTray::_HandleSize()
|
|
{
|
|
//
|
|
// if somehow we got minimized go ahead and un-minimize
|
|
//
|
|
if (((GetWindowLong(_hwnd, GWL_STYLE)) & WS_MINIMIZE))
|
|
{
|
|
ASSERT(FALSE);
|
|
ShowWindow(_hwnd, SW_RESTORE);
|
|
}
|
|
|
|
//
|
|
// if we are in the move/size loop and are visible then
|
|
// re-snap the current stuck rect to the new window size
|
|
//
|
|
#ifdef DEBUG
|
|
if (_fSysSizing && (_uAutoHide & AH_HIDING)) {
|
|
TraceMsg(DM_TRACE, "fSysSize && hiding");
|
|
ASSERT(0);
|
|
}
|
|
#endif
|
|
if (_fSysSizing &&
|
|
((_uAutoHide & (AH_ON | AH_HIDING)) != (AH_ON | AH_HIDING)))
|
|
{
|
|
_uStuckPlace = _RecalcStuckPos(NULL);
|
|
_UpdateVertical(_uStuckPlace);
|
|
}
|
|
|
|
//
|
|
// if we are in fulldrag or we are not in the middle of a move/size then
|
|
// we should resize all our child windows to reflect our new size
|
|
//
|
|
if (g_fDragFullWindows || !_fSysSizing)
|
|
SizeWindows();
|
|
|
|
//
|
|
// if we are just plain resized and we are visible we may need re-dock
|
|
//
|
|
if (!_fSysSizing && !_fSelfSizing && IsWindowVisible(_hwnd))
|
|
{
|
|
if (_uAutoHide & AH_ON)
|
|
{
|
|
UINT uPlace = _uStuckPlace;
|
|
HWND hwndOther =_AppBarGetAutoHideBar(uPlace);
|
|
|
|
//
|
|
// we sometimes defer checking for this until after a move
|
|
// so as to avoid interrupting a full-window-drag in progress
|
|
// if there is a different autohide window in our slot then whimper
|
|
//
|
|
if (hwndOther?
|
|
(hwndOther != _hwnd) :
|
|
!_AppBarSetAutoHideBar2(_hwnd, TRUE, uPlace))
|
|
{
|
|
_AutoHideCollision();
|
|
}
|
|
}
|
|
|
|
_StuckTrayChange();
|
|
|
|
//
|
|
// make sure we clip to tray to the current monitor (if necessary)
|
|
//
|
|
_ClipWindow(TRUE);
|
|
}
|
|
|
|
if (_hwndStartBalloon)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(_hwndStart, &rc);
|
|
SendMessage(_hwndStartBalloon, TTM_TRACKPOSITION, 0, MAKELONG((rc.left + rc.right)/2, rc.top));
|
|
SetWindowZorder(_hwndStartBalloon, HWND_TOPMOST);
|
|
}
|
|
}
|
|
|
|
BOOL _IsSliverHeight(int cy)
|
|
{
|
|
//
|
|
// Is this height clearly bigger than the pure-border height that you
|
|
// get when you resize the taskbar as small as it will go?
|
|
//
|
|
return (cy < (3 * (g_cyDlgFrame + g_cyBorder)));
|
|
}
|
|
|
|
BOOL CTray::_HandleSizing(WPARAM code, LPRECT lprc, UINT uStuckPlace)
|
|
{
|
|
BOOL fChangedSize = FALSE;
|
|
RECT rcDisplay;
|
|
SIZE sNewWidths;
|
|
RECT rcTemp;
|
|
BOOL fHiding;
|
|
|
|
if (!lprc)
|
|
{
|
|
rcTemp = _arStuckRects[uStuckPlace];
|
|
lprc = &rcTemp;
|
|
}
|
|
|
|
fHiding = (_uAutoHide & AH_HIDING);
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(FALSE);
|
|
}
|
|
|
|
//
|
|
// get the a bunch of relevant dimensions
|
|
//
|
|
// (dli) need to change this funciton or get rid of it
|
|
_GetDisplayRectFromRect(&rcDisplay, lprc, MONITOR_DEFAULTTONEAREST);
|
|
|
|
if (code)
|
|
{
|
|
// if code != 0, this is the user sizing.
|
|
// make sure they clip it to the screen.
|
|
RECT rcMax = rcDisplay;
|
|
if (!_hTheme)
|
|
{
|
|
InflateRect(&rcMax, g_cxEdge, g_cyEdge);
|
|
}
|
|
// don't do intersect rect because of sizing up from the bottom
|
|
// (when taskbar docked on bottom) confuses people
|
|
switch (uStuckPlace)
|
|
{
|
|
case STICK_LEFT:
|
|
lprc->left = rcMax.left;
|
|
break;
|
|
|
|
case STICK_TOP:
|
|
lprc->top = rcMax.top;
|
|
break;
|
|
|
|
case STICK_RIGHT:
|
|
lprc->right = rcMax.right;
|
|
break;
|
|
|
|
case STICK_BOTTOM:
|
|
lprc->top += (rcMax.bottom-lprc->bottom);
|
|
lprc->bottom = rcMax.bottom;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// compute the new widths
|
|
// don't let either be more than half the screen
|
|
//
|
|
sNewWidths.cx = min(RECTWIDTH(*lprc), RECTWIDTH(rcDisplay) / 2);
|
|
sNewWidths.cy = min(RECTHEIGHT(*lprc), RECTHEIGHT(rcDisplay) / 2);
|
|
|
|
if (_hTheme && (_fCanSizeMove || _fShowSizingBarAlways))
|
|
{
|
|
sNewWidths.cy = max(_sizeSizingBar.cy, sNewWidths.cy);
|
|
}
|
|
|
|
//
|
|
// compute an initial size
|
|
//
|
|
_MakeStuckRect(lprc, &rcDisplay, sNewWidths, uStuckPlace);
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hs starting rect is {%d, %d, %d, %d}"), lprc->left, lprc->top, lprc->right, lprc->bottom);
|
|
|
|
//
|
|
// negotiate the exact size with our children
|
|
//
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hs tray is being calculated for %s"), STUCK_HORIZONTAL(uStuckPlace) ? TEXT("HORIZONTAL") : TEXT("VERTICAL"));
|
|
|
|
_UpdateVertical(uStuckPlace);
|
|
if (_ptbs && _fBandSiteInitialized)
|
|
{
|
|
IDeskBarClient* pdbc;
|
|
if (SUCCEEDED(_ptbs->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pdbc))))
|
|
{
|
|
RECT rcClient = *lprc;
|
|
RECT rcOldClient = _arStuckRects[uStuckPlace];
|
|
|
|
// Go from a Window Rect to Client Rect
|
|
if (_hTheme && (_fCanSizeMove || _fShowSizingBarAlways))
|
|
{
|
|
_AdjustRectForSizingBar(uStuckPlace, &rcClient, -1);
|
|
_AdjustRectForSizingBar(uStuckPlace, &rcOldClient, -1);
|
|
}
|
|
else if (!_hTheme)
|
|
{
|
|
InflateRect(&rcClient, -g_cxFrame, -g_cyFrame);
|
|
InflateRect(&rcOldClient, -g_cxFrame, -g_cyFrame);
|
|
}
|
|
// Make rcClient start at 0,0, Rebar only used the right and bottom values of this rect
|
|
OffsetRect(&rcClient, -rcClient.left, -rcClient.top);
|
|
OffsetRect(&rcOldClient, -rcOldClient.left, -rcOldClient.top);
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hs starting client rect is {%d, %d, %d, %d}"), rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
|
|
|
|
RECT rcNotify;
|
|
RECT rcView;
|
|
RECT rcOldView;
|
|
// Go from the taskbar's client rect to the rebar's client rect
|
|
_GetWindowSizes(uStuckPlace, &rcClient, &rcView, &rcNotify);
|
|
_GetWindowSizes(uStuckPlace, &rcOldClient, &rcOldView, &rcNotify);
|
|
// Make rcView start at 0,0, Rebar only used the right and bottom values of this rect
|
|
OffsetRect(&rcView, -rcView.left, -rcView.top);
|
|
OffsetRect(&rcOldView, -rcOldView.left, -rcOldView.top);
|
|
if (!_fCanSizeMove || (RECTHEIGHT(rcView) && RECTWIDTH(rcView)))
|
|
{
|
|
// This following function will cause a WINDOWPOSCHAGING which will call DoneMoving
|
|
// DoneMoving will then go a screw up all of the window sizing
|
|
_fIgnoreDoneMoving = TRUE;
|
|
pdbc->GetSize(DBC_GS_SIZEDOWN, &rcView);
|
|
_fIgnoreDoneMoving = FALSE;
|
|
}
|
|
|
|
// Go from a Client Rect to Window Rect
|
|
if (STUCK_HORIZONTAL(uStuckPlace))
|
|
{
|
|
rcClient.top = rcView.top;
|
|
rcClient.bottom = rcView.bottom;
|
|
}
|
|
else
|
|
{
|
|
rcClient.left = rcView.left;
|
|
rcClient.right = rcView.right;
|
|
}
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hs ending client rect is {%d, %d, %d, %d}"), rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
|
|
if (_hTheme && (_fCanSizeMove || _fShowSizingBarAlways))
|
|
{
|
|
_AdjustRectForSizingBar(uStuckPlace, &rcClient, 1);
|
|
_AdjustRectForSizingBar(uStuckPlace, &rcOldClient, 1);
|
|
}
|
|
else if (!_hTheme)
|
|
{
|
|
InflateRect(&rcClient, g_cxFrame, g_cyFrame);
|
|
InflateRect(&rcOldClient, g_cxFrame, g_cyFrame);
|
|
}
|
|
|
|
// Prevent huge growth of taskbar, caused by bugs in the rebar sizing code
|
|
if (RECTHEIGHT(rcView) && RECTHEIGHT(rcOldView) && (RECTHEIGHT(rcClient) > (3 * RECTHEIGHT(rcOldClient))))
|
|
{
|
|
rcClient = rcOldClient;
|
|
}
|
|
|
|
if (STUCK_HORIZONTAL(uStuckPlace) && sNewWidths.cy != RECTHEIGHT(rcClient))
|
|
{
|
|
sNewWidths.cy = RECTHEIGHT(rcClient);
|
|
fChangedSize = TRUE;
|
|
}
|
|
if (!STUCK_HORIZONTAL(uStuckPlace) && sNewWidths.cx != RECTWIDTH(rcClient))
|
|
{
|
|
sNewWidths.cx = RECTWIDTH(rcClient);
|
|
fChangedSize = TRUE;
|
|
}
|
|
|
|
pdbc->Release();
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// was there a change?
|
|
//
|
|
if (fChangedSize)
|
|
{
|
|
//
|
|
// yes, update the final rectangle
|
|
//
|
|
_MakeStuckRect(lprc, &rcDisplay, sNewWidths, uStuckPlace);
|
|
}
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hs final rect is {%d, %d, %d, %d}"), lprc->left, lprc->top, lprc->right, lprc->bottom);
|
|
|
|
//
|
|
// store the new size in the appropriate StuckRect
|
|
//
|
|
_arStuckRects[uStuckPlace] = *lprc;
|
|
|
|
if (fHiding)
|
|
{
|
|
InvisibleUnhide(TRUE);
|
|
}
|
|
|
|
if (_hwndStartBalloon)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(_hwndStart, &rc);
|
|
SendMessage(_hwndStartBalloon, TTM_TRACKPOSITION, 0, MAKELONG((rc.left + rc.right)/2, rc.top));
|
|
SetWindowZorder(_hwndStartBalloon, HWND_TOPMOST);
|
|
}
|
|
|
|
return fChangedSize;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------
|
|
** the screen size changed, and we need to adjust some stuff, mostly
|
|
** globals. if the tray was docked, it needs to be resized, too.
|
|
**
|
|
** TRICKINESS: the handling of WM_WINDOWPOSCHANGING is used to
|
|
** actually do all the real sizing work. this saves a bit of
|
|
** extra code here.
|
|
**-------------------------------------------------------------------*/
|
|
|
|
BOOL WINAPI CTray::MonitorEnumProc(HMONITOR hMonitor, HDC hdc, LPRECT lprc, LPARAM lData)
|
|
{
|
|
CTray* ptray = (CTray*)lData;
|
|
|
|
RECT rcWork;
|
|
int iRet = ptray->_RecomputeWorkArea(NULL, hMonitor, &rcWork);
|
|
|
|
if (iRet == RWA_CHANGED)
|
|
{
|
|
// only send SENDWININICHANGE if the desktop has been created (otherwise
|
|
// we will hang the explorer because the main thread is currently blocked)
|
|
|
|
// PERF FEATURE: it will be nice to send WININICHANGE only once, but we can't
|
|
// because each time the rcWork is different, and there is no way to do it all
|
|
SystemParametersInfo(SPI_SETWORKAREA, TRUE, &rcWork, v_hwndDesktop ? SPIF_SENDWININICHANGE : 0);
|
|
RedrawDesktop(&rcWork);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::_RecomputeAllWorkareas()
|
|
{
|
|
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)this);
|
|
}
|
|
|
|
void CTray::_ScreenSizeChange(HWND hwnd)
|
|
{
|
|
// Set our new HMONITOR in case there is some change
|
|
{
|
|
MONITORINFO mi = {0};
|
|
mi.cbSize = sizeof(mi);
|
|
|
|
// Is our old HMONITOR still valid?
|
|
// NOTE: This test is used to tell whether somethings happened to the
|
|
// HMONITOR's or just the screen size changed
|
|
if (!GetMonitorInfo(_hmonStuck, &mi))
|
|
{
|
|
// No, this means the HMONITORS changed, our monitor might have gone away
|
|
_SetStuckMonitor();
|
|
_fIsLogoff = FALSE;
|
|
_RecomputeAllWorkareas();
|
|
}
|
|
}
|
|
|
|
// screen size changed, so we need to adjust globals
|
|
g_cxPrimaryDisplay = GetSystemMetrics(SM_CXSCREEN);
|
|
g_cyPrimaryDisplay = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
_ResizeStuckRects(_arStuckRects);
|
|
|
|
if (hwnd)
|
|
{
|
|
//
|
|
// set a bogus windowpos and actually repaint with the right
|
|
// shape/size in handling the WINDOWPOSCHANGING message
|
|
//
|
|
SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
SizeWindows();
|
|
|
|
RECT rc = _arStuckRects[_uStuckPlace];
|
|
_HandleSizing(0, &rc, _uStuckPlace);
|
|
// In the multi-monitor case, we need to turn on clipping for the dynamic
|
|
// monitor changes i.e. when the user add monitors or remove them from the
|
|
// control panel.
|
|
_ClipWindow(TRUE);
|
|
}
|
|
|
|
BOOL CTray::_UpdateAlwaysOnTop(BOOL fAlwaysOnTop)
|
|
{
|
|
BOOL fChanged = ((_fAlwaysOnTop == 0) != (fAlwaysOnTop == 0));
|
|
//
|
|
// The user clicked on the AlwaysOnTop menu item, we should now toggle
|
|
// the state and update the window accordingly...
|
|
//
|
|
_fAlwaysOnTop = fAlwaysOnTop;
|
|
_ResetZorder();
|
|
|
|
// Make sure the screen limits are update to the new state.
|
|
_StuckTrayChange();
|
|
return fChanged;
|
|
}
|
|
|
|
|
|
|
|
void CTray::_SaveTrayAndDesktop(void)
|
|
{
|
|
_SaveTray();
|
|
|
|
if (v_hwndDesktop)
|
|
SendMessage(v_hwndDesktop, DTM_SAVESTATE, 0, 0);
|
|
|
|
if (_hwndNotify)
|
|
SendMessage(_hwndNotify, TNM_SAVESTATE, 0, 0);
|
|
}
|
|
|
|
void CTray::_SlideStep(HWND hwnd, const RECT *prcMonitor, const RECT *prcOld, const RECT *prcNew)
|
|
{
|
|
SIZE sizeOld = {prcOld->right - prcOld->left, prcOld->bottom - prcOld->top};
|
|
SIZE sizeNew = {prcNew->right - prcNew->left, prcNew->bottom - prcNew->top};
|
|
BOOL fClipFirst = FALSE;
|
|
UINT flags;
|
|
|
|
DAD_ShowDragImage(FALSE); // Make sure this is off - client function must turn back on!!!
|
|
if (prcMonitor)
|
|
{
|
|
RECT rcClip, rcClipSafe, rcClipTest;
|
|
|
|
_CalcClipCoords(&rcClip, prcMonitor, prcNew);
|
|
|
|
rcClipTest = rcClip;
|
|
|
|
OffsetRect(&rcClipTest, prcOld->left, prcOld->top);
|
|
IntersectRect(&rcClipSafe, &rcClipTest, prcMonitor);
|
|
|
|
fClipFirst = EqualRect(&rcClipTest, &rcClipSafe);
|
|
|
|
if (fClipFirst)
|
|
_ClipInternal(&rcClip);
|
|
}
|
|
|
|
flags = SWP_NOZORDER|SWP_NOACTIVATE;
|
|
if ((sizeOld.cx == sizeNew.cx) && (sizeOld.cy == sizeNew.cy))
|
|
flags |= SWP_NOSIZE;
|
|
|
|
SetWindowPos(hwnd, NULL,
|
|
prcNew->left, prcNew->top, sizeNew.cx, sizeNew.cy, flags);
|
|
|
|
if (prcMonitor && !fClipFirst)
|
|
{
|
|
RECT rcClip;
|
|
|
|
_CalcClipCoords(&rcClip, prcMonitor, prcNew);
|
|
_ClipInternal(&rcClip);
|
|
}
|
|
}
|
|
|
|
void CTray::_SlideWindow(HWND hwnd, RECT *prc, BOOL fShow)
|
|
{
|
|
RECT rcLast;
|
|
RECT rcMonitor;
|
|
const RECT *prcMonitor;
|
|
DWORD dt;
|
|
BOOL fAnimate;
|
|
|
|
if (!IsWindowVisible(hwnd))
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sw window is hidden, just moving"));
|
|
MoveWindow(_hwnd, prc->left, prc->top, RECTWIDTH(*prc), RECTHEIGHT(*prc), FALSE);
|
|
return;
|
|
}
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sw -----------------BEGIN-----------------"));
|
|
|
|
if (GetSystemMetrics(SM_CMONITORS) > 1)
|
|
{
|
|
_GetStuckDisplayRect(_uStuckPlace, &rcMonitor);
|
|
prcMonitor = &rcMonitor;
|
|
}
|
|
else
|
|
prcMonitor = NULL;
|
|
|
|
GetWindowRect(hwnd, &rcLast);
|
|
|
|
dt = fShow? _dtSlideShow : _dtSlideHide;
|
|
|
|
// See if we can use animation effects.
|
|
SystemParametersInfo(SPI_GETMENUANIMATION, 0, &fAnimate, 0);
|
|
|
|
if (g_fDragFullWindows && fAnimate && (dt > 0))
|
|
{
|
|
RECT rcOld, rcNew, rcMove;
|
|
int dx, dy, priority;
|
|
DWORD t, t2, t0;
|
|
HANDLE me;
|
|
|
|
rcOld = rcLast;
|
|
rcNew = *prc;
|
|
|
|
dx = ((rcNew.left + rcNew.right) - (rcOld.left + rcOld.right)) / 2;
|
|
dy = ((rcNew.top + rcNew.bottom) - (rcOld.top + rcOld.bottom)) / 2;
|
|
ASSERT(dx == 0 || dy == 0);
|
|
|
|
me = GetCurrentThread();
|
|
priority = GetThreadPriority(me);
|
|
SetThreadPriority(me, THREAD_PRIORITY_HIGHEST);
|
|
|
|
t2 = t0 = GetTickCount();
|
|
|
|
rcMove = rcOld;
|
|
while ((t = GetTickCount()) - t0 < dt)
|
|
{
|
|
int dtdiff;
|
|
if (t != t2)
|
|
{
|
|
rcMove.right -= rcMove.left;
|
|
rcMove.left = rcOld.left + (dx) * (t - t0) / dt;
|
|
rcMove.right += rcMove.left;
|
|
|
|
rcMove.bottom -= rcMove.top;
|
|
rcMove.top = rcOld.top + (dy) * (t - t0) / dt;
|
|
rcMove.bottom += rcMove.top;
|
|
|
|
_SlideStep(hwnd, prcMonitor, &rcLast, &rcMove);
|
|
|
|
if (fShow)
|
|
UpdateWindow(hwnd);
|
|
|
|
rcLast = rcMove;
|
|
t2 = t;
|
|
}
|
|
|
|
// don't draw frames faster than user can see, e.g. 20ms
|
|
#define ONEFRAME 20
|
|
dtdiff = GetTickCount();
|
|
if ((dtdiff - t) < ONEFRAME)
|
|
Sleep(ONEFRAME - (dtdiff - t));
|
|
|
|
// try to give desktop a chance to update
|
|
// only do it on hide because desktop doesn't need to paint on taskbar show
|
|
if (!fShow)
|
|
{
|
|
DWORD_PTR lres;
|
|
SendMessageTimeout(v_hwndDesktop, DTM_UPDATENOW, 0, 0, SMTO_ABORTIFHUNG, 50, &lres);
|
|
}
|
|
}
|
|
|
|
SetThreadPriority(me, priority);
|
|
}
|
|
|
|
_SlideStep(hwnd, prcMonitor, &rcLast, prc);
|
|
|
|
if (fShow)
|
|
UpdateWindow(hwnd);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sw ------------------END------------------"));
|
|
}
|
|
|
|
void CTray::_UnhideNow()
|
|
{
|
|
if (_uModalMode == MM_SHUTDOWN)
|
|
return;
|
|
|
|
_fSelfSizing = TRUE;
|
|
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
|
|
_SlideWindow(_hwnd, &_arStuckRects[_uStuckPlace], _dtSlideShow);
|
|
DAD_ShowDragImage(TRUE); // restore the lock state.
|
|
_fSelfSizing = FALSE;
|
|
|
|
SendMessage(_hwndNotify, TNM_TRAYHIDE, 0, FALSE);
|
|
}
|
|
|
|
void CTray::_ComputeHiddenRect(LPRECT prc, UINT uStuck)
|
|
{
|
|
int dwh;
|
|
HMONITOR hMon;
|
|
RECT rcMon;
|
|
|
|
hMon = MonitorFromRect(prc, MONITOR_DEFAULTTONULL);
|
|
if (!hMon)
|
|
return;
|
|
GetMonitorRect(hMon, &rcMon);
|
|
|
|
if (STUCK_HORIZONTAL(uStuck))
|
|
dwh = prc->bottom - prc->top;
|
|
else
|
|
dwh = prc->right - prc->left;
|
|
|
|
switch (uStuck)
|
|
{
|
|
case STICK_LEFT:
|
|
prc->right = rcMon.left + (g_cxFrame / 2);
|
|
prc->left = prc->right - dwh;
|
|
break;
|
|
|
|
case STICK_RIGHT:
|
|
prc->left = rcMon.right - (g_cxFrame / 2);
|
|
prc->right = prc->left + dwh;
|
|
break;
|
|
|
|
case STICK_TOP:
|
|
prc->bottom = rcMon.top + (g_cyFrame / 2);
|
|
prc->top = prc->bottom - dwh;
|
|
break;
|
|
|
|
case STICK_BOTTOM:
|
|
prc->top = rcMon.bottom - (g_cyFrame / 2);
|
|
prc->bottom = prc->top + dwh;
|
|
break;
|
|
}
|
|
}
|
|
|
|
UINT CTray::_GetDockedRect(LPRECT prc, BOOL fMoving)
|
|
{
|
|
UINT uPos;
|
|
|
|
if (fMoving && (_uMoveStuckPlace != (UINT)-1))
|
|
uPos = _uMoveStuckPlace;
|
|
else
|
|
uPos = _uStuckPlace;
|
|
|
|
*prc = _arStuckRects[uPos];
|
|
|
|
if ((_uAutoHide & (AH_ON | AH_HIDING)) == (AH_ON | AH_HIDING))
|
|
{
|
|
_ComputeHiddenRect(prc, uPos);
|
|
}
|
|
|
|
return uPos;
|
|
}
|
|
|
|
void CTray::_CalcClipCoords(RECT *prcClip, const RECT *prcMonitor, const RECT *prcNew)
|
|
{
|
|
RECT rcMonitor;
|
|
RECT rcWindow;
|
|
|
|
if (!prcMonitor)
|
|
{
|
|
_GetStuckDisplayRect(_uStuckPlace, &rcMonitor);
|
|
prcMonitor = &rcMonitor;
|
|
}
|
|
|
|
if (!prcNew)
|
|
{
|
|
GetWindowRect(_hwnd, &rcWindow);
|
|
prcNew = &rcWindow;
|
|
}
|
|
|
|
IntersectRect(prcClip, prcMonitor, prcNew);
|
|
OffsetRect(prcClip, -prcNew->left, -prcNew->top);
|
|
}
|
|
|
|
void CTray::_ClipInternal(const RECT *prcClip)
|
|
{
|
|
HRGN hrgnClip;
|
|
|
|
// don't worry about clipping if there's only one monitor
|
|
if (GetSystemMetrics(SM_CMONITORS) <= 1)
|
|
prcClip = NULL;
|
|
|
|
if (prcClip)
|
|
{
|
|
_fMonitorClipped = TRUE;
|
|
hrgnClip = CreateRectRgnIndirect(prcClip);
|
|
}
|
|
else
|
|
{
|
|
// SetWindowRgn is expensive, skip ones that are NOPs
|
|
if (!_fMonitorClipped)
|
|
return;
|
|
|
|
_fMonitorClipped = FALSE;
|
|
hrgnClip = NULL;
|
|
}
|
|
|
|
SetWindowRgn(_hwnd, hrgnClip, TRUE);
|
|
}
|
|
|
|
void CTray::_ClipWindow(BOOL fClipState)
|
|
{
|
|
RECT rcClip;
|
|
RECT *prcClip;
|
|
|
|
if (_fSelfSizing || _fSysSizing)
|
|
{
|
|
TraceMsg(TF_WARNING, "_ClipWindow: _fSelfSizing %x, _fSysSizing %x", _fSelfSizing, _fSysSizing);
|
|
return;
|
|
}
|
|
|
|
if ((GetSystemMetrics(SM_CMONITORS) <= 1) || _hTheme)
|
|
fClipState = FALSE;
|
|
|
|
if (fClipState)
|
|
{
|
|
prcClip = &rcClip;
|
|
_CalcClipCoords(prcClip, NULL, NULL);
|
|
}
|
|
else
|
|
prcClip = NULL;
|
|
|
|
_ClipInternal(prcClip);
|
|
}
|
|
|
|
void CTray::_Hide()
|
|
{
|
|
RECT rcNew;
|
|
|
|
// if we're in shutdown or if we're on boot up
|
|
// don't hide
|
|
if (_uModalMode == MM_SHUTDOWN)
|
|
{
|
|
TraceMsg(TF_TRAY, "e.th: suppress hide (shutdown || Notify)");
|
|
return;
|
|
}
|
|
|
|
KillTimer(_hwnd, IDT_AUTOHIDE);
|
|
|
|
_fSelfSizing = TRUE;
|
|
|
|
//
|
|
// update the flags here to prevent race conditions
|
|
//
|
|
_uAutoHide = AH_ON | AH_HIDING;
|
|
_GetDockedRect(&rcNew, FALSE);
|
|
|
|
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
|
|
_SlideWindow(_hwnd, &rcNew, _dtSlideHide);
|
|
DAD_ShowDragImage(FALSE); // Another thread could have locked while we were gone
|
|
DAD_ShowDragImage(TRUE); // restore the lock state.
|
|
|
|
SendMessage(_hwndNotify, TNM_TRAYHIDE, 0, TRUE);
|
|
|
|
_fSelfSizing = FALSE;
|
|
}
|
|
|
|
void CTray::_AutoHideCollision()
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_ahc COLLISION! (posting UI request)"));
|
|
|
|
PostMessage(_hwnd, TM_WARNNOAUTOHIDE, ((_uAutoHide & AH_ON) != 0),
|
|
0L);
|
|
}
|
|
|
|
LONG CTray::_SetAutoHideState(BOOL fAutoHide)
|
|
{
|
|
//
|
|
// make sure we have something to do
|
|
//
|
|
if ((fAutoHide != 0) == ((_uAutoHide & AH_ON) != 0))
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.sahs nothing to do"));
|
|
return MAKELONG(FALSE, TRUE);
|
|
}
|
|
|
|
//
|
|
// make sure we can do it
|
|
//
|
|
if (!_AppBarSetAutoHideBar2(_hwnd, fAutoHide, _uStuckPlace))
|
|
{
|
|
_AutoHideCollision();
|
|
return MAKELONG(FALSE, FALSE);
|
|
}
|
|
|
|
//
|
|
// do it
|
|
//
|
|
if (fAutoHide)
|
|
{
|
|
_uAutoHide = AH_ON;
|
|
_RefreshSettings();
|
|
_Hide();
|
|
#ifdef DEBUG
|
|
// _Hide updates the flags for us (sanity)
|
|
if (!(_uAutoHide & AH_ON))
|
|
{
|
|
TraceMsg(DM_WARNING, "e.sahs: !AH_ON"); // ok to fail on boot/shutdown
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
_uAutoHide = 0;
|
|
KillTimer(_hwnd, IDT_AUTOHIDE);
|
|
_UnhideNow();
|
|
_RefreshSettings();
|
|
}
|
|
|
|
//
|
|
// brag about it
|
|
//
|
|
_StuckTrayChange();
|
|
return MAKELONG(TRUE, TRUE);
|
|
}
|
|
|
|
void CTray::_HandleEnterMenuLoop()
|
|
{
|
|
// kill the timer when we're in the menu loop so that we don't
|
|
// pop done while browsing the menus.
|
|
if (_uAutoHide & AH_ON)
|
|
{
|
|
KillTimer(_hwnd, IDT_AUTOHIDE);
|
|
}
|
|
}
|
|
|
|
void CTray::_SetAutoHideTimer()
|
|
{
|
|
if (_uAutoHide & AH_ON)
|
|
{
|
|
SetTimer(_hwnd, IDT_AUTOHIDE, 500, NULL);
|
|
}
|
|
}
|
|
|
|
void CTray::_HandleExitMenuLoop()
|
|
{
|
|
// when we leave the menu stuff, start checking again.
|
|
_SetAutoHideTimer();
|
|
}
|
|
|
|
void CTray::Unhide()
|
|
{
|
|
// handle autohide
|
|
if ((_uAutoHide & AH_ON) &&
|
|
(_uAutoHide & AH_HIDING))
|
|
{
|
|
_UnhideNow();
|
|
_uAutoHide &= ~AH_HIDING;
|
|
_SetAutoHideTimer();
|
|
|
|
if (_fShouldResize)
|
|
{
|
|
ASSERT(0);
|
|
ASSERT(!(_uAutoHide & AH_HIDING));
|
|
SizeWindows();
|
|
_fShouldResize = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_SetUnhideTimer(LONG x, LONG y)
|
|
{
|
|
// handle autohide
|
|
if ((_uAutoHide & AH_ON) &&
|
|
(_uAutoHide & AH_HIDING))
|
|
{
|
|
LONG dx = x-_ptLastHittest.x;
|
|
LONG dy = y-_ptLastHittest.y;
|
|
LONG rr = dx*dx + dy*dy;
|
|
LONG dd = GetSystemMetrics(SM_CXDOUBLECLK) * GetSystemMetrics(SM_CYDOUBLECLK);
|
|
|
|
if (rr > dd)
|
|
{
|
|
SetTimer(_hwnd, IDT_AUTOUNHIDE, 50, NULL);
|
|
_ptLastHittest.x = x;
|
|
_ptLastHittest.y = y;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_StartButtonReset()
|
|
{
|
|
// Get an idea about how big we need everyhting to be.
|
|
TCHAR szStart[50];
|
|
LoadString(hinstCabinet, _hTheme ? IDS_START : IDS_STARTCLASSIC, szStart, ARRAYSIZE(szStart));
|
|
SetWindowText(_hwndStart, szStart);
|
|
|
|
if (_hFontStart)
|
|
DeleteObject(_hFontStart);
|
|
|
|
_hFontStart = _CreateStartFont(_hwndStart);
|
|
|
|
int idbStart = IDB_START16;
|
|
|
|
HDC hdc = GetDC(NULL);
|
|
if (hdc)
|
|
{
|
|
int bpp = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
|
|
if (bpp > 8)
|
|
{
|
|
idbStart = _hTheme ? IDB_START : IDB_STARTCLASSIC;
|
|
}
|
|
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
HBITMAP hbmFlag = (HBITMAP)LoadImage(hinstCabinet, MAKEINTRESOURCE(idbStart), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
|
|
if (hbmFlag)
|
|
{
|
|
BITMAP bm;
|
|
if (GetObject(hbmFlag, sizeof(BITMAP), &bm))
|
|
{
|
|
BUTTON_IMAGELIST biml = {0};
|
|
if (_himlStartFlag)
|
|
ImageList_Destroy(_himlStartFlag);
|
|
|
|
|
|
DWORD dwFlags = ILC_COLOR32;
|
|
HBITMAP hbmFlagMask = NULL;
|
|
if (idbStart == IDB_START16)
|
|
{
|
|
dwFlags = ILC_COLOR8 | ILC_MASK;
|
|
hbmFlagMask = (HBITMAP)LoadImage(hinstCabinet, MAKEINTRESOURCE(IDB_START16MASK), IMAGE_BITMAP, 0, 0, LR_MONOCHROME);
|
|
}
|
|
|
|
if (IS_WINDOW_RTL_MIRRORED(_hwndStart))
|
|
{
|
|
dwFlags |= ILC_MIRROR;
|
|
}
|
|
biml.himl = _himlStartFlag = ImageList_Create(bm.bmWidth, bm.bmHeight, dwFlags, 1, 1);
|
|
ImageList_Add(_himlStartFlag, hbmFlag, hbmFlagMask);
|
|
biml.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
|
|
|
|
Button_SetImageList(_hwndStart, &biml);
|
|
}
|
|
DeleteObject(hbmFlag);
|
|
}
|
|
|
|
if (_hFontStart)
|
|
{
|
|
SendMessage(_hwndStart, WM_SETFONT, (WPARAM)_hFontStart, TRUE);
|
|
_sizeStart.cx = 0;
|
|
}
|
|
|
|
_AlignStartButton();
|
|
|
|
}
|
|
|
|
void CTray::_OnNewSystemSizes()
|
|
{
|
|
TraceMsg(TF_TRAY, "Handling win ini change.");
|
|
_StartButtonReset();
|
|
VerifySize(TRUE);
|
|
}
|
|
|
|
//*** CheckWindowPositions -- flag which windows actually changed
|
|
// ENTRY/EXIT
|
|
// _pPositions->hdsaWP[*]->fRestore modified
|
|
// NOTES
|
|
// in order to correctly implement 'Undo Minimize-all(Cascade/Tile)',
|
|
// we need to tell which windows were changed by the 'Do' operation.
|
|
// (nt5:183421: we used to restore *every* top-level window).
|
|
int WINAPI CTray::CheckWndPosEnumProc(void *pItem, void *pData)
|
|
{
|
|
HWNDANDPLACEMENT *pI2 = (HWNDANDPLACEMENT *)pItem;
|
|
WINDOWPLACEMENT wp;
|
|
|
|
wp.length = sizeof(wp);
|
|
pI2->fRestore = TRUE;
|
|
if (GetWindowPlacement(pI2->hwnd, &wp)) {
|
|
if (memcmp(&pI2->wp, &wp, sizeof(wp)) == 0)
|
|
pI2->fRestore = FALSE;
|
|
}
|
|
|
|
TraceMsg(TF_TRAY, "cwp: (hwnd=0x%x) fRestore=%d", pI2->hwnd, pI2->fRestore);
|
|
|
|
return 1; // 1:continue enum
|
|
}
|
|
|
|
void CTray::CheckWindowPositions()
|
|
{
|
|
ENTERCRITICAL; // i think this is needed...
|
|
if (_pPositions) {
|
|
if (_pPositions->hdsaWP) {
|
|
DSA_EnumCallback(_pPositions->hdsaWP, CheckWndPosEnumProc, NULL);
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL BandSite_PermitAutoHide(IUnknown* punk)
|
|
{
|
|
OLECMD cmd = { DBID_PERMITAUTOHIDE, 0 };
|
|
if (SUCCEEDED(IUnknown_QueryStatus(punk, &IID_IDockingWindow, 1, &cmd, NULL)))
|
|
{
|
|
return !(cmd.cmdf & OLECMDF_SUPPORTED) || (cmd.cmdf & OLECMDF_ENABLED);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::_HandleTimer(WPARAM wTimerID)
|
|
{
|
|
switch (wTimerID)
|
|
{
|
|
case IDT_CHECKDISKSPACE:
|
|
CheckDiskSpace();
|
|
break;
|
|
|
|
case IDT_DESKTOPCLEANUP:
|
|
_CheckDesktopCleanup();
|
|
break;
|
|
|
|
case IDT_CHANGENOTIFY:
|
|
// did somebody send another notify since we last handled one?
|
|
if (_fUseChangeNotifyTimer)
|
|
{
|
|
// yep.
|
|
// all we do is check the staging area.
|
|
CheckStagingArea();
|
|
|
|
// kill it off the next time.
|
|
_fUseChangeNotifyTimer = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// nope.
|
|
KillTimer(_hwnd, IDT_CHANGENOTIFY);
|
|
_fChangeNotifyTimerRunning = FALSE;
|
|
}
|
|
break;
|
|
|
|
case IDT_HANDLEDELAYBOOTSTUFF:
|
|
KillTimer(_hwnd, IDT_HANDLEDELAYBOOTSTUFF);
|
|
PostMessage(_hwnd, TM_HANDLEDELAYBOOTSTUFF, 0, 0);
|
|
break;
|
|
|
|
case IDT_STARTMENU:
|
|
SetForegroundWindow(_hwnd);
|
|
KillTimer(_hwnd, wTimerID);
|
|
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
|
|
SendMessage(_hwndStart, BM_SETSTATE, TRUE, 0);
|
|
UpdateWindow(_hwndStart);
|
|
DAD_ShowDragImage(TRUE); // restore the lock state.
|
|
break;
|
|
|
|
case IDT_SAVESETTINGS:
|
|
KillTimer(_hwnd, IDT_SAVESETTINGS);
|
|
_SaveTray();
|
|
break;
|
|
|
|
case IDT_ENABLEUNDO:
|
|
KillTimer(_hwnd, IDT_ENABLEUNDO);
|
|
CheckWindowPositions();
|
|
_fUndoEnabled = TRUE;
|
|
break;
|
|
|
|
case IDT_AUTOHIDE:
|
|
if (!_fSysSizing && (_uAutoHide & AH_ON))
|
|
{
|
|
POINT pt;
|
|
RECT rc;
|
|
|
|
// Don't hide if we're already hiding, a balloon tip is showing, or
|
|
// (on NT5) if any apps are flashing.
|
|
//
|
|
if (!(_uAutoHide & AH_HIDING) && BandSite_PermitAutoHide(_ptbs) && !_fBalloonUp)
|
|
{
|
|
// Get the cursor position.
|
|
GetCursorPos(&pt);
|
|
|
|
// Get the tray rect and inflate it a bit.
|
|
rc = _arStuckRects[_uStuckPlace];
|
|
InflateRect(&rc, g_cxEdge * 4, g_cyEdge*4);
|
|
|
|
// Don't hide if cursor is within inflated tray rect.
|
|
if (!PtInRect(&rc, pt))
|
|
{
|
|
// Don't hide if the tray is active
|
|
if (!_IsActive() && _uStartButtonState != SBSM_SPACTIVE)
|
|
{
|
|
// Don't hide if the view has a system menu up.
|
|
if (!SendMessage(_hwndTasks, TBC_SYSMENUCOUNT, 0, 0L))
|
|
{
|
|
// Phew! We made it. Hide the tray.
|
|
_Hide();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDT_AUTOUNHIDE:
|
|
if (!_fSysSizing && (_uAutoHide & AH_ON))
|
|
{
|
|
POINT pt;
|
|
RECT rc;
|
|
|
|
KillTimer(_hwnd, wTimerID);
|
|
_ptLastHittest.x = -0x0fff;
|
|
_ptLastHittest.y = -0x0fff;
|
|
GetWindowRect(_hwnd, &rc);
|
|
if (_uAutoHide & AH_HIDING)
|
|
{
|
|
GetCursorPos(&pt);
|
|
if (PtInRect(&rc, pt))
|
|
Unhide();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDT_STARTBUTTONBALLOON:
|
|
_DestroyStartButtonBalloon();
|
|
break;
|
|
|
|
case IDT_COFREEUNUSED:
|
|
CoFreeUnusedLibraries();
|
|
KillTimer(_hwnd, IDT_COFREEUNUSED);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void CTray::_CheckStagingAreaOnTimer()
|
|
{
|
|
if (_fChangeNotifyTimerRunning)
|
|
{
|
|
// we're already running the timer, so force a check the next time it comes up
|
|
_fUseChangeNotifyTimer = TRUE;
|
|
}
|
|
else
|
|
{
|
|
_fChangeNotifyTimerRunning = TRUE;
|
|
|
|
// check once immediately
|
|
CheckStagingArea();
|
|
|
|
// check again in half a minute, but only if notifies have been happening in the meantime.
|
|
SetTimer(_hwnd, IDT_CHANGENOTIFY, 30 * 1000, NULL);
|
|
}
|
|
}
|
|
|
|
void CTray::_HandleChangeNotify(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPITEMIDLIST *ppidl;
|
|
LONG lEvent;
|
|
LPSHChangeNotificationLock pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
|
|
if (pshcnl)
|
|
{
|
|
if (lEvent & SHCNE_STAGINGAREANOTIFICATIONS)
|
|
{
|
|
// something has changed within the staging area.
|
|
_CheckStagingAreaOnTimer();
|
|
}
|
|
SHChangeNotification_Unlock(pshcnl);
|
|
}
|
|
}
|
|
|
|
BOOL _ExecItemByPidls(HWND hwnd, LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
|
|
{
|
|
BOOL fRes = FALSE;
|
|
|
|
if (pidlFolder && pidlItem)
|
|
{
|
|
IShellFolder *psf = BindToFolder(pidlFolder);
|
|
if (psf)
|
|
{
|
|
fRes = SUCCEEDED(SHInvokeDefaultCommand(hwnd, psf, pidlItem));
|
|
}
|
|
else
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
SHGetPathFromIDList(pidlFolder, szPath);
|
|
ShellMessageBox(hinstCabinet, hwnd, MAKEINTRESOURCE(IDS_CANTFINDSPECIALDIR),
|
|
NULL, MB_ICONEXCLAMATION, szPath);
|
|
}
|
|
}
|
|
return fRes;
|
|
}
|
|
|
|
void _DestroySavedWindowPositions(LPWINDOWPOSITIONS pPositions);
|
|
|
|
LRESULT CTray::_HandleDestroy()
|
|
{
|
|
MINIMIZEDMETRICS mm;
|
|
|
|
TraceMsg(DM_SHUTDOWN, "_HD: enter");
|
|
|
|
mm.cbSize = sizeof(mm);
|
|
SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, sizeof(mm), &mm, FALSE);
|
|
mm.iArrange &= ~ARW_HIDE;
|
|
SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, sizeof(mm), &mm, FALSE);
|
|
|
|
_RevokeDropTargets();
|
|
_DestroyStartMenu();
|
|
Mixer_Shutdown();
|
|
|
|
// Tell the start menu to free all its cached darwin links
|
|
SHRegisterDarwinLink(NULL, NULL, TRUE);
|
|
|
|
_DestroySavedWindowPositions(_pPositions);
|
|
_pPositions = NULL;
|
|
|
|
if (_hTheme)
|
|
{
|
|
CloseThemeData(_hTheme);
|
|
_hTheme = NULL;
|
|
}
|
|
|
|
_UnregisterGlobalHotkeys();
|
|
|
|
if (_uNotify)
|
|
{
|
|
SHChangeNotifyDeregister(_uNotify);
|
|
_uNotify = 0;
|
|
}
|
|
|
|
ATOMICRELEASE(_ptbs);
|
|
ATOMICRELEASE(_pdbTasks);
|
|
_hwndTasks = NULL;
|
|
|
|
if (_hwndTrayTips)
|
|
{
|
|
DestroyWindow(_hwndTrayTips);
|
|
_hwndTrayTips = NULL;
|
|
}
|
|
|
|
_DestroyStartButtonBalloon();
|
|
|
|
// REVIEW
|
|
PostQuitMessage(0);
|
|
|
|
if (_hbmpStartBkg)
|
|
{
|
|
DeleteBitmap(_hbmpStartBkg);
|
|
}
|
|
|
|
if (_hFontStart)
|
|
{
|
|
DeleteObject(_hFontStart);
|
|
}
|
|
|
|
if (_himlStartFlag)
|
|
{
|
|
ImageList_Destroy(_himlStartFlag);
|
|
}
|
|
|
|
// clean up service objects
|
|
_ssomgr.Destroy();
|
|
|
|
if (_hShellReadyEvent)
|
|
{
|
|
ResetEvent(_hShellReadyEvent);
|
|
CloseHandle(_hShellReadyEvent);
|
|
_hShellReadyEvent = NULL;
|
|
}
|
|
|
|
if (_fHandledDelayBootStuff)
|
|
{
|
|
TBOOL(WinStationUnRegisterConsoleNotification(SERVERNAME_CURRENT, v_hwndTray));
|
|
}
|
|
|
|
DeleteCriticalSection(&_csHotkey);
|
|
|
|
// The order in which we shut down the HTTP key monitoring is important.
|
|
//
|
|
// We must close the key before closing the event handle because
|
|
// closing the key causes the event to be signalled and we don't
|
|
// want ADVAPI32 to try to signal an event after we closed its handle...
|
|
//
|
|
// To avoid a spurious trigger when the event fires, we unregister
|
|
// the wait before closing the key.
|
|
//
|
|
|
|
if (_hHTTPWait)
|
|
{
|
|
UnregisterWait(_hHTTPWait);
|
|
_hHTTPWait = NULL;
|
|
}
|
|
|
|
if (_hkHTTP)
|
|
{
|
|
RegCloseKey(_hkHTTP);
|
|
_hkHTTP = NULL;
|
|
}
|
|
|
|
if (_hHTTPEvent)
|
|
{
|
|
CloseHandle(_hHTTPEvent);
|
|
_hHTTPEvent = NULL;
|
|
}
|
|
|
|
// End of order-sensitive operations ----------------------------------
|
|
|
|
v_hwndTray = NULL;
|
|
_hwndStart = NULL;
|
|
|
|
|
|
TraceMsg(DM_SHUTDOWN, "_HD: leave");
|
|
return 0;
|
|
}
|
|
|
|
void CTray::_SetFocus(HWND hwnd)
|
|
{
|
|
IUnknown_UIActivateIO(_ptbs, FALSE, NULL);
|
|
SetFocus(hwnd);
|
|
}
|
|
|
|
#define TRIEDTOOMANYTIMES 100
|
|
|
|
void CTray::_ActAsSwitcher()
|
|
{
|
|
if (_uModalMode)
|
|
{
|
|
if (_uModalMode != MM_SHUTDOWN)
|
|
{
|
|
SwitchToThisWindow(GetLastActivePopup(_hwnd), TRUE);
|
|
}
|
|
MessageBeep(0);
|
|
}
|
|
else
|
|
{
|
|
HWND hwndForeground;
|
|
HWND hwndActive;
|
|
|
|
static int s_iRecurse = 0;
|
|
s_iRecurse++;
|
|
|
|
ASSERT(s_iRecurse < TRIEDTOOMANYTIMES);
|
|
TraceMsg(TF_TRAY, "s_iRecurse = %d", s_iRecurse);
|
|
|
|
hwndForeground = GetForegroundWindow();
|
|
hwndActive = GetActiveWindow();
|
|
BOOL fIsTrayActive = (hwndForeground == _hwnd) && (hwndActive == _hwnd);
|
|
if (v_hwndStartPane && hwndForeground == v_hwndStartPane && hwndActive == v_hwndStartPane)
|
|
{
|
|
fIsTrayActive = TRUE;
|
|
}
|
|
// only do the button once we're the foreground dude.
|
|
if (fIsTrayActive)
|
|
{
|
|
// This code path causes the start button to do something because
|
|
// of the keyboard. So reflect that with the focus rect.
|
|
SendMessage(_hwndStart, WM_UPDATEUISTATE, MAKEWPARAM(UIS_CLEAR,
|
|
UISF_HIDEFOCUS), 0);
|
|
|
|
if (SendMessage(_hwndStart, BM_GETSTATE, 0, 0) & BST_PUSHED)
|
|
{
|
|
ClosePopupMenus();
|
|
ForceStartButtonUp();
|
|
}
|
|
else
|
|
{
|
|
// This pushes the start button and causes the start menu to popup.
|
|
SendMessage(GetDlgItem(_hwnd, IDC_START), BM_SETSTATE, TRUE, 0);
|
|
}
|
|
s_iRecurse = 0;
|
|
}
|
|
else
|
|
{
|
|
// we don't want to loop endlessly trying to become
|
|
// foreground. With NT's new SetForegroundWindow rules, it would
|
|
// be pointless to try and hopefully we won't need to anyhow.
|
|
// Randomly, I picked a quarter as many times as the debug squirty would indicate
|
|
// as the number of times to try on NT.
|
|
// Hopefully that is enough on most machines.
|
|
if (s_iRecurse > (TRIEDTOOMANYTIMES / 4))
|
|
{
|
|
s_iRecurse = 0;
|
|
return;
|
|
}
|
|
// until then, try to come forward.
|
|
HandleFullScreenApp(NULL);
|
|
if (hwndForeground == v_hwndDesktop)
|
|
{
|
|
_SetFocus(_hwndStart);
|
|
if (GetFocus() != _hwndStart)
|
|
return;
|
|
}
|
|
|
|
SwitchToThisWindow(_hwnd, TRUE);
|
|
SetForegroundWindow(_hwnd);
|
|
Sleep(20); // give some time for other async activation messages to get posted
|
|
PostMessage(_hwnd, TM_ACTASTASKSW, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_OnWinIniChange(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
Cabinet_InitGlobalMetrics(wParam, (LPTSTR)lParam);
|
|
|
|
// Reset the programs menu.
|
|
// REVIEW IANEL - We should only need to listen to the SPI_SETNONCLIENT stuff
|
|
// but deskcpl doesn't send one.
|
|
if (wParam == SPI_SETNONCLIENTMETRICS || (!wParam && (!lParam || (lstrcmpi((LPTSTR)lParam, TEXT("WindowMetrics")) == 0))))
|
|
{
|
|
#ifdef DEBUG
|
|
if (wParam == SPI_SETNONCLIENTMETRICS)
|
|
TraceMsg(TF_TRAY, "c.t_owic: Non-client metrics (probably) changed.");
|
|
else
|
|
TraceMsg(TF_TRAY, "c.t_owic: Window metrics changed.");
|
|
#endif
|
|
|
|
_OnNewSystemSizes();
|
|
}
|
|
|
|
// Handle old extensions.
|
|
if (!lParam || (lParam && (lstrcmpi((LPTSTR)lParam, TEXT("Extensions")) == 0)))
|
|
{
|
|
TraceMsg(TF_TRAY, "t_owic: Extensions section change.");
|
|
CheckWinIniForAssocs();
|
|
}
|
|
|
|
if (lParam && (0 == lstrcmpi((LPCTSTR)lParam, TEXT("TraySettings"))))
|
|
{
|
|
_Command(FCIDM_REFRESH);
|
|
}
|
|
|
|
// Tell shell32 to refresh its cache
|
|
SHSettingsChanged(wParam, lParam);
|
|
}
|
|
|
|
HWND CTray::_HotkeyInUse(WORD wHK)
|
|
{
|
|
HWND hwnd;
|
|
DWORD_PTR lrHKInUse = 0;
|
|
int nMod;
|
|
WORD wHKNew;
|
|
#ifdef DEBUG
|
|
TCHAR sz[MAX_PATH];
|
|
#endif
|
|
|
|
// Map the modifiers back.
|
|
nMod = 0;
|
|
if (HIBYTE(wHK) & MOD_SHIFT)
|
|
nMod |= HOTKEYF_SHIFT;
|
|
if (HIBYTE(wHK) & MOD_CONTROL)
|
|
nMod |= HOTKEYF_CONTROL;
|
|
if (HIBYTE(wHK) & MOD_ALT)
|
|
nMod |= HOTKEYF_ALT;
|
|
|
|
wHKNew = (WORD)((nMod*256)+LOBYTE(wHK));
|
|
|
|
DebugMsg(DM_IANELHK, TEXT("c.hkl_hiu: Checking for %x"), wHKNew);
|
|
hwnd = GetWindow(GetDesktopWindow(), GW_CHILD);
|
|
while (hwnd)
|
|
{
|
|
SendMessageTimeout(hwnd, WM_GETHOTKEY, 0, 0, SMTO_ABORTIFHUNG| SMTO_BLOCK, 3000, &lrHKInUse);
|
|
if (wHKNew == (WORD)lrHKInUse)
|
|
{
|
|
#ifdef DEBUG
|
|
GetWindowText(hwnd, sz, ARRAYSIZE(sz));
|
|
DebugMsg(DM_IANELHK, TEXT("c.hkl_hiu: %s (%x) is using %x"), sz, hwnd, lrHKInUse);
|
|
#endif
|
|
return hwnd;
|
|
}
|
|
#ifdef DEBUG
|
|
else if (lrHKInUse)
|
|
{
|
|
GetWindowText(hwnd, sz, ARRAYSIZE(sz));
|
|
DebugMsg(DM_IANELHK, TEXT("c.hkl_hiu: %s (%x) is using %x"), sz, hwnd, lrHKInUse);
|
|
}
|
|
#endif
|
|
hwnd = GetWindow(hwnd, GW_HWNDNEXT);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void CTray::_HandleHotKey(int nID)
|
|
{
|
|
TraceMsg(TF_TRAY, "c.hkl_hh: Handling hotkey (%d).", nID);
|
|
|
|
// Find it in the list.
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
HOTKEYITEM *phki = (HOTKEYITEM *)DSA_GetItemPtr(_hdsaHKI, nID);
|
|
if (phki && phki->wGHotkey)
|
|
{
|
|
TraceMsg(TF_TRAY, "c.hkl_hh: Hotkey listed.");
|
|
|
|
// Are global hotkeys enabled?
|
|
if (!_fGlobalHotkeyDisable)
|
|
{
|
|
// Yep.
|
|
HWND hwnd = _HotkeyInUse(phki->wGHotkey);
|
|
// Make sure this hotkey isn't already in use by someone.
|
|
if (hwnd)
|
|
{
|
|
TraceMsg(TF_TRAY, "c.hkl_hh: Hotkey is already in use.");
|
|
// Activate it.
|
|
SwitchToThisWindow(GetLastActivePopup(hwnd), TRUE);
|
|
}
|
|
else
|
|
{
|
|
DECLAREWAITCURSOR;
|
|
// Exec the item.
|
|
SetWaitCursor();
|
|
TraceMsg(TF_TRAY, "c.hkl_hh: Hotkey is not in use, execing item.");
|
|
ASSERT(phki->pidlFolder && phki->pidlItem);
|
|
BOOL fRes = _ExecItemByPidls(_hwnd, phki->pidlFolder, phki->pidlItem);
|
|
ResetWaitCursor();
|
|
#ifdef DEBUG
|
|
if (!fRes)
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("c.hkl_hh: Can't exec command ."));
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("c.hkl_hh: Global hotkeys have been disabled."));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("c.hkl_hh: Hotkey not listed."));
|
|
}
|
|
LeaveCriticalSection(&_csHotkey);
|
|
}
|
|
|
|
LRESULT CTray::_UnregisterHotkey(HWND hwnd, int i)
|
|
{
|
|
TraceMsg(TF_TRAY, "c.t_uh: Unregistering hotkey (%d).", i);
|
|
|
|
if (!UnregisterHotKey(hwnd, i))
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("c.t_rh: Unable to unregister hotkey %d."), i);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Add hotkey to the shell's list of global hotkeys.
|
|
LRESULT CTray::_ShortcutRegisterHotkey(HWND hwnd, WORD wHotkey, ATOM atom)
|
|
{
|
|
int i;
|
|
LPITEMIDLIST pidl;
|
|
TCHAR szPath[MAX_PATH];
|
|
ASSERT(atom);
|
|
|
|
if (GlobalGetAtomName(atom, szPath, MAX_PATH))
|
|
{
|
|
TraceMsg(TF_TRAY, "c.t_srh: Hotkey %d for %s", wHotkey, szPath);
|
|
|
|
pidl = ILCreateFromPath(szPath);
|
|
if (pidl)
|
|
{
|
|
i = _HotkeyAddCached(_MapHotkeyToGlobalHotkey(wHotkey), pidl);
|
|
if (i != -1)
|
|
{
|
|
_RegisterHotkey(_hwnd, i);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Remove hotkey from shell's list.
|
|
LRESULT CTray::_ShortcutUnregisterHotkey(HWND hwnd, WORD wHotkey)
|
|
{
|
|
// DebugMsg(DM_TRACE, "c.t_suh: Hotkey %d", wHotkey);
|
|
int i = _HotkeyRemove(wHotkey);
|
|
if (i == -1)
|
|
i = _HotkeyRemoveCached(_MapHotkeyToGlobalHotkey(wHotkey));
|
|
|
|
if (i != -1)
|
|
_UnregisterHotkey(hwnd, i);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CTray::_RegisterHotkey(HWND hwnd, int i)
|
|
{
|
|
HOTKEYITEM *phki;
|
|
WORD wGHotkey = 0;
|
|
|
|
ASSERT(IS_VALID_HANDLE(_hdsaHKI, DSA));
|
|
|
|
TraceMsg(TF_TRAY, "c.t_rh: Registering hotkey (%d).", i);
|
|
|
|
EnterCriticalSection(&_csHotkey);
|
|
|
|
phki = (HOTKEYITEM *)DSA_GetItemPtr(_hdsaHKI, i);
|
|
ASSERT(phki);
|
|
if (phki)
|
|
{
|
|
wGHotkey = phki->wGHotkey;
|
|
}
|
|
|
|
LeaveCriticalSection(&_csHotkey);
|
|
|
|
if (wGHotkey)
|
|
{
|
|
// Is the hotkey available?
|
|
if (RegisterHotKey(hwnd, i, HIBYTE(wGHotkey), LOBYTE(wGHotkey)))
|
|
{
|
|
// Yes.
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Delete any cached items that might be using this
|
|
// hotkey.
|
|
int iCached = _HotkeyRemoveCached(wGHotkey);
|
|
ASSERT(iCached != i);
|
|
if (iCached != -1)
|
|
{
|
|
// Free up the hotkey for us.
|
|
_UnregisterHotkey(hwnd, iCached);
|
|
// Yep, nuked the cached item. Try again.
|
|
if (RegisterHotKey(hwnd, i, HIBYTE(wGHotkey), LOBYTE(wGHotkey)))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Can't set hotkey for this item.
|
|
DebugMsg(DM_ERROR, TEXT("c.t_rh: Unable to register hotkey %d."), i);
|
|
// Null out this item.
|
|
phki->wGHotkey = 0;
|
|
phki->pidlFolder = NULL;
|
|
phki->pidlItem = NULL;
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("c.t_rh: Hotkey item is invalid."));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
#define GetABDHWnd(pabd) ((HWND)ULongToPtr((pabd)->dwWnd))
|
|
|
|
void CTray::_AppBarGetTaskBarPos(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
APPBARDATA3264 *pabd;
|
|
|
|
pabd = (APPBARDATA3264*)SHLockShared(UlongToPtr(ptabd->hSharedABD), ptabd->dwProcId);
|
|
if (pabd)
|
|
{
|
|
pabd->rc = _arStuckRects[_uStuckPlace];
|
|
pabd->uEdge = _uStuckPlace; // compat: new to ie4
|
|
SHUnlockShared(pabd);
|
|
}
|
|
}
|
|
|
|
void CTray::_NukeAppBar(int i)
|
|
{
|
|
LocalFree(DPA_GetPtr(_hdpaAppBars, i));
|
|
DPA_DeletePtr(_hdpaAppBars, i);
|
|
}
|
|
|
|
void CTray::_AppBarRemove(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
int i;
|
|
|
|
if (!_hdpaAppBars)
|
|
return;
|
|
|
|
i = DPA_GetPtrCount(_hdpaAppBars);
|
|
|
|
while (i--)
|
|
{
|
|
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(_hdpaAppBars, i);
|
|
|
|
if (GetABDHWnd(&ptabd->abd) == pab->hwnd)
|
|
{
|
|
RECT rcNuke = pab->rc;
|
|
|
|
_NukeAppBar(i);
|
|
_StuckAppChange(GetABDHWnd(&ptabd->abd), &rcNuke, NULL, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
PAPPBAR CTray::_FindAppBar(HWND hwnd)
|
|
{
|
|
if (_hdpaAppBars)
|
|
{
|
|
int i = DPA_GetPtrCount(_hdpaAppBars);
|
|
|
|
while (i--)
|
|
{
|
|
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(_hdpaAppBars, i);
|
|
|
|
if (hwnd == pab->hwnd)
|
|
return pab;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CTray::_AppBarNotifyAll(HMONITOR hmon, UINT uMsg, HWND hwndExclude, LPARAM lParam)
|
|
{
|
|
if (!_hdpaAppBars)
|
|
return;
|
|
|
|
int i = DPA_GetPtrCount(_hdpaAppBars);
|
|
|
|
while (i--)
|
|
{
|
|
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(_hdpaAppBars, i);
|
|
|
|
// We need to check pab here as an appbar can delete other
|
|
// appbars on the callback.
|
|
if (pab && (hwndExclude != pab->hwnd))
|
|
{
|
|
if (!IsWindow(pab->hwnd))
|
|
{
|
|
_NukeAppBar(i);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// if a monitor was specified only tell appbars on that display
|
|
//
|
|
if (hmon &&
|
|
(hmon != MonitorFromWindow(pab->hwnd, MONITOR_DEFAULTTONULL)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
PostMessage(pab->hwnd, pab->uCallbackMessage, uMsg, lParam);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CTray::_AppBarNew(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
PAPPBAR pab;
|
|
if (!_hdpaAppBars)
|
|
{
|
|
_hdpaAppBars = DPA_Create(4);
|
|
if (!_hdpaAppBars)
|
|
return FALSE;
|
|
|
|
}
|
|
else if (_FindAppBar(GetABDHWnd(&ptabd->abd)))
|
|
{
|
|
// already have this hwnd
|
|
return FALSE;
|
|
}
|
|
|
|
pab = (PAPPBAR)LocalAlloc(LPTR, sizeof(APPBAR));
|
|
if (!pab)
|
|
return FALSE;
|
|
|
|
pab->hwnd = GetABDHWnd(&ptabd->abd);
|
|
pab->uCallbackMessage = ptabd->abd.uCallbackMessage;
|
|
pab->uEdge = (UINT)-1;
|
|
|
|
if (DPA_AppendPtr(_hdpaAppBars, pab) == -1)
|
|
{
|
|
// insertion failed
|
|
LocalFree(pab);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CTray::_AppBarOutsideOf(PAPPBAR pabReq, PAPPBAR pab)
|
|
{
|
|
if (pabReq->uEdge == pab->uEdge)
|
|
{
|
|
switch (pab->uEdge)
|
|
{
|
|
case ABE_RIGHT:
|
|
return (pab->rc.right >= pabReq->rc.right);
|
|
|
|
case ABE_BOTTOM:
|
|
return (pab->rc.bottom >= pabReq->rc.bottom);
|
|
|
|
case ABE_TOP:
|
|
return (pab->rc.top <= pabReq->rc.top);
|
|
|
|
case ABE_LEFT:
|
|
return (pab->rc.left <= pabReq->rc.left);
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void CTray::_AppBarQueryPos(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
int i;
|
|
PAPPBAR pabReq = _FindAppBar(GetABDHWnd(&ptabd->abd));
|
|
|
|
if (pabReq)
|
|
{
|
|
APPBARDATA3264 *pabd;
|
|
|
|
pabd = (APPBARDATA3264*)SHLockShared(UlongToPtr(ptabd->hSharedABD), ptabd->dwProcId);
|
|
if (pabd)
|
|
{
|
|
HMONITOR hmon;
|
|
|
|
pabd->rc = ptabd->abd.rc;
|
|
|
|
//
|
|
// default to the primary display for this call because old appbars
|
|
// sometimes pass a huge rect and let us pare it down. if they do
|
|
// something like that they don't support multiple displays anyway
|
|
// so just put them on the primary display...
|
|
//
|
|
hmon = MonitorFromRect(&pabd->rc, MONITOR_DEFAULTTOPRIMARY);
|
|
|
|
//
|
|
// always subtract off the tray if it's on the same display
|
|
//
|
|
if (!_uAutoHide && (hmon == _hmonStuck))
|
|
{
|
|
APPBAR ab;
|
|
|
|
ab.uEdge = _GetDockedRect(&ab.rc, FALSE);
|
|
_AppBarSubtractRect(&ab, &pabd->rc);
|
|
}
|
|
|
|
i = DPA_GetPtrCount(_hdpaAppBars);
|
|
|
|
while (i--)
|
|
{
|
|
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(_hdpaAppBars, i);
|
|
|
|
//
|
|
// give top and bottom preference
|
|
// ||
|
|
// if we're not changing edges,
|
|
// subtract anything currently on the outside of us
|
|
// ||
|
|
// if we are changing sides,
|
|
// subtract off everything on the new side.
|
|
//
|
|
// of course ignore appbars which are not on the same display...
|
|
//
|
|
if ((((pabReq->hwnd != pab->hwnd) &&
|
|
STUCK_HORIZONTAL(pab->uEdge) &&
|
|
!STUCK_HORIZONTAL(ptabd->abd.uEdge)) ||
|
|
((pabReq->hwnd != pab->hwnd) &&
|
|
(pabReq->uEdge == ptabd->abd.uEdge) &&
|
|
_AppBarOutsideOf(pabReq, pab)) ||
|
|
((pabReq->hwnd != pab->hwnd) &&
|
|
(pabReq->uEdge != ptabd->abd.uEdge) &&
|
|
(pab->uEdge == ptabd->abd.uEdge))) &&
|
|
(hmon == MonitorFromRect(&pab->rc, MONITOR_DEFAULTTONULL)))
|
|
{
|
|
_AppBarSubtractRect(pab, &pabd->rc);
|
|
}
|
|
}
|
|
SHUnlockShared(pabd);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_AppBarSetPos(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
PAPPBAR pab = _FindAppBar(GetABDHWnd(&ptabd->abd));
|
|
|
|
if (pab)
|
|
{
|
|
RECT rcOld;
|
|
APPBARDATA3264 *pabd;
|
|
BOOL fChanged = FALSE;
|
|
|
|
_AppBarQueryPos(ptabd);
|
|
|
|
pabd = (APPBARDATA3264*)SHLockShared(UlongToPtr(ptabd->hSharedABD), ptabd->dwProcId);
|
|
if (pabd)
|
|
{
|
|
if (!EqualRect(&pab->rc, &pabd->rc)) {
|
|
rcOld = pab->rc;
|
|
pab->rc = pabd->rc;
|
|
pab->uEdge = ptabd->abd.uEdge;
|
|
fChanged = TRUE;
|
|
}
|
|
SHUnlockShared(pabd);
|
|
}
|
|
|
|
if (fChanged)
|
|
_StuckAppChange(GetABDHWnd(&ptabd->abd), &rcOld, &pab->rc, FALSE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// FEATURE: need to get rid of this array-based implementation to allow autohide
|
|
// appbars on secondary display (or a/h tray on 2nd with a/h appbar on primary)
|
|
// change it to an _AppBarFindAutoHideBar that keeps flags on the appbardata...
|
|
//
|
|
HWND CTray::_AppBarGetAutoHideBar(UINT uEdge)
|
|
{
|
|
if (uEdge >= ABE_MAX)
|
|
return FALSE;
|
|
else
|
|
{
|
|
HWND hwndAutoHide = _aHwndAutoHide[uEdge];
|
|
if (!IsWindow(hwndAutoHide))
|
|
{
|
|
_aHwndAutoHide[uEdge] = NULL;
|
|
}
|
|
return _aHwndAutoHide[uEdge];
|
|
}
|
|
}
|
|
|
|
BOOL CTray::_AppBarSetAutoHideBar2(HWND hwnd, BOOL fAutoHide, UINT uEdge)
|
|
{
|
|
HWND hwndAutoHide = _aHwndAutoHide[uEdge];
|
|
if (!IsWindow(hwndAutoHide))
|
|
{
|
|
_aHwndAutoHide[uEdge] = NULL;
|
|
}
|
|
|
|
if (fAutoHide)
|
|
{
|
|
// register
|
|
if (!_aHwndAutoHide[uEdge])
|
|
{
|
|
_aHwndAutoHide[uEdge] = hwnd;
|
|
}
|
|
|
|
return _aHwndAutoHide[uEdge] == hwnd;
|
|
}
|
|
else
|
|
{
|
|
// unregister
|
|
if (_aHwndAutoHide[uEdge] == hwnd)
|
|
{
|
|
_aHwndAutoHide[uEdge] = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL CTray::_AppBarSetAutoHideBar(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
UINT uEdge = ptabd->abd.uEdge;
|
|
if (uEdge >= ABE_MAX)
|
|
return FALSE;
|
|
else {
|
|
return _AppBarSetAutoHideBar2(GetABDHWnd(&ptabd->abd), BOOLFROMPTR(ptabd->abd.lParam), uEdge);
|
|
}
|
|
}
|
|
|
|
void CTray::_AppBarActivationChange2(HWND hwnd, UINT uEdge)
|
|
{
|
|
//
|
|
// FEATURE: make this multi-monitor cool
|
|
//
|
|
HWND hwndAutoHide = _AppBarGetAutoHideBar(uEdge);
|
|
|
|
if (hwndAutoHide && (hwndAutoHide != hwnd))
|
|
{
|
|
//
|
|
// the _AppBar got this notification inside a SendMessage from USER
|
|
// and is now in a SendMessage to us. don't try to do a SetWindowPos
|
|
// right now...
|
|
//
|
|
PostMessage(_hwnd, TM_BRINGTOTOP, (WPARAM)hwndAutoHide, uEdge);
|
|
}
|
|
}
|
|
|
|
void CTray::_AppBarActivationChange(PTRAYAPPBARDATA ptabd)
|
|
{
|
|
PAPPBAR pab = _FindAppBar(GetABDHWnd(&ptabd->abd));
|
|
if (pab)
|
|
{
|
|
// if this is an autohide bar and they're claiming to be on an edge not the same as their autohide edge,
|
|
// we don't do any activation of other autohides
|
|
for (UINT i = 0; i < ABE_MAX; i++)
|
|
{
|
|
if (_aHwndAutoHide[i] == GetABDHWnd(&ptabd->abd) &&
|
|
i != pab->uEdge)
|
|
return;
|
|
}
|
|
_AppBarActivationChange2(GetABDHWnd(&ptabd->abd), pab->uEdge);
|
|
}
|
|
}
|
|
|
|
LRESULT CTray::_OnAppBarMessage(PCOPYDATASTRUCT pcds)
|
|
{
|
|
PTRAYAPPBARDATA ptabd = (PTRAYAPPBARDATA)pcds->lpData;
|
|
|
|
ASSERT(pcds->cbData == sizeof(TRAYAPPBARDATA));
|
|
ASSERT(ptabd->abd.cbSize == sizeof(APPBARDATA3264));
|
|
|
|
switch (ptabd->dwMessage) {
|
|
case ABM_NEW:
|
|
return _AppBarNew(ptabd);
|
|
|
|
case ABM_REMOVE:
|
|
_AppBarRemove(ptabd);
|
|
break;
|
|
|
|
case ABM_QUERYPOS:
|
|
_AppBarQueryPos(ptabd);
|
|
break;
|
|
|
|
case ABM_SETPOS:
|
|
_AppBarSetPos(ptabd);
|
|
break;
|
|
|
|
case ABM_GETSTATE:
|
|
return _desktray.AppBarGetState();
|
|
|
|
case ABM_SETSTATE:
|
|
_AppBarSetState((UINT)ptabd->abd.lParam);
|
|
break;
|
|
|
|
case ABM_GETTASKBARPOS:
|
|
_AppBarGetTaskBarPos(ptabd);
|
|
break;
|
|
|
|
case ABM_WINDOWPOSCHANGED:
|
|
case ABM_ACTIVATE:
|
|
_AppBarActivationChange(ptabd);
|
|
break;
|
|
|
|
case ABM_GETAUTOHIDEBAR:
|
|
return (LRESULT)_AppBarGetAutoHideBar(ptabd->abd.uEdge);
|
|
|
|
case ABM_SETAUTOHIDEBAR:
|
|
return _AppBarSetAutoHideBar(ptabd);
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
// EA486701-7F92-11cf-9E05-444553540000
|
|
const GUID CLSID_HIJACKINPROC = {0xEA486701, 0x7F92, 0x11cf, 0x9E, 0x05, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00};
|
|
|
|
HRESULT CTray::_LoadInProc(PCOPYDATASTRUCT pcds)
|
|
{
|
|
ASSERT(pcds->cbData == sizeof(LOADINPROCDATA));
|
|
|
|
PLOADINPROCDATA plipd = (PLOADINPROCDATA)pcds->lpData;
|
|
|
|
// Hack to allow us to kill W95 shell extensions that do reall hacky things that
|
|
// we can not support. In this case Hijack pro
|
|
if (IsEqualIID(plipd->clsid, CLSID_HIJACKINPROC))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
return _ssomgr.EnableObject(&plipd->clsid, plipd->dwFlags);
|
|
}
|
|
|
|
// Allow the trays global hotkeys to be disabled for a while.
|
|
LRESULT CTray::_SetHotkeyEnable(HWND hwnd, BOOL fEnable)
|
|
{
|
|
_fGlobalHotkeyDisable = !fEnable;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL IsPosInHwnd(LPARAM lParam, HWND hwnd)
|
|
{
|
|
RECT r1;
|
|
POINT pt;
|
|
|
|
pt.x = GET_X_LPARAM(lParam);
|
|
pt.y = GET_Y_LPARAM(lParam);
|
|
GetWindowRect(hwnd, &r1);
|
|
return PtInRect(&r1, pt);
|
|
}
|
|
|
|
void CTray::_HandleWindowPosChanging(LPWINDOWPOS lpwp)
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hwpc"));
|
|
|
|
if (_uMoveStuckPlace != (UINT)-1)
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hwpc handling pending move"));
|
|
_DoneMoving(lpwp);
|
|
}
|
|
else if (_fSysSizing || !_fSelfSizing)
|
|
{
|
|
RECT rc;
|
|
|
|
if (_fSysSizing)
|
|
{
|
|
GetWindowRect(_hwnd, &rc);
|
|
if (!(lpwp->flags & SWP_NOMOVE))
|
|
{
|
|
rc.left = lpwp->x;
|
|
rc.top = lpwp->y;
|
|
}
|
|
if (!(lpwp->flags & SWP_NOSIZE))
|
|
{
|
|
rc.right = rc.left + lpwp->cx;
|
|
rc.bottom = rc.top + lpwp->cy;
|
|
}
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hwpc sys sizing to rect {%d, %d, %d, %d}"), rc.left, rc.top, rc.right, rc.bottom);
|
|
|
|
_uStuckPlace = _RecalcStuckPos(&rc);
|
|
_UpdateVertical(_uStuckPlace);
|
|
}
|
|
|
|
_GetDockedRect(&rc, _fSysSizing);
|
|
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.t_hwpc using rect {%d, %d, %d, %d}"), rc.left, rc.top, rc.right, rc.bottom);
|
|
|
|
lpwp->x = rc.left;
|
|
lpwp->y = rc.top;
|
|
lpwp->cx = RECTWIDTH(rc);
|
|
lpwp->cy = RECTHEIGHT(rc);
|
|
|
|
lpwp->flags &= ~(SWP_NOMOVE | SWP_NOSIZE);
|
|
}
|
|
|
|
lpwp->flags |= SWP_FRAMECHANGED;
|
|
}
|
|
|
|
void CTray::_HandlePowerStatus(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fResetDisplay = FALSE;
|
|
|
|
//
|
|
// always reset the display when the machine wakes up from a
|
|
// suspend. NOTE: we don't need this for a standby suspend.
|
|
//
|
|
// a critical resume does not generate a WM_POWERBROADCAST
|
|
// to windows for some reason, but it does generate an old
|
|
// WM_POWER message.
|
|
//
|
|
switch (uMsg)
|
|
{
|
|
case WM_POWER:
|
|
fResetDisplay = (wParam == PWR_CRITICALRESUME);
|
|
break;
|
|
|
|
case WM_POWERBROADCAST:
|
|
switch (wParam)
|
|
{
|
|
case PBT_APMRESUMECRITICAL:
|
|
fResetDisplay = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (fResetDisplay)
|
|
ChangeDisplaySettings(NULL, CDS_RESET);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////
|
|
|
|
//
|
|
// This function checks whether we need to run the cleaner
|
|
// We will not run if user is guest, user has forced us not to, or if the requisite
|
|
// number of days have not yet elapsed
|
|
//
|
|
// We execute a great deal of code to decide whether to run or not that logically should be
|
|
// in fldrclnr.dll, but we execute it here so that we don't have to load fldrclnr.dll unless
|
|
// we absolutely have to, since we execute this path on every logon of explorer.exe
|
|
//
|
|
|
|
#define REGSTR_PATH_CLEANUPWIZ REGSTR_PATH_EXPLORER TEXT("\\Desktop\\CleanupWiz")
|
|
#define REGSTR_OEM_PATH REGSTR_PATH_SETUP TEXT("\\OemStartMenuData")
|
|
#define REGSTR_VAL_TIME TEXT("Last used time")
|
|
#define REGSTR_VAL_DELTA_DAYS TEXT("Days between clean up")
|
|
#define REGSTR_VAL_DONTRUN TEXT("NoRun")
|
|
#define REGSTR_OEM_OPTIN TEXT("DoDesktopCleanup")
|
|
|
|
//
|
|
// iDays can be negative or positive, indicating time in the past or future
|
|
//
|
|
//
|
|
#define FTsPerDayOver1000 (10000*60*60*24) // we've got (1000 x 10,000) 100ns intervals per second
|
|
|
|
void CTray::_DesktopCleanup_GetFileTimeNDaysFromGivenTime(const FILETIME *pftGiven, FILETIME * pftReturn, int iDays)
|
|
{
|
|
__int64 i64 = *((__int64 *) pftGiven);
|
|
i64 += Int32x32To64(iDays*1000,FTsPerDayOver1000);
|
|
|
|
*pftReturn = *((FILETIME *) &i64);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////
|
|
|
|
BOOL CTray::_DesktopCleanup_ShouldRun()
|
|
{
|
|
BOOL fRetVal = FALSE;
|
|
|
|
if (!IsOS(OS_ANYSERVER) &&
|
|
_fIsDesktopConnected &&
|
|
!SHTestTokenMembership(NULL, DOMAIN_ALIAS_RID_GUESTS) &&
|
|
!SHRestricted(REST_NODESKTOPCLEANUP))
|
|
{
|
|
fRetVal = TRUE;
|
|
|
|
FILETIME ftNow, ftLast;
|
|
SYSTEMTIME st;
|
|
GetLocalTime(&st);
|
|
SystemTimeToFileTime(&st, &ftNow);
|
|
|
|
DWORD cb = sizeof(ftLast);
|
|
DWORD dwData;
|
|
if (ERROR_SUCCESS != SHRegGetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_TIME,
|
|
NULL, &ftLast, &cb, FALSE, NULL, 0))
|
|
{
|
|
cb = sizeof(dwData);
|
|
if ((ERROR_SUCCESS == SHGetValue(HKEY_LOCAL_MACHINE, REGSTR_OEM_PATH, REGSTR_OEM_OPTIN, NULL, &dwData, &cb)) &&
|
|
(dwData != 0))
|
|
{
|
|
// to get the timer to kick in 60 days from now, set last to be now
|
|
ftLast = ftNow;
|
|
}
|
|
else
|
|
{
|
|
// to get the timer to kick in 14 days from now, set last to be 46 days ago
|
|
_DesktopCleanup_GetFileTimeNDaysFromGivenTime(&ftNow, &ftLast, -60 + 14);
|
|
}
|
|
|
|
SHRegSetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_TIME, NULL, &ftLast, sizeof(ftLast), SHREGSET_FORCE_HKCU);
|
|
}
|
|
|
|
HUSKEY hkey = NULL;
|
|
if (ERROR_SUCCESS == SHRegOpenUSKey(REGSTR_PATH_CLEANUPWIZ, KEY_READ, NULL, &hkey, FALSE))
|
|
{
|
|
//
|
|
// if we're in normal mode and the DONT RUN flag is set, we return immediately
|
|
// (the user checked the "don't run automatically" box)
|
|
//
|
|
cb = sizeof (DWORD);
|
|
if ((ERROR_SUCCESS == SHRegQueryUSValue(hkey, REGSTR_VAL_DONTRUN, NULL, &dwData, &cb, FALSE, NULL, 0)) &&
|
|
(dwData != 0))
|
|
{
|
|
fRetVal = FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// we need to figure out if if we are within the (last run time + delta days)
|
|
// time period
|
|
//
|
|
int iDays = 60;
|
|
if (ERROR_SUCCESS == (SHRegGetUSValue(REGSTR_PATH_CLEANUPWIZ, REGSTR_VAL_DELTA_DAYS,
|
|
NULL, &dwData, &cb,FALSE, NULL, 0)))
|
|
{
|
|
iDays = dwData;
|
|
}
|
|
|
|
// if (iDays == 0), run every time!
|
|
if (iDays > 0)
|
|
{
|
|
FILETIME ftRange;
|
|
|
|
_DesktopCleanup_GetFileTimeNDaysFromGivenTime(&ftLast, &ftRange, iDays);
|
|
if (!(CompareFileTime(&ftNow, &ftRange) > 0))
|
|
{
|
|
fRetVal = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
SHRegCloseUSKey(hkey);
|
|
}
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
void CTray::_CheckDesktopCleanup()
|
|
{
|
|
if (_DesktopCleanup_ShouldRun())
|
|
{
|
|
PROCESS_INFORMATION pi = {0};
|
|
TCHAR szRunDll32[MAX_PATH];
|
|
|
|
GetSystemDirectory(szRunDll32, ARRAYSIZE(szRunDll32));
|
|
PathAppend(szRunDll32, TEXT("rundll32.exe"));
|
|
|
|
if (CreateProcessWithArgs(szRunDll32, TEXT("fldrclnr.dll,Wizard_RunDLL"), NULL, &pi))
|
|
{
|
|
CloseHandle(pi.hProcess);
|
|
CloseHandle(pi.hThread);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Try tacking a 1, 2, 3 or whatever on to a file or
|
|
// directory name until it is unique. When on a file,
|
|
// stick it before the extension.
|
|
//
|
|
void _MakeBetterUniqueName(LPTSTR pszPathName)
|
|
{
|
|
TCHAR szNewPath[MAX_PATH];
|
|
int i = 1;
|
|
|
|
if (PathIsDirectory(pszPathName))
|
|
{
|
|
do
|
|
{
|
|
wsprintf(szNewPath, TEXT("%s%d"), pszPathName, i++);
|
|
} while (-1 != GetFileAttributes(szNewPath));
|
|
|
|
lstrcpy(pszPathName, szNewPath);
|
|
}
|
|
else
|
|
{
|
|
TCHAR szExt[MAX_PATH];
|
|
LPTSTR pszExt;
|
|
|
|
pszExt = PathFindExtension(pszPathName);
|
|
if (pszExt)
|
|
{
|
|
lstrcpy(szExt, pszExt);
|
|
*pszExt = 0;
|
|
|
|
do
|
|
{
|
|
wsprintf(szNewPath, TEXT("%s%d%s"), pszPathName, i++,szExt);
|
|
} while (-1 != GetFileAttributes(szNewPath));
|
|
|
|
lstrcpy(pszPathName, szNewPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL_PTR WINAPI CTray::RogueProgramFileDlgProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TCHAR szBuffer[MAX_PATH*2];
|
|
TCHAR szBuffer2[MAX_PATH*2];
|
|
static TCHAR szBetterPath[MAX_PATH];
|
|
static TCHAR *pszPath = NULL;
|
|
|
|
switch (iMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
pszPath = (TCHAR *)lParam;
|
|
lstrcpy(szBetterPath, pszPath);
|
|
_MakeBetterUniqueName(szBetterPath);
|
|
SendDlgItemMessage(hWnd, IDC_MSG, WM_GETTEXT, (WPARAM)(MAX_PATH*2), (LPARAM)szBuffer);
|
|
wsprintf(szBuffer2, szBuffer, pszPath, szBetterPath);
|
|
SendDlgItemMessage(hWnd, IDC_MSG, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer2);
|
|
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_RENAME:
|
|
//rename and fall through
|
|
if (pszPath)
|
|
{
|
|
MoveFile(pszPath, szBetterPath);
|
|
}
|
|
EndDialog(hWnd, IDC_RENAME);
|
|
return TRUE;
|
|
|
|
case IDIGNORE:
|
|
EndDialog(hWnd, IDIGNORE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Check to see if there are any files or folders that could interfere
|
|
// with the fact that Program Files has a space in it.
|
|
//
|
|
// An example would be a directory called: "C:\Program" or a file called"C:\Program.exe".
|
|
//
|
|
// This can prevent apps that dont quote strings in the registry or call CreateProcess with
|
|
// unquoted strings from working properly since CreateProcess wont know what the real exe is.
|
|
//
|
|
void CTray::_CheckForRogueProgramFile()
|
|
{
|
|
TCHAR szProgramFilesPath[MAX_PATH];
|
|
TCHAR szProgramFilesShortName[MAX_PATH];
|
|
|
|
if (S_OK == SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, szProgramFilesPath))
|
|
{
|
|
LPTSTR pszRoguePattern;
|
|
|
|
pszRoguePattern = StrChr(szProgramFilesPath, TEXT(' '));
|
|
|
|
if (pszRoguePattern)
|
|
{
|
|
HANDLE hFind;
|
|
WIN32_FIND_DATA wfd;
|
|
|
|
// Remember short name for folder name comparison below
|
|
*pszRoguePattern = TEXT('\0');
|
|
lstrcpy(szProgramFilesShortName, szProgramFilesPath);
|
|
|
|
// turn "C:\program files" into "C:\program.*"
|
|
lstrcpy(pszRoguePattern, TEXT(".*"));
|
|
pszRoguePattern = szProgramFilesPath;
|
|
|
|
hFind = FindFirstFile(pszRoguePattern, &wfd);
|
|
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
int iRet = 0;
|
|
TCHAR szRogueFileName[MAX_PATH];
|
|
|
|
// we found a file (eg "c:\Program.txt")
|
|
lstrcpyn(szRogueFileName, pszRoguePattern, ARRAYSIZE(szRogueFileName));
|
|
PathRemoveFileSpec(szRogueFileName);
|
|
lstrcatn(szRogueFileName, wfd.cFileName, ARRAYSIZE(szRogueFileName));
|
|
|
|
// don't worry about folders unless they are called "Program"
|
|
if (!((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
lstrcmpi(szProgramFilesShortName, szRogueFileName) != 0))
|
|
{
|
|
|
|
iRet = SHMessageBoxCheckEx(GetDesktopWindow(),
|
|
hinstCabinet,
|
|
MAKEINTRESOURCE(DLG_PROGRAMFILECONFLICT),
|
|
RogueProgramFileDlgProc,
|
|
(void *)szRogueFileName,
|
|
IDIGNORE,
|
|
TEXT("RogueProgramName"));
|
|
}
|
|
|
|
if ((iRet == IDIGNORE) || !FindNextFile(hFind, &wfd))
|
|
{
|
|
// user hit ignore or we are done, so don't keep going
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
FindClose(hFind);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_OnWaitCursorNotify(LPNMHDR pnm)
|
|
{
|
|
_iWaitCount += (pnm->code == NM_STARTWAIT ? 1 :-1);
|
|
ASSERT(_iWaitCount >= 0);
|
|
// Don't let it go negative or we'll never get rid of it.
|
|
if (_iWaitCount < 0)
|
|
_iWaitCount = 0;
|
|
// what we really want is for user to simulate a mouse move/setcursor
|
|
SetCursor(LoadCursor(NULL, _iWaitCount ? IDC_APPSTARTING : IDC_ARROW));
|
|
}
|
|
|
|
void CTray::_HandlePrivateCommand(LPARAM lParam)
|
|
{
|
|
LPSTR psz = (LPSTR) lParam; // lParam always ansi.
|
|
|
|
if (!lstrcmpiA(psz, "ToggleDesktop"))
|
|
{
|
|
_RaiseDesktop(!g_fDesktopRaised, TRUE);
|
|
}
|
|
else if (!lstrcmpiA(psz, "Explorer"))
|
|
{
|
|
// Fast way to bring up explorer window on root of
|
|
// windows dir.
|
|
SHELLEXECUTEINFO shei = {0};
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
if (GetWindowsDirectory(szPath, ARRAYSIZE(szPath)) != 0)
|
|
{
|
|
PathStripToRoot(szPath);
|
|
|
|
shei.lpIDList = ILCreateFromPath(szPath);
|
|
if (shei.lpIDList)
|
|
{
|
|
shei.cbSize = sizeof(shei);
|
|
shei.fMask = SEE_MASK_IDLIST;
|
|
shei.nShow = SW_SHOWNORMAL;
|
|
shei.lpVerb = TEXT("explore");
|
|
ShellExecuteEx(&shei);
|
|
ILFree((LPITEMIDLIST)shei.lpIDList);
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree(psz);
|
|
}
|
|
|
|
//***
|
|
//
|
|
void CTray::_OnFocusMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fActivate = (BOOL) wParam;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case TM_UIACTIVATEIO:
|
|
{
|
|
#ifdef DEBUG
|
|
{
|
|
int dtb = (int) lParam;
|
|
|
|
TraceMsg(DM_FOCUS, "tiois: TM_UIActIO fAct=%d dtb=%d", fActivate, dtb);
|
|
|
|
ASSERT(dtb == 1 || dtb == -1);
|
|
}
|
|
#endif
|
|
|
|
if (fActivate)
|
|
{
|
|
// Since we are tabbing into the tray, turn the focus rect on.
|
|
SendMessage(_hwnd, WM_UPDATEUISTATE, MAKEWPARAM(UIS_CLEAR,
|
|
UISF_HIDEFOCUS), 0);
|
|
|
|
SendMessage(v_hwndDesktop, DTM_ONFOCUSCHANGEIS, TRUE, (LPARAM) _hwnd);
|
|
SetForegroundWindow(_hwnd);
|
|
|
|
// fake an IUnknown_UIActivateIO(_ptbs, TRUE, &msg);
|
|
if (GetAsyncKeyState(VK_SHIFT) < 0)
|
|
{
|
|
_SetFocus(_hwndNotify);
|
|
}
|
|
else
|
|
{
|
|
_SetFocus(_hwndStart);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Ldeact:
|
|
IUnknown_UIActivateIO(_ptbs, FALSE, NULL);
|
|
SetForegroundWindow(v_hwndDesktop);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TM_ONFOCUSCHANGEIS:
|
|
{
|
|
HWND hwnd = (HWND) lParam;
|
|
|
|
TraceMsg(DM_FOCUS, "tiois: TM_OnFocChgIS hwnd=%x fAct=%d", hwnd, fActivate);
|
|
|
|
if (fActivate)
|
|
{
|
|
// someone else is activating, so we need to deactivate
|
|
goto Ldeact;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#define TSVC_NTIMER (IDT_SERVICELAST - IDT_SERVICE0 + 1)
|
|
|
|
struct {
|
|
#ifdef DEBUG
|
|
UINT_PTR idtWin;
|
|
#endif
|
|
TIMERPROC pfnSvc;
|
|
} g_timerService[TSVC_NTIMER];
|
|
|
|
#define TSVC_IDToIndex(id) ((id) - IDT_SERVICE0)
|
|
#define TSVC_IndexToID(i) ((i) + IDT_SERVICE0)
|
|
|
|
int CTray::_OnTimerService(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int i;
|
|
UINT_PTR idt;
|
|
TIMERPROC pfn;
|
|
BOOL b;
|
|
|
|
switch (uMsg) {
|
|
case TM_SETTIMER:
|
|
TraceMsg(DM_UEMTRACE, "e.TM_SETTIMER: wP=0x%x lP=%x", wParam, lParam);
|
|
ASSERT(IS_VALID_CODE_PTR(lParam, TIMERPROC));
|
|
for (i = 0; i < TSVC_NTIMER; i++) {
|
|
if (g_timerService[i].pfnSvc == 0) {
|
|
g_timerService[i].pfnSvc = (TIMERPROC)lParam;
|
|
idt = SetTimer(_hwnd, TSVC_IndexToID(i), (UINT)wParam, 0);
|
|
if (idt == 0) {
|
|
TraceMsg(DM_UEMTRACE, "e.TM_SETTIMER: ST()=%d (!)", idt);
|
|
break;
|
|
}
|
|
ASSERT(idt == (UINT_PTR)TSVC_IndexToID(i));
|
|
DBEXEC(TRUE, (g_timerService[i].idtWin = idt));
|
|
TraceMsg(DM_UEMTRACE, "e.TM_SETTIMER: ret=0x%x", TSVC_IndexToID(i));
|
|
return TSVC_IndexToID(i); // idtWin
|
|
}
|
|
}
|
|
TraceMsg(DM_UEMTRACE, "e.TM_SETTIMER: ret=0 (!)");
|
|
return 0;
|
|
|
|
case TM_KILLTIMER: // lP=idtWin
|
|
TraceMsg(DM_UEMTRACE, "e.TM_KILLTIMER: wP=0x%x lP=%x", wParam, lParam);
|
|
if (EVAL(IDT_SERVICE0 <= lParam && lParam <= IDT_SERVICE0 + TSVC_NTIMER - 1)) {
|
|
i = (int)TSVC_IDToIndex(lParam);
|
|
if (g_timerService[i].pfnSvc) {
|
|
ASSERT(g_timerService[i].idtWin == (UINT)lParam);
|
|
b = KillTimer(_hwnd, lParam);
|
|
ASSERT(b);
|
|
g_timerService[i].pfnSvc = 0;
|
|
DBEXEC(TRUE, (g_timerService[i].idtWin = 0));
|
|
return TRUE;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
case WM_TIMER: // wP=idtWin lP=0
|
|
TraceMsg(DM_UEMTRACE, "e.TM_TIMER: wP=0x%x lP=%x", wParam, lParam);
|
|
if (EVAL(IDT_SERVICE0 <= wParam && wParam <= IDT_SERVICE0 + TSVC_NTIMER - 1)) {
|
|
i = (int)TSVC_IDToIndex(wParam);
|
|
pfn = g_timerService[i].pfnSvc;
|
|
if (EVAL(IS_VALID_CODE_PTR(pfn, TIMERPROC)))
|
|
(*pfn)(_hwnd, WM_TIMER, wParam, GetTickCount());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ASSERT(0); /*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
void CTray::RealityCheck()
|
|
{
|
|
//
|
|
// Make sure that the tray's actual z-order position agrees with what we think
|
|
// it is. We need to do this because there's a recurring bug where the tray
|
|
// gets bumped out of TOPMOST position. (Lots of things, like a tray-owned
|
|
// window moving itself to non-TOPMOST or a random app messing with the tray
|
|
// window position, can cause this.)
|
|
//
|
|
_ResetZorder();
|
|
}
|
|
|
|
#define DELAY_STARTUPTROUBLESHOOT (15 * 1000)
|
|
|
|
void CTray::LogFailedStartupApp()
|
|
{
|
|
if (_hwnd)
|
|
{
|
|
PostMessage(_hwnd, TM_HANDLESTARTUPFAILED, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
_fEarlyStartupFailure = TRUE;
|
|
}
|
|
}
|
|
|
|
void WINAPI CTray::TroubleShootStartupCB(HWND hwnd, UINT uMsg, UINT_PTR idTimer, DWORD dwTime)
|
|
{
|
|
KillTimer(hwnd, idTimer);
|
|
|
|
if (!c_tray._fStartupTroubleshooterLaunched)
|
|
{
|
|
TCHAR szCmdLine[MAX_PATH];
|
|
DWORD cb;
|
|
|
|
c_tray._fStartupTroubleshooterLaunched = TRUE;
|
|
cb = sizeof(szCmdLine);
|
|
if (SHGetValue(HKEY_LOCAL_MACHINE, REGSTR_PATH_EXPLORER,
|
|
TEXT("StartupTroubleshoot"), NULL,
|
|
szCmdLine, &cb) == ERROR_SUCCESS)
|
|
{
|
|
ShellExecuteRegApp(szCmdLine, RRA_NOUI | RRA_DELETE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_OnHandleStartupFailed()
|
|
{
|
|
/*
|
|
* Don't launch the troubleshooter until we have gone
|
|
* DELAY_STARTUPTROUBLESHOOT milliseconds without a startup problem.
|
|
* This gives time for the system to settle down before starting to
|
|
* annoy the user all over again.
|
|
*
|
|
* (And, of course, don't launch it more than once.)
|
|
*/
|
|
if (!_fStartupTroubleshooterLaunched)
|
|
{
|
|
SetTimer(_hwnd, IDT_STARTUPFAILED, DELAY_STARTUPTROUBLESHOOT, TroubleShootStartupCB);
|
|
}
|
|
}
|
|
|
|
void CTray::_HandleDelayBootStuff()
|
|
{
|
|
// This posted message is the last one processed by the primary
|
|
// thread (tray thread) when we boot. At this point we will
|
|
// want to load the shell services (which usually create threads)
|
|
// and resume both the background start menu thread and the fs_notfiy
|
|
// thread.
|
|
|
|
if (!_fHandledDelayBootStuff)
|
|
{
|
|
if (GetShellWindow() == NULL)
|
|
{
|
|
// The desktop browser hasn't finished navigating yet.
|
|
SetTimer(_hwnd, IDT_HANDLEDELAYBOOTSTUFF, 3 * 1000, NULL);
|
|
return;
|
|
}
|
|
|
|
_fHandledDelayBootStuff = TRUE;
|
|
|
|
if (g_dwStopWatchMode)
|
|
{
|
|
StopWatch_StartTimed(SWID_STARTUP, TEXT("_DelayedBootStuff"), SPMODE_SHELL | SPMODE_DEBUGOUT, GetPerfTime());
|
|
}
|
|
|
|
PostMessage(_hwnd, TM_SHELLSERVICEOBJECTS, 0, 0);
|
|
|
|
BandSite_HandleDelayBootStuff(_ptbs);
|
|
|
|
//check to see if there are any files or folders that could interfere
|
|
//with the fact that Program Files has a space in it. An example would
|
|
//be a folder called "C:\Program" or a file called "C:\Program.exe"
|
|
_CheckForRogueProgramFile();
|
|
|
|
// Create a named event and fire it so that the services can
|
|
// go to work, reducing contention during boot.
|
|
_hShellReadyEvent = CreateEvent(0, TRUE, TRUE, TEXT("ShellReadyEvent"));
|
|
if (_hShellReadyEvent)
|
|
{
|
|
// Set the event in case it was already created and our "create
|
|
// signaled" parameter to CreateEvent got ignored.
|
|
SetEvent(_hShellReadyEvent);
|
|
}
|
|
|
|
// Check whether we should launch Desktop Cleanup Wizard
|
|
_CheckDesktopCleanup();
|
|
|
|
TBOOL(WinStationRegisterConsoleNotification(SERVERNAME_CURRENT, _hwnd, NOTIFY_FOR_THIS_SESSION));
|
|
|
|
if (g_dwStopWatchMode)
|
|
{
|
|
StopWatch_StopTimed(SWID_STARTUP, TEXT("_DelayedBootStuff"), SPMODE_SHELL | SPMODE_DEBUGOUT, GetPerfTime());
|
|
}
|
|
}
|
|
}
|
|
|
|
LRESULT CTray::_OnDeviceChange(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (wParam)
|
|
{
|
|
case DBT_CONFIGCHANGED:
|
|
// We got an update. Refresh.
|
|
_RefreshStartMenu();
|
|
break;
|
|
|
|
case DBT_QUERYCHANGECONFIG:
|
|
//
|
|
// change to registry settings
|
|
//
|
|
ChangeDisplaySettings(NULL, 0);
|
|
break;
|
|
|
|
case DBT_MONITORCHANGE:
|
|
//
|
|
// handle monitor change
|
|
//
|
|
HandleDisplayChange(LOWORD(lParam), HIWORD(lParam), TRUE);
|
|
break;
|
|
|
|
case DBT_CONFIGCHANGECANCELED:
|
|
//
|
|
// if the config change was canceled go back
|
|
//
|
|
HandleDisplayChange(0, 0, FALSE);
|
|
break;
|
|
}
|
|
|
|
Mixer_DeviceChange(wParam, lParam);
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// The "resizable" edge of the taskbar is the edge adjacent to
|
|
// the desktop, i.e. opposite the stuck place.
|
|
//
|
|
// returns HTXXX if on a resizable edge, else HTBORDER
|
|
//
|
|
DWORD CTray::_PtOnResizableEdge(POINT pt, LPRECT prcClient)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(_hwnd, &rc);
|
|
|
|
DWORD dwHit = HTBORDER;
|
|
|
|
switch (_uStuckPlace)
|
|
{
|
|
case STICK_LEFT: rc.left = prcClient->right; dwHit = HTRIGHT; break;
|
|
case STICK_TOP: rc.top = prcClient->bottom; dwHit = HTBOTTOM; break;
|
|
case STICK_RIGHT: rc.right = prcClient->left; dwHit = HTLEFT; break;
|
|
case STICK_BOTTOM: rc.bottom = prcClient->top; dwHit = HTTOP; break;
|
|
}
|
|
|
|
return PtInRect(&rc, pt) ? dwHit : HTBORDER;
|
|
}
|
|
|
|
//
|
|
// _OnFactoryMessage
|
|
//
|
|
// The OPK "factory.exe" tool sends us this message to tell us that
|
|
// it has dorked some setting or other and we should refresh so the
|
|
// OEM can see the effect immediately and feel confident that it
|
|
// actually worked. This is not technically necessary but it cuts
|
|
// down on OEM support calls when they ask us why their setting didn't
|
|
// work. (It did work, they just have to log off and back on to see
|
|
// it.)
|
|
//
|
|
|
|
int CTray::_OnFactoryMessage(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (wParam)
|
|
{
|
|
case 0: // FACTORY_OEMLINK: factory.exe has dorked the OEM link
|
|
ClosePopupMenus();
|
|
_BuildStartMenu(); // Force a rebuild
|
|
return 1;
|
|
|
|
case 1: // FACTORY_MFU: factory.exe has written a new MFU
|
|
HandleFirstTime(); // Rebuild the default MFU
|
|
ClosePopupMenus();
|
|
_BuildStartMenu(); // Force a rebuild
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define CX_OFFSET g_cxEdge
|
|
#define CY_OFFSET g_cyEdge
|
|
|
|
//
|
|
// _MapNCToClient
|
|
//
|
|
// see comments in _TryForwardNCToClient
|
|
//
|
|
BOOL CTray::_MapNCToClient(LPARAM* plParam)
|
|
{
|
|
POINT pt = { GET_X_LPARAM(*plParam), GET_Y_LPARAM(*plParam) };
|
|
|
|
RECT rcClient;
|
|
GetClientRect(_hwnd, &rcClient);
|
|
MapWindowPoints(_hwnd, NULL, (LPPOINT)&rcClient, 2);
|
|
|
|
//
|
|
// point must be outside the client area and not on the
|
|
// resizable edge of the taskbar
|
|
//
|
|
|
|
if (!PtInRect(&rcClient, pt) && _PtOnResizableEdge(pt, &rcClient) == HTBORDER)
|
|
{
|
|
//
|
|
// fudge it over onto the client edge and return TRUE
|
|
//
|
|
if (pt.x < rcClient.left)
|
|
pt.x = rcClient.left + CX_OFFSET;
|
|
else if (pt.x > rcClient.right)
|
|
pt.x = rcClient.right - CX_OFFSET;
|
|
|
|
if (pt.y < rcClient.top)
|
|
pt.y = rcClient.top + CY_OFFSET;
|
|
else if (pt.y > rcClient.bottom)
|
|
pt.y = rcClient.bottom - CY_OFFSET;
|
|
|
|
*plParam = MAKELONG(pt.x, pt.y);
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// didn't pass the test. leave the point alone and return FALSE.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
HWND _TopChildWindowFromPoint(HWND hwnd, POINT pt)
|
|
{
|
|
HWND hwndLast = NULL;
|
|
hwnd = ChildWindowFromPoint(hwnd, pt);
|
|
while (hwnd && hwnd != hwndLast)
|
|
{
|
|
hwndLast = hwnd;
|
|
hwnd = ChildWindowFromPoint(hwnd, pt);
|
|
}
|
|
return hwndLast;
|
|
}
|
|
|
|
//
|
|
// _TryForwardNCToClient
|
|
//
|
|
// Hack! This exists to solve a usability problem. When you slam your
|
|
// mouse into the bottom corner of the screen and click, we want that to
|
|
// activate the start button. Similarly, when you slam your mouse below
|
|
// a Quick Launch button or task button and click, we want that to
|
|
// activate the button.
|
|
//
|
|
// We hack this by remapping the coordinate of NC mouse messages and
|
|
// manually forwarding to the appropriate window. We only do this for
|
|
// clicks on the edges non-resizable edge of the taskbar.
|
|
//
|
|
// We also warp the mouse cursor over to the new position. This is needed
|
|
// because e.g. if toolbar is the client window we're forwarding
|
|
// to, it will set capture and receive subsequent mouse messages. (And
|
|
// once it gets a mouse message outside the window, it will deselect the
|
|
// button and so the button won't get activated.)
|
|
//
|
|
// _MapNCToClient has the rules for figuring out if the click is on
|
|
// one of the edges we want and for remapping the coordinate into the
|
|
// client area.
|
|
//
|
|
BOOL CTray::_TryForwardNCToClient(UINT uMsg, LPARAM lParam)
|
|
{
|
|
if (_MapNCToClient(&lParam))
|
|
{
|
|
// see if this is over one of our windows
|
|
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
|
|
MapWindowPoints(NULL, _hwnd, &pt, 1);
|
|
HWND hwnd = _TopChildWindowFromPoint(_hwnd, pt);
|
|
|
|
if (hwnd)
|
|
{
|
|
// warp the mouse cursor to this screen coord
|
|
SetCursorPos(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
|
|
// map to window coords
|
|
MapWindowPoints(_hwnd, hwnd, &pt, 1);
|
|
|
|
// set lparam to window coords
|
|
lParam = MAKELONG(pt.x, pt.y);
|
|
|
|
// map to client message
|
|
ASSERT(InRange(uMsg, WM_NCMOUSEFIRST, WM_NCMOUSELAST));
|
|
uMsg += (WM_LBUTTONDOWN - WM_NCLBUTTONDOWN);
|
|
|
|
// forward it
|
|
SendMessage(hwnd, uMsg, 0, lParam);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CTray::CountOfRunningPrograms
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: DWORD
|
|
//
|
|
// Purpose: Iterates the window list. Looks for windows that are visible
|
|
// with a non-zero length window title. Gets that window process
|
|
// ID and keeps the IDs in a list. For each window iterated it
|
|
// checks against the list to see if the process is already
|
|
// tagged and if so doesn't add it again. Finally it returns the
|
|
// count of the unique processes handling open visible windows
|
|
// in the user's desktop.
|
|
//
|
|
// The list is fixed at 1000 processes (using stack space).
|
|
//
|
|
// History: 2000-06-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
static const int MAXIMUM_PROCESS_COUNT = 1000;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwCount;
|
|
DWORD dwProcessIDs[MAXIMUM_PROCESS_COUNT];
|
|
} tProcessIDList;
|
|
|
|
bool FoundProcessID (tProcessIDList *pProcessIDList, DWORD dwProcessID)
|
|
|
|
{
|
|
bool fFound;
|
|
DWORD dwIndex;
|
|
|
|
for (fFound = false, dwIndex = 0; !fFound && (dwIndex < pProcessIDList->dwCount); ++dwIndex)
|
|
{
|
|
fFound = (pProcessIDList->dwProcessIDs[dwIndex] == dwProcessID);
|
|
}
|
|
return(fFound);
|
|
}
|
|
|
|
void AddProcessID (tProcessIDList *pProcessIDList, DWORD dwProcessID)
|
|
|
|
{
|
|
if (pProcessIDList->dwCount < MAXIMUM_PROCESS_COUNT)
|
|
{
|
|
pProcessIDList->dwProcessIDs[pProcessIDList->dwCount++] = dwProcessID;
|
|
}
|
|
}
|
|
|
|
BOOL CALLBACK CountOfRunningProgramsEnumWindowsProc (HWND hwnd, LPARAM lParam)
|
|
|
|
{
|
|
if ((GetShellWindow() != hwnd) && IsWindowVisible(hwnd))
|
|
{
|
|
DWORD dwThreadID, dwProcessID;
|
|
TCHAR szWindowTitle[256];
|
|
|
|
dwThreadID = GetWindowThreadProcessId(hwnd, &dwProcessID);
|
|
if ((InternalGetWindowText(hwnd, szWindowTitle, ARRAYSIZE(szWindowTitle)) > 0) &&
|
|
(szWindowTitle[0] != TEXT('\0')))
|
|
{
|
|
if (!FoundProcessID(reinterpret_cast<tProcessIDList*>(lParam), dwProcessID))
|
|
{
|
|
AddProcessID(reinterpret_cast<tProcessIDList*>(lParam), dwProcessID);
|
|
}
|
|
}
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
DWORD CTray::CountOfRunningPrograms()
|
|
{
|
|
tProcessIDList processIDList = {0};
|
|
TBOOL(EnumWindows(CountOfRunningProgramsEnumWindowsProc, reinterpret_cast<LPARAM>(&processIDList)));
|
|
return processIDList.dwCount;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CTray::_OnSessionChange
|
|
//
|
|
// Arguments: wParam = WTS_xxx notification.
|
|
// lParam = WTS_SESSION_NOTIFICATION struct pointer.
|
|
//
|
|
// Returns: LRESULT
|
|
//
|
|
// Purpose: Handles console/remote dis/reconnects.
|
|
//
|
|
// History: 2000-07-12 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
LRESULT CTray::_OnSessionChange(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERTMSG(DWORD(lParam) == NtCurrentPeb()->SessionId, "Session ID mismatch in CTray::_OnSessionChange");
|
|
|
|
if ((WTS_CONSOLE_CONNECT == wParam) || (WTS_REMOTE_CONNECT == wParam) || (WTS_SESSION_UNLOCK == wParam))
|
|
{
|
|
_fIsDesktopConnected = TRUE;
|
|
}
|
|
else if ((WTS_CONSOLE_DISCONNECT == wParam) || (WTS_REMOTE_DISCONNECT == wParam) || (WTS_SESSION_LOCK == wParam))
|
|
{
|
|
_fIsDesktopConnected = FALSE;
|
|
}
|
|
|
|
if ((WTS_CONSOLE_CONNECT == wParam) || (WTS_REMOTE_CONNECT == wParam))
|
|
{
|
|
_RefreshStartMenu();
|
|
SHUpdateRecycleBinIcon();
|
|
}
|
|
else if ((WTS_SESSION_LOCK == wParam) || (WTS_SESSION_UNLOCK == wParam))
|
|
{
|
|
if (IsOS(OS_FASTUSERSWITCHING))
|
|
{
|
|
if (wParam == WTS_SESSION_LOCK)
|
|
{
|
|
ExplorerPlaySound(TEXT("WindowsLogoff"));
|
|
}
|
|
else if (wParam == WTS_SESSION_UNLOCK)
|
|
{
|
|
ExplorerPlaySound(TEXT("WindowsLogon"));
|
|
}
|
|
}
|
|
|
|
PostMessage(_hwnd, TM_WORKSTATIONLOCKED, (WTS_SESSION_LOCK == wParam), 0);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
LRESULT CTray::_NCPaint(HRGN hrgn)
|
|
{
|
|
ASSERT(_hTheme);
|
|
|
|
if (_fCanSizeMove || _fShowSizingBarAlways)
|
|
{
|
|
if ((INT_PTR)hrgn == 1)
|
|
hrgn = NULL;
|
|
|
|
HDC hdc = GetDCEx( _hwnd, hrgn, DCX_USESTYLE|DCX_WINDOW|DCX_LOCKWINDOWUPDATE|
|
|
((hrgn != NULL) ? DCX_INTERSECTRGN|DCX_NODELETERGN : 0));
|
|
|
|
if (hdc)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(_hwnd, &rc);
|
|
OffsetRect(&rc, -rc.left, -rc.top);
|
|
|
|
_AdjustRectForSizingBar(_uStuckPlace, &rc, 0);
|
|
DrawThemeBackground(_hTheme, hdc, _GetPart(TRUE, _uStuckPlace), 0, &rc, 0);
|
|
ReleaseDC(_hwnd, hdc);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CTray::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static UINT uDDEExec = 0;
|
|
LRESULT lres = 0;
|
|
MSG msg;
|
|
|
|
msg.hwnd = hwnd;
|
|
msg.message = uMsg;
|
|
msg.wParam = wParam;
|
|
msg.lParam = lParam;
|
|
|
|
if (_pmbStartMenu &&
|
|
_pmbStartMenu->TranslateMenuMessage(&msg, &lres) == S_OK)
|
|
return lres;
|
|
|
|
if (_pmbStartPane &&
|
|
_pmbStartPane->TranslateMenuMessage(&msg, &lres) == S_OK)
|
|
return lres;
|
|
|
|
if (_pmbTasks &&
|
|
_pmbTasks->TranslateMenuMessage(&msg, &lres) == S_OK)
|
|
return lres;
|
|
|
|
wParam = msg.wParam;
|
|
lParam = msg.lParam;
|
|
|
|
INSTRUMENT_WNDPROC(SHCNFI_TRAY_WNDPROC, hwnd, uMsg, wParam, lParam);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WMTRAY_REGISTERHOTKEY:
|
|
return _RegisterHotkey(hwnd, (int)wParam);
|
|
|
|
case WMTRAY_UNREGISTERHOTKEY:
|
|
return _UnregisterHotkey(hwnd, (int)wParam);
|
|
|
|
case WMTRAY_SCREGISTERHOTKEY:
|
|
return _ShortcutRegisterHotkey(hwnd, (WORD)wParam, (ATOM)lParam);
|
|
|
|
case WMTRAY_SCUNREGISTERHOTKEY:
|
|
return _ShortcutUnregisterHotkey(hwnd, (WORD)wParam);
|
|
|
|
case WMTRAY_SETHOTKEYENABLE:
|
|
return _SetHotkeyEnable(hwnd, (BOOL)wParam);
|
|
|
|
case WMTRAY_QUERY_MENU:
|
|
return (LRESULT)_hmenuStart;
|
|
|
|
case WMTRAY_QUERY_VIEW:
|
|
return (LRESULT)_hwndTasks;
|
|
|
|
case WMTRAY_TOGGLEQL:
|
|
return _ToggleQL((int)lParam);
|
|
|
|
case WM_COPYDATA:
|
|
// Check for NULL it can happen if user runs out of selectors or memory...
|
|
if (lParam)
|
|
{
|
|
switch (((PCOPYDATASTRUCT)lParam)->dwData) {
|
|
case TCDM_NOTIFY:
|
|
{
|
|
BOOL bRefresh = FALSE;
|
|
|
|
lres = _trayNotify.TrayNotify(_hwndNotify, (HWND)wParam, (PCOPYDATASTRUCT)lParam, &bRefresh);
|
|
if (bRefresh)
|
|
{
|
|
SizeWindows();
|
|
}
|
|
return(lres);
|
|
}
|
|
|
|
case TCDM_APPBAR:
|
|
return _OnAppBarMessage((PCOPYDATASTRUCT)lParam);
|
|
|
|
case TCDM_LOADINPROC:
|
|
return (UINT)_LoadInProc((PCOPYDATASTRUCT)lParam);
|
|
}
|
|
}
|
|
return FALSE;
|
|
|
|
case WM_NCCALCSIZE:
|
|
if (_hTheme)
|
|
{
|
|
if ((_fCanSizeMove || _fShowSizingBarAlways) && lParam)
|
|
{
|
|
_AdjustRectForSizingBar(_uStuckPlace, (LPRECT)lParam, -1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
goto L_default;
|
|
}
|
|
break;
|
|
|
|
case WM_NCLBUTTONDBLCLK:
|
|
if (!_TryForwardNCToClient(uMsg, lParam))
|
|
{
|
|
if (IsPosInHwnd(lParam, _hwndNotify))
|
|
{
|
|
_Command(IDM_SETTIME);
|
|
|
|
// Hack! If you click on the tray clock, this tells the tooltip
|
|
// "Hey, I'm using this thing; stop putting up a tip for me."
|
|
// You can get the tooltip to lose track of when it needs to
|
|
// reset the "stop it!" flag and you get stuck in "stop it!" mode.
|
|
// It's particularly easy to make happen on Terminal Server.
|
|
//
|
|
// So let's assume that the only reason people click on the
|
|
// tray clock is to change the time. when they change the time,
|
|
// kick the tooltip in the head to reset the "stop it!" flag.
|
|
|
|
SendMessage(_hwndTrayTips, TTM_POP, 0, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_NCLBUTTONDOWN:
|
|
case WM_NCLBUTTONUP:
|
|
if (!_TryForwardNCToClient(uMsg, lParam))
|
|
{
|
|
goto L_WM_NCMOUSEMOVE;
|
|
}
|
|
break;
|
|
|
|
case WM_NCMOUSEMOVE:
|
|
L_WM_NCMOUSEMOVE:
|
|
if (IsPosInHwnd(lParam, _hwndNotify))
|
|
{
|
|
MSG msgInner;
|
|
msgInner.lParam = lParam;
|
|
msgInner.wParam = wParam;
|
|
msgInner.message = uMsg;
|
|
msgInner.hwnd = hwnd;
|
|
SendMessage(_hwndTrayTips, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)&msgInner);
|
|
if (uMsg == WM_NCLBUTTONDOWN)
|
|
_SetFocus(_hwndNotify);
|
|
}
|
|
goto DoDefault;
|
|
|
|
case WM_CREATE:
|
|
return _OnCreate(hwnd);
|
|
|
|
case WM_DESTROY:
|
|
return _HandleDestroy();
|
|
|
|
#ifdef DEBUG
|
|
case WM_QUERYENDSESSION:
|
|
TraceMsg(DM_SHUTDOWN, "Tray.wp WM_QUERYENDSESSION");
|
|
goto DoDefault;
|
|
#endif
|
|
|
|
case WM_ENDSESSION:
|
|
// save our settings if we are shutting down
|
|
if (wParam)
|
|
{
|
|
if (lParam | ENDSESSION_LOGOFF)
|
|
{
|
|
_fIsLogoff = TRUE;
|
|
_RecomputeAllWorkareas();
|
|
}
|
|
|
|
_SaveTrayAndDesktop();
|
|
|
|
ShowWindow(_hwnd, SW_HIDE);
|
|
ShowWindow(v_hwndDesktop, SW_HIDE);
|
|
|
|
DestroyWindow(_hwnd);
|
|
}
|
|
break;
|
|
|
|
case WM_PRINTCLIENT:
|
|
case WM_PAINT:
|
|
{
|
|
RECT rc;
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = (HDC)wParam;
|
|
if (hdc == 0)
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
|
|
GetClientRect(hwnd, &rc);
|
|
|
|
|
|
if (_hTheme)
|
|
{
|
|
RECT rcClip;
|
|
if (GetClipBox(hdc, &rcClip) == NULLREGION)
|
|
rcClip = rc;
|
|
|
|
DrawThemeBackground(_hTheme, hdc, _GetPart(FALSE, _uStuckPlace), 0, &rc, &rcClip);
|
|
}
|
|
else
|
|
{
|
|
FillRect(hdc, &rc, (HBRUSH)(COLOR_3DFACE + 1));
|
|
|
|
// draw etched line around on either side of the bandsite
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&rc, 2);
|
|
InflateRect(&rc, g_cxEdge, g_cyEdge);
|
|
DrawEdge(hdc, &rc, EDGE_ETCHED, BF_TOPLEFT);
|
|
}
|
|
|
|
if (wParam == 0)
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
break;
|
|
|
|
case WM_ERASEBKGND:
|
|
if (_hTheme)
|
|
{
|
|
if (!_fSkipErase)
|
|
{
|
|
RECT rc;
|
|
GetClientRect(hwnd, &rc);
|
|
DrawThemeBackground(_hTheme, (HDC)wParam, _GetPart(FALSE, _uStuckPlace), 0, &rc, NULL);
|
|
|
|
// Only draw the first time to prevent piece-mail taskbar painting
|
|
_fSkipErase = TRUE;
|
|
}
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
goto DoDefault;
|
|
}
|
|
break;
|
|
|
|
case WM_NCPAINT:
|
|
if (_hTheme)
|
|
{
|
|
return _NCPaint((HRGN)wParam);
|
|
}
|
|
else
|
|
{
|
|
goto DoDefault;
|
|
}
|
|
break;
|
|
|
|
case WM_POWER:
|
|
case WM_POWERBROADCAST:
|
|
_PropagateMessage(hwnd, uMsg, wParam, lParam);
|
|
_HandlePowerStatus(uMsg, wParam, lParam);
|
|
goto DoDefault;
|
|
|
|
case WM_DEVICECHANGE:
|
|
lres = _OnDeviceChange(hwnd, wParam, lParam);
|
|
if (lres == 0)
|
|
{
|
|
goto DoDefault;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *pnm = (NMHDR*)lParam;
|
|
if (!BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, &lres)) {
|
|
switch (pnm->code)
|
|
{
|
|
case SEN_DDEEXECUTE:
|
|
if (((LPNMHDR)lParam)->idFrom == 0)
|
|
{
|
|
LPNMVIEWFOLDER pnmPost = DDECreatePostNotify((LPNMVIEWFOLDER)pnm);
|
|
|
|
if (pnmPost)
|
|
{
|
|
PostMessage(hwnd, GetDDEExecMsg(), 0, (LPARAM)pnmPost);
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NM_STARTWAIT:
|
|
case NM_ENDWAIT:
|
|
_OnWaitCursorNotify((NMHDR *)lParam);
|
|
PostMessage(v_hwndDesktop, ((NMHDR*)lParam)->code == NM_STARTWAIT ? DTM_STARTWAIT : DTM_ENDWAIT,
|
|
0, 0); // forward it along
|
|
break;
|
|
|
|
case NM_THEMECHANGED:
|
|
// Force the start button to recalc its size
|
|
_sizeStart.cx = 0;
|
|
SizeWindows();
|
|
break;
|
|
|
|
case TTN_NEEDTEXT:
|
|
//
|
|
// Make the clock manage its own tooltip.
|
|
//
|
|
return SendMessage(_GetClockWindow(), WM_NOTIFY, wParam, lParam);
|
|
|
|
case TTN_SHOW:
|
|
SetWindowZorder(_hwndTrayTips, HWND_TOP);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_CLOSE:
|
|
_DoExitWindows(v_hwndDesktop);
|
|
break;
|
|
|
|
case WM_NCHITTEST:
|
|
{
|
|
RECT r1;
|
|
POINT pt;
|
|
|
|
GetClientRect(hwnd, &r1);
|
|
MapWindowPoints(hwnd, NULL, (LPPOINT)&r1, 2);
|
|
|
|
pt.x = GET_X_LPARAM(lParam);
|
|
pt.y = GET_Y_LPARAM(lParam);
|
|
|
|
_SetUnhideTimer(pt.x, pt.y);
|
|
|
|
// If the user can't size or move the taskbar, then just say
|
|
// they hit something useless
|
|
if (!_fCanSizeMove)
|
|
{
|
|
return HTBORDER;
|
|
}
|
|
else if (PtInRect(&r1, pt))
|
|
{
|
|
// allow dragging if mouse is in client area of _hwnd
|
|
return HTCAPTION;
|
|
}
|
|
else
|
|
{
|
|
return _PtOnResizableEdge(pt, &r1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
_HandleWindowPosChanging((LPWINDOWPOS)lParam);
|
|
break;
|
|
|
|
case WM_ENTERSIZEMOVE:
|
|
DebugMsg(DM_TRAYDOCK, TEXT("Tray -- WM_ENTERSIZEMOVE"));
|
|
g_fInSizeMove = TRUE;
|
|
GetCursorPos((LPPOINT)&_rcSizeMoveIgnore);
|
|
_rcSizeMoveIgnore.right = _rcSizeMoveIgnore.left;
|
|
_rcSizeMoveIgnore.bottom = _rcSizeMoveIgnore.top;
|
|
InflateRect(&_rcSizeMoveIgnore, GetSystemMetrics(SM_CXICON),
|
|
GetSystemMetrics(SM_CYICON));
|
|
|
|
//
|
|
// unclip the tray from the current monitor.
|
|
// keeping the tray properly clipped in the MoveSize loop is extremely
|
|
// hairy and provides almost no benefit. we'll re-clip when it lands.
|
|
//
|
|
_ClipWindow(FALSE);
|
|
|
|
// Remember the old monitor we were on
|
|
_hmonOld = _hmonStuck;
|
|
|
|
// set up for WM_MOVING/WM_SIZING messages
|
|
_uMoveStuckPlace = (UINT)-1;
|
|
_fSysSizing = TRUE;
|
|
|
|
if (!g_fDragFullWindows)
|
|
{
|
|
SendMessage(_hwndRebar, WM_SETREDRAW, FALSE, 0);
|
|
}
|
|
break;
|
|
|
|
case WM_EXITSIZEMOVE:
|
|
DebugMsg(DM_TRAYDOCK, TEXT("Tray -- WM_EXITSIZEMOVE"));
|
|
|
|
// done sizing
|
|
_fSysSizing = FALSE;
|
|
_fDeferedPosRectChange = FALSE;
|
|
|
|
if (!g_fDragFullWindows)
|
|
{
|
|
SendMessage(_hwndRebar, WM_SETREDRAW, TRUE, 0);
|
|
}
|
|
|
|
//
|
|
// kick the size code one last time after the loop is done.
|
|
// NOTE: we rely on the WM_SIZE code re-clipping the tray.
|
|
//
|
|
PostMessage(hwnd, WM_SIZE, 0, 0L);
|
|
g_fInSizeMove = FALSE;
|
|
break;
|
|
|
|
case WM_MOVING:
|
|
_HandleMoving(wParam, (LPRECT)lParam);
|
|
break;
|
|
|
|
case WM_ENTERMENULOOP:
|
|
// DebugMsg(DM_TRACE, "c.twp: Enter menu loop.");
|
|
_HandleEnterMenuLoop();
|
|
break;
|
|
|
|
case WM_EXITMENULOOP:
|
|
// DebugMsg(DM_TRACE, "c.twp: Exit menu loop.");
|
|
_HandleExitMenuLoop();
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
if (IDT_SERVICE0 <= wParam && wParam <= IDT_SERVICELAST)
|
|
return _OnTimerService(uMsg, wParam, lParam);
|
|
_HandleTimer(wParam);
|
|
break;
|
|
|
|
case WM_SIZING:
|
|
_HandleSizing(wParam, (LPRECT)lParam, _uStuckPlace);
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
_HandleSize();
|
|
break;
|
|
|
|
case WM_DISPLAYCHANGE:
|
|
// NOTE: we get WM_DISPLAYCHANGE in the below two situations
|
|
// 1. a display size changes (HMON will not change in USER)
|
|
// 2. a display goes away or gets added (HMON will change even if
|
|
// the monitor that went away has nothing to do with our hmonStuck)
|
|
|
|
// In the above two situations we actually need to do different things
|
|
// because in 1, we do not want to update our hmonStuck because we might
|
|
// end up on another monitor, but in 2 we do want to update hmonStuck because
|
|
// our hmon is invalid
|
|
|
|
// The way we handle this is to call GetMonitorInfo on our old HMONITOR
|
|
// and see if it's still valid, if not, we update it by calling _SetStuckMonitor
|
|
// all these code is in _ScreenSizeChange;
|
|
|
|
_ScreenSizeChange(hwnd);
|
|
|
|
// Force the Start Pane to rebuild because a change in color depth
|
|
// causes themes to run around destroying fonts (ruining the OOBE
|
|
// text) and we need to reload our bitmaps for the new color depth
|
|
// anyway.
|
|
::PostMessage(_hwnd, SBM_REBUILDMENU, 0, 0);
|
|
|
|
break;
|
|
|
|
// Don't go to default wnd proc for this one...
|
|
case WM_INPUTLANGCHANGEREQUEST:
|
|
return(LRESULT)0L;
|
|
|
|
case WM_GETMINMAXINFO:
|
|
((MINMAXINFO *)lParam)->ptMinTrackSize.x = g_cxFrame;
|
|
((MINMAXINFO *)lParam)->ptMinTrackSize.y = g_cyFrame;
|
|
break;
|
|
|
|
case WM_WININICHANGE:
|
|
if (lParam && (0 == lstrcmpi((LPCTSTR)lParam, TEXT("SaveTaskbar"))))
|
|
{
|
|
_SaveTrayAndDesktop();
|
|
}
|
|
else
|
|
{
|
|
BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, NULL);
|
|
_PropagateMessage(hwnd, uMsg, wParam, lParam);
|
|
_OnWinIniChange(hwnd, wParam, lParam);
|
|
}
|
|
|
|
if (lParam)
|
|
TraceMsg(TF_TRAY, "Tray Got: lParam=%s", (LPCSTR)lParam);
|
|
|
|
break;
|
|
|
|
case WM_TIMECHANGE:
|
|
_PropagateMessage(hwnd, uMsg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_SYSCOLORCHANGE:
|
|
_OnNewSystemSizes();
|
|
BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, NULL);
|
|
_PropagateMessage(hwnd, uMsg, wParam, lParam);
|
|
break;
|
|
|
|
case WM_SETCURSOR:
|
|
if (_iWaitCount) {
|
|
SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
|
|
return TRUE;
|
|
} else
|
|
goto DoDefault;
|
|
|
|
case WM_SETFOCUS:
|
|
IUnknown_UIActivateIO(_ptbs, TRUE, NULL);
|
|
break;
|
|
|
|
case WM_SYSCHAR:
|
|
if (wParam == TEXT(' ')) {
|
|
HMENU hmenu;
|
|
int idCmd;
|
|
|
|
SHSetWindowBits(hwnd, GWL_STYLE, WS_SYSMENU, WS_SYSMENU);
|
|
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);
|
|
EnableMenuItem(hmenu, SC_MOVE, (_fCanSizeMove ? MFS_ENABLED : MFS_GRAYED) | MF_BYCOMMAND);
|
|
EnableMenuItem(hmenu, SC_SIZE, (_fCanSizeMove ? MFS_ENABLED : MFS_GRAYED) | MF_BYCOMMAND);
|
|
|
|
idCmd = _TrackMenu(hmenu);
|
|
if (idCmd)
|
|
SendMessage(_hwnd, WM_SYSCOMMAND, idCmd, 0L);
|
|
}
|
|
SHSetWindowBits(hwnd, GWL_STYLE, WS_SYSMENU, 0L);
|
|
}
|
|
break;
|
|
|
|
case WM_SYSCOMMAND:
|
|
|
|
// if we are sizing, make the full screen accessible
|
|
switch (wParam & 0xFFF0) {
|
|
case SC_CLOSE:
|
|
_DoExitWindows(v_hwndDesktop);
|
|
break;
|
|
|
|
default:
|
|
goto DoDefault;
|
|
}
|
|
break;
|
|
|
|
|
|
case TM_DESKTOPSTATE:
|
|
_OnDesktopState(lParam);
|
|
break;
|
|
|
|
case TM_RAISEDESKTOP:
|
|
_RaiseDesktop((BOOL)wParam, FALSE);
|
|
break;
|
|
|
|
#ifdef DEBUG
|
|
case TM_NEXTCTL:
|
|
#endif
|
|
case TM_UIACTIVATEIO:
|
|
case TM_ONFOCUSCHANGEIS:
|
|
_OnFocusMsg(uMsg, wParam, lParam);
|
|
break;
|
|
|
|
case TM_MARSHALBS: // wParam=IID lRes=pstm
|
|
return BandSite_OnMarshallBS(wParam, lParam);
|
|
|
|
case TM_SETTIMER:
|
|
case TM_KILLTIMER:
|
|
return _OnTimerService(uMsg, wParam, lParam);
|
|
break;
|
|
|
|
case TM_FACTORY:
|
|
return _OnFactoryMessage(wParam, lParam);
|
|
|
|
case TM_ACTASTASKSW:
|
|
_ActAsSwitcher();
|
|
break;
|
|
|
|
case TM_RELAYPOSCHANGED:
|
|
_AppBarNotifyAll((HMONITOR)lParam, ABN_POSCHANGED, (HWND)wParam, 0);
|
|
break;
|
|
|
|
case TM_BRINGTOTOP:
|
|
SetWindowZorder((HWND)wParam, HWND_TOP);
|
|
break;
|
|
|
|
case TM_WARNNOAUTOHIDE:
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.twp collision UI request"));
|
|
|
|
//
|
|
// this may look a little funny but what we do is post this message all
|
|
// over the place and ignore it when we think it is a bad time to put
|
|
// up a message (like the middle of a fulldrag...)
|
|
//
|
|
// wParam tells us if we need to try to clear the state
|
|
// the lowword of _SetAutoHideState's return tells if anything changed
|
|
//
|
|
if ((!_fSysSizing || !g_fDragFullWindows) &&
|
|
(!wParam || LOWORD(_SetAutoHideState(FALSE))))
|
|
{
|
|
ShellMessageBox(hinstCabinet, hwnd,
|
|
MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
|
|
MAKEINTRESOURCE(IDS_TASKBAR), MB_OK | MB_ICONINFORMATION);
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRAYDOCK, TEXT("TRAYDOCK.twp blowing off extraneous collision UI request"));
|
|
}
|
|
break;
|
|
|
|
case TM_PRIVATECOMMAND:
|
|
_HandlePrivateCommand(lParam);
|
|
break;
|
|
|
|
case TM_HANDLEDELAYBOOTSTUFF:
|
|
_HandleDelayBootStuff();
|
|
break;
|
|
|
|
case TM_SHELLSERVICEOBJECTS:
|
|
_ssomgr.LoadRegObjects();
|
|
break;
|
|
|
|
case TM_CHANGENOTIFY:
|
|
_HandleChangeNotify(wParam, lParam);
|
|
break;
|
|
|
|
case TM_GETHMONITOR:
|
|
*((HMONITOR *)lParam) = _hmonStuck;
|
|
break;
|
|
|
|
case TM_DOTRAYPROPERTIES:
|
|
DoProperties(TPF_TASKBARPAGE);
|
|
break;
|
|
|
|
case TM_STARTUPAPPSLAUNCHED:
|
|
PostMessage(_hwndNotify, TNM_STARTUPAPPSLAUNCHED, 0, 0);
|
|
break;
|
|
|
|
case TM_LANGUAGEBAND:
|
|
return _ToggleLanguageBand(lParam);
|
|
|
|
case WM_NCRBUTTONUP:
|
|
uMsg = WM_CONTEXTMENU;
|
|
wParam = (WPARAM)_hwndTasks;
|
|
goto L_WM_CONTEXTMENU;
|
|
|
|
case WM_CONTEXTMENU:
|
|
L_WM_CONTEXTMENU:
|
|
|
|
if (!SHRestricted(REST_NOTRAYCONTEXTMENU))
|
|
{
|
|
if (((HWND)wParam) == _hwndStart)
|
|
{
|
|
// Don't display of the Start Menu is up.
|
|
if (SendMessage(_hwndStart, BM_GETSTATE, 0, 0) & BST_PUSHED)
|
|
break;
|
|
|
|
_fFromStart = TRUE;
|
|
|
|
StartMenuContextMenu(_hwnd, (DWORD)lParam);
|
|
|
|
_fFromStart = FALSE;
|
|
}
|
|
else if (IsPosInHwnd(lParam, _hwndNotify) || SHIsChildOrSelf(_hwndNotify, GetFocus()) == S_OK)
|
|
{
|
|
// if click was inthe clock, include
|
|
// the time
|
|
_ContextMenu((DWORD)lParam, TRUE);
|
|
}
|
|
else
|
|
{
|
|
BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, &lres);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_INITMENUPOPUP:
|
|
case WM_MEASUREITEM:
|
|
case WM_DRAWITEM:
|
|
case WM_MENUCHAR:
|
|
// Don't call bandsite message handler when code path started via the start button context menu
|
|
if (!_fFromStart)
|
|
{
|
|
BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, &lres);
|
|
}
|
|
break;
|
|
|
|
case TM_DOEXITWINDOWS:
|
|
_DoExitWindows(v_hwndDesktop);
|
|
break;
|
|
|
|
case TM_HANDLESTARTUPFAILED:
|
|
_OnHandleStartupFailed();
|
|
break;
|
|
|
|
case WM_HOTKEY:
|
|
if (wParam < GHID_FIRST)
|
|
{
|
|
_HandleHotKey((WORD)wParam);
|
|
}
|
|
else
|
|
{
|
|
_HandleGlobalHotkey(wParam);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if (!BandSite_HandleMessage(_ptbs, hwnd, uMsg, wParam, lParam, &lres))
|
|
_Command(GET_WM_COMMAND_ID(wParam, lParam));
|
|
break;
|
|
|
|
case SBM_CANCELMENU:
|
|
ClosePopupMenus();
|
|
break;
|
|
|
|
case SBM_REBUILDMENU:
|
|
_BuildStartMenu();
|
|
break;
|
|
|
|
case WM_WINDOWPOSCHANGED:
|
|
_AppBarActivationChange2(hwnd, _uStuckPlace);
|
|
SendMessage(_hwndNotify, TNM_TRAYPOSCHANGED, 0, 0);
|
|
goto DoDefault;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
if (_hwndStartBalloon)
|
|
{
|
|
RECT rc;
|
|
POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
|
|
GetWindowRect(_hwndStartBalloon, &rc);
|
|
MapWindowRect(HWND_DESKTOP, _hwnd, &rc);
|
|
|
|
if (PtInRect(&rc, pt))
|
|
{
|
|
ShowWindow(_hwndStartBalloon, SW_HIDE);
|
|
_DontShowTheStartButtonBalloonAnyMore();
|
|
_DestroyStartButtonBalloon();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TM_SETPUMPHOOK:
|
|
ATOMICRELEASE(_pmbTasks);
|
|
ATOMICRELEASE(_pmpTasks);
|
|
if (wParam && lParam)
|
|
{
|
|
_pmbTasks = (IMenuBand*)wParam;
|
|
_pmbTasks->AddRef();
|
|
_pmpTasks = (IMenuPopup*)lParam;
|
|
_pmpTasks->AddRef();
|
|
}
|
|
break;
|
|
|
|
case WM_ACTIVATE:
|
|
_AppBarActivationChange2(hwnd, _uStuckPlace);
|
|
if (wParam != WA_INACTIVE)
|
|
{
|
|
Unhide();
|
|
}
|
|
else
|
|
{
|
|
// When tray is deactivated, remove our keyboard cues:
|
|
//
|
|
SendMessage(hwnd, WM_CHANGEUISTATE,
|
|
MAKEWPARAM(UIS_SET, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);
|
|
|
|
IUnknown_UIActivateIO(_ptbs, FALSE, NULL);
|
|
}
|
|
//
|
|
// Tray activation is a good time to do a reality check
|
|
// (make sure "always-on-top" agrees with actual window
|
|
// position, make sure there are no ghost buttons, etc).
|
|
//
|
|
RealityCheck();
|
|
goto L_default;
|
|
|
|
case WM_WTSSESSION_CHANGE:
|
|
{
|
|
lres = _OnSessionChange(wParam, lParam);
|
|
break;
|
|
}
|
|
|
|
case WM_THEMECHANGED:
|
|
{
|
|
if (_hTheme)
|
|
{
|
|
CloseThemeData(_hTheme);
|
|
_hTheme = NULL;
|
|
}
|
|
if (wParam)
|
|
{
|
|
_hTheme = OpenThemeData(_hwnd, c_wzTaskbarTheme);
|
|
_fShowSizingBarAlways = (_uAutoHide & AH_ON) ? TRUE : FALSE;
|
|
if (_hTheme)
|
|
{
|
|
GetThemeBool(_hTheme, 0, 0, TMT_ALWAYSSHOWSIZINGBAR, &_fShowSizingBarAlways);
|
|
}
|
|
_UpdateVertical(_uStuckPlace, TRUE);
|
|
// Force Refresh of frame
|
|
SetWindowPos(_hwnd, NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
|
|
}
|
|
|
|
// Force the start button to recalc its size
|
|
_sizeStart.cx = 0;
|
|
_StartButtonReset();
|
|
InvalidateRect(_hwnd, NULL, TRUE);
|
|
|
|
// Force the Start Pane to rebuild with new theme
|
|
::PostMessage(_hwnd, SBM_REBUILDMENU, 0, 0);
|
|
|
|
SetWindowStyle(_hwnd, WS_BORDER | WS_THICKFRAME, !_hTheme);
|
|
}
|
|
break;
|
|
|
|
case TM_WORKSTATIONLOCKED:
|
|
{
|
|
// Desktop locked status changed...
|
|
BOOL fIsDesktopLocked = (BOOL) wParam;
|
|
if (_fIsDesktopLocked != fIsDesktopLocked)
|
|
{
|
|
_fIsDesktopLocked = fIsDesktopLocked;
|
|
_fIsLogoff = FALSE;
|
|
_RecomputeAllWorkareas();
|
|
PostMessage(_hwndNotify, TNM_WORKSTATIONLOCKED, wParam, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TM_SHOWTRAYBALLOON:
|
|
PostMessage(_hwndNotify, TNM_SHOWTRAYBALLOON, wParam, 0);
|
|
break;
|
|
|
|
case TM_STARTMENUDISMISSED:
|
|
// 107561 - call CoFreeUnusedLibraries() peridically to free up dlls - ZekeL - 4-MAY-2001
|
|
// specifically to support MSONSEXT (webfolders) being used in RecentDocs
|
|
// after a file has been opened via webfolders. we get the icon via
|
|
// their namespace but then COM holds on to the DLL for a while (forever?)
|
|
// calling CoFreeUnusedLibraries() does the trick
|
|
SetTimer(_hwnd, IDT_COFREEUNUSED, 3 * 60 * 1000, NULL);
|
|
break;
|
|
|
|
case MM_MIXM_CONTROL_CHANGE:
|
|
Mixer_ControlChange(wParam, lParam);
|
|
break;
|
|
|
|
default:
|
|
L_default:
|
|
if (uMsg == GetDDEExecMsg())
|
|
{
|
|
ASSERT(lParam && 0 == ((LPNMHDR)lParam)->idFrom);
|
|
DDEHandleViewFolderNotify(NULL, _hwnd, (LPNMVIEWFOLDER)lParam);
|
|
LocalFree((LPNMVIEWFOLDER)lParam);
|
|
return TRUE;
|
|
}
|
|
else if (uMsg == _uStartButtonBalloonTip)
|
|
{
|
|
_ShowStartButtonToolTip();
|
|
}
|
|
else if (uMsg == _uLogoffUser)
|
|
{
|
|
// Log off the current user (message from U&P control panel)
|
|
ExitWindowsEx(EWX_LOGOFF, 0);
|
|
}
|
|
else if (uMsg == _uMsgEnableUserTrackedBalloonTips)
|
|
{
|
|
PostMessage(_hwndNotify, TNM_ENABLEUSERTRACKINGINFOTIPS, wParam, 0);
|
|
}
|
|
else if (uMsg == _uWinMM_DeviceChange)
|
|
{
|
|
Mixer_MMDeviceChange();
|
|
}
|
|
|
|
|
|
DoDefault:
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
return lres;
|
|
}
|
|
|
|
void CTray::_DoExitWindows(HWND hwnd)
|
|
{
|
|
static BOOL s_fShellShutdown = FALSE;
|
|
|
|
if (!s_fShellShutdown)
|
|
{
|
|
|
|
if (_Restricted(hwnd, REST_NOCLOSE))
|
|
return;
|
|
|
|
{
|
|
UEMFireEvent(&UEMIID_SHELL, UEME_CTLSESSION, UEMF_XEVENT, FALSE, -1);
|
|
// really #ifdef DEBUG, but want for testing
|
|
// however can't do unconditionally due to perf
|
|
if (ERROR_SUCCESS == SHGetValue(HKEY_CURRENT_USER, REGSTR_EXPLORER_ADVANCED, TEXT("StartMenuForceRefresh"),
|
|
NULL, NULL, NULL) || GetAsyncKeyState(VK_SHIFT) < 0)
|
|
{
|
|
_RefreshStartMenu();
|
|
}
|
|
}
|
|
|
|
_SaveTrayAndDesktop();
|
|
|
|
_uModalMode = MM_SHUTDOWN;
|
|
ExitWindowsDialog(hwnd);
|
|
|
|
// NB User can have problems if the focus is forcebly changed to the desktop while
|
|
// shutting down since it tries to serialize the whole process by making windows sys-modal.
|
|
// If we hit this code at just the wrong moment (ie just after the sharing dialog appears)
|
|
// the desktop will become sys-modal so you can't switch back to the sharing dialog
|
|
// and you won't be able to shutdown.
|
|
// SetForegroundWindow(hwnd);
|
|
// SetFocus(hwnd);
|
|
|
|
_uModalMode = 0;
|
|
if ((GetKeyState(VK_SHIFT) < 0) && (GetKeyState(VK_CONTROL) < 0) && (GetKeyState(VK_MENU) < 0))
|
|
{
|
|
// User cancelled...
|
|
// The shift key means exit the tray...
|
|
// ??? - Used to destroy all cabinets...
|
|
// PostQuitMessage(0);
|
|
g_fFakeShutdown = TRUE; // Don't blow away session state; the session will survive
|
|
TraceMsg(TF_TRAY, "c.dew: Posting quit message for tid=%#08x hwndDesk=%x(IsWnd=%d) hwndTray=%x(IsWnd=%d)", GetCurrentThreadId(),
|
|
v_hwndDesktop,IsWindow(v_hwndDesktop), _hwnd,IsWindow(_hwnd));
|
|
// 1 means close all the shell windows too
|
|
PostMessage(v_hwndDesktop, WM_QUIT, 0, 1);
|
|
PostMessage(_hwnd, WM_QUIT, 0, 0);
|
|
|
|
s_fShellShutdown = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CTray::_SaveTray(void)
|
|
{
|
|
if (SHRestricted(REST_NOSAVESET))
|
|
return;
|
|
|
|
if (SHRestricted(REST_CLEARRECENTDOCSONEXIT))
|
|
ClearRecentDocumentsAndMRUStuff(FALSE);
|
|
|
|
//
|
|
// Don't persist tray stuff if in safe mode. We want this
|
|
// to be a temporary mode where the UI settings don't stick.
|
|
//
|
|
if (GetSystemMetrics(SM_CLEANBOOT) == 0)
|
|
{
|
|
_SaveTrayStuff();
|
|
}
|
|
}
|
|
|
|
DWORD WINAPI CTray::PropertiesThreadProc(void* pv)
|
|
{
|
|
return c_tray._PropertiesThreadProc(PtrToUlong(pv));
|
|
}
|
|
|
|
DWORD CTray::_PropertiesThreadProc(DWORD dwFlags)
|
|
{
|
|
HWND hwnd;
|
|
RECT rc;
|
|
DWORD dwExStyle = WS_EX_TOOLWINDOW;
|
|
|
|
GetWindowRect(_hwndStart, &rc);
|
|
dwExStyle |= IS_BIDI_LOCALIZED_SYSTEM() ? dwExStyleRTLMirrorWnd : 0L;
|
|
|
|
_hwndProp = hwnd = CreateWindowEx(dwExStyle, TEXT("static"), NULL, 0 ,
|
|
rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hinstCabinet, NULL);
|
|
|
|
#define IDI_STTASKBR 40 // stolen from shell32\ids.h
|
|
if (_hwndProp)
|
|
{
|
|
// Get the Alt+Tab icon right
|
|
HICON hicoStub = LoadIcon(GetModuleHandle(TEXT("SHELL32")), MAKEINTRESOURCE(IDI_STTASKBR));
|
|
SendMessage(_hwndProp, WM_SETICON, ICON_BIG, (LPARAM)hicoStub);
|
|
|
|
// SwitchToThisWindow(hwnd, TRUE);
|
|
// SetForegroundWindow(hwnd);
|
|
|
|
DoTaskBarProperties(hwnd, dwFlags);
|
|
|
|
_hwndProp = NULL;
|
|
DestroyWindow(hwnd);
|
|
if (hicoStub)
|
|
DestroyIcon(hicoStub);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define RUNWAITSECS 5
|
|
void CTray::DoProperties(DWORD dwFlags)
|
|
{
|
|
if (!_Restricted(_hwnd, REST_NOSETTASKBAR))
|
|
{
|
|
int i = RUNWAITSECS;
|
|
while (_hwndProp == ((HWND)-1) &&i--)
|
|
{
|
|
// we're in the process of coming up. wait
|
|
Sleep(1000);
|
|
}
|
|
|
|
// failed! blow it off.
|
|
if (_hwndProp == (HWND)-1)
|
|
{
|
|
_hwndProp = NULL;
|
|
}
|
|
|
|
if (_hwndProp)
|
|
{
|
|
// there's a window out there... activate it
|
|
SwitchToThisWindow(GetLastActivePopup(_hwndProp), TRUE);
|
|
}
|
|
else
|
|
{
|
|
_hwndProp = (HWND)-1;
|
|
if (!SHCreateThread(PropertiesThreadProc, IntToPtr(dwFlags), CTF_COINIT, NULL))
|
|
{
|
|
_hwndProp = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CTray::TileEnumProc(HWND hwnd, LPARAM lParam)
|
|
{
|
|
CTray* ptray = (CTray*)lParam;
|
|
|
|
if (IsWindowVisible(hwnd) && !IsIconic(hwnd) &&
|
|
((GetWindowLong(hwnd, GWL_STYLE) & WS_CAPTION) == WS_CAPTION) &&
|
|
(hwnd != ptray->_hwnd) && hwnd != v_hwndDesktop)
|
|
{
|
|
return FALSE; // we *can* tile this guy
|
|
}
|
|
return TRUE; // we *cannot* tile this guy
|
|
}
|
|
|
|
HMENU CTray::BuildContextMenu(BOOL fIncludeTime)
|
|
{
|
|
HMENU hmContext = LoadMenuPopup(MAKEINTRESOURCE(MENU_TRAYCONTEXT));
|
|
if (!hmContext)
|
|
return NULL;
|
|
|
|
if (fIncludeTime)
|
|
{
|
|
if (_trayNotify.GetIsNoTrayItemsDisplayPolicyEnabled())
|
|
{
|
|
// We know the position of IDM_NOTIFYCUST from the menu resource...
|
|
DeleteMenu(hmContext, 1, MF_BYPOSITION);
|
|
}
|
|
else
|
|
{
|
|
UINT uEnable = MF_BYCOMMAND;
|
|
if (_trayNotify.GetIsNoAutoTrayPolicyEnabled() || !_trayNotify.GetIsAutoTrayEnabledByUser())
|
|
{
|
|
uEnable |= MFS_DISABLED;
|
|
}
|
|
else
|
|
{
|
|
uEnable |= MFS_ENABLED;
|
|
}
|
|
EnableMenuItem(hmContext, IDM_NOTIFYCUST, uEnable);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
INSTRUMENT_STATECHANGE(SHCNFI_STATE_TRAY_CONTEXT);
|
|
for (int i = 2; i >= 0; i--) // separator, IDM_SETTIME, IDM_NOTIFYCUST,
|
|
{
|
|
DeleteMenu(hmContext, i, MF_BYPOSITION);
|
|
}
|
|
}
|
|
|
|
CheckMenuItem(hmContext, IDM_LOCKTASKBAR,
|
|
MF_BYCOMMAND | (_fCanSizeMove ? MF_UNCHECKED : MF_CHECKED));
|
|
|
|
// Don't let users accidentally check lock the taskbar when the taskbar is zero height
|
|
RECT rc;
|
|
GetClientRect(_hwnd, &rc);
|
|
EnableMenuItem(hmContext, IDM_LOCKTASKBAR,
|
|
MF_BYCOMMAND | ((_IsSizeMoveRestricted() || (RECTHEIGHT(rc) == 0)) ? MFS_DISABLED : MFS_ENABLED));
|
|
|
|
if (!_fUndoEnabled || !_pPositions)
|
|
{
|
|
DeleteMenu(hmContext, IDM_UNDO, MF_BYCOMMAND);
|
|
}
|
|
else
|
|
{
|
|
TCHAR szTemplate[30];
|
|
TCHAR szCommand[30];
|
|
TCHAR szMenu[64];
|
|
LoadString(hinstCabinet, IDS_UNDOTEMPLATE, szTemplate, ARRAYSIZE(szTemplate));
|
|
LoadString(hinstCabinet, _pPositions->idRes, szCommand, ARRAYSIZE(szCommand));
|
|
wsprintf(szMenu, szTemplate, szCommand);
|
|
ModifyMenu(hmContext, IDM_UNDO, MF_BYCOMMAND | MF_STRING, IDM_UNDO, szMenu);
|
|
}
|
|
|
|
if (g_fDesktopRaised)
|
|
{
|
|
TCHAR szHideDesktop[64];
|
|
LoadString(hinstCabinet, IDS_HIDEDESKTOP, szHideDesktop, ARRAYSIZE(szHideDesktop));
|
|
ModifyMenu(hmContext, IDM_TOGGLEDESKTOP, MF_BYCOMMAND | MF_STRING, IDM_TOGGLEDESKTOP, szHideDesktop);
|
|
}
|
|
|
|
if (!_CanTileAnyWindows())
|
|
{
|
|
EnableMenuItem(hmContext, IDM_CASCADE, MFS_GRAYED | MF_BYCOMMAND);
|
|
EnableMenuItem(hmContext, IDM_HORIZTILE, MFS_GRAYED | MF_BYCOMMAND);
|
|
EnableMenuItem(hmContext, IDM_VERTTILE, MFS_GRAYED | MF_BYCOMMAND);
|
|
}
|
|
|
|
HKEY hKeyPolicy;
|
|
if (RegOpenKeyEx(HKEY_CURRENT_USER,
|
|
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System"),
|
|
0, KEY_READ, &hKeyPolicy) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwType, dwData = 0, dwSize = sizeof(dwData);
|
|
RegQueryValueEx(hKeyPolicy, TEXT("DisableTaskMgr"), NULL,
|
|
&dwType, (LPBYTE) &dwData, &dwSize);
|
|
RegCloseKey(hKeyPolicy);
|
|
if (dwData)
|
|
EnableMenuItem(hmContext, IDM_SHOWTASKMAN, MFS_GRAYED | MF_BYCOMMAND);
|
|
}
|
|
|
|
return hmContext;
|
|
}
|
|
|
|
void CTray::ContextMenuInvoke(int idCmd)
|
|
{
|
|
if (idCmd)
|
|
{
|
|
if (idCmd < IDM_TRAYCONTEXTFIRST)
|
|
{
|
|
BandSite_HandleMenuCommand(_ptbs, idCmd);
|
|
}
|
|
else
|
|
{
|
|
_Command(idCmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// CTray::AsyncSaveSettings
|
|
//
|
|
// We need to save our tray settings, but there may be a bunch
|
|
// of these calls coming, (at startup time or when dragging
|
|
// items in the task bar) so gather them up into one save that
|
|
// will happen in at least 2 seconds.
|
|
//
|
|
void CTray::AsyncSaveSettings()
|
|
{
|
|
if (!_fHandledDelayBootStuff) // no point in saving if we're not done booting
|
|
return;
|
|
|
|
KillTimer(_hwnd, IDT_SAVESETTINGS);
|
|
SetTimer(_hwnd, IDT_SAVESETTINGS, 2000, NULL);
|
|
}
|
|
|
|
|
|
void CTray::_ContextMenu(DWORD dwPos, BOOL fIncludeTime)
|
|
{
|
|
POINT pt = {LOWORD(dwPos), HIWORD(dwPos)};
|
|
|
|
SwitchToThisWindow(_hwnd, TRUE);
|
|
SetForegroundWindow(_hwnd);
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
|
|
|
|
if (dwPos != (DWORD)-1 &&
|
|
IsChildOrHWND(_hwndRebar, WindowFromPoint(pt)))
|
|
{
|
|
// if the context menu came from below us, reflect down
|
|
BandSite_HandleMessage(_ptbs, _hwnd, WM_CONTEXTMENU, 0, dwPos, NULL);
|
|
|
|
}
|
|
else
|
|
{
|
|
HMENU hmenu;
|
|
|
|
if (dwPos == (DWORD)-1)
|
|
{
|
|
HWND hwnd = GetFocus();
|
|
pt.x = pt.y = 0;
|
|
ClientToScreen(hwnd, &pt);
|
|
dwPos = MAKELONG(pt.x, pt.y);
|
|
}
|
|
|
|
hmenu = BuildContextMenu(fIncludeTime);
|
|
if (hmenu)
|
|
{
|
|
int idCmd;
|
|
|
|
BandSite_AddMenus(_ptbs, hmenu, 0, 0, IDM_TRAYCONTEXTFIRST);
|
|
|
|
idCmd = TrackPopupMenu(hmenu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
|
|
GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos), 0, _hwnd, NULL);
|
|
|
|
DestroyMenu(hmenu);
|
|
|
|
ContextMenuInvoke(idCmd);
|
|
}
|
|
}
|
|
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
|
|
}
|
|
|
|
void _RunFileDlg(HWND hwnd, UINT idIcon, LPCITEMIDLIST pidlWorkingDir, UINT idTitle, UINT idPrompt, DWORD dwFlags)
|
|
{
|
|
HICON hIcon;
|
|
LPCTSTR lpszTitle;
|
|
LPCTSTR lpszPrompt;
|
|
TCHAR szTitle[256];
|
|
TCHAR szPrompt[256];
|
|
TCHAR szWorkingDir[MAX_PATH];
|
|
|
|
dwFlags |= RFD_USEFULLPATHDIR;
|
|
szWorkingDir[0] = 0;
|
|
|
|
hIcon = idIcon ? LoadIcon(hinstCabinet, MAKEINTRESOURCE(idIcon)) : NULL;
|
|
|
|
if (!pidlWorkingDir || !SHGetPathFromIDList(pidlWorkingDir, szWorkingDir))
|
|
{
|
|
// This is either the Tray, or some non-file system folder, so
|
|
// we will "suggest" the Desktop as a working dir, but if the
|
|
// user types a full path, we will use that instead. This is
|
|
// what WIN31 Progman did (except they started in the Windows
|
|
// dir instead of the Desktop).
|
|
goto UseDesktop;
|
|
}
|
|
|
|
// if it's a removable dir, make sure it's still there
|
|
if (szWorkingDir[0])
|
|
{
|
|
int idDrive = PathGetDriveNumber(szWorkingDir);
|
|
if ((idDrive != -1))
|
|
{
|
|
UINT dtype = DriveType(idDrive);
|
|
if (((dtype == DRIVE_REMOVABLE) || (dtype == DRIVE_CDROM))
|
|
&& !PathFileExists(szWorkingDir))
|
|
{
|
|
goto UseDesktop;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if this is a directory. Notice that it could be a in-place
|
|
// navigated document.
|
|
//
|
|
if (PathIsDirectory(szWorkingDir)) {
|
|
goto UseWorkingDir;
|
|
}
|
|
|
|
UseDesktop:
|
|
SHGetSpecialFolderPath(hwnd, szWorkingDir, CSIDL_DESKTOPDIRECTORY, FALSE);
|
|
|
|
UseWorkingDir:
|
|
|
|
if (idTitle)
|
|
{
|
|
LoadString(hinstCabinet, idTitle, szTitle, ARRAYSIZE(szTitle));
|
|
lpszTitle = szTitle;
|
|
}
|
|
else
|
|
lpszTitle = NULL;
|
|
if (idPrompt)
|
|
{
|
|
LoadString(hinstCabinet, idPrompt, szPrompt, ARRAYSIZE(szPrompt));
|
|
lpszPrompt = szPrompt;
|
|
}
|
|
else
|
|
lpszPrompt = NULL;
|
|
|
|
RunFileDlg(hwnd, hIcon, szWorkingDir, lpszTitle, lpszPrompt, dwFlags);
|
|
}
|
|
|
|
BOOL CTray::SavePosEnumProc(HWND hwnd, LPARAM lParam)
|
|
{
|
|
// dont need to entercritical here since we are only ever
|
|
// called from SaveWindowPositions, which as already entered the critical secion
|
|
// for _pPositions
|
|
|
|
ASSERTCRITICAL;
|
|
|
|
CTray* ptray = (CTray*)lParam;
|
|
|
|
ASSERT(ptray->_pPositions);
|
|
|
|
if (IsWindowVisible(hwnd) &&
|
|
(hwnd != ptray->_hwnd) &&
|
|
(hwnd != v_hwndDesktop))
|
|
{
|
|
HWNDANDPLACEMENT hap;
|
|
|
|
hap.wp.length = sizeof(WINDOWPLACEMENT);
|
|
GetWindowPlacement(hwnd, &hap.wp);
|
|
|
|
if (hap.wp.showCmd != SW_SHOWMINIMIZED)
|
|
{
|
|
hap.hwnd = hwnd;
|
|
hap.fRestore = TRUE;
|
|
|
|
DSA_AppendItem(ptray->_pPositions->hdsaWP, &hap);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::SaveWindowPositions(UINT idRes)
|
|
{
|
|
ENTERCRITICAL;
|
|
if (_pPositions)
|
|
{
|
|
if (_pPositions->hdsaWP)
|
|
DSA_DeleteAllItems(_pPositions->hdsaWP);
|
|
}
|
|
else
|
|
{
|
|
_pPositions = (LPWINDOWPOSITIONS)LocalAlloc(LPTR, sizeof(WINDOWPOSITIONS));
|
|
if (_pPositions)
|
|
{
|
|
_pPositions->hdsaWP = DSA_Create(sizeof(HWNDANDPLACEMENT), 4);
|
|
}
|
|
}
|
|
|
|
if (_pPositions)
|
|
{
|
|
_pPositions->idRes = idRes;
|
|
|
|
// CheckWindowPositions tested for these...
|
|
ASSERT(idRes == IDS_MINIMIZEALL || idRes == IDS_CASCADE || idRes == IDS_TILE);
|
|
EnumWindows(SavePosEnumProc, (LPARAM)this);
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
LPWINDOWPOSITIONS pPositions;
|
|
HWND hwndDesktop;
|
|
HWND hwndTray;
|
|
BOOL fPostLowerDesktop;
|
|
} RESTOREWNDDATA, *PRESTOREWNDDATA;
|
|
|
|
DWORD WINAPI RestoreWndPosThreadProc(void* pv)
|
|
{
|
|
PRESTOREWNDDATA pWndData = (PRESTOREWNDDATA)pv;
|
|
if (pWndData && pWndData->pPositions)
|
|
{
|
|
LPHWNDANDPLACEMENT phap;
|
|
LONG iAnimate;
|
|
ANIMATIONINFO ami;
|
|
|
|
ami.cbSize = sizeof(ANIMATIONINFO);
|
|
SystemParametersInfo(SPI_GETANIMATION, sizeof(ami), &ami, FALSE);
|
|
iAnimate = ami.iMinAnimate;
|
|
ami.iMinAnimate = FALSE;
|
|
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
|
|
|
if (pWndData->pPositions->hdsaWP)
|
|
{
|
|
for (int i = DSA_GetItemCount(pWndData->pPositions->hdsaWP) - 1 ; i >= 0; i--)
|
|
{
|
|
phap = (LPHWNDANDPLACEMENT)DSA_GetItemPtr(pWndData->pPositions->hdsaWP, i);
|
|
if (IsWindow(phap->hwnd))
|
|
{
|
|
|
|
#ifndef WPF_ASYNCWINDOWPLACEMENT
|
|
#define WPF_ASYNCWINDOWPLACEMENT 0x0004
|
|
#endif
|
|
// pass this async.
|
|
if (!IsHungAppWindow(phap->hwnd))
|
|
{
|
|
phap->wp.length = sizeof(WINDOWPLACEMENT);
|
|
phap->wp.flags |= WPF_ASYNCWINDOWPLACEMENT;
|
|
if (phap->fRestore)
|
|
{
|
|
// only restore those guys we've actually munged.
|
|
SetWindowPlacement(phap->hwnd, &phap->wp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ami.iMinAnimate = iAnimate;
|
|
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
|
|
|
_DestroySavedWindowPositions(pWndData->pPositions);
|
|
|
|
if (pWndData->fPostLowerDesktop)
|
|
{
|
|
PostMessage(pWndData->hwndDesktop, DTM_RAISE, (WPARAM)pWndData->hwndTray, DTRF_LOWER);
|
|
}
|
|
|
|
delete pWndData;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
BOOL CTray::_RestoreWindowPositions(BOOL fPostLowerDesktop)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
ENTERCRITICAL;
|
|
if (_pPositions)
|
|
{
|
|
PRESTOREWNDDATA pWndData = new RESTOREWNDDATA;
|
|
if (pWndData)
|
|
{
|
|
pWndData->pPositions = _pPositions;
|
|
pWndData->fPostLowerDesktop = fPostLowerDesktop;
|
|
pWndData->hwndDesktop = v_hwndDesktop;
|
|
pWndData->hwndTray = _hwnd;
|
|
|
|
if (SHCreateThread(RestoreWndPosThreadProc, pWndData, 0, NULL))
|
|
{
|
|
fRet = TRUE;
|
|
_pPositions = NULL;
|
|
}
|
|
else
|
|
{
|
|
delete pWndData;
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
return fRet;
|
|
}
|
|
|
|
void _DestroySavedWindowPositions(LPWINDOWPOSITIONS pPositions)
|
|
{
|
|
ENTERCRITICAL;
|
|
if (pPositions)
|
|
{
|
|
// free the global struct
|
|
DSA_Destroy(pPositions->hdsaWP);
|
|
LocalFree(pPositions);
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
void CTray::HandleWindowDestroyed(HWND hwnd)
|
|
{
|
|
// enter critical section so we dont corrupt the hdsaWP
|
|
ENTERCRITICAL;
|
|
if (_pPositions)
|
|
{
|
|
int i = DSA_GetItemCount(_pPositions->hdsaWP) - 1;
|
|
for (; i >= 0; i--) {
|
|
LPHWNDANDPLACEMENT phap = (LPHWNDANDPLACEMENT)DSA_GetItemPtr(_pPositions->hdsaWP, i);
|
|
if (phap->hwnd == hwnd || !IsWindow(phap->hwnd)) {
|
|
DSA_DeleteItem(_pPositions->hdsaWP, i);
|
|
}
|
|
}
|
|
|
|
if (!DSA_GetItemCount(_pPositions->hdsaWP))
|
|
{
|
|
_DestroySavedWindowPositions(_pPositions);
|
|
_pPositions = NULL;
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// Allow us to bump the activation of the run dlg hidden window.
|
|
// Certain apps (Norton Desktop setup) use the active window at RunDlg time
|
|
// as the parent for their dialogs. If that window disappears then they fault.
|
|
// We don't want the tray to get the activation coz it will cause it to appeare
|
|
// if you're in auto-hide mode.
|
|
LRESULT WINAPI RunDlgStaticSubclassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_ACTIVATE:
|
|
if (wParam == WA_ACTIVE)
|
|
{
|
|
// Bump the activation to the desktop.
|
|
if (v_hwndDesktop)
|
|
{
|
|
SetForegroundWindow(v_hwndDesktop);
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
// relay it to the tray
|
|
return SendMessage(v_hwndTray, uMsg, wParam, lParam);
|
|
}
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
DWORD WINAPI CTray::RunDlgThreadProc(void *pv)
|
|
{
|
|
return c_tray._RunDlgThreadProc((HANDLE)pv);
|
|
}
|
|
|
|
BOOL _IsBrowserWindow(HWND hwnd)
|
|
{
|
|
static const TCHAR* c_szClasses[] =
|
|
{
|
|
TEXT("ExploreWClass"),
|
|
TEXT("CabinetWClass"),
|
|
TEXT("IEFrame"),
|
|
};
|
|
|
|
TCHAR szClass[32];
|
|
GetClassName(hwnd, szClass, ARRAYSIZE(szClass));
|
|
|
|
for (int i = 0; i < ARRAYSIZE(c_szClasses); i++)
|
|
{
|
|
if (lstrcmpi(szClass, c_szClasses[i]) == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD CTray::_RunDlgThreadProc(HANDLE hdata)
|
|
{
|
|
RECT rc, rcTemp;
|
|
HRESULT hrInit = SHCoInitialize();
|
|
|
|
// 99/04/12 #316424 vtan: Get the rectangle for the "Start" button.
|
|
// If this is off the screen the tray is probably in auto hide mode.
|
|
// In this case offset the rectangle into the monitor where it should
|
|
// belong. This may be up, down, left or right depending on the
|
|
// position of the tray.
|
|
|
|
// First thing to do is to establish the dimensions of the monitor on
|
|
// which the tray resides. If no monitor can be found then use the
|
|
// primary monitor.
|
|
|
|
MONITORINFO monitorInfo;
|
|
monitorInfo.cbSize = sizeof(monitorInfo);
|
|
if (GetMonitorInfo(_hmonStuck, &monitorInfo) == 0)
|
|
{
|
|
TBOOL(SystemParametersInfo(SPI_GETWORKAREA, 0, &monitorInfo.rcMonitor, 0));
|
|
}
|
|
|
|
// Get the co-ordinates of the "Start" button.
|
|
|
|
GetWindowRect(_hwndStart, &rc);
|
|
|
|
// Look for an intersection in the monitor.
|
|
|
|
if (IntersectRect(&rcTemp, &rc, &monitorInfo.rcMonitor) == 0)
|
|
{
|
|
LONG lDeltaX, lDeltaY;
|
|
|
|
// Does not exist in the monitor. Move the co-ordinates by the
|
|
// width or height of the tray so that it does.
|
|
|
|
// This bizarre arithmetic is used because _ComputeHiddenRect()
|
|
// takes into account the frame and that right/bottom of RECT
|
|
// is exclusive in GDI.
|
|
|
|
lDeltaX = _sStuckWidths.cx - g_cxFrame;
|
|
lDeltaY = _sStuckWidths.cy - g_cyFrame;
|
|
if (rc.left < monitorInfo.rcMonitor.left)
|
|
{
|
|
--lDeltaX;
|
|
lDeltaY = 0;
|
|
}
|
|
else if (rc.top < monitorInfo.rcMonitor.top)
|
|
{
|
|
lDeltaX = 0;
|
|
--lDeltaY;
|
|
}
|
|
else if (rc.right > monitorInfo.rcMonitor.right)
|
|
{
|
|
lDeltaX = -lDeltaX;
|
|
lDeltaY = 0;
|
|
}
|
|
else if (rc.bottom > monitorInfo.rcMonitor.bottom)
|
|
{
|
|
lDeltaX = 0;
|
|
lDeltaY = -lDeltaY;
|
|
}
|
|
TBOOL(OffsetRect(&rc, lDeltaX, lDeltaY));
|
|
}
|
|
|
|
HWND hwnd = CreateWindowEx(WS_EX_TOOLWINDOW, TEXT("static"), NULL, 0 ,
|
|
rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hinstCabinet, NULL);
|
|
if (hwnd)
|
|
{
|
|
BOOL fSimple = FALSE;
|
|
HANDLE hMemWorkDir = NULL;
|
|
LPITEMIDLIST pidlWorkingDir = NULL;
|
|
|
|
// Subclass it.
|
|
SubclassWindow(hwnd, RunDlgStaticSubclassWndProc);
|
|
|
|
if (hdata)
|
|
SetProp(hwnd, TEXT("WaitingThreadID"), hdata);
|
|
|
|
if (!SHRestricted(REST_STARTRUNNOHOMEPATH))
|
|
{
|
|
// On NT, we like to start apps in the HOMEPATH directory. This
|
|
// should be the current directory for the current process.
|
|
TCHAR szDir[MAX_PATH];
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetEnvironmentVariable(TEXT("HOMEDRIVE"), szDir, ARRAYSIZE(szDir));
|
|
GetEnvironmentVariable(TEXT("HOMEPATH"), szPath, ARRAYSIZE(szPath));
|
|
|
|
if (PathAppend(szDir, szPath) && PathIsDirectory(szDir))
|
|
{
|
|
pidlWorkingDir = SHSimpleIDListFromPath(szDir);
|
|
if (pidlWorkingDir)
|
|
{
|
|
// free it the "simple" way...
|
|
fSimple = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!pidlWorkingDir)
|
|
{
|
|
// If the last active window was a folder/explorer window with the
|
|
// desktop as root, use its as the current dir
|
|
if (_hwndLastActive)
|
|
{
|
|
ENTERCRITICAL;
|
|
if (_hwndLastActive && !IsMinimized(_hwndLastActive) && _IsBrowserWindow(_hwndLastActive))
|
|
{
|
|
SendMessageTimeout(_hwndLastActive, CWM_CLONEPIDL, GetCurrentProcessId(), 0, SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, (DWORD_PTR*)&hMemWorkDir);
|
|
pidlWorkingDir = (LPITEMIDLIST)SHLockShared(hMemWorkDir, GetCurrentProcessId());
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
}
|
|
|
|
_RunFileDlg(hwnd, 0, pidlWorkingDir, 0, 0, 0);
|
|
if (pidlWorkingDir)
|
|
{
|
|
if (fSimple)
|
|
{
|
|
ILFree(pidlWorkingDir);
|
|
}
|
|
else
|
|
{
|
|
SHUnlockShared(pidlWorkingDir);
|
|
}
|
|
}
|
|
|
|
if (hMemWorkDir)
|
|
{
|
|
ASSERT(fSimple == FALSE);
|
|
SHFreeShared(hMemWorkDir, GetCurrentProcessId());
|
|
}
|
|
|
|
if (hdata)
|
|
{
|
|
RemoveProp(hwnd, TEXT("WaitingThreadID"));
|
|
}
|
|
|
|
DestroyWindow(hwnd);
|
|
}
|
|
|
|
SHCoUninitialize(hrInit);
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::_RunDlg()
|
|
{
|
|
HANDLE hEvent;
|
|
void *pvThreadParam;
|
|
|
|
if (!_Restricted(_hwnd, REST_NORUN))
|
|
{
|
|
TCHAR szRunDlgTitle[MAX_PATH];
|
|
HWND hwndOldRun;
|
|
LoadString(hinstCabinet, IDS_RUNDLGTITLE, szRunDlgTitle, ARRAYSIZE(szRunDlgTitle));
|
|
|
|
// See if there is already a run dialog up, and if so, try to activate it
|
|
|
|
hwndOldRun = FindWindow(WC_DIALOG, szRunDlgTitle);
|
|
if (hwndOldRun)
|
|
{
|
|
DWORD dwPID;
|
|
|
|
GetWindowThreadProcessId(hwndOldRun, &dwPID);
|
|
if (dwPID == GetCurrentProcessId())
|
|
{
|
|
if (IsWindowVisible(hwndOldRun))
|
|
{
|
|
SetForegroundWindow(hwndOldRun);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create an event so we can wait for the run dlg to appear before
|
|
// continue - this allows it to capture any type-ahead.
|
|
hEvent = CreateEvent(NULL, TRUE, FALSE, TEXT("MSShellRunDlgReady"));
|
|
if (hEvent)
|
|
pvThreadParam = IntToPtr(GetCurrentThreadId());
|
|
else
|
|
pvThreadParam = NULL;
|
|
|
|
if (SHQueueUserWorkItem(RunDlgThreadProc, pvThreadParam, 0, 0, NULL, NULL, TPS_LONGEXECTIME | TPS_DEMANDTHREAD))
|
|
{
|
|
if (hEvent)
|
|
{
|
|
SHProcessMessagesUntilEvent(NULL, hEvent, 10 * 1000);
|
|
DebugMsg(DM_TRACE, TEXT("c.t_rd: Done waiting."));
|
|
}
|
|
}
|
|
|
|
if (hEvent)
|
|
CloseHandle(hEvent);
|
|
}
|
|
}
|
|
|
|
void CTray::_ExploreCommonStartMenu(BOOL bExplore)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
TCHAR szCmdLine[MAX_PATH + 50];
|
|
|
|
//
|
|
// Get the common start menu path.
|
|
//
|
|
// we want to force the directory to exist, but not on W95 machines
|
|
if (!SHGetSpecialFolderPath(NULL, szPath, CSIDL_COMMON_STARTMENU, FALSE))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// If we are starting in explorer view, then the command line
|
|
// has a "/e, " before the quoted diretory.
|
|
//
|
|
|
|
if (bExplore)
|
|
{
|
|
lstrcpy(szCmdLine, TEXT("explorer.exe /e, \""));
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(szCmdLine, TEXT("explorer.exe \""));
|
|
}
|
|
|
|
lstrcat(szCmdLine, szPath);
|
|
lstrcat(szCmdLine, TEXT("\""));
|
|
|
|
// Initialize process startup info
|
|
STARTUPINFO si = {0};
|
|
si.cb = sizeof(si);
|
|
si.dwFlags = STARTF_USESHOWWINDOW;
|
|
si.wShowWindow = SW_SHOWNORMAL;
|
|
|
|
// Start explorer
|
|
PROCESS_INFORMATION pi = {0};
|
|
if (CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi))
|
|
{
|
|
// Close the process and thread handles
|
|
CloseHandle(pi.hProcess);
|
|
CloseHandle(pi.hThread);
|
|
}
|
|
}
|
|
|
|
int CTray::_GetQuickLaunchID()
|
|
{
|
|
int iQLBandID = -1;
|
|
|
|
DWORD dwBandID;
|
|
for (int i = 0; (iQLBandID == -1) && SUCCEEDED(_ptbs->EnumBands(i, &dwBandID)); i++)
|
|
{
|
|
if (BandSite_TestBandCLSID(_ptbs, dwBandID, CLSID_ISFBand) == S_OK)
|
|
{
|
|
IUnknown* punk;
|
|
if (SUCCEEDED(_ptbs->GetBandObject(dwBandID, IID_PPV_ARG(IUnknown, &punk))))
|
|
{
|
|
VARIANTARG v = {0};
|
|
v.vt = VT_I4;
|
|
if (SUCCEEDED(IUnknown_Exec(punk, &CLSID_ISFBand, 1, 0, NULL, &v)))
|
|
{
|
|
if ((v.vt == VT_I4) && (CSIDL_APPDATA == (DWORD)v.lVal))
|
|
{
|
|
iQLBandID = (int)dwBandID;
|
|
}
|
|
}
|
|
punk->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return iQLBandID;
|
|
}
|
|
|
|
int CTray::_ToggleQL(int iVisible)
|
|
{
|
|
int iQLBandID = _GetQuickLaunchID();
|
|
|
|
bool fOldVisible = (-1 != iQLBandID);
|
|
bool fNewVisible = (0 != iVisible);
|
|
|
|
if ((iVisible != -1) && (fNewVisible != fOldVisible))
|
|
{
|
|
if (fNewVisible)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA, &pidl)))
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
SHGetPathFromIDList(pidl, szPath);
|
|
PathCombine(szPath, szPath, L"Microsoft\\Internet Explorer\\Quick Launch");
|
|
ILFree(pidl);
|
|
pidl = ILCreateFromPath(szPath);
|
|
|
|
if (pidl)
|
|
{
|
|
IFolderBandPriv *pfbp;
|
|
// create an ISF band to show folders as hotlinks
|
|
if (SUCCEEDED(CoCreateInstance(CLSID_ISFBand, NULL, CLSCTX_INPROC, IID_PPV_ARG(IFolderBandPriv, &pfbp))))
|
|
{
|
|
IShellFolderBand* psfb;
|
|
if (SUCCEEDED(pfbp->QueryInterface(IID_PPV_ARG(IShellFolderBand, &psfb))))
|
|
{
|
|
if (SUCCEEDED(psfb->InitializeSFB(NULL, pidl)))
|
|
{
|
|
pfbp->SetNoText(TRUE);
|
|
|
|
VARIANTARG v;
|
|
v.vt = VT_I4;
|
|
v.lVal = CSIDL_APPDATA;
|
|
IUnknown_Exec(psfb, &CLSID_ISFBand, 1, 0, &v, NULL);
|
|
|
|
v.lVal = UEMIND_SHELL; // UEMIND_SHELL/BROWSER
|
|
IUnknown_Exec(psfb, &CGID_ShellDocView, SHDVID_UEMLOG, 0, &v, NULL);
|
|
|
|
IDeskBand* ptb;
|
|
if (SUCCEEDED(pfbp->QueryInterface(IID_PPV_ARG(IDeskBand, &ptb))))
|
|
{
|
|
HRESULT hr = _ptbs->AddBand(ptb);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_ptbs->SetBandState(ShortFromResult(hr), BSSF_NOTITLE, BSSF_NOTITLE);
|
|
}
|
|
ptb->Release();
|
|
}
|
|
}
|
|
psfb->Release();
|
|
}
|
|
pfbp->Release();
|
|
}
|
|
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iBandID;
|
|
do {
|
|
iBandID = _GetQuickLaunchID();
|
|
if (iBandID != -1)
|
|
{
|
|
_ptbs->RemoveBand(iBandID);
|
|
}
|
|
} while (iBandID != -1);
|
|
}
|
|
}
|
|
|
|
return iQLBandID;
|
|
}
|
|
|
|
void CTray::StartMenuContextMenu(HWND hwnd, DWORD dwPos)
|
|
{
|
|
LPITEMIDLIST pidlStart = SHCloneSpecialIDList(hwnd, CSIDL_STARTMENU, TRUE);
|
|
INSTRUMENT_STATECHANGE(SHCNFI_STATE_TRAY_CONTEXT_START);
|
|
HandleFullScreenApp(NULL);
|
|
|
|
SetForegroundWindow(hwnd);
|
|
|
|
if (pidlStart)
|
|
{
|
|
LPITEMIDLIST pidlLast = ILClone(ILFindLastID(pidlStart));
|
|
ILRemoveLastID(pidlStart);
|
|
|
|
if (pidlLast)
|
|
{
|
|
IShellFolder *psf = BindToFolder(pidlStart);
|
|
if (psf)
|
|
{
|
|
HMENU hmenu = CreatePopupMenu();
|
|
if (hmenu)
|
|
{
|
|
IContextMenu *pcm;
|
|
HRESULT hr = psf->GetUIObjectOf(hwnd, 1, (LPCITEMIDLIST*)&pidlLast, IID_X_PPV_ARG(IContextMenu, NULL, &pcm));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pcm->QueryContextMenu(hmenu, 0, IDSYSPOPUP_FIRST, IDSYSPOPUP_LAST, CMF_VERBSONLY);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
int idCmd;
|
|
TCHAR szCommon[MAX_PATH];
|
|
|
|
//Add the menu to invoke the "Start Menu Properties"
|
|
LoadString (hinstCabinet, IDS_STARTMENUPROP, szCommon, ARRAYSIZE(szCommon));
|
|
AppendMenu (hmenu, MF_STRING, IDSYSPOPUP_STARTMENUPROP, szCommon);
|
|
if (!SHRestricted(REST_NOCOMMONGROUPS))
|
|
{
|
|
// If the user has access to the Common Start Menu, then we can add those items. If not,
|
|
// then we should not.
|
|
BOOL fAddCommon = (S_OK == SHGetFolderPath(NULL, CSIDL_COMMON_STARTMENU, NULL, 0, szCommon));
|
|
|
|
if (fAddCommon)
|
|
fAddCommon = IsUserAnAdmin();
|
|
|
|
|
|
// Since we don't show this on the start button when the user is not an admin, don't show it here... I guess...
|
|
if (fAddCommon)
|
|
{
|
|
AppendMenu (hmenu, MF_SEPARATOR, 0, NULL);
|
|
LoadString (hinstCabinet, IDS_OPENCOMMON, szCommon, ARRAYSIZE(szCommon));
|
|
AppendMenu (hmenu, MF_STRING, IDSYSPOPUP_OPENCOMMON, szCommon);
|
|
LoadString (hinstCabinet, IDS_EXPLORECOMMON, szCommon, ARRAYSIZE(szCommon));
|
|
AppendMenu (hmenu, MF_STRING, IDSYSPOPUP_EXPLORECOMMON, szCommon);
|
|
}
|
|
}
|
|
|
|
if (dwPos == (DWORD)-1)
|
|
{
|
|
idCmd = _TrackMenu(hmenu);
|
|
}
|
|
else
|
|
{
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
|
|
idCmd = TrackPopupMenu(hmenu,
|
|
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
|
|
GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos), 0, hwnd, NULL);
|
|
SendMessage(_hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
|
|
}
|
|
|
|
|
|
switch(idCmd)
|
|
{
|
|
case 0: //User did not select a menu item; so, nothing to do!
|
|
break;
|
|
|
|
case IDSYSPOPUP_OPENCOMMON:
|
|
_ExploreCommonStartMenu(FALSE);
|
|
break;
|
|
|
|
case IDSYSPOPUP_EXPLORECOMMON:
|
|
_ExploreCommonStartMenu(TRUE);
|
|
break;
|
|
|
|
case IDSYSPOPUP_STARTMENUPROP:
|
|
DoProperties(TPF_STARTMENUPAGE);
|
|
break;
|
|
|
|
default:
|
|
TCHAR szPath[MAX_PATH];
|
|
CMINVOKECOMMANDINFOEX ici = {0};
|
|
#ifdef UNICODE
|
|
CHAR szPathAnsi[MAX_PATH];
|
|
#endif
|
|
ici.cbSize = sizeof(CMINVOKECOMMANDINFOEX);
|
|
ici.hwnd = hwnd;
|
|
ici.lpVerb = (LPSTR)MAKEINTRESOURCE(idCmd - IDSYSPOPUP_FIRST);
|
|
ici.nShow = SW_NORMAL;
|
|
#ifdef UNICODE
|
|
SHGetPathFromIDListA(pidlStart, szPathAnsi);
|
|
SHGetPathFromIDList(pidlStart, szPath);
|
|
ici.lpDirectory = szPathAnsi;
|
|
ici.lpDirectoryW = szPath;
|
|
ici.fMask |= CMIC_MASK_UNICODE;
|
|
#else
|
|
SHGetPathFromIDList(pidlStart, szPath);
|
|
ici.lpDirectory = szPath;
|
|
#endif
|
|
pcm->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
|
|
|
|
break;
|
|
|
|
} // Switch(idCmd)
|
|
}
|
|
pcm->Release();
|
|
}
|
|
DestroyMenu(hmenu);
|
|
}
|
|
psf->Release();
|
|
}
|
|
ILFree(pidlLast);
|
|
}
|
|
ILFree(pidlStart);
|
|
}
|
|
}
|
|
|
|
void GiveDesktopFocus()
|
|
{
|
|
SetForegroundWindow(v_hwndDesktop);
|
|
SendMessage(v_hwndDesktop, DTM_UIACTIVATEIO, (WPARAM) TRUE, /*dtb*/0);
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: loads the given resource string and executes it.
|
|
The resource string should follow this format:
|
|
|
|
"program.exe>parameters"
|
|
|
|
If there are no parameters, the format should simply be:
|
|
|
|
"program.exe"
|
|
|
|
*/
|
|
void _ExecResourceCmd(UINT ids)
|
|
{
|
|
TCHAR szCmd[2*MAX_PATH];
|
|
|
|
if (LoadString(hinstCabinet, ids, szCmd, SIZECHARS(szCmd)))
|
|
{
|
|
SHELLEXECUTEINFO sei = {0};
|
|
|
|
// Find list of parameters (if any)
|
|
LPTSTR pszParam = StrChr(szCmd, TEXT('>'));
|
|
|
|
if (pszParam)
|
|
{
|
|
// Replace the '>' with a null terminator
|
|
*pszParam = 0;
|
|
pszParam++;
|
|
}
|
|
|
|
sei.cbSize = sizeof(sei);
|
|
sei.nShow = SW_SHOWNORMAL;
|
|
sei.lpFile = szCmd;
|
|
sei.lpParameters = pszParam;
|
|
ShellExecuteEx(&sei);
|
|
}
|
|
}
|
|
|
|
void CTray::_RefreshStartMenu()
|
|
{
|
|
if (_pmbStartMenu)
|
|
{
|
|
IUnknown_Exec(_pmbStartMenu, &CLSID_MenuBand, MBANDCID_REFRESH, 0, NULL, NULL);
|
|
}
|
|
else if (_pmpStartPane)
|
|
{
|
|
IUnknown_Exec(_pmpStartPane, &CLSID_MenuBand, MBANDCID_REFRESH, 0, NULL, NULL);
|
|
}
|
|
_RefreshSettings();
|
|
_UpdateBandSiteStyle();
|
|
}
|
|
|
|
BOOL CTray::_CanMinimizeAll()
|
|
{
|
|
#ifdef FEATURE_STARTPAGE
|
|
if (Tray_ShowStartPageEnabled())
|
|
return FALSE;
|
|
#endif
|
|
return (_hwndTasks && SendMessage(_hwndTasks, TBC_CANMINIMIZEALL, 0, 0));
|
|
}
|
|
|
|
BOOL CTray::_MinimizeAll(BOOL fPostRaiseDesktop)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
if (_hwndTasks)
|
|
{
|
|
fRet = (BOOL)SendMessage(_hwndTasks, TBC_MINIMIZEALL, (WPARAM)_hwnd, (LPARAM)fPostRaiseDesktop);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
extern void _UpdateNotifySetting(BOOL fNotifySetting);
|
|
|
|
//
|
|
// Due to the weirdness of PnP, if the eject request occurs on a thread
|
|
// that contains windows, the eject stalls for 15 seconds. So do it
|
|
// on its own thread.
|
|
//
|
|
DWORD CALLBACK _EjectThreadProc(LPVOID lpThreadParameter)
|
|
{
|
|
CM_Request_Eject_PC();
|
|
return 0;
|
|
}
|
|
|
|
void CTray::_Command(UINT idCmd)
|
|
{
|
|
INSTRUMENT_ONCOMMAND(SHCNFI_TRAYCOMMAND, _hwnd, idCmd);
|
|
|
|
switch (idCmd) {
|
|
|
|
case IDM_CONTROLS:
|
|
case IDM_PRINTERS:
|
|
_ShowFolder(_hwnd,
|
|
idCmd == IDM_CONTROLS ? CSIDL_CONTROLS : CSIDL_PRINTERS, COF_USEOPENSETTINGS);
|
|
break;
|
|
|
|
case IDM_EJECTPC:
|
|
// Must use SHCreateThread and not a queued workitem because
|
|
// a workitem might inherit a thread that has windows on it.
|
|
// CTF_INSIST: In emergency, eject synchronously. This stalls
|
|
// for 15 seconds but it's better than nothing.
|
|
SHCreateThread(_EjectThreadProc, NULL, CTF_INSIST, NULL);
|
|
break;
|
|
|
|
case IDM_LOGOFF:
|
|
// Let the desktop get a chance to repaint to get rid of the
|
|
// start menu bits before bringing up the logoff dialog box.
|
|
UpdateWindow(_hwnd);
|
|
Sleep(100);
|
|
|
|
_SaveTrayAndDesktop();
|
|
LogoffWindowsDialog(v_hwndDesktop);
|
|
break;
|
|
|
|
case IDM_MU_DISCONNECT:
|
|
// Do the same sleep as above for the same reason.
|
|
UpdateWindow(_hwnd);
|
|
Sleep(100);
|
|
DisconnectWindowsDialog(v_hwndDesktop);
|
|
break;
|
|
|
|
case IDM_EXITWIN:
|
|
// Do the same sleep as above for the same reason.
|
|
UpdateWindow(_hwnd);
|
|
Sleep(100);
|
|
|
|
_DoExitWindows(v_hwndDesktop);
|
|
break;
|
|
|
|
case IDM_TOGGLEDESKTOP:
|
|
_RaiseDesktop(!g_fDesktopRaised, TRUE);
|
|
break;
|
|
|
|
case IDM_FILERUN:
|
|
_RunDlg();
|
|
break;
|
|
|
|
case IDM_MINIMIZEALLHOTKEY:
|
|
_HandleGlobalHotkey(GHID_MINIMIZEALL);
|
|
break;
|
|
|
|
#ifdef DEBUG
|
|
case IDM_SIZEUP:
|
|
{
|
|
RECT rcView;
|
|
GetWindowRect(_hwndRebar, &rcView);
|
|
MapWindowPoints(HWND_DESKTOP, _hwnd, (LPPOINT)&rcView, 2);
|
|
rcView.bottom -= 18;
|
|
SetWindowPos(_hwndRebar, NULL, 0, 0, RECTWIDTH(rcView), RECTHEIGHT(rcView), SWP_NOMOVE | SWP_NOZORDER);
|
|
}
|
|
break;
|
|
|
|
case IDM_SIZEDOWN:
|
|
{
|
|
RECT rcView;
|
|
GetWindowRect(_hwndRebar, &rcView);
|
|
MapWindowPoints(HWND_DESKTOP, _hwnd, (LPPOINT)&rcView, 2);
|
|
rcView.bottom += 18;
|
|
SetWindowPos(_hwndRebar, NULL, 0, 0, RECTWIDTH(rcView), RECTHEIGHT(rcView), SWP_NOMOVE | SWP_NOZORDER);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case IDM_MINIMIZEALL:
|
|
// minimize all window
|
|
_MinimizeAll(FALSE);
|
|
_fUndoEnabled = TRUE;
|
|
break;
|
|
|
|
case IDM_UNDO:
|
|
_RestoreWindowPositions(FALSE);
|
|
break;
|
|
|
|
case IDM_SETTIME:
|
|
// run the default applet in timedate.cpl
|
|
SHRunControlPanel(TEXT("timedate.cpl"), _hwnd);
|
|
break;
|
|
|
|
case IDM_NOTIFYCUST:
|
|
DoProperties(TPF_TASKBARPAGE | TPF_INVOKECUSTOMIZE);
|
|
break;
|
|
|
|
case IDM_LOCKTASKBAR:
|
|
{
|
|
BOOL fCanSizeMove = !_fCanSizeMove; // toggle
|
|
SHRegSetUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarSizeMove"),
|
|
REG_DWORD, &fCanSizeMove , sizeof(DWORD), SHREGSET_FORCE_HKCU);
|
|
_RefreshSettings();
|
|
_UpdateBandSiteStyle();
|
|
}
|
|
break;
|
|
|
|
case IDM_SHOWTASKMAN:
|
|
RunSystemMonitor();
|
|
break;
|
|
|
|
case IDM_CASCADE:
|
|
case IDM_VERTTILE:
|
|
case IDM_HORIZTILE:
|
|
if (_CanTileAnyWindows())
|
|
{
|
|
SaveWindowPositions((idCmd == IDM_CASCADE) ? IDS_CASCADE : IDS_TILE);
|
|
|
|
_AppBarNotifyAll(NULL, ABN_WINDOWARRANGE, NULL, TRUE);
|
|
|
|
if (idCmd == IDM_CASCADE)
|
|
{
|
|
CascadeWindows(GetDesktopWindow(), 0, NULL, 0, NULL);
|
|
}
|
|
else
|
|
{
|
|
TileWindows(GetDesktopWindow(), ((idCmd == IDM_VERTTILE)?
|
|
MDITILE_VERTICAL : MDITILE_HORIZONTAL), NULL, 0, NULL);
|
|
}
|
|
|
|
// do it *before* ABN_xxx so don't get 'indirect' moves
|
|
// REVIEW or should it be after?
|
|
// CheckWindowPositions();
|
|
_fUndoEnabled = FALSE;
|
|
SetTimer(_hwnd, IDT_ENABLEUNDO, 500, NULL);
|
|
|
|
_AppBarNotifyAll(NULL, ABN_WINDOWARRANGE, NULL, FALSE);
|
|
}
|
|
break;
|
|
|
|
case IDM_TRAYPROPERTIES:
|
|
DoProperties(TPF_TASKBARPAGE);
|
|
break;
|
|
|
|
case IDM_SETTINGSASSIST:
|
|
SHCreateThread(SettingsUIThreadProc, NULL, 0, NULL);
|
|
break;
|
|
|
|
case IDM_HELPSEARCH:
|
|
_ExecResourceCmd(IDS_HELP_CMD);
|
|
break;
|
|
|
|
// NB The Alt-s comes in here.
|
|
case IDC_KBSTART:
|
|
SetForegroundWindow(_hwnd);
|
|
// This pushes the start button and causes the start menu to popup.
|
|
SendMessage(_hwndStart, BM_SETSTATE, TRUE, 0);
|
|
// This forces the button back up.
|
|
SendMessage(_hwndStart, BM_SETSTATE, FALSE, 0);
|
|
break;
|
|
|
|
case IDC_ASYNCSTART:
|
|
#if 0 // (for testing UAssist locking code)
|
|
UEMFireEvent(&UEMIID_SHELL, UEME_DBSLEEP, UEMF_XEVENT, -1, (LPARAM)10000);
|
|
#endif
|
|
#ifdef DEBUG
|
|
if (GetAsyncKeyState(VK_SHIFT) < 0)
|
|
{
|
|
UEMFireEvent(&UEMIID_SHELL, UEME_CTLSESSION, UEMF_XEVENT, TRUE, -1);
|
|
_RefreshStartMenu();
|
|
}
|
|
#endif
|
|
|
|
// Make sure the button is down.
|
|
// DebugMsg(DM_TRACE, "c.twp: IDC_START.");
|
|
|
|
// Make sure the Start button is down.
|
|
if (!_bMainMenuInit && SendMessage(_hwndStart, BM_GETSTATE, 0, 0) & BST_PUSHED)
|
|
{
|
|
// DebugMsg(DM_TRACE, "c.twp: Start button down.");
|
|
// Set the focus.
|
|
_SetFocus(_hwndStart);
|
|
_ToolbarMenu();
|
|
}
|
|
break;
|
|
|
|
// NB LButtonDown on the Start button come in here.
|
|
// Space-bar stuff also comes in here.
|
|
case IDC_START:
|
|
// User gets a bit confused with space-bar tuff (the popup ends up
|
|
// getting the key-up and beeps).
|
|
PostMessage(_hwnd, WM_COMMAND, IDC_ASYNCSTART, 0);
|
|
break;
|
|
|
|
case FCIDM_FINDFILES:
|
|
SHFindFiles(NULL, NULL);
|
|
break;
|
|
|
|
case FCIDM_FINDCOMPUTER:
|
|
SHFindComputer(NULL, NULL);
|
|
break;
|
|
|
|
case FCIDM_REFRESH:
|
|
_RefreshStartMenu();
|
|
break;
|
|
|
|
case FCIDM_NEXTCTL:
|
|
{
|
|
MSG msg = { 0, WM_KEYDOWN, VK_TAB };
|
|
HWND hwndFocus = GetFocus();
|
|
|
|
// Since we are Tab or Shift Tab we should turn the focus rect on.
|
|
//
|
|
// Note: we don't need to do this in the GiveDesktopFocus cases below,
|
|
// but in those cases we're probably already in the UIS_CLEAR UISF_HIDEFOCUS
|
|
// state so this message is cheap to send.
|
|
//
|
|
SendMessage(_hwnd, WM_UPDATEUISTATE, MAKEWPARAM(UIS_CLEAR,
|
|
UISF_HIDEFOCUS), 0);
|
|
|
|
BOOL fShift = GetAsyncKeyState(VK_SHIFT) < 0;
|
|
|
|
if (hwndFocus && (IsChildOrHWND(_hwndStart, hwndFocus)))
|
|
{
|
|
if (fShift)
|
|
{
|
|
// gotta deactivate manually
|
|
GiveDesktopFocus();
|
|
}
|
|
else
|
|
{
|
|
IUnknown_UIActivateIO(_ptbs, TRUE, &msg);
|
|
}
|
|
}
|
|
else if (hwndFocus && (IsChildOrHWND(_hwndNotify, hwndFocus)))
|
|
{
|
|
if (fShift)
|
|
{
|
|
IUnknown_UIActivateIO(_ptbs, TRUE, &msg);
|
|
}
|
|
else
|
|
{
|
|
GiveDesktopFocus();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (IUnknown_TranslateAcceleratorIO(_ptbs, &msg) != S_OK)
|
|
{
|
|
if (fShift)
|
|
{
|
|
_SetFocus(_hwndStart);
|
|
}
|
|
else
|
|
{
|
|
// if you tab forward out of the bands, the next focus guy is the tray notify set
|
|
_SetFocus(_hwndNotify);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDM_MU_SECURITY:
|
|
MuSecurity();
|
|
break;
|
|
}
|
|
}
|
|
|
|
//// Start menu/Tray tab as a drop target
|
|
|
|
HRESULT CStartDropTarget::_GetStartMenuDropTarget(IDropTarget** pptgt)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
*pptgt = NULL;
|
|
|
|
LPITEMIDLIST pidlStart = SHCloneSpecialIDList(NULL, CSIDL_STARTMENU, TRUE);
|
|
|
|
if (pidlStart)
|
|
{
|
|
IShellFolder *psf = BindToFolder(pidlStart);
|
|
if (psf)
|
|
{
|
|
hr = psf->CreateViewObject(_ptray->_hwnd, IID_PPV_ARG(IDropTarget, pptgt));
|
|
psf->Release();
|
|
}
|
|
|
|
ILFree(pidlStart);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDropTargetBase::QueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENT(CDropTargetBase, IDropTarget),
|
|
{ 0 },
|
|
};
|
|
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDropTargetBase::AddRef()
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDropTargetBase::Release()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHODIMP CDropTargetBase::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
_ptray->_SetUnhideTimer(ptl.x, ptl.y);
|
|
|
|
HWND hwndLock = _ptray->_hwnd; // no clippy
|
|
|
|
_DragEnter(hwndLock, ptl, pdtobj);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDropTargetBase::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
_ptray->_SetUnhideTimer(ptl.x, ptl.y);
|
|
_DragMove(_ptray->_hwndStart, ptl);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDropTargetBase::DragLeave()
|
|
{
|
|
DAD_DragLeave();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDropTargetBase::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
DAD_DragLeave();
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// There are two different policies for the Start Button depending on
|
|
// whether we are in Classic mode or Personal (New Start Pane) mode.
|
|
//
|
|
// Classic mode: Drops onto the Start Button are treated as if they
|
|
// were drops into the CSIDL_STARTMENU folder.
|
|
//
|
|
// Personal mode: Drops onto the Start Button are treated as if they
|
|
// were drops into the pin list.
|
|
//
|
|
|
|
CStartDropTarget::CStartDropTarget() : CDropTargetBase(IToClass(CTray, _dtStart, this))
|
|
{
|
|
}
|
|
|
|
CTrayDropTarget::CTrayDropTarget() : CDropTargetBase(IToClass(CTray, _dtTray, this))
|
|
{
|
|
}
|
|
|
|
STDMETHODIMP CTrayDropTarget::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
return CDropTargetBase::DragEnter(pdtobj, grfKeyState, ptl, pdwEffect);
|
|
}
|
|
|
|
STDMETHODIMP CTrayDropTarget::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
return CDropTargetBase::DragOver(grfKeyState, ptl, pdwEffect);
|
|
}
|
|
|
|
void CStartDropTarget::_StartAutoOpenTimer(POINTL *pptl)
|
|
{
|
|
POINT pt = { pptl->x, pptl->y };
|
|
RECT rc;
|
|
//Make sure it really is in the start menu..
|
|
GetWindowRect(_ptray->_hwndStart, &rc);
|
|
if (PtInRect(&rc,pt))
|
|
{
|
|
SetTimer(_ptray->_hwnd, IDT_STARTMENU, 1000, NULL);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CStartDropTarget::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hr;
|
|
if (Tray_StartPanelEnabled())
|
|
{
|
|
// Personal mode: Treat it as an add to the pin list.
|
|
if (_ptray->_psmpin && _ptray->_psmpin->IsPinnable(pdtobj, SMPINNABLE_REJECTSLOWMEDIA, NULL) == S_OK)
|
|
{
|
|
_dwEffectsAllowed = DROPEFFECT_LINK;
|
|
}
|
|
else
|
|
{
|
|
_dwEffectsAllowed = DROPEFFECT_NONE;
|
|
}
|
|
|
|
*pdwEffect &= _dwEffectsAllowed;
|
|
|
|
// Always start the AutoOpen timer because once we open, the user
|
|
// can drop onto other things which may have different drop policies
|
|
// from the pin list.
|
|
_StartAutoOpenTimer(&ptl);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
// Classic mode: Treat it as a drop on the Start Menu folder.
|
|
IDropTarget* ptgt;
|
|
_dwEffectsAllowed = DROPEFFECT_LINK;
|
|
|
|
hr = _GetStartMenuDropTarget(&ptgt);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Check to make sure that we're going to accept the drop before we expand the start menu.
|
|
ptgt->DragEnter(pdtobj, grfKeyState, ptl,
|
|
pdwEffect);
|
|
|
|
// DROPEFFECT_NONE means it ain't gonna work, so don't popup the Start Menu.
|
|
if (*pdwEffect != DROPEFFECT_NONE)
|
|
{
|
|
_StartAutoOpenTimer(&ptl);
|
|
}
|
|
|
|
ptgt->DragLeave();
|
|
ptgt->Release();
|
|
}
|
|
}
|
|
|
|
CDropTargetBase::DragEnter(pdtobj, grfKeyState, ptl, pdwEffect);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CStartDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
*pdwEffect = (_dwEffectsAllowed & DROPEFFECT_LINK);
|
|
return CDropTargetBase::DragOver(grfKeyState, pt, pdwEffect);
|
|
}
|
|
|
|
STDMETHODIMP CStartDropTarget::DragLeave()
|
|
{
|
|
KillTimer(_ptray->_hwnd, IDT_STARTMENU);
|
|
return CDropTargetBase::DragLeave();
|
|
}
|
|
|
|
STDMETHODIMP CStartDropTarget::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
KillTimer(_ptray->_hwnd, IDT_STARTMENU);
|
|
|
|
HRESULT hr;
|
|
|
|
if (Tray_StartPanelEnabled())
|
|
{
|
|
// Personal mode: Treat it as an add to the pin list.
|
|
LPITEMIDLIST pidl;
|
|
if (_ptray->_psmpin && _ptray->_psmpin->IsPinnable(pdtobj, SMPINNABLE_REJECTSLOWMEDIA, &pidl) == S_OK)
|
|
{
|
|
// Delete it from the pin list if it's already there because
|
|
// we want to move it to the bottom.
|
|
_ptray->_psmpin->Modify(pidl, NULL);
|
|
// Now add it to the bottom.
|
|
_ptray->_psmpin->Modify(NULL, pidl);
|
|
ILFree(pidl);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IDropTarget* pdrop;
|
|
hr = _GetStartMenuDropTarget(&pdrop);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!Tray_StartPanelEnabled())
|
|
{
|
|
POINTL ptDrop = { 0, 0 };
|
|
DWORD grfKeyStateDrop = 0;
|
|
|
|
*pdwEffect &= DROPEFFECT_LINK;
|
|
|
|
pdrop->DragEnter(pdtobj, grfKeyStateDrop, ptDrop, pdwEffect);
|
|
hr = pdrop->Drop(pdtobj, grfKeyStateDrop, ptDrop, pdwEffect);
|
|
|
|
pdrop->DragLeave();
|
|
}
|
|
pdrop->Release();
|
|
}
|
|
}
|
|
|
|
DAD_DragLeave();
|
|
|
|
return hr;
|
|
}
|
|
|
|
void CTray::_RegisterDropTargets()
|
|
{
|
|
THR(RegisterDragDrop(_hwndStart, &_dtStart));
|
|
THR(RegisterDragDrop(_hwnd, &_dtTray));
|
|
|
|
// It is not a serious error if this fails; it just means that
|
|
// drag/drop to the Start Button will not add to the pin list
|
|
CoCreateInstance(CLSID_StartMenuPin, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_PPV_ARG(IStartMenuPin, &_psmpin));
|
|
}
|
|
|
|
void CTray::_RevokeDropTargets()
|
|
{
|
|
RevokeDragDrop(_hwndStart);
|
|
RevokeDragDrop(_hwnd);
|
|
ATOMICRELEASET(_psmpin, IStartMenuPin);
|
|
}
|
|
|
|
void CTray::_HandleGlobalHotkey(WPARAM wParam)
|
|
{
|
|
INSTRUMENT_HOTKEY(SHCNFI_GLOBALHOTKEY, wParam);
|
|
|
|
switch(wParam)
|
|
{
|
|
case GHID_RUN:
|
|
_RunDlg();
|
|
break;
|
|
|
|
case GHID_MINIMIZEALL:
|
|
if (_CanMinimizeAll())
|
|
_MinimizeAll(FALSE);
|
|
SetForegroundWindow(v_hwndDesktop);
|
|
break;
|
|
|
|
case GHID_UNMINIMIZEALL:
|
|
_RestoreWindowPositions(FALSE);
|
|
break;
|
|
|
|
case GHID_HELP:
|
|
_Command(IDM_HELPSEARCH);
|
|
break;
|
|
|
|
case GHID_DESKTOP:
|
|
_RaiseDesktop(!g_fDesktopRaised, TRUE);
|
|
break;
|
|
|
|
case GHID_TRAYNOTIFY:
|
|
SwitchToThisWindow(_hwnd, TRUE);
|
|
SetForegroundWindow(_hwnd);
|
|
_SetFocus(_hwndNotify);
|
|
break;
|
|
|
|
case GHID_EXPLORER:
|
|
_ShowFolder(_hwnd, CSIDL_DRIVES, COF_CREATENEWWINDOW | COF_EXPLORE);
|
|
break;
|
|
|
|
case GHID_FINDFILES:
|
|
if (!SHRestricted(REST_NOFIND))
|
|
_Command(FCIDM_FINDFILES);
|
|
break;
|
|
|
|
case GHID_FINDCOMPUTER:
|
|
if (!SHRestricted(REST_NOFIND))
|
|
_Command(FCIDM_FINDCOMPUTER);
|
|
break;
|
|
|
|
case GHID_TASKTAB:
|
|
case GHID_TASKSHIFTTAB:
|
|
if (GetForegroundWindow() != _hwnd)
|
|
SetForegroundWindow(_hwnd);
|
|
SendMessage(_hwndTasks, TBC_TASKTAB, wParam == GHID_TASKTAB ? 1 : -1, 0L);
|
|
break;
|
|
|
|
case GHID_SYSPROPERTIES:
|
|
#define IDS_SYSDMCPL 0x2334 // from shelldll
|
|
SHRunControlPanel(MAKEINTRESOURCE(IDS_SYSDMCPL), _hwnd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CTray::_UnregisterGlobalHotkeys()
|
|
{
|
|
for (int i = GHID_FIRST; i < GHID_MAX; i++)
|
|
{
|
|
UnregisterHotKey(_hwnd, i);
|
|
}
|
|
}
|
|
|
|
void CTray::_RegisterGlobalHotkeys()
|
|
{
|
|
int i;
|
|
// Are the Windows keys restricted?
|
|
DWORD dwRestricted = SHRestricted(REST_NOWINKEYS);
|
|
|
|
for (i = GHID_FIRST ; i < GHID_MAX; i++)
|
|
{
|
|
// If the Windows Keys are Not restricted or it's not a Windows key
|
|
if (!((HIWORD(GlobalKeylist[i - GHID_FIRST]) & MOD_WIN) && dwRestricted))
|
|
{
|
|
// Then register it.
|
|
RegisterHotKey(_hwnd, i, HIWORD(GlobalKeylist[i - GHID_FIRST]), LOWORD(GlobalKeylist[i - GHID_FIRST]));
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_RaiseDesktop(BOOL fRaise, BOOL fRestoreWindows)
|
|
{
|
|
if (v_hwndDesktop && (fRaise == !g_fDesktopRaised) && !_fProcessingDesktopRaise)
|
|
{
|
|
_fProcessingDesktopRaise = TRUE;
|
|
BOOL fPostMessage = TRUE;
|
|
|
|
if (fRaise)
|
|
{
|
|
HWND hwndFG = GetForegroundWindow();
|
|
// If no window has focus then set focus to the tray
|
|
if (hwndFG)
|
|
{
|
|
hwndFG = _hwnd;
|
|
}
|
|
|
|
if (!_hwndFocusBeforeRaise)
|
|
{
|
|
// See if the Foreground Window had a popup window
|
|
_hwndFocusBeforeRaise = GetLastActivePopup(hwndFG);
|
|
}
|
|
if (!IsWindowVisible(_hwndFocusBeforeRaise))
|
|
{
|
|
_hwndFocusBeforeRaise = hwndFG;
|
|
}
|
|
|
|
// _MinimizeAll will save the windows positions synchronously, and will minimize the
|
|
// the windows on a background thread
|
|
_fMinimizedAllBeforeRaise = _CanMinimizeAll();
|
|
if (_fMinimizedAllBeforeRaise)
|
|
{
|
|
fPostMessage = !_MinimizeAll(TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fRestoreWindows)
|
|
{
|
|
HWND hwnd = _hwndFocusBeforeRaise;
|
|
if (_fMinimizedAllBeforeRaise)
|
|
{
|
|
// Since the windows are restored on a seperate thread, I want the make that the
|
|
// desktop is not raised until they are done, so the window restore thread will
|
|
// actually post the message for raising the desktop
|
|
fPostMessage = !_RestoreWindowPositions(TRUE);
|
|
}
|
|
|
|
SetForegroundWindow(hwnd);
|
|
if (hwnd == _hwnd)
|
|
{
|
|
_SetFocus(_hwndStart);
|
|
}
|
|
}
|
|
|
|
_hwndFocusBeforeRaise = NULL;
|
|
}
|
|
|
|
#ifdef FEATURE_STARTPAGE
|
|
if (Tray_ShowStartPageEnabled())
|
|
{
|
|
if (fPostMessage)
|
|
SendMessage(v_hwndDesktop, DTM_RAISE, (WPARAM)_hwnd, fRaise ? DTRF_RAISE : DTRF_LOWER);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (fPostMessage)
|
|
PostMessage(v_hwndDesktop, DTM_RAISE, (WPARAM)_hwnd, fRaise ? DTRF_RAISE : DTRF_LOWER);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTray::_OnDesktopState(LPARAM lParam)
|
|
{
|
|
g_fDesktopRaised = (!(lParam & DTRF_LOWER));
|
|
|
|
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
|
|
|
|
if (!g_fDesktopRaised)
|
|
{
|
|
HandleFullScreenApp(NULL);
|
|
}
|
|
else
|
|
{
|
|
// if the desktop is raised, we need to force the tray to be always on top
|
|
// until it's lowered again
|
|
_ResetZorder();
|
|
}
|
|
|
|
DAD_ShowDragImage(TRUE); // unlock the drag sink if we are dragging.
|
|
_fProcessingDesktopRaise = FALSE;
|
|
}
|
|
|
|
BOOL CTray::_ToggleLanguageBand(BOOL fShowIt)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
DWORD dwBandID;
|
|
BOOL fFound = FALSE;
|
|
for (int i = 0; !fFound && SUCCEEDED(_ptbs->EnumBands(i, &dwBandID)); i++)
|
|
{
|
|
if (BandSite_TestBandCLSID(_ptbs, dwBandID, CLSID_MSUTBDeskBand) == S_OK)
|
|
{
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL fShow = fFound;
|
|
|
|
if (fShowIt && !fFound)
|
|
{
|
|
IDeskBand* pdb;
|
|
HRESULT hr = CoCreateInstance(CLSID_MSUTBDeskBand, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IDeskBand, &pdb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _ptbs->AddBand(pdb);
|
|
fShow = TRUE;
|
|
pdb->Release();
|
|
}
|
|
}
|
|
else if (!fShowIt && fFound)
|
|
{
|
|
hr = _ptbs->RemoveBand(dwBandID);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fShow = FALSE;
|
|
}
|
|
}
|
|
|
|
return fShow;
|
|
}
|
|
|
|
// Process the message by propagating it to all of our child windows
|
|
typedef struct
|
|
{
|
|
UINT uMsg;
|
|
WPARAM wP;
|
|
LPARAM lP;
|
|
CTray* ptray;
|
|
} CABPM;
|
|
|
|
BOOL CTray::PropagateEnumProc(HWND hwnd, LPARAM lParam)
|
|
{
|
|
CABPM *ppm = (CABPM *)lParam;
|
|
|
|
if (SHIsChildOrSelf(ppm->ptray->_hwndRebar, hwnd) == S_OK)
|
|
{
|
|
return TRUE;
|
|
}
|
|
SendMessage(hwnd, ppm->uMsg, ppm->wP, ppm->lP);
|
|
return TRUE;
|
|
}
|
|
|
|
void CTray::_PropagateMessage(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CABPM pm = {uMessage, wParam, lParam, this};
|
|
|
|
ASSERT(hwnd != _hwndRebar);
|
|
EnumChildWindows(hwnd, PropagateEnumProc, (LPARAM)&pm);
|
|
}
|
|
|
|
//
|
|
// Called from SETTINGS.DLL when the tray property sheet needs
|
|
// to be activated. See SettingsUIThreadProc below.
|
|
//
|
|
// Also used by desktop2\deskhost.cpp to get to the tray properties.
|
|
//
|
|
void WINAPI Tray_DoProperties(DWORD dwFlags)
|
|
{
|
|
c_tray.DoProperties(dwFlags);
|
|
}
|
|
|
|
|
|
DWORD WINAPI CTray::SettingsUIThreadProc(void *pv)
|
|
{
|
|
//
|
|
// Open up the "Settings Wizards" UI.
|
|
//
|
|
HMODULE hmodSettings = LoadLibrary(TEXT("settings.dll"));
|
|
if (NULL != hmodSettings)
|
|
{
|
|
//
|
|
// Entry point in SETTINGS.DLL is ordinal 1.
|
|
// Don't want to export this entry point by name.
|
|
//
|
|
PSETTINGSUIENTRY pfDllEntry = (PSETTINGSUIENTRY)GetProcAddress(hmodSettings, (LPCSTR)1);
|
|
if (NULL != pfDllEntry)
|
|
{
|
|
//
|
|
// This call will open and run the UI.
|
|
// The thread's message loop is inside settings.dll.
|
|
// This call will not return until the settings UI has been closed.
|
|
//
|
|
(*pfDllEntry)(Tray_DoProperties);
|
|
}
|
|
|
|
FreeLibrary(hmodSettings);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void _MigrateIEXPLORE(HKEY hkBrowser)
|
|
{
|
|
TCHAR szAppName[MAX_PATH];
|
|
LONG cb = sizeof(szAppName);
|
|
|
|
if (ERROR_SUCCESS == RegQueryValue(hkBrowser, NULL, szAppName, &cb))
|
|
{
|
|
if (0 == lstrcmp(szAppName, TEXT("Internet Explorer")))
|
|
{
|
|
TraceMsg(TF_WARNING, "Migrating old StartMenuInternet setting (you just upgraded from build 2465+)");
|
|
|
|
// copy in the good value
|
|
lstrcpy(szAppName, TEXT("iexplore.exe"));
|
|
|
|
// this will fail if the user is not an admin, oh well.
|
|
if (ERROR_SUCCESS == RegSetValueEx(hkBrowser, NULL, 0, REG_SZ, (BYTE *)szAppName, sizeof(TCHAR) * (lstrlen(szAppName)+1)))
|
|
{
|
|
// Now tell everybody about the change
|
|
SHSendMessageBroadcast(WM_SETTINGCHANGE, 0, (LPARAM)TEXT("Software\\Clients\\StartMenuInternet"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// This function is called whenever we detect a change to the default
|
|
// browser registration in HKCR\http\shell\open\command.
|
|
//
|
|
// For compatibility with old browsers, if the default browser (URL handler)
|
|
// is not XP-aware, then auto-generate a StartMenuInternet client
|
|
// registration and set it as the default.
|
|
//
|
|
|
|
void CTray::_MigrateOldBrowserSettings()
|
|
{
|
|
// We want only one person to do this work per machine (though it doesn't
|
|
// hurt to have more than one person do it; it's just pointless), so try
|
|
// to filter out people who clearly didn't instigate the key change.
|
|
//
|
|
if (!_fIsDesktopLocked && _fIsDesktopConnected)
|
|
{
|
|
// If the user does not have write access then we can't migrate the
|
|
// setting... (In which case there was nothing to migrate anyway
|
|
// since you need to be administrator to change the default browser...)
|
|
|
|
HKEY hkBrowser;
|
|
DWORD dwDisposition;
|
|
|
|
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Clients\\StartMenuInternet"),
|
|
0, NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkBrowser, &dwDisposition) == ERROR_SUCCESS)
|
|
{
|
|
TCHAR szCommand[MAX_PATH];
|
|
DWORD cch = ARRAYSIZE(szCommand);
|
|
|
|
// It is important that we use AssocQueryString to parse the
|
|
// executable, because Netscape has a habit of registering
|
|
// their path incorrectly (they forget to quote the space in
|
|
// "Program Files") but AssocQueryString has special recovery
|
|
// code to detect and repair that case...
|
|
if (SUCCEEDED(AssocQueryString(ASSOCF_NOUSERSETTINGS,
|
|
ASSOCSTR_EXECUTABLE, L"http",
|
|
L"open", szCommand, &cch)) &&
|
|
szCommand[0])
|
|
{
|
|
TCHAR szAppName[MAX_PATH];
|
|
lstrcpyn(szAppName, PathFindFileName(szCommand), ARRAYSIZE(szAppName));
|
|
|
|
// You might think that we need to special-case MSN Explorer,
|
|
// since they shipped before XP RTM'd, and convert MSN6.EXE
|
|
// to "MSN Explorer", but that's not true because
|
|
// they never take over as the default http handler, so we
|
|
// will never see them here!
|
|
|
|
|
|
// TODO - Remove _MigrateIXPLORE post-whistler. (saml 010622)
|
|
|
|
// we do need to special-case the string "Internet Explorer"
|
|
// which was written out starting with build 2465 (post-B2!)
|
|
// We want ie.inx to continue to specify FLG_ADDREG_NOCLOBBER (=2) on software\client\startmenuinternet,
|
|
// since we really don't want want to clobber this value
|
|
// Therefore, just special-case migrate the known bad value to the new good value ("iexplore.exe")
|
|
_MigrateIEXPLORE(hkBrowser);
|
|
|
|
// Create a registration for the new default browser if necessary.
|
|
// We keep our hands off once we see a DefaultIcon key, since that
|
|
// proves that the application is XP-aware.
|
|
|
|
// When IE Access is turned off, StartMenuInternet\IExplore.exe is
|
|
// also removed so that IE will not appear in "Customize Start Menu"
|
|
// dialog box. Do not migrate IE.
|
|
|
|
HKEY hkClient;
|
|
|
|
if ( 0 != lstrcmpi(szAppName, TEXT("IEXPLORE.EXE")) &&
|
|
RegCreateKeyEx(hkBrowser, szAppName, 0, NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE, NULL, &hkClient, &dwDisposition) == ERROR_SUCCESS)
|
|
{
|
|
if (dwDisposition == REG_CREATED_NEW_KEY)
|
|
{
|
|
TCHAR szFriendly[MAX_PATH];
|
|
cch = ARRAYSIZE(szFriendly);
|
|
if (SUCCEEDED(AssocQueryString(ASSOCF_NOUSERSETTINGS | ASSOCF_INIT_BYEXENAME | ASSOCF_VERIFY,
|
|
ASSOCSTR_FRIENDLYAPPNAME, szCommand,
|
|
NULL, szFriendly, &cch)))
|
|
{
|
|
// Set the friendly name
|
|
RegSetValueEx(hkClient, TEXT("LocalizedString"), 0, REG_SZ, (BYTE*)szFriendly, sizeof(TCHAR) * (cch + 1));
|
|
|
|
// Set the command string (properly quoted)
|
|
PathQuoteSpaces(szCommand);
|
|
SHSetValue(hkClient, TEXT("shell\\open\\command"), NULL,
|
|
REG_SZ, szCommand, sizeof(TCHAR) * (1 + lstrlen(szCommand)));
|
|
}
|
|
}
|
|
|
|
LONG l = 0;
|
|
if (RegQueryValue(hkClient, TEXT("DefaultIcon"), NULL, &l) == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
// Set it as the system default
|
|
RegSetValueEx(hkBrowser, NULL, 0, REG_SZ, (BYTE*)szAppName, sizeof(TCHAR) * (lstrlen(szAppName) + 1));
|
|
|
|
// Now tell everybody about the change
|
|
SHSendMessageBroadcast(WM_SETTINGCHANGE, 0, (LPARAM)TEXT("Software\\Clients\\StartMenuInternet"));
|
|
}
|
|
RegCloseKey(hkClient);
|
|
}
|
|
|
|
}
|
|
RegCloseKey(hkBrowser);
|
|
}
|
|
}
|
|
|
|
// Restart the monitoring of the registry...
|
|
// (RegNotifyChangeKeyValue is good for only one shot.)
|
|
// Some apps (like Opera) delete the key as part of their registration,
|
|
// which causes our HKEY to go bad, so close it and make a new one.
|
|
|
|
if (_hkHTTP)
|
|
{
|
|
RegCloseKey(_hkHTTP);
|
|
_hkHTTP = NULL;
|
|
}
|
|
|
|
//
|
|
// Note! We have to register on HKCR\http\shell recursively
|
|
// even though we only care about HKCR\http\shell\open\command.
|
|
// The reason is that shell\open\command might not exist (IE
|
|
// deletes it as part of its uninstall) and you can't register
|
|
// a wait on a key that doesn't exist. We don't want to create
|
|
// a blank key on our own, because that means "To launch a web
|
|
// browser, run the null string as a command," which doesn't work
|
|
// too great.
|
|
//
|
|
if (RegCreateKeyEx(HKEY_CLASSES_ROOT, TEXT("http\\shell"),
|
|
0, NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_NOTIFY,
|
|
NULL, &_hkHTTP, NULL) == ERROR_SUCCESS)
|
|
{
|
|
RegNotifyChangeKeyValue(_hkHTTP, TRUE,
|
|
REG_NOTIFY_CHANGE_NAME |
|
|
REG_NOTIFY_CHANGE_LAST_SET,
|
|
_hHTTPEvent, TRUE);
|
|
}
|
|
}
|
|
|
|
void CTray::_MigrateOldBrowserSettingsCB(PVOID lpParameter, BOOLEAN)
|
|
{
|
|
//
|
|
// Sleep a little while so the app can finish installing all the
|
|
// registry keys it wants before we start cleaning up behind it.
|
|
//
|
|
Sleep(1000);
|
|
|
|
CTray *self = (CTray *)lpParameter;
|
|
self->_MigrateOldBrowserSettings();
|
|
}
|
|
|
|
//
|
|
// *** WARNING ***
|
|
//
|
|
// This is a private interface EXPLORER.EXE exposes to SHDOCVW, which
|
|
// allows SHDOCVW (mostly desktop) to access tray. All member must be
|
|
// thread safe!
|
|
//
|
|
|
|
CDeskTray::CDeskTray()
|
|
{
|
|
_ptray = IToClass(CTray, _desktray, this);
|
|
}
|
|
|
|
HRESULT CDeskTray::QueryInterface(REFIID riid, void ** ppvObj)
|
|
{
|
|
#if 0 // no IID_IDeskTray yet defined
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENT(CDeskTray, IDeskTray),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
#else
|
|
return E_NOTIMPL;
|
|
#endif
|
|
}
|
|
|
|
ULONG CDeskTray::AddRef()
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
ULONG CDeskTray::Release()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
HRESULT CDeskTray::GetTrayWindow(HWND* phwndTray)
|
|
{
|
|
ASSERT(_ptray->_hwnd);
|
|
*phwndTray = _ptray->_hwnd;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CDeskTray::SetDesktopWindow(HWND hwndDesktop)
|
|
{
|
|
ASSERT(v_hwndDesktop == NULL);
|
|
v_hwndDesktop = hwndDesktop;
|
|
return S_OK;
|
|
}
|
|
|
|
UINT CDeskTray::AppBarGetState()
|
|
{
|
|
return (_ptray->_uAutoHide ? ABS_AUTOHIDE : 0) |
|
|
(_ptray->_fAlwaysOnTop ? ABS_ALWAYSONTOP : 0);
|
|
}
|
|
|
|
//*** CDeskTray::SetVar -- set an explorer variable (var#i := value)
|
|
// ENTRY/EXIT
|
|
// var id# of variable to be changed
|
|
// value value to be assigned
|
|
// NOTES
|
|
// WARNING: thread safety is up to caller!
|
|
// notes: currently only called in 1 place, but extra generality is cheap
|
|
// minimal cost
|
|
HRESULT CDeskTray::SetVar(int var, DWORD value)
|
|
{
|
|
extern BOOL g_fExitExplorer;
|
|
|
|
TraceMsg(DM_TRACE, "c.cdt_sv: set var(%d):=%d", var, value);
|
|
switch (var) {
|
|
case SVTRAY_EXITEXPLORER:
|
|
TraceMsg(DM_TRACE, "c.cdt_sv: set g_fExitExplorer:=%d", value);
|
|
g_fExitExplorer = value;
|
|
WriteCleanShutdown(1);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
return S_FALSE;
|
|
}
|
|
return S_OK;
|
|
}
|