//--------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation 1991-1992
//
// File: desktop.c
//
// Contains: Shell desktop functions.
//
// History:
// 12-28-92 SatoNa Calls FileIconIndex().
//
//---------------------------------------------------------------------------
#include "cabinet.h"
#include "cabwnd.h"
#include "rcids.h"
#include <shellapi.h>
#include "trayclok.h"
#include <fsmenu.h>
#include <shguidp.h>
#include <trayp.h>
#include "traynot.h"
#include "help.h" // help ids
#if defined(FE_IME)
#include <immp.h>
#endif
#include <regstr.h>
#ifndef WINNT // BUGBUG - Fix this when NT gets POWERMGT features
#include <vmm.h>
#include <bios.h>
#define NOPOWERSTATUSDEFINES
#include <pwrioctl.h>
#include <wshioctl.h>
#include <dbt.h>
#include <pbt.h>
#define Not_VxD
#define No_CM_Calls
#include <configmg.h>
#endif
#define IsEjectAllowed() (g_ts.hBIOS != INVALID_HANDLE_VALUE)
#define ENTERCRITICAL MEnterCriticalSection(&g_csThreads)
#define LEAVECRITICAL MLeaveCriticalSection(&g_csThreads)
#define POLLINTERVAL (15*1000) // 15 seconds
#define MINPOLLINTERVAL (3*1000) // 3 seconds
#define ERRTIMEOUT (5*1000) // 5 seconds
#define SECOND 1000
#define RUNWAITSECS 5
#ifdef WINNT
#define MAXPRINTERBUFFER (MAX_PATH+18+1)
#define JOB_STATUS_ERROR_BITS (JOB_STATUS_USER_INTERVENTION|JOB_STATUS_ERROR)
#else
#define MAXPRINTERBUFFER 32
#define JOB_STATUS_ERROR_BITS JOB_STATUS_USER_INTERVENTION
#endif
#define TM_RELAYPOSCHANGED (WM_USER + 0x150)
#define TM_INVALIDATEREBUILDMENU (WM_USER + 0x151)
#define TM_BRINGTOTOP (WM_USER + 0x152)
#define RDM_ACTIVATE (WM_USER + 0x101)
#if !defined(_PPC_) // PPC compiler generates random 4701s
#pragma warning(3 : 4700 4701 4702)
#endif
// DSA haPrinterNames structure:
typedef struct _PRINTERNAME {
TCHAR szPrinterName[MAXPRINTERBUFFER];
LPITEMIDLIST pidlPrinter; // relative pidl to printer
BOOL fInErrorState;
} PRINTERNAME, * LPPRINTERNAME;
void PrintNotify_Init(HWND hWnd);
void PrintNotify_AddToQueue(LPHANDLE phaPrinterNames, LPSHELLFOLDER *ppsf, LPCITEMIDLIST pidlPrinter);
BOOL PrintNotify_StartThread(HWND hWnd);
void PrintNotify_HandleFSNotify(HWND hWnd, LPCITEMIDLIST *ppidl, LONG lEvent);
void PrintNotify_Exit(void);
void PrintNotify_IconNotify(HWND hWnd, UINT uMsg);
STDMETHODIMP CShellTray_AddViewPropertySheetPages(IShellBrowser * psb, DWORD dwReserved, LPFNADDPROPSHEETPAGE lpfn, LPARAM lParam);
STDMETHODIMP ShellDesktop_BrowseObject(LPSHELLBROWSER psb, LPCITEMIDLIST pdil, UINT wFlags);
void Tray_ScreenSizeChange(HWND hWnd);
void Tray_SizeWindows();
void Tray_ContextMenu(PFileCabinet pfc, DWORD dwPos, BOOL fSetTime);
void StuckSizeChange();
void StartMenu_Build(PFileCabinet pfc);
void SetWindowStyleBit(HWND hwnd, DWORD dwBit, DWORD dwValue);
LRESULT Tray_HandleInitMenuPopup(HMENU hmenuPopup);
HMENU Menu_FindSubMenuByFirstID(HMENU hmenu, UINT id);
void CStartDropTarget_Register(LPFileCabinet pfc);
void CStartDropTarget_Revoke(LPFileCabinet pfc);
void DestroySavedWindowPositions();
void RebuildEntireMenu(PFileCabinet pfc);
void Cabinet_InitGlobalMetrics(WPARAM, LPTSTR);
void StartMenuFolder_ContextMenu(PFileCabinet pfc, DWORD dwPos);
void Tray_HandleSizing(PFileCabinet pfc, UINT code, LPRECT lprc, UINT uStuckPlace);
void MinimizeAll(HWND hwndView);
void RegisterGlobalHotkeys();
void TrayUnhide();
int HotkeyList_Restore(HWND hwnd);
LRESULT Tray_RegisterHotkey(HWND hwnd, int i);
void CheckWinIniForAssocs(void);
void SetAutoHideTimer();
#if (defined(DBCS) || defined(FE_IME))
// b#11258-win95d
#if !defined(WINNT)
DWORD WINAPI ImmGetAppIMECompatFlags(DWORD dwThreadID);
#endif
#endif
// appbar stuff
BOOL IAppBarSetAutoHideBar(HWND hwnd, BOOL fSet, UINT uEdge);
void IAppBarActivationChange(HWND hWnd, UINT uEdge);
HWND g_hwndAutoHide[ABE_MAX] = { NULL, NULL, NULL, NULL };
#define ClockCtl_HandleTrayHide(fHiding) SendMessage(g_ts.hwndNotify, TNM_TRAYHIDE, 0, fHiding)
// dyna-res change for multi-config hot/warm-doc
void HandleDisplayChange(int x, int y, BOOL fCritical);
BOOL IsDisplayChangeSafe(void);
DWORD GetMinDisplayRes(void);
// appbar stuff
void AppBarNotifyAll(UINT uMsg, HWND hwndExclude, LPARAM lParam);
HWND v_hwndTray = NULL;
PFileCabinet g_pfcTray = NULL; // we should move all the other globals into here
UINT g_cfIDList = 0;
// Button subclass.
WNDPROC g_ButtonProc = NULL;
// desktop and tray stuff
#define tray_cxScreen (g_cxScreen + g_cxEdge)
#define tray_cyScreen (g_cyScreen + g_cyEdge)
#define tray_xScreen (-g_cxEdge)
#define tray_yScreen (-g_cyEdge)
// timer IDs
#define IDT_AUTOHIDE 2
#define IDT_AUTOUNHIDE 3
#define IDT_FAVOURITE 4
#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 RECTWIDTH(rc) ((rc).right-(rc).left)
#define RECTHEIGHT(rc) ((rc).bottom-(rc).top)
extern HWND g_hwndDde;
int g_cyTrayBorders = -1; // the amount of Y difference between the window and client height;
//
// amount of time to show/hide the tray
// to turn sliding off set these to 0
//
int g_dtSlideHide;
int g_dtSlideShow;
typedef enum
{
SMCT_NONE = 0x0,
SMCT_PRIMARY = 0x1,
SMCT_WININIASSOCS = 0x2,
SMCT_BUILDLISTOFPATHS = 0x3,
SMCT_INITPROGRAMS = 0x4,
SMCT_INITRECENT = 0x5,
SMCT_PARTFILLPROGRAMS = 0x6,
SMCT_FILLRECENT = 0x7,
SMCT_FILLPROGRAMS = 0x8,
SMCT_FILLFAVOURITE = 0x9,
SMCT_DESKTOPHOTKEYS = 0xa,
SMCT_DONE = 0xb,
SMCT_FILLRECENTONLY = 0xc,
SMCT_FILLPROGRAMSONLY = 0xd,
SMCT_DESKTOPHOTKEYSONLY = 0xe,
SMCT_STOP = 0xf,
SMCT_RESTART = 0x10
} STARTMENUCONTROLTHREAD;
enum
{
GHID_RUN = 0,
GHID_MINIMIZEALL,
GHID_UNMINIMIZEALL,
GHID_HELP,
GHID_EXPLORER,
GHID_FINDFILES,
GHID_FINDCOMPUTER,
GHID_TASKTAB,
GHID_TASKSHIFTTAB,
GHID_SYSPROPERTIES,
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)
};
void DoExitWindows(HWND hwnd);
void TrayCommand(PFileCabinet pfc, UINT idCmd);
BOOL SetAutoHideState(BOOL fAutoHide);
LRESULT CALLBACK TrayWndProc(HWND, UINT, WPARAM, LPARAM);
//---------------------------------------------------------------------------
// Global to this file only.
// NB None of the tray stuff needs thread serialising because
// we only ever have one tray.
TRAYSTUFF g_ts = {0};
// g_fDockingFlags bits
#define DOCKFLAG_WARMEJECTABLENOW (1<<0)
// TVSD Flags.
#define TVSD_NULL 0x0000
#define TVSD_TOPMOST 0x0002
#define TVSD_SMSMALLICONS 0x0004
#define TVSD_HIDECLOCK 0x0008
#define DM_IANELHK DM_TRACE
// Define a 16/32 bit independant format for saving the tray information
// into
typedef struct _TVSD // Tray View Size (or save) Data
{
DWORD dwSize;
// Screen size in X direction.
LONG cxScreen;
LONG cyScreen;
// Only save Widths and heights for the four edges not whole values
LONG dxLeft;
LONG dxRight;
LONG dyTop;
LONG dyBottom;
// Additional data for AutoHide
DWORD uAutoHide;
RECTL rclAutoHide;
// More stuff.
DWORD uStuckPlace;
DWORD dwFlags;
} TVSD;
#define IDC_FOLDERTABS 1
BOOL CreateClockWindow(HWND hwnd)
{
g_ts.hwndNotify = TrayNotifyCreate(hwnd, IDC_CLOCK, hinstCabinet);
return (BOOL)g_ts.hwndNotify;
}
BOOL InitTrayClass(HINSTANCE hInstance)
{
WNDCLASS wc;
wc.lpszClassName = c_szTrayClass;
wc.style = CS_DBLCLKS;
wc.lpfnWndProc = TrayWndProc;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
wc.lpszMenuName = NULL;
wc.cbClsExtra = 0;
wc.cbWndExtra = SIZEOF(PFileCabinet);
return RegisterClass(&wc);
}
#define CXGAP 4
//----------------------------------------------------------------------------
// Compose the Start bitmap out of a flag and some text.
// REVIEW UNDONE - Put the up/down arrow back in.
HBITMAP CreateStartBitmap(HWND hwndTray)
{
HBITMAP hbmpStart = NULL;
HBITMAP hbmpStartOld = NULL;
HICON hiconFlag = NULL;
int cx, cy, cySmIcon;
TCHAR szStart[CCHSZNORMAL];
SIZE size;
HDC hdcStart;
HDC hdcScreen;
HFONT hfontStart = NULL;
HFONT hfontStartOld = NULL;
NONCLIENTMETRICS ncm;
RECT rcStart;
// DebugMsg(DM_TRACE, "c.csb: Creating start bitmap.");
hdcScreen = GetDC(NULL);
hdcStart = CreateCompatibleDC(hdcScreen);
if (hdcStart)
{
ncm.cbSize = SIZEOF(ncm);
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, SIZEOF(ncm), &ncm, FALSE))
{
ncm.lfCaptionFont.lfWeight = FW_BOLD;
hfontStart = CreateFontIndirect(&ncm.lfCaptionFont);
hfontStartOld = SelectObject(hdcStart , hfontStart);
}
else
{
DebugMsg(DM_ERROR, TEXT("c.csb: Can't create font."));
}
// Get an idea about how big we need everyhting to be.
LoadString(hinstCabinet, IDS_START, szStart, ARRAYSIZE(szStart));
GetTextExtentPoint(hdcStart, szStart, lstrlen(szStart), &size);
// Mimick the tray and ignore the font size for determining the height.
#if 0
cy = max(g_cySize, size.cy);
#else
cy = g_cySize;
#endif
cySmIcon = GetSystemMetrics(SM_CYSMICON);
cx = (cy + size.cx) + CXGAP;
hbmpStart = CreateCompatibleBitmap(hdcScreen, cx, cy);
hbmpStartOld = SelectObject(hdcStart, hbmpStart);
rcStart.left = -g_cxEdge; // subtract this off because drawcaptiontemp adds it on
rcStart.top = 0;
rcStart.right = cx;
rcStart.bottom = cy;
hiconFlag = (HICON)LoadImage(NULL, MAKEINTRESOURCE(OIC_WINLOGO_DEFAULT), IMAGE_ICON, cySmIcon, cySmIcon, 0);
// Get User to draw everything for us.
DrawCaptionTemp(hwndTray, hdcStart, &rcStart, hfontStart, hiconFlag, szStart, DC_INBUTTON | DC_TEXT | DC_ICON | DC_NOSENDMSG);
// Clean up Start stuff.
SelectObject(hdcStart, hbmpStartOld);
if (hfontStart)
{
SelectObject(hdcStart, hfontStartOld);
DeleteObject(hfontStart);
}
DeleteDC(hdcStart);
DestroyIcon(hiconFlag);
}
else
{
DebugMsg(DM_ERROR, TEXT("c.csb: Can't create Start bitmap."));
}
ReleaseDC(NULL, hdcScreen);
return hbmpStart;
}
VOID _GetSaveStateAndInitRects()
{
TVSD tvsd;
DWORD cbData = SIZEOF(tvsd);
if (Reg_GetStruct(g_hkeyExplorer, c_szCabinetStuckRects, c_szSettings, &tvsd, &cbData) &&
(cbData == SIZEOF(tvsd)) && (tvsd.dwSize == SIZEOF(tvsd)))
{
// Now lets validate the information that was returned
if ((tvsd.dyTop < 0) || tvsd.dyTop > g_cyScreen / 2)
tvsd.dyTop = g_ts.sizeStart.cy + (g_cyDlgFrame + g_cxBorder) * 2;
if ((tvsd.dyBottom < 0) || tvsd.dyBottom > g_cyScreen / 2)
tvsd.dyBottom = g_ts.sizeStart.cy + (g_cyDlgFrame + g_cxBorder) * 2;
if ((tvsd.dxLeft < 0) || tvsd.dxLeft > g_cxScreen / 2)
tvsd.dxLeft = g_ts.sizeStart.cx + (g_cxDlgFrame + g_cyBorder) * 2;
if ((tvsd.dxRight < 0) || tvsd.dxRight > g_cxScreen / 2)
tvsd.dxRight = g_ts.sizeStart.cx + (g_cxDlgFrame + g_cyBorder) * 2;
// Restore the autohide rectangles and settings also.
g_ts.uAutoHide = (UINT)tvsd.uAutoHide;
g_ts.rc.left = (int)tvsd.rclAutoHide.left;
g_ts.rc.right = (int)tvsd.rclAutoHide.right;
g_ts.rc.top = (int)tvsd.rclAutoHide.top;
g_ts.rc.bottom = (int)tvsd.rclAutoHide.bottom;
g_ts.uStuckPlace = (UINT)tvsd.uStuckPlace;
g_ts.fAlwaysOnTop = tvsd.dwFlags & TVSD_TOPMOST ? 1 : 0;
g_ts.fSMSmallIcons = tvsd.dwFlags & TVSD_SMSMALLICONS ? 1 : 0;
g_ts.fHideClock = tvsd.dwFlags & TVSD_HIDECLOCK ? 1 : 0;
}
else
{
// setup for default rects, when it failed.
tvsd.cxScreen = g_cxScreen;
tvsd.cyScreen = g_cyScreen;
// Now get the sizes for the four edges.
tvsd.dyTop = tvsd.dyBottom = g_ts.sizeStart.cy +
(g_cyDlgFrame + g_cxBorder) * 2;
tvsd.dxLeft = tvsd.dxRight = g_ts.sizeStart.cx +
(g_cxDlgFrame + g_cyBorder) * 2;
// this is just a sanity check. if there were
// no settings, then auto-hide is off, and
// this rect will be initialized if/when autohide is turned on
// (unless we have a bug....)
g_ts.rc.left = 0;
g_ts.rc.right = g_cxScreen;
g_ts.rc.bottom = g_cyScreen;
g_ts.rc.top = g_cyScreen - 20;
// the ever changing default
g_ts.uStuckPlace = STICK_BOTTOM;
g_ts.fAlwaysOnTop = TRUE;
g_ts.fHideClock = FALSE;
}
// Now set the rects to match the sizes that are in our save record
GetWindowRect(GetDesktopWindow(), &g_ts.arStuckRects[STICK_TOP]);
InflateRect(&g_ts.arStuckRects[STICK_TOP], g_cxEdge, g_cyEdge);
g_ts.arStuckRects[STICK_BOTTOM] = g_ts.arStuckRects[STICK_TOP];
g_ts.arStuckRects[STICK_LEFT] = g_ts.arStuckRects[STICK_TOP];
g_ts.arStuckRects[STICK_RIGHT] = g_ts.arStuckRects[STICK_TOP];
g_ts.arStuckRects[STICK_TOP].bottom = (int)tray_yScreen + tvsd.dyTop;
g_ts.arStuckRects[STICK_BOTTOM].top = tray_cyScreen - (int)tvsd.dyBottom;
g_ts.arStuckRects[STICK_LEFT].right = (int)tray_xScreen + tvsd.dxLeft;
g_ts.arStuckRects[STICK_RIGHT].left = tray_cxScreen - (int)tvsd.dxRight;
// See if the screen resolution changed
if ((g_cxScreen != tvsd.cxScreen) || (g_cyScreen != tvsd.cyScreen))
Tray_ScreenSizeChange(NULL);
}
/*------------------------------------------------------------------
** align toolbar so that buttons are flush with client area
** and make toolbar's buttons to be MENU style
**------------------------------------------------------------------*/
void AlignStartButton(HWND hwndStart)
{
if (hwndStart)
{
BITMAP bm;
HBITMAP hbm = (HBITMAP)SendMessage(hwndStart, BM_GETIMAGE, IMAGE_BITMAP, 0);
if (hbm)
{
GetObject(hbm, SIZEOF(bm), &bm);
g_ts.sizeStart.cx = bm.bmWidth + 2 * g_cxEdge;
g_ts.sizeStart.cy = bm.bmHeight + 2 * g_cyEdge;
if (g_ts.sizeStart.cy < g_cySize + 2*g_cyEdge)
g_ts.sizeStart.cy = g_cySize + 2*g_cyEdge;
}
else
{
// BUGBUG: New user may have caused this to fail...
// Setup some size for it that wont be too bad...
g_ts.sizeStart.cx = g_cxMinimized;
g_ts.sizeStart.cy = g_cySize + 2*g_cyEdge;
}
SetWindowPos(hwndStart, NULL, 0, 0, g_ts.sizeStart.cx, g_ts.sizeStart.cy, SWP_NOZORDER | SWP_NOACTIVATE);
}
}
//----------------------------------------------------------------------------
// Allow us to do stuff on a "button-down".
LRESULT CALLBACK StartButtonSubclassWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// PFileCabinet pfc;
LRESULT lRet;
static UINT uDown = 0;
Assert(g_ButtonProc)
// Is the button going down?
if (uMsg == BM_SETSTATE)
{
if (wParam) {
// DebugMsg(DM_TRACE, "c.stswp: Set state %d", wParam);
// Yep, Is it already down?
if (!uDown)
{
// Nope.
uDown = 1;
// Show the button down.
lRet = CallWindowProc(g_ButtonProc, hWnd, uMsg, wParam, lParam);
// Notify the parent.
SendMessage(GetParent(hWnd), WM_COMMAND,
(WPARAM)LOWORD(GetDlgCtrlID(hWnd)), (LPARAM)hWnd);
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?
if (uDown == 1)
{
// Yep, do nothing.
uDown = 2;
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
else
{
// Nope, Forward it on.
uDown = 0;
return CallWindowProc(g_ButtonProc, hWnd, uMsg, wParam, lParam);
}
}
}
else
{
if (uMsg == WM_MOUSEMOVE) {
MSG msg;
msg.lParam = lParam;
msg.wParam = wParam;
msg.message = uMsg;
msg.hwnd = hWnd;
SendMessage(g_ts.hwndTrayTips, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)&msg);
}
return CallWindowProc(g_ButtonProc, hWnd, uMsg, wParam, lParam);
}
}
const TCHAR c_szButton[] = TEXT("button");
/*------------------------------------------------------------------
** create the toolbar with the three buttons and align windows
**------------------------------------------------------------------*/
HWND Tray_MakeStartButton(HWND hwndTray)
{
HWND hwnd;
HBITMAP hbm;
// BUGBUG: BS_CENTER | VS_VCENTER required, user bug?
hwnd = CreateWindowEx(0, c_szButton, NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS |
BS_PUSHBUTTON | BS_BITMAP | BS_LEFT | BS_VCENTER,
0, 0, 0, 0, hwndTray, (HMENU)IDC_START, hinstCabinet, NULL);
if (hwnd) {
// Subclass it.
g_ts.hwndStart = hwnd;
g_ButtonProc = (WNDPROC)GetWindowLong(hwnd, GWL_WNDPROC);
SetWindowLong(hwnd, GWL_WNDPROC, (LONG)(FARPROC)StartButtonSubclassWndProc);
hbm = CreateStartBitmap(hwndTray);
if (hbm) {
SendMessage(hwnd, BM_SETIMAGE, IMAGE_BITMAP, (DWORD)hbm);
AlignStartButton(hwnd);
return hwnd;
}
DestroyWindow(hwnd);
}
return NULL;
}
void Tray_GetWindowSizes(PRECT prcClient, PRECT prcView, PRECT prcClock)
{
int xFSView, yFSView, cxFSView, cyFSView;
int xClock, yClock, cxClock, cyClock;
DWORD dwClockMinSize;
// size to fill either horizontally or vertically
if ((prcClient->right - g_ts.sizeStart.cx) > (prcClient->bottom - g_ts.sizeStart.cy))
{
//
// Horizontal - Two cases. One where we have room below the
// toolbar to display the clock. so display it there, else
// display it on the right hand side...
//
yFSView = 0;
cyFSView = prcClient->bottom - yFSView;
dwClockMinSize = SendMessage(g_ts.hwndNotify, WM_CALCMINSIZE,
g_ts.sizeStart.cx, 0);
cxClock = LOWORD(dwClockMinSize);
cyClock = HIWORD(dwClockMinSize);
#ifdef ALLOW_CLOCK_ON_RIGHT
//
// we're now disallowing this case because the clock would
// jump to the right when a notify hits and makes the clock
// too wide to fit under the clock
//
if ((g_ts.sizeStart.cy + cyClock + g_cyTabSpace) <= prcClient->bottom)
{
// put it below
xClock = 0;
if (cxClock < g_ts.sizeStart.cx)
cxClock = g_ts.sizeStart.cx;
yClock = g_ts.sizeStart.cy + g_cyTabSpace;
xFSView = cxClock + g_cxFrame;
cxFSView = prcClient->right - xFSView;
}
else
{
#endif
// Recalc the min size for horizontal arrangement
dwClockMinSize = SendMessage(g_ts.hwndNotify, WM_CALCMINSIZE,
0x7fff, 0);
cxClock = LOWORD(dwClockMinSize);
cyClock = HIWORD(dwClockMinSize);
// xClock = prcClient->right - cxClock - g_cxFrame; // A little gap...
xClock = prcClient->right - cxClock;
#ifdef VCENTER_CLOCK
yClock = (prcClient->bottom-cyClock)/2; // Center it vertically.
#else
yClock = 0;
#endif
xFSView = g_ts.sizeStart.cx + g_cxFrame;
cxFSView = xClock - xFSView - g_cxFrame;
#ifdef ALLOW_CLOCK_ON_RIGHT
}
#endif
}
else
{
// Vertical - Again two cases. One where we have room to the
// right to display the clock. Note: we want some gap here between
// the clock and toolbar. If it does not fit, then we will center
// it at the bottom...
xFSView = 0;
cxFSView = prcClient->right - xFSView;
dwClockMinSize = SendMessage(g_ts.hwndNotify, WM_CALCMINSIZE,
0x7fff, 0);
cxClock = LOWORD(dwClockMinSize);
cyClock = HIWORD(dwClockMinSize);
if ((g_ts.sizeStart.cx + cxClock + 4 * g_cyTabSpace) < prcClient->right)
{
int cyMax = g_ts.sizeStart.cy;;
// Can fit on the same row!
xClock = prcClient->right - cxClock - (2 * g_cxEdge); // A little gap...
yClock = 0;
if (cyClock > cyMax)
cyMax = cyClock;
yFSView = cyMax + g_cyTabSpace;
cyFSView = prcClient->bottom - yFSView;
}
else
{
// Nope put at bottom
// Recalc the min size for vertical arrangement
dwClockMinSize = SendMessage(g_ts.hwndNotify, WM_CALCMINSIZE,
cxFSView, 0);
cxClock = min(LOWORD(dwClockMinSize), prcClient->right);
cyClock = HIWORD(dwClockMinSize);
xClock = (prcClient->right - cxClock) / 2;
yClock = prcClient->bottom - cyClock - g_cyTabSpace;
yFSView = g_ts.sizeStart.cy + g_cyTabSpace;
cyFSView = yClock - yFSView - g_cyTabSpace;
}
}
prcView->left = xFSView;
prcView->top = yFSView;
prcView->right = xFSView + cxFSView;
prcView->bottom = yFSView + cyFSView;
prcClock->left = xClock;
prcClock->top = yClock;
prcClock->right = xClock + cxClock;
prcClock->bottom = yClock + cyClock;
}
void _TrayRestoreWindowPos(HWND hWnd)
{
WINDOWPLACEMENT wp;
//first restore the stuck postitions
_GetSaveStateAndInitRects();
wp.length = SIZEOF(wp);
g_ts.uMoveStuckPlace = g_ts.uStuckPlace;
wp.rcNormalPosition = g_ts.arStuckRects[g_ts.uStuckPlace];
wp.showCmd = SW_HIDE;
SendMessage(g_ts.hwndNotify, TNM_HIDECLOCK, 0, g_ts.fHideClock);
SetWindowPlacement(hWnd, &wp);
}
//----------------------------------------------------------------------------
// Sort of a registry equivalent of the profile API's.
BOOL Reg_GetStruct(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPVOID pData, DWORD *pcbData)
{
HKEY hkeyNew;
BOOL fRet = FALSE;
DWORD dwType;
if (!GetSystemMetrics(SM_CLEANBOOT) && (RegOpenKeyEx(hkey, pszSubKey, 0L, KEY_READ, &hkeyNew) == ERROR_SUCCESS))
{
if (RegQueryValueEx(hkeyNew, (LPVOID)pszValue, 0, &dwType, pData, pcbData) == ERROR_SUCCESS)
{
fRet = TRUE;
}
RegCloseKey(hkeyNew);
}
return fRet;
}
//----------------------------------------------------------------------------
// Sort of a registry equivalent of the profile API's.
BOOL Reg_SetStruct(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPVOID lpData, DWORD cbData)
{
HKEY hkeyNew = hkey;
BOOL fRet = FALSE;
if (pszSubKey)
{
if (RegCreateKey(hkey, pszSubKey, &hkeyNew) != ERROR_SUCCESS)
{
return fRet;
}
}
if (RegSetValueEx(hkeyNew, pszValue, 0, REG_BINARY, lpData, cbData) == ERROR_SUCCESS)
{
fRet = TRUE;
}
if (pszSubKey)
RegCloseKey(hkeyNew);
return fRet;
}
/*-------------------------------------------------------------------
** the screen size has changed, so the docked rectangles need to be
** adjusted to the new screen. since only the bottom and right change,
** only need to increment/decrement certain edges.
**-------------------------------------------------------------------*/
void ResizeStuckRects(RECT *arStuckRects)
{
int xChange, yChange;
xChange = tray_cxScreen - arStuckRects[STICK_RIGHT].right;
yChange = tray_cyScreen - arStuckRects[STICK_BOTTOM].bottom;
arStuckRects[STICK_TOP].right = tray_cxScreen;
arStuckRects[STICK_LEFT].bottom = tray_cyScreen;
arStuckRects[STICK_BOTTOM].top += yChange;
arStuckRects[STICK_BOTTOM].right = tray_cxScreen;
arStuckRects[STICK_BOTTOM].bottom = tray_cyScreen;
arStuckRects[STICK_RIGHT].left += xChange;
arStuckRects[STICK_RIGHT].right = tray_cxScreen;
arStuckRects[STICK_RIGHT].bottom = tray_cyScreen;
}
//----------------------------------------------------------------------------
STDAPI Tasks_CreateInstance(REFIID riid, void **ppv);
//---------------------------------------------------------------------------
// Create the tray IShellView instance
HWND Tray_CreateShellView(PFileCabinet pfc)
{
if (FAILED(Tasks_CreateInstance(&IID_IShellView, &pfc->psv)))
return NULL; // This is very bad
if (FAILED(pfc->psv->lpVtbl->CreateViewWindow(pfc->psv, NULL, NULL, &pfc->sb, NULL, &pfc->hwndView)))
{
Assert(pfc->hwndView == NULL); // the failure case shouls set this
// pfc->hwndView = NULL;
}
return pfc->hwndView;
}
// tray IShellBrowser vtbl
IShellBrowserVtbl s_TraySBVtbl = {
// *** IUnknown methods ***
CFileCabinet_QueryInterface,
CFileCabinet_AddRef,
CFileCabinet_Release,
// *** IOleWindow methods ***
CFileCabinet_GetWindow,
ShellDesktop_ContextSensitiveHelp,
// *** IShellBrowser methods ***
ShellDesktop_InsertMenus,
ShellDesktop_SetMenu,
ShellDesktop_RemoveMenus,
ShellDesktop_SetStatusText,
CFileCabinet_EnableModeless,
CFileCabinet_TranslateAccelerator,
// *** IShellBrowser methods ***
ShellDesktop_BrowseObject,
CDeskTray_GetViewStateStream,
ShellDesktop_GetControlWindow,
ShellDesktop_SendControlMsg,
CFileCabinet_QueryActiveShellView,
ShellDesktop_OnViewWindowActive,
ShellDesktop_SetToolbarItems,
};
void UpdateDockingFlags()
{
#ifndef WINNT
BOOL fIoSuccess;
BIOSPARAMS bp;
DWORD cbOut;
#endif
static BOOL fFirstTime=TRUE;
if ((!fFirstTime) && (g_ts.hBIOS == INVALID_HANDLE_VALUE)) {
return;
}
#ifdef WINNT
g_ts.hBIOS = INVALID_HANDLE_VALUE;
fFirstTime = FALSE;
return;
#else
g_ts.hBIOS = CreateFile(c_szBIOSDevice,
GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
if (g_ts.hBIOS == INVALID_HANDLE_VALUE) {
fFirstTime = FALSE;
return;
}
bp.bp_ret=0;
fIoSuccess=DeviceIoControl(
g_ts.hBIOS,
PNPBIOS_SERVICE_GETDOCKCAPABILITIES,
&bp,
SIZEOF(bp),
&bp,
SIZEOF(bp),
&cbOut,
NULL);
if (fFirstTime) {
// first time through, if a warm dock change is not possible,
// don't bother with the menu item.
fFirstTime=FALSE;
if (!fIoSuccess) {
// problem getting the dock capabilities:
// if problem wasn't "undocked now" or "can't identify dock"
// then warm ejecting isn't possible.
if ((bp.bp_ret!=PNPBIOS_ERR_SYSTEM_NOT_DOCKED) &&
(bp.bp_ret!=PNPBIOS_ERR_CANT_DETERMINE_DOCKING)) {
CloseHandle(g_ts.hBIOS);
g_ts.hBIOS=INVALID_HANDLE_VALUE;
return;
}
} else {
// success getting the dock capabilities:
// if the dock isn't capable of warm or hot docking
// then warm ejecting isn't possible
if (!(bp.bp_ret&PNPBIOS_DOCK_CAPABILITY_TEMPERATURE)) {
CloseHandle(g_ts.hBIOS);
g_ts.hBIOS=INVALID_HANDLE_VALUE;
return;
}
}
}
// on each call we update WARMEJECTABLENOW
// depending on whether the dock is capable of warm ejecting right now
if ((fIoSuccess) && (bp.bp_ret&PNPBIOS_DOCK_CAPABILITY_TEMPERATURE)) {
g_ts.fDockingFlags|=DOCKFLAG_WARMEJECTABLENOW;
} else {
g_ts.fDockingFlags&=~DOCKFLAG_WARMEJECTABLENOW;
}
return;
#endif
}
/* Check if system is currently in a docking station.
*
* Returns: TRUE if docked, FALSE if undocked or can't tell.
*
*/
BOOL GetDockedState(void)
{
#ifndef WINNT // BUGBUG - Fix this when NT gets docking capability
struct _ghwpi { // Get_Hardware_Profile_Info parameter blk
CMAPI cmApi;
ULONG ulIndex;
PFARHWPROFILEINFO pHWProfileInfo;
ULONG ulFlags;
HWPROFILEINFO HWProfileInfo;
} *pghwpi;
HANDLE hCMHeap;
UINT Result = DOCKSTATE_UNKNOWN;
DWORD dwRecipients = BSM_VXDS;
#define HEAP_SHARED 0x04000000 /* put heap in shared memory--undoc'd */
// Create a shared heap for CONFIGMG parameters
if ((hCMHeap = HeapCreate(HEAP_SHARED, 1, 4096)) == NULL)
return DOCKSTATE_UNKNOWN;
// Allocate parameter block in shared memory
pghwpi = (struct _ghwpi *)HeapAlloc(hCMHeap, HEAP_ZERO_MEMORY,
SIZEOF(*pghwpi));
if (pghwpi == NULL)
{
HeapDestroy(hCMHeap);
return DOCKSTATE_UNKNOWN;
}
pghwpi->cmApi.dwCMAPIRet = 0;
pghwpi->cmApi.dwCMAPIService = GetVxDServiceOrdinal(_CONFIGMG_Get_Hardware_Profile_Info);
pghwpi->cmApi.pCMAPIStack = (DWORD)(((LPBYTE)pghwpi) + SIZEOF(pghwpi->cmApi));
pghwpi->ulIndex = 0xFFFFFFFF;
pghwpi->pHWProfileInfo = &pghwpi->HWProfileInfo;
pghwpi->ulFlags = 0;
// "Call" _CONFIGMG_Get_Hardware_Profile_Info service
BroadcastSystemMessage(0, &dwRecipients, WM_DEVICECHANGE, DBT_CONFIGMGAPI32,
(LPARAM)pghwpi);
if (pghwpi->cmApi.dwCMAPIRet == CR_SUCCESS) {
switch (pghwpi->HWProfileInfo.HWPI_dwFlags) {
case CM_HWPI_DOCKED:
Result = DOCKSTATE_DOCKED;
break;
case CM_HWPI_UNDOCKED:
Result = DOCKSTATE_UNDOCKED;
break;
default:
Result = DOCKSTATE_UNKNOWN;
break;
}
}
HeapDestroy(hCMHeap);
return Result;
#else
return(FALSE);
#endif
}
#undef HEAP_SHARED
const TCHAR c_szREGSTR_ROOT_APM[] = REGSTR_KEY_ENUM TEXT("\\") REGSTR_KEY_ROOTENUM TEXT("\\") REGSTR_KEY_APM TEXT("\\") REGSTR_DEFAULT_INSTANCE;
const TCHAR c_szREGSTR_BIOS_APM[] = REGSTR_KEY_ENUM TEXT("\\") REGSTR_KEY_BIOSENUM TEXT("\\") REGSTR_KEY_APM;
const TCHAR c_szREGSTR_VAL_APMMENUSUSPEND[] = REGSTR_VAL_APMMENUSUSPEND;
/* Open the registry APM device key
*/
BOOL OpenAPMKey(HKEY *phKey)
{
HKEY hBiosSys;
BOOL rc = FALSE;
TCHAR szInst[MAX_PATH+1];
DWORD cchInst = ARRAYSIZE(szInst);
// Open HKLM\Enum\Root\*PNP0C05\0000 - This is the APM key for
// non-PnP BIOS machines.
if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szREGSTR_ROOT_APM, phKey) == ERROR_SUCCESS)
return TRUE;
// Open HKLM\Enum\BIOS\*PNP0C05, Enum the 1st subkey, open that. Example:
// HKLM\Enum\BIOS\*PNP0C05\03.
if (RegOpenKey(HKEY_LOCAL_MACHINE,c_szREGSTR_BIOS_APM,&hBiosSys) == ERROR_SUCCESS)
{
if (RegEnumKey(hBiosSys, 0, szInst, cchInst) == ERROR_SUCCESS &&
RegOpenKey(hBiosSys, szInst, phKey) == ERROR_SUCCESS)
rc = TRUE;
RegCloseKey(hBiosSys);
}
return rc;
}
/* Determine if "Suspend" should appear on the Tray menu.
*
* Returns: TRUE if Suspend should appear on menu, FALSE if not.
* Sets g_ts.fSuspendUndocked if Suspend should be disabled
* when system is docked.
*/
BOOL IsSuspendAllowed(void)
{
HKEY hkey;
DWORD dwType;
BOOL fRet = TRUE;
BYTE bMenuSuspend = APMMENUSUSPEND_ENABLED;
DWORD cbSize = SIZEOF(bMenuSuspend);
#ifdef WINNT // BUGBUG - Fix this when NT gets APM.
return FALSE;
#else
/* Check the Registry APM key for an APMMenuSuspend value.
* APMMenuSuspend may have the following values: APMMENUSUSPEND_DISABLED,
* APMMENUSUSPEND_ENABLED, or APMMENUSUSPEND_UNDOCKED.
*
* An APMMenuSuspend value of APMMENUSUSPEND_DISABLED means the
* tray should never show the Suspend menu item on its menu.
*
* APMMENUSUSPEND_ENABLED means the Suspend menu item should be shown
* if the machine has APM support enabled (VPOWERD is loaded). This is
* the default.
*
* APMMENUSUSPEND_UNDOCKED means the Suspend menu item should be shown,
* but only enabled when the machine is not in a docking station.
*
*/
if (OpenAPMKey(&hkey))
{
if (RegQueryValueEx(hkey, (LPTSTR)c_szREGSTR_VAL_APMMENUSUSPEND, 0,
&dwType, &bMenuSuspend, &cbSize) == ERROR_SUCCESS)
{
bMenuSuspend &= ~(APMMENUSUSPEND_NOCHANGE); // don't care about nochange flag
if (bMenuSuspend == APMMENUSUSPEND_UNDOCKED)
g_ts.fSuspendUndocked = TRUE;
else
{
g_ts.fSuspendUndocked = FALSE;
if (bMenuSuspend == APMMENUSUSPEND_DISABLED)
fRet = FALSE;
}
}
RegCloseKey(hkey);
}
if (fRet) {
DWORD dwPmLevel, cbOut;
BOOL fIoSuccess;
// Disable Suspend menu item if 1) only wanted when undocked and
// system is currently docked, 2) power mgnt level < advanced
if (g_ts.fSuspendUndocked && g_ts.DockedState == DOCKSTATE_DOCKED)
fRet = FALSE;
else
{
#ifdef WINNT // BUGBUG - Fix this when NT does APM
fRet = FALSE;
#else
fIoSuccess = DeviceIoControl(g_ts.hVPowerD,
VPOWERD_IOCTL_GET_PM_LEVEL, NULL, 0,
&dwPmLevel, SIZEOF(dwPmLevel), &cbOut,
NULL);
fRet = (fIoSuccess && (dwPmLevel==PMLEVEL_ADVANCED));
#endif
}
}
return fRet;
#endif
}
void Tray_VerifySize(PFileCabinet pfc, BOOL fWinIni)
{
RECT rc;
RECT rcView;
GetWindowRect(pfc->hwndMain, &rc);
Tray_HandleSizing(pfc, 0, &rc, g_ts.uStuckPlace);
//
// if the old view had a height, and now it won't...
// push it up to at least one height
//
// do this only on win ini if we're on the top or bottom
if (fWinIni && STUCK_HORIZONTAL(g_ts.uStuckPlace)) {
// stash the old view size;
GetClientRect(pfc->hwndView, &rcView);
if (RECTHEIGHT(rcView) && (RECTHEIGHT(rc) == g_cyTrayBorders)) {
int cyOneRow = g_cySize + 2 * g_cyEdge;
if (g_ts.uStuckPlace == STICK_TOP) {
rc.bottom = rc.top + cyOneRow;
} else {
rc.top = rc.bottom - cyOneRow;
}
// now snap this size.
Tray_HandleSizing(pfc, 0, &rc, g_ts.uStuckPlace);
}
}
g_ts.fSelfSizing = TRUE;
SetWindowPos(pfc->hwndMain, NULL, rc.left, rc.top, RECTWIDTH(rc),RECTHEIGHT(rc), SWP_NOZORDER|SWP_NOACTIVATE);
StuckSizeChange();
g_ts.fSelfSizing = FALSE;
}
//----------------------------------------------------------------------------
TCHAR const c_szCheckAssociations[] = TEXT("CheckAssociations");
//----------------------------------------------------------------------------
// Returns true if GrpConv says we should check extensions again (and then
// clears the flag).
// The assumption here is that runonce gets run before we call this (so
// GrpConv -s can set this).
BOOL CheckAssociations(void)
{
DWORD dw = 0;
DWORD cb = SIZEOF(dw);
if (Reg_GetStruct(g_hkeyExplorer, NULL, c_szCheckAssociations,
&dw, &cb) && dw)
{
dw = 0;
Reg_SetStruct(g_hkeyExplorer, NULL, c_szCheckAssociations, &dw, SIZEOF(dw));
return TRUE;
}
return FALSE;
}
ULONG _RegisterNotify(HWND hwnd, UINT nMsg, LPITEMIDLIST pidl, BOOL fRecursive);
//----------------------------------------------------------------------------
void RegisterDesktopNotify(PFileCabinet pfc)
{
LPITEMIDLIST pidl;
DebugMsg(DM_TRACE, TEXT("c.rdn: Notify for desktop."));
if (!g_ts.uDesktopNotify)
{
pidl = SHCloneSpecialIDList(NULL, CSIDL_DESKTOPDIRECTORY, TRUE);
if (pidl)
{
g_ts.uDesktopNotify = _RegisterNotify(pfc->hwndMain, WMTRAY_DESKTOPCHANGE, pidl, FALSE);
ILFree(pidl);
}
}
if (!SHRestricted(REST_NOCOMMONGROUPS) && !g_ts.uCommonDesktopNotify)
{
pidl = SHCloneSpecialIDList(NULL, CSIDL_COMMON_DESKTOPDIRECTORY, TRUE);
if (pidl)
{
g_ts.uCommonDesktopNotify = _RegisterNotify(pfc->hwndMain, WMTRAY_DESKTOPCHANGE, pidl, FALSE);
ILFree(pidl);
}
}
}
LRESULT Tray_OnCreate(HWND hWnd, LPCREATESTRUCT lpcs)
{
PFileCabinet pfc;
MINIMIZEDMETRICS mm;
v_hwndTray = hWnd;
mm.cbSize = SIZEOF(mm);
SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, SIZEOF(mm), &mm, FALSE);
mm.iArrange |= ARW_HIDE;
SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, SIZEOF(mm), &mm, FALSE);
UpdateDockingFlags();
g_ts.DockedState = GetDockedState();
// Try to open a handle to VPOWERD if the Suspend menu item is allowed.
// Failure to open VPOWERD will cause the Suspend item to be deleted
// from the menu later.
#ifndef WINNT // BUGBUG - Fix this when NT gets APM
g_ts.hVPowerD = CreateFile(c_szPOWERDevice,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
#endif
pfc = CreateSimpleFileCabinet(hWnd, &s_TraySBVtbl);
if (pfc)
{
SetPFC(hWnd, pfc);
g_pfcTray = pfc;
pfc->hMainAccel = LoadAccelerators(hinstCabinet, MAKEINTRESOURCE(ACCEL_TRAY));
pfc->pidl = SHCloneSpecialIDList(NULL, CSIDL_DESKTOPDIRECTORY, FALSE);
// get a pointer to the tray's information packet
pfc->hwndToolbar = Tray_MakeStartButton(hWnd);
if (pfc->hwndToolbar)
{
// Clock
if (CreateClockWindow(hWnd))
{
//
// We need to set the tray position, before creating
// the view window, because it will call back our
// GetWindowRect member functions.
//
_TrayRestoreWindowPos(hWnd);
g_ts.hwndTrayTips = CreateWindow(c_szSToolTipsClass, c_szNULL,
WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hinstCabinet,
NULL);
SetWindowPos(g_ts.hwndTrayTips, HWND_TOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
if (g_ts.hwndTrayTips) {
HWND hwndClock;
TOOLINFO ti;
ti.cbSize = SIZEOF(ti);
ti.uFlags = TTF_IDISHWND;
ti.hwnd = hWnd;
ti.uId = (UINT)pfc->hwndToolbar;
ti.lpszText = (LPTSTR)MAKEINTRESOURCE(IDS_STARTBUTTONTIP);
ti.hinst = hinstCabinet;
SendMessage(g_ts.hwndTrayTips, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
if (NULL != (hwndClock = (HWND)SendMessage(g_ts.hwndNotify, TNM_GETCLOCK, 0, 0L))) {
ti.uFlags = 0;
ti.uId = (UINT)hwndClock;
ti.lpszText = LPSTR_TEXTCALLBACK;
ti.rect.left = ti.rect.top = ti.rect.bottom = ti.rect.right = 0;
SendMessage(g_ts.hwndTrayTips, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
}
}
if (Tray_CreateShellView(pfc))
{
// we need to be unhidden to verify our size
TrayUnhide();
Tray_VerifySize(pfc, FALSE);
Tray_SizeWindows(); // size after all windows created
#ifdef WINNT
{
// On NT, load different start menu background bitmaps
// for workstation vs. server installations
NT_PRODUCT_TYPE type;
RtlGetNtProductType(&type);
if (type == NtProductWinNt)
{
g_ts.hbmpStartBkg = LoadBitmap(hinstCabinet, MAKEINTRESOURCE(IDB_STARTBKG));
}
else
{
g_ts.hbmpStartBkg = LoadBitmap(hinstCabinet, MAKEINTRESOURCE(IDB_SERVERSTARTBKG));
}
}
#else
g_ts.hbmpStartBkg = LoadBitmap(hinstCabinet, MAKEINTRESOURCE(IDB_STARTBKG));
#endif
if (g_ts.hbmpStartBkg)
{
UpdateWindow(hWnd);
StartMenu_Build(pfc);
CStartDropTarget_Register(pfc);
PrintNotify_Init(hWnd);
if (CheckAssociations())
CheckWinIniForAssocs();
RegisterDesktopNotify(pfc);
return 1; // success
}
else
{
DebugMsg(DM_ERROR, TEXT("c.t_oc: Unable to load start menu background."));
}
}
}
}
}
return -1; // failure
}
BOOL IsHwndObscured(HWND hwnd)
{
if (IsWindowVisible(hwnd)) {
RECT rc;
HWND hwndHit;
POINT pt;
GetWindowRect(hwnd, &rc);
if (rc.left < 0 && 0 < rc.right)
rc.left = 0;
if (rc.top < 0 && 0 < rc.bottom)
rc.top = 0;
pt.x = rc.left;
pt.y = rc.top;
hwndHit = WindowFromPoint(pt);
if (hwndHit == hwnd ||
IsChild(hwnd, hwndHit) ||
IsChild(hwndHit, hwnd)) {
DebugMsg(DM_TRACE, TEXT("hwnd (%d) is NOT obscured"), hwnd);
return FALSE;
}
}
DebugMsg(DM_TRACE, TEXT("hwnd (%d) is obscured"), hwnd);
return TRUE;
}
void DeskTray_DestroyShellView(PFileCabinet pfc)
{
if (pfc->psv)
{
pfc->psv->lpVtbl->DestroyViewWindow(pfc->psv);
pfc->psv->lpVtbl->Release(pfc->psv);
pfc->hwndView = NULL;
pfc->psv = NULL;
}
}
void Tray_HandleFullScreenApp(BOOL fFullScreen, HWND hwnd)
{
// in autohide mode, only drop if the window activated has no sysmenu
if (hwnd) {
if (fFullScreen && (g_ts.uAutoHide & AH_ON) &&
GetWindowLong(hwnd, GWL_STYLE) & WS_SYSMENU) {
//safe to bail here. fFullScreen is true so we're guaranteed to
// get another notification later with fFullScreen = FALSE
fFullScreen = FALSE;
}
}
// only do this if the bit has changed and we're marked for always on top
if (v_hwndTray) {
if (g_ts.fAlwaysOnTop &&
(fFullScreen ? TRUE : FALSE) != (g_ts.fRudeApp ? TRUE : FALSE)) {
SetWindowPos(v_hwndTray,
fFullScreen ? HWND_BOTTOM : HWND_TOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
AppBarNotifyAll(ABN_FULLSCREENAPP, NULL, fFullScreen);
g_ts.fRudeApp = fFullScreen ? TRUE : FALSE;
if (fFullScreen && !IsHwndObscured(v_hwndTray)) {
// they lied.
Tray_HandleFullScreenApp(FALSE, hwnd);
return;
}
}
// Notify clock we are hiding to avoid doing all the paints etc
if (!(g_ts.uAutoHide & AH_ON)) {
BOOL fStopClock;
// before we're willing to stop the clock, make sure we're really obscured
fStopClock = g_ts.fRudeApp &&
IsHwndObscured((HWND)SendMessage(g_ts.hwndNotify, TNM_GETCLOCK, 0, 0));
ClockCtl_HandleTrayHide(fStopClock);
}
}
}
/*------------------------------------------------------------------
** Create the tray, toolbar, and ListView windows, get the borders together,
** size to the appropriate shape, and show it.
**------------------------------------------------------------------*/
BOOL InitTray(HINSTANCE hInst)
{
// initalize globals that need to be non-zero
g_ts.wThreadCmd = SMCT_DONE;
g_ts.hBIOS = g_ts.hVPowerD = INVALID_HANDLE_VALUE;
if (GetSystemMetrics(SM_SLOWMACHINE)) {
g_dtSlideHide = 0; // dont slide the tray out
g_dtSlideShow = 0;
}
else {
//BUGBUG: we should read from registry.
g_dtSlideHide = 400;
g_dtSlideShow = 200;
}
v_hwndTray = CreateWindowEx(WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW,
c_szTrayClass, NULL,
WS_CLIPCHILDREN | WS_POPUP | WS_BORDER | WS_THICKFRAME,
0, 0, 100, 100, NULL, NULL, hInst, NULL);
if (v_hwndTray) {
ShowWindow(v_hwndTray, SW_SHOW);
// no obey the always on top flag
SetWindowPos(v_hwndTray,
g_ts.fAlwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
UpdateWindow(v_hwndTray);
StuckSizeChange();
// this kick starts autohide
if (g_ts.uAutoHide & AH_ON) {
// register it
if (!IAppBarSetAutoHideBar(v_hwndTray, TRUE, g_ts.uStuckPlace)) {
SetAutoHideState(FALSE);
ShellMessageBox(hinstCabinet, v_hwndTray, MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
MAKEINTRESOURCE(IDS_TASKBAR),MB_OK|MB_ICONSTOP);
} else {
if (!(g_ts.uAutoHide & AH_HIDING)) {
SetAutoHideTimer();
}
}
}
// this needs to be done here because some of the hotkeys rely on
// the tray
RegisterGlobalHotkeys();
// Init the user defined hotkeys too.
HotkeyList_Restore(v_hwndTray);
return TRUE;
} else
return FALSE;
}
//----------------------------------------------------------------------------
BOOL WINAPI Reg_GetString(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPTSTR psz, DWORD cb)
{
HKEY hkeyNew;
BOOL fRet = FALSE;
DWORD dwType;
if (!GetSystemMetrics(SM_CLEANBOOT) && (RegOpenKey(hkey, pszSubKey, &hkeyNew) == ERROR_SUCCESS))
{
if (RegQueryValueEx(hkeyNew, (LPVOID)pszValue, 0, &dwType, (LPBYTE) psz, &cb) == ERROR_SUCCESS)
{
fRet = TRUE;
}
RegCloseKey(hkeyNew);
}
return fRet;
}
//----------------------------------------------------------------------------
BOOL WINAPI Reg_SetString(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPCTSTR psz)
{
HKEY hkeyNew;
BOOL fRet = FALSE;
if (RegCreateKey(hkey, pszSubKey, &hkeyNew) == ERROR_SUCCESS)
{
if (RegSetValueEx(hkeyNew, pszValue, 0, REG_SZ, (LPBYTE) psz, (lstrlen(psz)+1)*sizeof(TCHAR)) == ERROR_SUCCESS)
{
fRet = TRUE;
}
RegCloseKey(hkeyNew);
}
return fRet;
}
TCHAR c_szRegPathIniExtensions[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Extensions");
//----------------------------------------------------------------------------
// Returns TRUE if there is a proper shell\open\command for the given
// extension that matches the given command line.
// NB This is for MGX Designer which registers an extension and commands for
// printing but relies on win.ini extensions for Open. We need to detect that
// there's no open command and add the appropriate entries to the registry.
// If the given extension maps to a type name we return that in pszTypeName
// otherwise it will be null.
// FMH This also affects Asymetric Compel which makes a new .CPL association.
// We need to merge it up into our Control Panel .CPL association. We depend
// on Control Panels NOT having a proper Open so users can see both verb sets.
// NB pszLine is the original line from win.ini eg foo.exe /bar ^.fred, see
// comments below...
BOOL Reg_ShellOpenForExtension(LPCTSTR pszExt, LPTSTR pszCmdLine,
LPTSTR pszTypeName, int cchTypeName, LPCTSTR pszLine)
{
TCHAR sz[MAX_PATH];
TCHAR szExt[MAX_PATH];
LONG cb;
if (pszTypeName)
pszTypeName[0] = TEXT('\0');
// Is the extension registed at all?
cb = SIZEOF(sz);
sz[0] = TEXT('\0');
if (RegQueryValue(HKEY_CLASSES_ROOT, pszExt, sz, &cb) == ERROR_SUCCESS)
{
// Is there a file type?
if (*sz)
{
// Yep, check there.
// DebugMsg(DM_TRACE, "c.r_rofe: Extension has a file type name %s.", sz);
lstrcpy(szExt, sz);
if (pszTypeName)
lstrcpyn(pszTypeName, sz, cchTypeName);
}
else
{
// No, check old style associations.
// DebugMsg(DM_TRACE, "c.r_rofe: Extension has no file type name.", pszExt);
lstrcpy(szExt, pszExt);
}
// See if there's an open command.
lstrcat(szExt, TEXT("\\"));
lstrcat(szExt, c_szShellOpenCommand);
cb = SIZEOF(sz);
if (RegQueryValue(HKEY_CLASSES_ROOT, szExt, sz, &cb) == ERROR_SUCCESS)
{
// DebugMsg(DM_TRACE, "c.r_rofe: Extension %s already registed with an open command.", pszExt);
// NB We want to compare the paths only, not the %1 stuff.
if (PathIsRelative(pszCmdLine))
{
int cch;
// If a relative path was passed in, we may have a fully qualifed
// one that is now in the registry... In that case we should
// say that it matches...
LPTSTR pszT = PathGetArgs(sz);
if (pszT)
{
*(pszT-1) = TEXT('\0');
}
PathUnquoteSpaces(sz);
PathRemoveBlanks(pszCmdLine);
cch = lstrlen(sz) - lstrlen(pszCmdLine);
if ((cch >= 0) && (lstrcmpi(sz+cch, pszCmdLine) == 0))
{
// DebugMsg(DM_TRACE, "c.r_rofe: Open commands match.");
return TRUE;
}
lstrcat(pszCmdLine, c_szSpace); // Append blank back on...
}
else
{
// If absolute path we can cheat for matches
*(sz+lstrlen(pszCmdLine)) = TEXT('\0');
if (lstrcmpi(sz, pszCmdLine) == 0)
{
// DebugMsg(DM_TRACE, "c.r_rofe: Open commands match.");
return TRUE;
}
}
// DebugMsg(DM_TRACE, "c.r_rofe: Open commands don't match.");
// Open commands don't match, check to see if it's because the ini
// changed (return FALSE so the change is reflected in the registry) or
// if the registry changed (return TRUE so we keep the registry the way
// it is.
if (Reg_GetString(HKEY_LOCAL_MACHINE, c_szRegPathIniExtensions, pszExt, sz, SIZEOF(sz)))
{
if (lstrcmpi(sz, pszLine) == 0)
return TRUE;
}
return FALSE;
}
else
{
// DebugMsg(DM_TRACE, "c.r_rofe: Extension %s already registed but with no open command.", pszExt);
return FALSE;
}
}
// DebugMsg(DM_TRACE, "c.r_rofe: No open command for %s.", pszExt);
return FALSE;
}
//----------------------------------------------------------------------------
const TCHAR c_szDotDGW[] = TEXT(".dgw");
const TCHAR c_szDesignWDotExeSpace[] = TEXT("designw.exe ");
const TCHAR c_szHDesign[] = TEXT("HDesign");
//----------------------------------------------------------------------------
BOOL _PathIsExe(LPCTSTR pszPath)
{
TCHAR szPath[MAX_PATH];
lstrcpy(szPath, pszPath);
PathRemoveBlanks(szPath);
return PathIsExe(szPath);
}
//----------------------------------------------------------------------------
// Return TRUE for exe, com, bat, pif and lnk.
BOOL ReservedExtension(LPCTSTR pszExt)
{
TCHAR szExt[5]; // Dot+ext+null.
lstrcpyn(szExt, pszExt, ARRAYSIZE(szExt));
PathRemoveBlanks(szExt);
if (PathIsExe(szExt) || (lstrcmpi(szExt, c_szDotLnk) == 0))
{
return TRUE;
}
return FALSE;
}
//----------------------------------------------------------------------------
// This function will read in the extensions section of win.ini to see if
// there are any old style associations that we have not accounted for.
// NB Some apps screw up if their extensions magically disappear from the
// extensions section so DON'T DELETE the old entries from win.ini.
#define CWIFA_SIZE 4096
void CheckWinIniForAssocs(void)
{
LPTSTR pszBuf;
int cbRet;
LPTSTR pszLine;
TCHAR szExtension[MAX_PATH];
TCHAR szTypeName[MAX_PATH];
TCHAR szCmdLine[MAX_PATH];
LPTSTR pszExt;
LPTSTR pszT;
BOOL fAssocsMade = FALSE;
szExtension[0]=TEXT('.');
szExtension[1]=TEXT('\0');
// BUGBUG - BobDay - This code doesn't handle larger section
pszBuf = (LPTSTR)LocalAlloc(LPTR, CWIFA_SIZE*SIZEOF(TCHAR));
if (!pszBuf)
return; // Could not allocate the memory
cbRet = (int)GetProfileSection(c_szExtensions, pszBuf, CWIFA_SIZE);
//
// We now walk through the list to find any items that is not
// in the registry.
//
for (pszLine = pszBuf; *pszLine; pszLine += lstrlen(pszLine)+1)
{
// Get the extension for this file into a buffer.
pszExt = StrChr(pszLine, TEXT('='));
if (pszExt == NULL)
continue; // skip this line
szExtension[0]=TEXT('.');
// lstrcpyn will put the null terminator for us.
// We should now have something like .xls in szExtension.
lstrcpyn(szExtension+1, pszLine, (int)(pszExt-pszLine)+1);
// Ignore extensions bigger than dot + 3 chars.
if (lstrlen(szExtension) > 4)
{
DebugMsg(DM_ERROR, TEXT("c.cwia: Invalid extension, skipped."));
continue;
}
pszLine = pszExt+1; // Points to after the =;
while (*pszLine == TEXT(' '))
pszLine++; // skip blanks
// Now find the ^ in the command line.
pszExt = StrChr(pszLine, TEXT('^'));
if (pszExt == NULL)
continue; // dont process
// Now setup the command line
// WARNING: This assumes only 1 ^ and it assumes the extension...
lstrcpyn(szCmdLine, pszLine, (int)(pszExt-pszLine)+1);
// Don't bother moving over invalid entries (like the busted .hlp
// entry VB 3.0 creates).
if (!_PathIsExe(szCmdLine))
{
DebugMsg(DM_ERROR, TEXT("c.cwia: Invalid app, skipped."));
continue;
}
if (ReservedExtension(szExtension))
{
DebugMsg(DM_ERROR, TEXT("c.cwia: Invalid extension (%s), skipped."), szExtension);
continue;
}
// Now see if there is already a mapping for this extension.
if (Reg_ShellOpenForExtension(szExtension, szCmdLine, szTypeName, ARRAYSIZE(szTypeName), pszLine))
{
// Yep, Setup the initial list of ini extensions in the registry if they are
// not there already.
if (!Reg_GetString(HKEY_LOCAL_MACHINE, c_szRegPathIniExtensions, szExtension, szTypeName, SIZEOF(szTypeName)))
{
Reg_SetString(HKEY_LOCAL_MACHINE, c_szRegPathIniExtensions, szExtension, pszLine);
}
continue;
}
// No mapping.
// HACK for Expert Home Design. They put an association in win.ini
// (which we propagate as typeless) but then register a type and a
// print command the first time they run - stomping on our propagated
// Open command. The fix is to put their open command under the proper
// type instead of leaving it typeless.
if (lstrcmpi(szExtension, c_szDotDGW) == 0)
{
if (lstrcmpi(PathFindFileName(szCmdLine), c_szDesignWDotExeSpace) == 0)
{
// Put in a ProgID for them.
RegSetValue(HKEY_CLASSES_ROOT, szExtension, REG_SZ, c_szHDesign, 0L);
// Force Open command under their ProgID.
DebugMsg(DM_TRACE, TEXT("c.cwifa: Expert Home Design special case hit."));
lstrcpy(szTypeName, c_szHDesign);
}
}
//
// HACK for Windows OrgChart which does not register OLE1 class
// if ".WOC" is registered in the registry.
//
if (lstrcmpi(szExtension, TEXT(".WOC")) == 0)
{
if (lstrcmpi(PathFindFileName(szCmdLine), TEXT("WINORG.EXE ")) == 0)
{
DebugMsg(DM_ERROR, TEXT("c.cwia: HACK: Found WINORG (%s, %s), skipped."), szExtension, pszLine);
continue;
}
}
// Record that we're about to move things over in the registry so we won't keep
// doing it all the time.
Reg_SetString(HKEY_LOCAL_MACHINE, c_szRegPathIniExtensions, szExtension, pszLine);
lstrcat(szCmdLine, TEXT("%1"));
// see if there are anything else to copy out...
pszExt++; // get beyond the ^
pszT = szExtension;
while (*pszExt && (CharLower((LPTSTR)(DWORD)*pszExt) == CharLower((LPTSTR)(DWORD)*pszT)))
{
// Look for the next character...
pszExt++;
pszT++;
}
if (*pszExt)
lstrcat(szCmdLine, pszExt); // add the rest onto the command line
// Now lets make the actual association.
// We need to add on the right stuff onto the key...
if (*szTypeName)
lstrcpy(szExtension, szTypeName);
lstrcat(szExtension, TEXT("\\"));
lstrcat(szExtension, c_szShellOpenCommand);
RegSetValue(HKEY_CLASSES_ROOT, szExtension, REG_SZ, szCmdLine, 0L);
// DebugMsg(DM_TRACE, "c.cwifa: %s %s", szExtension, szCmdLine);
fAssocsMade = TRUE;
}
// If we made any associations we should let the cabinet know.
//
// Now call off to the notify function.
if (fAssocsMade)
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
// And cleanup our allocation
LocalFree((HLOCAL)pszBuf);
}
//---------------------------------------------------------------------------
void _InitAllSubMenuPopups(HMENU hmenu)
{
HMENU hmenuSub;
int i;
// DebugMsg(DM_IANELHK, "c.iasmp: Initing %x.", hmenu);
if (!hmenu)
return;
if (g_ts.fThreadTerminate)
{
return;
}
FileMenu_InitMenuPopup(hmenu);
for (i = GetMenuItemCount(hmenu) - 1; i >= 0 ; i--)
{
if (g_ts.fThreadTerminate)
{
break;
}
if (NULL != (hmenuSub = GetSubMenu(hmenu, i)))
{
FileMenu_InitMenuPopup(hmenuSub);
_InitAllSubMenuPopups(hmenuSub);
}
}
}
//---------------------------------------------------------------------------
void WINAPI FillFileMenus(int wID, BOOL fRecurse)
{
HMENU hmenu = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, wID);
int i;
if (!hmenu)
return;
if (g_ts.fThreadTerminate)
{
DebugMsg(DM_IANELHK, TEXT("c.ffm:...Aborted."));
return;
}
FileMenu_InitMenuPopup(hmenu);
for (i = GetMenuItemCount(hmenu) - 1; i >= 0 ; i--)
{
HMENU hmenuSub;
if (g_ts.fThreadTerminate)
break;
if (NULL != (hmenuSub = GetSubMenu(hmenu, i)))
{
if (fRecurse)
_InitAllSubMenuPopups(hmenuSub);
else
FileMenu_InitMenuPopup(hmenuSub);
}
}
// DebugMsg(DM_IANELHK, "c.ffm:...Done");
}
//---------------------------------------------------------------------------
ULONG _RegisterNotify(HWND hwnd, UINT nMsg, LPITEMIDLIST pidl, BOOL fRecursive)
{
SHChangeNotifyEntry fsne;
ULONG lReturn;
// DebugMsg(DM_TRACE, "c.rn: Notify for %s.", (LPSTR)lpszPath);
fsne.fRecursive = fRecursive;
fsne.pidl = pidl;
//
// Don't watch for attribute changes since we just want the
// name and icon. For example, if a printer is paused, we don't
// want to re-enumuerate everything.
//
lReturn = SHChangeNotifyRegister(hwnd, SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel,
((SHCNE_DISKEVENTS | SHCNE_UPDATEIMAGE) & ~SHCNE_ATTRIBUTES), nMsg, 1, &fsne);
return lReturn;
}
//---------------------------------------------------------------------------
ULONG RegisterNotify(HWND hwnd, UINT nMsg, LPITEMIDLIST pidl)
{
return _RegisterNotify(hwnd, nMsg, pidl, TRUE);
}
//---------------------------------------------------------------------------
void UnregisterNotify(ULONG nNotify)
{
if (nNotify)
SHChangeNotifyDeregister(nNotify);
}
//----------------------------------------------------------------------------
#define HKIF_NULL 0
#define HKIF_CACHED 1
#define HKIF_FREEPIDLS 2
typedef struct
{
LPITEMIDLIST pidlFolder;
LPITEMIDLIST pidlItem;
WORD wGHotkey;
// BOOL fCached;
WORD wFlags;
} HOTKEYITEM, *PHOTKEYITEM;
const TCHAR c_szSlashCLSID[] = TEXT("\\CLSID");
//
// like OLE GetClassFile(), but it only works on ProgID\CLSID type registration
// not real doc files or pattern matched files
//
HRESULT _CLSIDFromExtension(LPCTSTR pszExt, CLSID *pclsid)
{
TCHAR szProgID[80];
ULONG cb = SIZEOF(szProgID);
if (RegQueryValue(HKEY_CLASSES_ROOT, pszExt, szProgID, &cb) == ERROR_SUCCESS)
{
TCHAR szCLSID[80];
lstrcat(szProgID, c_szSlashCLSID);
cb = SIZEOF(szCLSID);
if (RegQueryValue(HKEY_CLASSES_ROOT, szProgID, szCLSID, &cb) == ERROR_SUCCESS)
return SHCLSIDFromString(szCLSID, pclsid);
}
return E_FAIL;
}
//----------------------------------------------------------------------------
// this gets hotkeys for files that support IShellLink, not just .lnk files
//
WORD _GetHotkeyFromPidls(LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
{
WORD wHotkey = 0;
LPITEMIDLIST pidl = ILCombine(pidlFolder, pidlItem);
if (pidl)
{
TCHAR szPath[MAX_PATH];
if (SHGetPathFromIDList(pidl, szPath))
{
IShellLink *psl;
CLSID clsid;
// BUGBUG: we really should call GetClassFile() but this could
// slow this down a lot... so chicken out and just look in the registry
if (FAILED(_CLSIDFromExtension(PathFindExtension(szPath), &clsid)))
clsid = CLSID_ShellLink; // assume it's a shell link
if (SUCCEEDED(ICoCreateInstance(&clsid, &IID_IShellLink, &psl)))
{
IPersistFile *ppf;
if (SUCCEEDED(psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf)))
{
WCHAR wszPath[MAX_PATH];
StrToOleStr(wszPath, szPath);
ppf->lpVtbl->Load(ppf, wszPath, 0);
ppf->lpVtbl->Release(ppf);
}
psl->lpVtbl->GetHotkey(psl, &wHotkey);
#ifdef DEBUG
// if (wHotkey)
// DebugMsg(DM_TRACE, "c.x: %s has hotkey %x.", szPath, wHotkey);
#endif
psl->lpVtbl->Release(psl);
}
}
ILFree(pidl);
}
return wHotkey;
}
//----------------------------------------------------------------------------
UINT HotkeyList_GetFreeItemIndex(void)
{
int i, cItems;
PHOTKEYITEM phki;
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.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 nVirtKey;
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;
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 HotkeyList_Add(WORD wHotkey, LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem, BOOL fClone)
{
LPITEMIDLIST pidl1, pidl2;
if (wHotkey)
{
HOTKEYITEM hki;
int i = HotkeyList_GetFreeItemIndex();
Assert(g_ts.hdsaHKI);
// 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 = pidl1;
hki.pidlItem = pidl2;
hki.wGHotkey = MapHotkeyToGlobalHotkey(wHotkey);
DSA_SetItem(g_ts.hdsaHKI, i, &hki);
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 HotkeyList_AddCached(WORD wGHotkey, LPITEMIDLIST pidl)
{
int i = -1;
if (wGHotkey)
{
LPITEMIDLIST pidlItem = ILClone(ILFindLastID(pidl));
Assert(g_ts.hdsaHKI);
if (pidlItem)
{
if (ILRemoveLastID(pidl))
{
HOTKEYITEM hki;
i = HotkeyList_GetFreeItemIndex();
// 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(g_ts.hdsaHKI, i, &hki);
}
}
}
return i;
}
const TCHAR c_szHotkeys[] = TEXT("Hotkeys");
//----------------------------------------------------------------------------
// NB Must do this before destroying the startmenu since the hotkey list
// uses it's pidls in a lot of cases.
int HotkeyList_Save(void)
{
int i, cItems;
PHOTKEYITEM phki;
LPITEMIDLIST pidl;
int cCached = 0;
int cbData = 0;
TCHAR szValue[32];
LPBYTE pData;
Assert(g_ts.hdsaHKI);
DebugMsg(DM_TRACE, TEXT("c.hl_s: Saving global hotkeys."));
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.hdsaHKI, i);
// Non cached item?
if (phki->wGHotkey && !(phki->wFlags & HKIF_CACHED))
{
// Yep, save it.
pidl = ILCombine(phki->pidlFolder, phki->pidlItem);
if (pidl)
{
cbData = SIZEOF(WORD) + ILGetSize(pidl);
pData = LocalAlloc(GPTR, cbData);
if (pData)
{
// DebugMsg(DM_TRACE, "c.hl_s: Saving %x.", phki->wGHotkey);
*((LPWORD)pData) = phki->wGHotkey;
memcpy(pData+SIZEOF(WORD), pidl, cbData-SIZEOF(DWORD));
wsprintf(szValue, TEXT("%d"), cCached);
Reg_SetStruct(g_hkeyExplorer, c_szHotkeys, szValue, pData, cbData);
cCached++;
LocalFree(pData);
}
ILFree(pidl);
}
}
}
return cCached;
}
//----------------------------------------------------------------------------
HKEY Reg_EnumValueCreate(HKEY hkey, LPCTSTR pszSubkey)
{
HKEY hkeyOut;
if (RegOpenKeyEx(hkey, pszSubkey, 0L, KEY_ALL_ACCESS, &hkeyOut) == ERROR_SUCCESS)
{
return hkeyOut;
}
return(NULL);
}
//----------------------------------------------------------------------------
int Reg_EnumValue(HKEY hkey, int i, LPBYTE pData, int cbData)
{
TCHAR szValue[MAX_PATH];
DWORD cchValue;
DWORD dw;
DWORD dwType;
cchValue = ARRAYSIZE(szValue);
if (RegEnumValue(hkey, i, szValue, &cchValue, &dw, &dwType, pData,
&cbData) == ERROR_SUCCESS)
{
return cbData;
}
return 0;
}
//----------------------------------------------------------------------------
BOOL Reg_EnumValueDestroy(HKEY hkey)
{
return RegCloseKey(hkey) == ERROR_SUCCESS;
}
//----------------------------------------------------------------------------
int HotkeyList_Restore(HWND hwnd)
{
int i = 0;
HKEY hkey;
LPBYTE pData;
int cbData;
WORD wGHotkey;
int id;
LPITEMIDLIST pidl;
DebugMsg(DM_TRACE, TEXT("c.hl.r: Restoring global hotkeys..."));
hkey = Reg_EnumValueCreate(g_hkeyExplorer, c_szHotkeys);
if (hkey)
{
cbData = Reg_EnumValue(hkey, i, NULL, 0);
while (cbData)
{
pData = LocalAlloc(GPTR, cbData);
if (pData)
{
Reg_EnumValue(hkey, i, pData, cbData);
// Get the hotkey and the pidl components.
wGHotkey = *((LPWORD)pData);
pidl = ILClone((LPITEMIDLIST)(pData+SIZEOF(WORD)));
// DebugMsg(DM_TRACE, "c.hl_r: Restoring %x", wGHotkey);
id = HotkeyList_AddCached(wGHotkey, pidl);
if (id != -1)
Tray_RegisterHotkey(hwnd, id);
LocalFree(pData);
}
i++;
cbData = Reg_EnumValue(hkey, i, NULL, 0);
}
Reg_EnumValueDestroy(hkey);
// Nuke the cached stuff.
SHRegDeleteKey(g_hkeyExplorer, c_szHotkeys);
}
return i;
}
//----------------------------------------------------------------------------
// We get called back for each item added to a filemenu.
void CALLBACK FileMenu_AddItemCallback(LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
{
WORD wHotkey = _GetHotkeyFromPidls(pidlFolder, pidlItem);
if (wHotkey)
{
int i = HotkeyList_Add(wHotkey, pidlFolder, pidlItem, TRUE);
if (i != -1)
{
// Register in the context of the tray's thread.
PostMessage(v_hwndTray, WMTRAY_REGISTERHOTKEY, i, 0);
}
}
}
//----------------------------------------------------------------------------
// NB Again, this takes window hotkey not a Global one.
// NB This doesn't delete cached hotkeys.
int HotkeyList_Remove(WORD wHotkey)
{
int i, cItems;
PHOTKEYITEM phki;
WORD wGHotkey;
// DebugMsg(DM_IANELHK, "c.hl_r: Remove hotkey for %x" , wHotkey);
// Unmap the modifiers.
wGHotkey = MapHotkeyToGlobalHotkey(wHotkey);
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.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;
return i;
}
}
return -1;
}
//----------------------------------------------------------------------------
// NB This takes a global hotkey.
int HotkeyList_RemoveCached(WORD wGHotkey)
{
int i, cItems;
PHOTKEYITEM phki;
// DebugMsg(DM_IANELHK, "c.hl_rc: Remove hotkey for %x" , wGHotkey);
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.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);
return i;
}
}
return -1;
}
//----------------------------------------------------------------------------
// We get called back when a submenu is delete.
void CALLBACK FileMenu_InvalidateCallback(LPITEMIDLIST pidlFolder)
{
int i, cItems;
PHOTKEYITEM phki;
// DebugMsg(DM_IANELHK, "c.gm_ic: Invalidating items for %x", pidlFolder);
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.hdsaHKI, i);
if (phki && (phki->pidlFolder == pidlFolder))
{
// DebugMsg(DM_IANELHK, "c.gm_ic: Invalidating %d", i);
phki->wGHotkey = 0;
phki->pidlFolder = NULL;
phki->pidlItem = NULL;
PostMessage(v_hwndTray, WMTRAY_UNREGISTERHOTKEY, i, 0);
}
}
}
//----------------------------------------------------------------------------
void CALLBACK FileMenu_Callback(LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
{
// A null item means that this is a delete of all the filemenu items in the
// given folder.
if (pidlItem)
FileMenu_AddItemCallback(pidlFolder, pidlItem);
else
FileMenu_InvalidateCallback(pidlFolder);
}
//----------------------------------------------------------------------------
// 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 HotkeyList_Create(void)
{
if (!g_ts.hdsaHKI)
{
// DebugMsg(DM_TRACE, "c.hkl_c: Creating global hotkey list.");
g_ts.hdsaHKI = DSA_Create(SIZEOF(HOTKEYITEM), 0);
}
if (g_ts.hdsaHKI)
return TRUE;
return FALSE;
}
//----------------------------------------------------------------------------
// Stick the contents of the "favourite" folder at the top of the start menu.
void StartMenu_InsertFavouriteItems(PFileCabinet pfc, HMENU hmenu)
{
LPITEMIDLIST pidlFav;
UINT cItems;
UINT fFilter = SHCONTF_NONFOLDERS;
Assert(pfc);
// create it so that we have soemthingto register notifies on
pidlFav = SHCloneSpecialIDList(NULL, CSIDL_STARTMENU, TRUE);
if (pidlFav)
{
if (!SHRestricted(REST_NOSTARTMENUSUBFOLDERS))
fFilter |= SHCONTF_FOLDERS;
cItems = FileMenu_InsertUsingPidl(hmenu, IDM_STARTMENU, pidlFav,
FMF_NOEMPTYITEM | FMF_NOPROGRAMS, fFilter, FileMenu_Callback);
if (!g_ts.uFavNotify)
g_ts.uFavNotify = RegisterNotify(pfc->hwndMain, WMTRAY_FAVCHANGE, pidlFav);
// If there are any items, insert a sep.
if (cItems)
FileMenu_AppendItem(hmenu, (LPTSTR)FMAI_SEPARATOR, 0, -1, NULL, 0);
ILFree(pidlFav);
}
if (!SHRestricted(REST_NOCOMMONGROUPS)) {
// Favorites from the common profile
// create it so that we have soemthingto register notifies on
pidlFav = SHCloneSpecialIDList(NULL, CSIDL_COMMON_STARTMENU, TRUE);
if (pidlFav)
{
cItems = FileMenu_AppendFilesForPidl(hmenu, pidlFav, FALSE);
if (!g_ts.uCommonFavNotify)
g_ts.uCommonFavNotify = RegisterNotify(pfc->hwndMain, WMTRAY_COMMONFAVCHANGE, pidlFav);
// If there are any items, insert a sep.
if (cItems)
FileMenu_AppendItem(hmenu, (LPTSTR)FMAI_SEPARATOR, 0, -1, NULL, 0);
ILFree(pidlFav);
}
}
}
//----------------------------------------------------------------------------
BOOL EnumFolder_GetHotkeys(LPSHELLFOLDER psf, HWND hwndOwner,
LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
{
WORD wHotkey;
DebugMsg(DM_TRACE, TEXT("c.ef_gh: ..."));
if (g_ts.fThreadTerminate)
return FALSE;
wHotkey = _GetHotkeyFromPidls(pidlFolder, pidlItem);
if (wHotkey)
{
int i = HotkeyList_Add(wHotkey, pidlFolder, pidlItem, TRUE);
if (i != -1)
{
// Register in the context of the tray's thread.
PostMessage(v_hwndTray, WMTRAY_REGISTERHOTKEY, i, 0);
}
}
return TRUE;
}
//----------------------------------------------------------------------------
void GetDesktopHotkeys(void)
{
LPITEMIDLIST pidlDesktop = NULL;
LPITEMIDLIST pidlCommonDesktop = NULL;
int i, cItems;
PHOTKEYITEM phki;
DebugMsg(DM_TRACE, TEXT("c.gdh: Global hotkeys from desktop."));
pidlDesktop = SHCloneSpecialIDList(NULL, CSIDL_DESKTOPDIRECTORY, TRUE);
pidlCommonDesktop = SHCloneSpecialIDList(NULL, CSIDL_COMMON_DESKTOPDIRECTORY, TRUE);
if (pidlDesktop && pidlCommonDesktop)
{
// Clean up all existing (non-cached) desktop hotkeys.
cItems = DSA_GetItemCount(g_ts.hdsaHKI);
for (i=0; i<cItems; i++)
{
phki = DSA_GetItemPtr(g_ts.hdsaHKI, i);
if (phki && phki->wGHotkey)
{
if (!(phki->wFlags & HKIF_CACHED) && (phki->wFlags & HKIF_FREEPIDLS)
&& phki->pidlFolder &&
(ILIsEqual(phki->pidlFolder, pidlDesktop) ||
ILIsEqual(phki->pidlFolder, pidlCommonDesktop)))
{
DebugMsg(DM_IANELHK, TEXT("c.gdh: Invalidating %d"), i);
if (phki->pidlFolder)
ILFree(phki->pidlFolder);
if (phki->pidlItem)
ILFree(phki->pidlItem);
phki->wGHotkey = 0;
phki->pidlFolder = NULL;
phki->pidlItem = NULL;
PostMessage(v_hwndTray, WMTRAY_UNREGISTERHOTKEY, i, 0);
}
}
}
// Add them back.
EnumFolder(NULL, pidlDesktop, SHCONTF_NONFOLDERS, (PFNENUMFOLDERCALLBACK)EnumFolder_GetHotkeys);
if (!SHRestricted(REST_NOCOMMONGROUPS)) {
EnumFolder(NULL, pidlCommonDesktop, SHCONTF_NONFOLDERS, (PFNENUMFOLDERCALLBACK)EnumFolder_GetHotkeys);
}
}
if (pidlDesktop)
ILFree(pidlDesktop);
if (pidlCommonDesktop)
ILFree(pidlCommonDesktop);
DebugMsg(DM_TRACE, TEXT("c.gdh: done."));
}
//----------------------------------------------------------------------------
#define BTF_DONELISTOFPATHS 0x0001
//----------------------------------------------------------------------------
DWORD WINAPI StartMenu_BkgThread(LPVOID lpv)
{
static UINT btflags = 0;
// Handle faults a bit better.
_try
{
while (!g_ts.fThreadTerminate)
{
switch (g_ts.wThreadCmd)
{
case SMCT_PRIMARY:
case SMCT_WININIASSOCS:
break;
case SMCT_BUILDLISTOFPATHS:
if (!(btflags & BTF_DONELISTOFPATHS))
{
RLBuildListOfPaths();
btflags |= BTF_DONELISTOFPATHS;
}
break;
case SMCT_INITPROGRAMS:
Tray_HandleInitMenuPopup(Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_PROGRAMSINIT));
break;
case SMCT_INITRECENT:
Tray_HandleInitMenuPopup(Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_RECENTINIT));
break;
case SMCT_PARTFILLPROGRAMS:
FillFileMenus(IDM_PROGRAMS, FALSE);
break;
case SMCT_FILLRECENT:
FillFileMenus(IDM_RECENT, FALSE);
break;
case SMCT_FILLPROGRAMS:
FillFileMenus(IDM_PROGRAMS, TRUE);
break;
case SMCT_DESKTOPHOTKEYS:
GetDesktopHotkeys();
break;
case SMCT_FILLFAVOURITE:
_InitAllSubMenuPopups(g_ts.hmenuStart);
break;
case SMCT_DONE:
goto Done;
case SMCT_FILLRECENTONLY:
FillFileMenus(IDM_RECENT, TRUE);
goto Done;
case SMCT_FILLPROGRAMSONLY:
FillFileMenus(IDM_PROGRAMS, TRUE);
goto Done;
case SMCT_DESKTOPHOTKEYSONLY:
GetDesktopHotkeys();
goto Done;
default:
DebugMsg(DM_ERROR, TEXT("c.sm_bt: Invalid thread command %d."), g_ts.wThreadCmd);
goto Done;
}
// If we're interupted we will need to repeat the command last command otherwise
// move on to the next command.
// NB Commands up to BUILDLISTOFPATHS aren't interuptable so don't need restarting.
if (!g_ts.fThreadTerminate || (g_ts.wThreadCmd <= SMCT_BUILDLISTOFPATHS))
g_ts.wThreadCmd++;
}
}
_except (SetErrorMode(SEM_NOGPFAULTERRORBOX),
UnhandledExceptionFilter(GetExceptionInformation()))
{
// Put up a nice error box.
ShellMessageBox(hinstCabinet, NULL, MAKEINTRESOURCE(IDS_EXCEPTIONMSG),
MAKEINTRESOURCE(IDS_CABINET), MB_ICONEXCLAMATION|MB_SETFOREGROUND);
}
Done:
if (g_ts.fThreadTerminate)
{
DebugMsg(DM_IANELHK, TEXT("c.sm_bt: Thread %d forced to terminate (%d)."), g_ts.hThread, g_ts.wThreadCmd);
}
else
{
g_ts.wThreadCmd = SMCT_DONE;
// DebugMsg(DM_IANELHK, "c.sm_bt: Thread %d completed normally.", g_ts.hThread);
}
Assert(g_ts.hThread);
CloseHandle(g_ts.hThread);
g_ts.hThread = NULL;
return 0;
}
//----------------------------------------------------------------------------
void Thread_CreateLowPri(void)
{
DWORD idThread;
LPFileCabinet pfc;
Assert(!g_ts.hThread);
pfc = g_pfcTray;
if (pfc && (pfc->bMainMenuInit))
{
DebugMsg(DM_IANELHK, TEXT("c.t_clp: Can't create thread, StartMenu is up or being modified."));
return;
}
g_ts.hThread = CreateThread(NULL, 0, StartMenu_BkgThread, NULL, 0, &idThread);
if (g_ts.hThread)
{
// DebugMsg(DM_IANELHK, "c.t_clp: Thread %d created.", g_ts.hThread);
SetThreadPriority(g_ts.hThread, THREAD_PRIORITY_BELOW_NORMAL);
}
else
{
DebugMsg(DM_ERROR, TEXT("c.t_clp: Failed to create thread."));
}
}
//----------------------------------------------------------------------------
BOOL WINAPI StartMenu_ControlBkgThread(STARTMENUCONTROLTHREAD smct)
{
BOOL fRet = FALSE;
switch (smct)
{
case SMCT_STOP:
DebugMsg(DM_IANELHK, TEXT("c.sm_cbt: Stop thread."));
if (!g_ts.hThread)
{
DebugMsg(DM_IANELHK, TEXT("c.sm_cbt: Thread not running."));
fRet = TRUE;
}
else
{
DebugMsg(DM_IANELHK, TEXT("c.sm_cbt: Waiting for %x to complete."), g_ts.hThread);
// Speed up stopping the filemenu.
FileMenu_AbortInitMenu();
g_ts.fThreadTerminate = TRUE;
if (WaitForSingleObject(g_ts.hThread, 1000) == WAIT_TIMEOUT)
{
DECLAREWAITCURSOR;
SetWaitCursor();
DebugMsg(DM_ERROR, TEXT("c.: Still waiting for %x."), g_ts.hThread);
if (MsgWaitForMultipleObjectsLoop(g_ts.hThread, 10*1000) == WAIT_TIMEOUT)
{
DebugMsg(DM_ERROR, TEXT("c.sm_cbt: Background thread timed-out."));
}
else
{
DebugMsg(DM_ERROR, TEXT("c.sm_cbt: Background thread finally completed."));
}
ResetWaitCursor();
}
else
{
DebugMsg(DM_ERROR, TEXT("c.sm_cbt: Background thread completed."));
}
g_ts.fThreadTerminate = FALSE;
// CloseHandle(g_ts.hThread);
// Assert that the terminated thread reset g_ts.hThread.
Assert(!g_ts.hThread);
}
fRet = TRUE;
break;
case SMCT_RESTART:
// DebugMsg(DM_IANELHK, "c.cm_st: Restart thread.");
if (g_ts.wThreadCmd == SMCT_DONE)
{
// DebugMsg(DM_IANELHK, "c.cm_st: Nothing to restart.");
fRet = TRUE;
}
else
{
DebugMsg(DM_IANELHK, TEXT("c.cm_st: Restarting with %d."), g_ts.wThreadCmd);
if (!g_ts.hThread)
Thread_CreateLowPri();
else
DebugMsg(DM_ERROR, TEXT("c.dm_cbt: Thread already running."));
}
break;
case SMCT_PRIMARY:
case SMCT_FILLPROGRAMSONLY:
case SMCT_FILLRECENTONLY:
#ifdef DEBUG
DebugMsg(DM_IANELHK, TEXT("c.cm_st: Handle %s stuff."),
SMCT_FILLRECENTONLY == smct ? TEXT("recent") :
SMCT_FILLPROGRAMSONLY == smct ? TEXT("programs") :
TEXT("primary")
);
#endif
g_ts.wThreadCmd = (WORD) smct;
if (!g_ts.hThread)
Thread_CreateLowPri();
break;
case SMCT_DESKTOPHOTKEYSONLY:
g_ts.wThreadCmd = (WORD) smct;
if (!g_ts.hThread)
Thread_CreateLowPri();
break;
}
return fRet;
}
//---------------------------------------------------------------------------
// Add all the items on menuSrc onto the end of menuDst where menu dst is
// a filemenu and menusrc is an ordinary menu. The initial image index to
// use for all non-seperator items is given by iDefImage. If it's -1 then
// no items will get images.
BOOL StartMenu_CatMenu(HMENU hmenuDst, HMENU hmenuSrc, int iDefImage, UINT cyItem)
{
int i, iMax, iImage;
TCHAR szText[CCHSZNORMAL];
HMENU hmenuSubCopy;
// Recursion would be bad.
if (hmenuDst == hmenuSrc)
return FALSE;
iMax = GetMenuItemCount(hmenuSrc);
if (iMax != -1)
{
MENUITEMINFO mii;
mii.cbSize = SIZEOF(MENUITEMINFO);
for (i=0; i<iMax; i++)
{
mii.dwTypeData = szText;
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_SUBMENU | MIIM_STATE | MIIM_DATA;
mii.cch = ARRAYSIZE(szText);
mii.hSubMenu = NULL;
mii.fType = MFT_SEPARATOR; // to avoid ramdom result.
mii.dwItemData = 0;
GetMenuItemInfo(hmenuSrc, i, TRUE, &mii);
// Give the settings sub menu's the right icons.
if ((i == 0) && (iDefImage == -1) && (mii.wID == IDM_CONTROLS))
iDefImage = II_STCPANEL;
if (mii.wID == IDM_FILERUN)
iDefImage = II_STRUN;
// NB Take out the icons and remove these id's when we're sure
// the Start Menu is stable.
// Skip programs(start menu) icon.
if (iDefImage == II_STSPROGS)
iDefImage++;
// Skip fonts icon.
if (iDefImage == II_STFONTS)
iDefImage++;
iImage = iDefImage;
// Make sure the find menu items have a default image.
if ((mii.wID >= TRAY_IDM_FINDFIRST) && (mii.wID <= TRAY_IDM_FINDLAST) && !mii.dwItemData)
mii.dwItemData = II_STFIND;
if (mii.fType & MFT_SEPARATOR)
{
FileMenu_AppendItem(hmenuDst, (LPTSTR)FMAI_SEPARATOR, mii.wID, -1, NULL, 0);
}
else if (mii.hSubMenu)
{
// Submenu.
hmenuSubCopy = FileMenu_Create((COLORREF)-1, 0, NULL, 0, 0);
// NB Only allow small submenu's for now.
StartMenu_CatMenu(hmenuSubCopy, mii.hSubMenu, -1, 0);
FileMenu_AppendItem(hmenuDst, szText, mii.wID, iImage, hmenuSubCopy, cyItem);
if (iDefImage != -1)
iDefImage++;
}
else
{
if ((iDefImage == -1) && (mii.dwItemData != 0))
{
FileMenu_AppendItem(hmenuDst, szText, mii.wID, mii.dwItemData, NULL, cyItem);
}
else
{
FileMenu_AppendItem(hmenuDst, szText, mii.wID, iImage, NULL, cyItem);
}
if (iDefImage != -1)
iDefImage++;
}
}
return TRUE;
}
return FALSE;
}
//----------------------------------------------------------------------------
// Remove restricted items and stuff that is specific to a particular hardware
// platform.
void StartMenu_RemoveUnavailableItems(void)
{
HMENU hmenu;
UINT iSep2ItemsMissing = 0;
// APM/Dockable stuff.
if (!IsEjectAllowed() || g_ts.DockedState == DOCKSTATE_UNDOCKED)
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_EJECTPC);
iSep2ItemsMissing++;
}
if (g_ts.hVPowerD == INVALID_HANDLE_VALUE || !IsSuspendAllowed())
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_SUSPEND);
iSep2ItemsMissing++;
}
// Restictions
if (SHRestricted(REST_NORUN))
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_FILERUN);
}
if (SHRestricted(REST_NOCLOSE))
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_EXITWIN);
iSep2ItemsMissing++;
}
if (iSep2ItemsMissing == 3)
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_SEP2);
}
// Setting stuff.
if (SHRestricted(REST_NOSETTASKBAR) || SHRestricted(REST_NOSETFOLDERS))
{
hmenu = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_CONTROLS);
if (hmenu)
{
// Both?
if (SHRestricted(REST_NOSETTASKBAR) && SHRestricted(REST_NOSETFOLDERS))
{
// Yep, toast the whole settings menu.
FileMenu_DeleteMenuItemByFirstID(g_ts.hmenuStart, IDM_CONTROLS);
}
else
{
// Nope, just one.
if (SHRestricted(REST_NOSETFOLDERS))
{
FileMenu_DeleteItemByCmd(hmenu, IDM_CONTROLS);
// FileMenu_DeleteItemByCmd(hmenu, IDM_PROGRAMSFOLDER);
FileMenu_DeleteItemByCmd(hmenu, IDM_PRINTERS);
// FileMenu_DeleteItemByCmd(hmenu, IDM_FONTS);
}
else if (SHRestricted(REST_NOSETTASKBAR))
{
FileMenu_DeleteItemByCmd(hmenu, IDM_TRAYPROPERTIES);
}
// Delete the seperator.
FileMenu_DeleteSeparator(hmenu);
}
}
else
{
DebugMsg(DM_ERROR, TEXT("c.fm_rui: Settings menu couldn't be found. Restricted items could not be removed."));
}
}
// Find menu.
if (SHRestricted(REST_NOFIND))
{
FileMenu_DeleteItemByCmd(g_ts.hmenuStart, IDM_MENU_FIND);
}
}
//----------------------------------------------------------------------------
// Make sure the menu fits on the screen. Remove items from the top if it
// doesn't.
void StartMenu_LimitHeight(void)
{
int i, j, cItems;
int cyMenu, cyMenuMax;
Assert(g_ts.hmenuStart);
cItems = GetMenuItemCount(g_ts.hmenuStart);
Assert(cItems);
cyMenu = 0;
cyMenuMax = GetSystemMetrics(SM_CYSCREEN);
// Stop when the menu gets to big.
for (i=cItems; i>0; i--)
{
cyMenu += HIWORD(FileMenu_GetItemExtent(g_ts.hmenuStart, i-1));
if (cyMenu > cyMenuMax)
break;
}
// Delete overflow items.
for (j=i; j>0; j--)
{
FileMenu_DeleteItemByIndex(g_ts.hmenuStart, j-1);
}
}
//----------------------------------------------------------------------------
void StartMenu_Build(PFileCabinet pfc)
{
HMENU hMenu, hMenuSub;
// DWORD idThread;
// Keep these menu's around - it's no longer safe to just delete
// them willy-nilly.
Assert(!g_ts.hmenuStart);
Assert(!g_ts.hThread);
hMenu = LoadMenu(hinstCabinet, MAKEINTRESOURCE(MENU_START));
if (hMenu)
{
hMenuSub = GetSubMenu(hMenu, 0);
if (hMenuSub)
{
// initialize the find extensions
// check to see if it's the find menu
MENUITEMINFO mii;
mii.cbSize = SIZEOF(MENUITEMINFO);
mii.fMask = MIIM_SUBMENU|MIIM_ID;
if (GetMenuItemInfo(hMenuSub, IDM_MENU_FIND, FALSE, &mii))
{
DebugMsg(DM_TRACE, TEXT("InitMenuPopup of Find commands"));
pfc->pcmFind = SHFind_InitMenuPopup(mii.hSubMenu, pfc->hwndMain, TRAY_IDM_FINDFIRST, TRAY_IDM_FINDLAST);
} else {
Assert(0);
}
if (g_ts.fSMSmallIcons)
g_ts.hmenuStart = FileMenu_Create((COLORREF)-1, 0, NULL, 0, FMF_NOBREAK);
else
g_ts.hmenuStart = FileMenu_Create(RGB(0,0,0), 21, g_ts.hbmpStartBkg, 0, FMF_LARGEICONS|FMF_NOBREAK);
if (g_ts.hmenuStart)
{
// List for global hotkeys.
HotkeyList_Create();
// Startmenu items.
StartMenu_InsertFavouriteItems(pfc, g_ts.hmenuStart);
// Default stuff.
StartMenu_CatMenu(g_ts.hmenuStart, hMenuSub, II_STPROGS, g_ts.fSMSmallIcons ? 0 : g_cyIcon);
// Remove stuff.
StartMenu_RemoveUnavailableItems();
// Limit it's height.
StartMenu_LimitHeight();
// Build programs menu's in the background.
StartMenu_ControlBkgThread(SMCT_PRIMARY);
}
}
DestroyMenu(hMenu);
}
}
//----------------------------------------------------------------------------
void StartMenu_Destroy(LPFileCabinet pfc)
{
StartMenu_ControlBkgThread(SMCT_STOP);
FileMenu_Destroy(g_ts.hmenuStart);
if (pfc && pfc->pcmFind)
{
pfc->pcmFind->lpVtbl->Release(pfc->pcmFind);
pfc->pcmFind = NULL;
}
g_ts.hmenuStart = NULL;
}
//----------------------------------------------------------------------------
void _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, g_ts.hwndStart, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE);
SendMessage(g_ts.hwndStart, BM_SETSTATE, FALSE, 0);
SendMessage(g_ts.hwndStart, BM_SETSTATE, FALSE, 0);
}
int Tray_TrackMenu(PFileCabinet pfc, HMENU hmenu, BOOL fFileMenu)
{
TPMPARAMS tpm;
int iret;
tpm.cbSize = SIZEOF(tpm);
GetClientRect(pfc->hwndToolbar, &tpm.rcExclude);
MapWindowPoints(pfc->hwndToolbar, NULL, (LPPOINT)&tpm.rcExclude, 2);
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
if (fFileMenu)
{
iret = FileMenu_TrackPopupMenuEx(hmenu, TPM_VERTICAL | TPM_BOTTOMALIGN | TPM_RETURNCMD,
tpm.rcExclude.left, tpm.rcExclude.bottom, v_hwndTray, &tpm);
}
else
{
iret = TrackPopupMenuEx(hmenu, TPM_VERTICAL | TPM_BOTTOMALIGN | TPM_RETURNCMD,
tpm.rcExclude.left, tpm.rcExclude.bottom, v_hwndTray, &tpm);
}
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
return iret;
}
//----------------------------------------------------------------------------
// Keep track of the menu font name and weight so we can redo the startmenu if
// these change before getting notified via win.ini.
BOOL StartMenu_FontChange(void)
{
NONCLIENTMETRICS ncm;
static TCHAR lfFaceName[LF_FACESIZE] = TEXT("");
static long lfHeight = 0;
ncm.cbSize = SIZEOF(ncm);
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, SIZEOF(ncm), &ncm, FALSE))
{
if (!*lfFaceName)
{
// DebugMsg(DM_TRACE, "sm_fc: No menu font - initing.");
lstrcpy(lfFaceName, ncm.lfMenuFont.lfFaceName);
lfHeight = ncm.lfMenuFont.lfHeight;
return FALSE;
}
else if ((lstrcmpi(ncm.lfMenuFont.lfFaceName, lfFaceName) == 0) &&
(ncm.lfMenuFont.lfHeight == lfHeight))
{
// DebugMsg(DM_TRACE, "sm_fc: Menu font unchanged.");
return FALSE;
}
else
{
// DebugMsg(DM_TRACE, "sm_fc: Menu font changed.");
lstrcpy(lfFaceName, ncm.lfMenuFont.lfFaceName);
lfHeight = ncm.lfMenuFont.lfHeight;
return TRUE;
}
}
return FALSE;
}
/*------------------------------------------------------------------
** Respond to a button's pressing by bringing up the appropriate menu.
** Clean up the button depression when the menu is dismissed.
**------------------------------------------------------------------*/
void ToolbarMenu(PFileCabinet pfc)
{
HMENU hmenuMain = NULL;
HMENU hMenu = NULL;
int idCmd;
// DWORD idThread;
SetActiveWindow(v_hwndTray);
#ifndef WINNT // BUGBUG - Fix this when NT gets docking ability
if (g_ts.hBIOS!=INVALID_HANDLE_VALUE)
{
FileMenu_EnableItemByCmd(g_ts.hmenuStart, IDM_EJECTPC,
g_ts.fDockingFlags&DOCKFLAG_WARMEJECTABLENOW);
}
#endif
// Keep the button down.
StartMenu_ControlBkgThread(SMCT_STOP);
if (g_ts.fFavInvalid || StartMenu_FontChange())
RebuildEntireMenu(pfc);
pfc->bMainMenuInit = TRUE;
idCmd = Tray_TrackMenu(pfc, g_ts.hmenuStart, TRUE);
pfc->bMainMenuInit = FALSE;
// This forces the button back up.
_ForceStartButtonUp();
// Restart the menu thread if needed.
StartMenu_ControlBkgThread(SMCT_RESTART);
if (idCmd) {
TrayCommand(pfc, idCmd); // execute if a menu was selected
}
}
void 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 AppBarSubtractRects(LPRECT lprc)
{
int i;
if (g_ts.hdpaAppBars) {
i = DPA_GetPtrCount(g_ts.hdpaAppBars);
// can't use subtract rect because of fully inclusion limitation
while (i--) {
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(g_ts.hdpaAppBars, i);
AppBarSubtractRect(pab, lprc);
}
}
}
void GetWorkArea(LPRECT lprcWAreaNew, LPRECT lprcFull, LPRECT lprcTray)
{
RECT rcWork;
// Calc size for new work areas. Only limit the screen if the tray is
// always on top and autohide is off.
if (!(g_ts.uAutoHide & AH_ON) && g_ts.fAlwaysOnTop)
{
SubtractRect(&rcWork, lprcFull, lprcTray);
} else {
rcWork = *lprcFull;
}
AppBarSubtractRects(&rcWork);
*lprcWAreaNew = rcWork;
}
/*------------------------------------------------------------------
** tell USER to limit the usable screen size because the tray is
** stuck to one of the sides.
**------------------------------------------------------------------*/
void LimitScreenSize(PRECT prTray)
{
RECT rcFull;
RECT rcWork;
RECT rcWAreaOld;
rcFull.top = rcFull.left = 0;
rcFull.right = g_cxScreen;
rcFull.bottom = g_cyScreen;
GetWorkArea(&rcWork, &rcFull, prTray);
// Did anything change?
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWAreaOld, 0);
if (!EqualRect(&rcWork, &rcWAreaOld))
{
DebugMsg(DM_TRACE, TEXT("c.lss: Changing desktop work area."));
SystemParametersInfo(SPI_SETWORKAREA, TRUE, &rcWork, SPIF_SENDWININICHANGE);
}
}
/*------------------------------------------------------------------
** the tray has either just been stuck to an edge or has resized while
** in the stuck position. so adjust the world to this real estate
** guzzling action. Other windows in the system are moved out of the way.
**------------------------------------------------------------------*/
void StuckSizeChange()
{
GetWindowRect(v_hwndTray, &g_ts.arStuckRects[g_ts.uStuckPlace]);
LimitScreenSize(&g_ts.arStuckRects[g_ts.uStuckPlace]);
SendMessage(v_hwndDesktop, DTM_SIZEDESKTOP, 0, 0);
}
/*------------------------------------------------------------------
** 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 Tray_DoneMoving(LPWINDOWPOS lpwp)
{
RECT rc;
rc = g_ts.arStuckRects[g_ts.uMoveStuckPlace];
lpwp->x = rc.left;
lpwp->y = rc.top;
lpwp->cx = rc.right - rc.left;
lpwp->cy = rc.bottom - rc.top;
// the size has changed
lpwp->flags &= ~SWP_NOSIZE;
// if we were autohiding, we need to update our appbar autohide rect
if (g_ts.uAutoHide & AH_ON) {
// unregister us from the old side
IAppBarSetAutoHideBar(v_hwndTray, FALSE, g_ts.uStuckPlace);
}
// remember the new state
g_ts.uStuckPlace = g_ts.uMoveStuckPlace;
if (g_ts.fSysSizing)
g_ts.rc = g_ts.arStuckRects[g_ts.uStuckPlace];
if (g_ts.uAutoHide & AH_ON) {
if (!IAppBarSetAutoHideBar(v_hwndTray, TRUE, g_ts.uStuckPlace)) {
SetAutoHideState(FALSE);
ShellMessageBox(hinstCabinet, v_hwndTray, MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
MAKEINTRESOURCE(IDS_TASKBAR),MB_OK|MB_ICONSTOP);
}
}
}
void Tray_WhichStuckRect(int left, int top, int right, int bottom)
{
int i;
for (i = STICK_BOTTOM ; i >= STICK_LEFT ; i--) {
if (g_ts.arStuckRects[i].left == left &&
g_ts.arStuckRects[i].top == top &&
g_ts.arStuckRects[i].right == right &&
g_ts.arStuckRects[i].bottom == bottom) {
g_ts.uMoveStuckPlace = i;
}
}
}
void Tray_CalcStuckPlace(POINT pt)
{
int i;
int dx, dy;
int horiz, vert;
// BUGBUG go in backward order to encourage good positioning
// BUGBUG ideally, we want to have the order: b,t,l,r.
for(i = STICK_BOTTOM; i >= STICK_LEFT; i--)
{
if (PtInRect(&(g_ts.arStuckRects[i]), pt))
{
g_ts.uMoveStuckPlace = i;
break;
}
}
// not in the rect, see which side we're closest to.
if (pt.x < (g_cxScreen/2)) {
dx = pt.x;
horiz = STICK_LEFT;
} else {
dx = g_cxScreen - pt.x;
horiz = STICK_RIGHT;
}
if (pt.y < (g_cyScreen/2)) {
dy = pt.y;
vert = STICK_TOP;
} else {
dy = g_cyScreen - pt.y;
vert = STICK_BOTTOM;
}
// if ((dx / g_cxScreen) < (dy / g_cyScreen))
// same as above
if ((g_cxScreen * dy ) > (g_cyScreen * dx))
g_ts.uMoveStuckPlace = horiz;
else
g_ts.uMoveStuckPlace = vert;
}
/*------------------------------------------------------------------
** processing of the WM_MOVING message.
**
** if the cursor is in one of the docking positions, make the
** fuzzy rect look like the docked position. if not, the fuzzy
** rectangle is the size of the undocked tray.
**
** g_ts.uMoveStuckPlace is set here for general use.
** return: fill in rectangle with new size.
**------------------------------------------------------------------*/
void Tray_HandleMoving(LPRECT lprc)
{
POINT ptCursor;
GetCursorPos(&ptCursor);
Tray_CalcStuckPlace(ptCursor);
*lprc = g_ts.arStuckRects[g_ts.uMoveStuckPlace];
}
//------------------------------------------------------------------
// Size the icon area to fill as much of the tray window as it can.
//------------------------------------------------------------------
void Tray_SizeWindows()
{
RECT rcView, rcClock, rcClient;
PFileCabinet pfc = g_pfcTray;
if (!g_pfcTray || !pfc->hwndView || !pfc->hwndMain || !g_ts.hwndNotify)
return;
if (g_ts.uAutoHide & AH_HIDING) {
g_ts.fShouldResize = TRUE;
return;
}
GetClientRect(pfc->hwndMain, &rcClient);
Tray_GetWindowSizes(&rcClient, &rcView, &rcClock);
SetWindowPos(g_ts.hwndStart, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
SetWindowPos(pfc->hwndToolbar, NULL, 0, 0,
(rcClient.right < g_ts.sizeStart.cx) ? rcClient.right : g_ts.sizeStart.cx,
g_ts.sizeStart.cy, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
// position the view
SetWindowPos(pfc->hwndView, NULL, rcView.left, rcView.top,
RECTWIDTH(rcView), RECTHEIGHT(rcView),
SWP_NOZORDER | SWP_NOACTIVATE);
// And the clock
SetWindowPos(g_ts.hwndNotify, NULL, rcClock.left, rcClock.top,
RECTWIDTH(rcClock), RECTHEIGHT(rcClock),
SWP_NOZORDER | SWP_NOACTIVATE);
{
TOOLINFO ti;
HWND hwndClock = (HWND)SendMessage(g_ts.hwndNotify, TNM_GETCLOCK, 0, 0L);
ti.cbSize = SIZEOF(ti);
ti.uFlags = 0;
ti.hwnd = pfc->hwndMain;
ti.lpszText = LPSTR_TEXTCALLBACK;
ti.uId = (UINT)hwndClock;
GetWindowRect(hwndClock, &ti.rect);
MapWindowPoints(HWND_DESKTOP, pfc->hwndMain, (LPPOINT)&ti.rect, 2);
SendMessage(g_ts.hwndTrayTips, TTM_NEWTOOLRECT, 0, (LPARAM)((LPTOOLINFO)&ti));
}
//InvalidateRect(pfc->hwndView, NULL, TRUE);
}
void Tray_NegotiateSizing(PFileCabinet pfc, UINT code, PRECT prcClient)
{
RECT rcView, rcClock;
int iHeight;
// given this sizing, what would our children's sizes be?
// use Client coords
prcClient->bottom -= prcClient->top;
prcClient->right -= prcClient->left;
prcClient->top = prcClient->left = 0;
Tray_GetWindowSizes(prcClient, &rcView, &rcClock);
iHeight = RECTHEIGHT(rcView);
// maybe we should translate this to screen coordinates?
// that would allow our children to prevent being in certain
// physical locations, but we're more concerned with size, not loc
SendMessage(pfc->hwndView, WM_SIZING, code, (LPARAM)(LPRECT)&rcView);
// did it change?
if (RECTHEIGHT(rcView) != iHeight) {
// grow the prcClient by the same amound rcView grew;
prcClient->bottom += RECTHEIGHT(rcView) - iHeight;
// try again until it doesn't change
Tray_NegotiateSizing(pfc, code, prcClient);
}
}
int Window_GetClientGapHeight(HWND hwnd)
{
RECT rc;
SetRectEmpty(&rc);
AdjustWindowRectEx(&rc, GetWindowLong(hwnd, GWL_STYLE), FALSE, GetWindowLong(hwnd, GWL_EXSTYLE));
return RECTHEIGHT(rc);
}
/*-------------------------------------------------------------
** process the WM_SIZING message.
**
** nothing exciting. just don't let a docked tray get sized
** too big.
**-------------------------------------------------------------*/
void Tray_HandleSizing(PFileCabinet pfc, UINT code, LPRECT lprc, UINT uStuckPlace)
{
RECT rc;
int iHeight;
int iYExtra; // the amount of Y difference between the window and client height;
iYExtra = Window_GetClientGapHeight(pfc->hwndMain);
if (g_cyTrayBorders == -1)
g_cyTrayBorders = iYExtra; // on initial boot
// first do original size check.. don't let it be more than half the
// screen if it's docked.
switch (uStuckPlace)
{
case STICK_TOP:
lprc->top = tray_yScreen;
lprc->right = tray_cxScreen;
lprc->left = tray_xScreen;
if (lprc->bottom > g_cyScreen/2)
lprc->bottom = g_cyScreen/2;
if (RECTHEIGHT(*lprc) <= (g_cyTrayBorders)) {
// the minmaxsize will prevent us from getting too small
// allow
//lprc->bottom = lprc->top + g_cyFrame;
g_cyTrayBorders = iYExtra;
return;
}
break;
case STICK_BOTTOM:
lprc->right = tray_cxScreen;
lprc->left = tray_xScreen;
if (lprc->top > tray_cyScreen) {
lprc->top = tray_cyScreen - (lprc->bottom - lprc->top);
}
lprc->bottom = tray_cyScreen;
if (lprc->top < g_cyScreen/2)
lprc->top = g_cyScreen/2;
if (RECTHEIGHT(*lprc) <= (g_cyTrayBorders)) {
// the minmaxsize will prevent us from getting too small
// allow
//lprc->top = lprc->bottom - g_cyFrame;
g_cyTrayBorders = iYExtra;
return;
}
break;
// in these two cases, we return, not break because we don't want
// to arbitrate size if we're stuck to the right or left sides
case STICK_RIGHT:
lprc->top = tray_yScreen;
lprc->bottom = tray_cyScreen;
if (lprc->left > tray_cxScreen) {
lprc->top = tray_cxScreen - (lprc->right - lprc->left);
}
lprc->right = tray_cxScreen;
if (lprc->left < g_cxScreen/2)
lprc->left = g_cxScreen/2;
return;
case STICK_LEFT:
lprc->top = tray_yScreen;
lprc->bottom = tray_cyScreen;
lprc->left = tray_xScreen;
if (lprc->right > g_cxScreen/2)
lprc->right = g_cxScreen/2;
return;
}
/////
// next we go and negotiate the size with our children.
// Take into account changes in the border by keeping track of it.
// if (!g_cyTrayBorders)
// g_cyTrayBorders = Window_GetClientGapHeight(pfc->hwndMain);
// it doesn't matter which we take off from,
rc = *lprc;
rc.bottom -= g_cyTrayBorders;
Tray_NegotiateSizing(pfc, code, &rc);
// was there a change? If so, adjust the lprc
iHeight = RECTHEIGHT(rc);
if ((iHeight+iYExtra) != RECTHEIGHT(*lprc)) {
switch(uStuckPlace)
{
case STICK_TOP:
lprc->bottom = lprc->top + iHeight + iYExtra;
break;
case STICK_BOTTOM:
lprc->top = lprc->bottom - (iHeight + iYExtra);
break;
}
}
// Remember the current client gap.
g_cyTrayBorders = iYExtra;
}
/*-------------------------------------------------------------------
** 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.
**-------------------------------------------------------------------*/
void Tray_ScreenSizeChange(HWND hWnd)
{
// screen size changed, so we need to adjust globals
g_cxScreen = GetSystemMetrics(SM_CXSCREEN);
g_cyScreen = GetSystemMetrics(SM_CYSCREEN);
ResizeStuckRects(g_ts.arStuckRects);
// recompute the autohide rect
if (g_ts.uAutoHide & AH_ON) {
int x,y;
x = RECTWIDTH(g_ts.rc);
y = RECTHEIGHT(g_ts.rc);
g_ts.rc = g_ts.arStuckRects[g_ts.uStuckPlace];
switch(g_ts.uStuckPlace) {
case STICK_TOP:
g_ts.rc.bottom = g_ts.rc.top + y;
break;
case STICK_BOTTOM:
g_ts.rc.top = g_ts.rc.bottom - y;
break;
case STICK_RIGHT:
g_ts.rc.left = g_ts.rc.right - x;
break;
case STICK_LEFT:
g_ts.rc.right = g_ts.rc.left + x;
break;
}
}
if (hWnd) {
// fake up position globals to set "new" docking position
// since WINDOWPOSCHANGING will be used, fake up gmove_ data
// to make it look like things moved.
// "current" position is faked to be some other docked state
g_ts.uMoveStuckPlace = g_ts.uStuckPlace;
g_ts.uStuckPlace = (g_ts.uStuckPlace + 1) % 4;
//// set a bogus windowpos and actually repaint with the right
//// shape/size in handling the WINDOWPOSCHANGING message
SetWindowPos(hWnd, NULL,
g_ts.arStuckRects[g_ts.uMoveStuckPlace].left,
g_ts.arStuckRects[g_ts.uMoveStuckPlace].top,
g_ts.arStuckRects[g_ts.uMoveStuckPlace].right -
g_ts.arStuckRects[g_ts.uMoveStuckPlace].left,
g_ts.arStuckRects[g_ts.uMoveStuckPlace].bottom -
g_ts.arStuckRects[g_ts.uMoveStuckPlace].top,
SWP_NOZORDER | SWP_NOACTIVATE);
// we went to the stuck rects which means we hid if AH_ON is set
if (g_ts.uAutoHide & AH_ON)
g_ts.uAutoHide |= AH_HIDING;
}
// Space for StartMenu items may be different now.
// We'll need to rebuild the whole menu before showing it again.
g_ts.fFavInvalid = TRUE;
// if there's a rude app up and we're obscured, don't set the timer to rebuild
if (!(g_ts.fAlwaysOnTop && g_ts.fRudeApp && IsHwndObscured(v_hwndTray)))
{
// Use the "Update Favourite" timer to do it as
// soon as possible.
SetTimer(v_hwndTray, IDT_FAVOURITE, 2*1000, NULL);
}
Tray_SizeWindows();
}
void _UpdateAlwaysOnTop(BOOL fAlwaysOnTop)
{
//
// The user clicked on the AlwaysOnTop menu item, we should now toggle
// the state and update the window occordingly...
//
g_ts.fAlwaysOnTop = fAlwaysOnTop;
SetWindowPos(v_hwndTray,
g_ts.fAlwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
// Make sure the screen limits are update to the new state.
StuckSizeChange();
AppBarNotifyAll(ABN_STATECHANGE, NULL, 0);
}
void ViewOptionsUpdateDisplay(HWND hDlg);
void _ApplyViewOptionsFromDialog(LPPROPSHEETPAGE psp, HWND hDlg)
{
// We need to get the Cabinet structure from the property sheet info.
LPSHELLBROWSER psb = (LPSHELLBROWSER)(psp->lParam);
PFileCabinet pfc = IToClassN(CFileCabinet, sb, psb);
BOOL fSmallPrev;
BOOL fSmallNew;
BOOL fAutoHide;
// First check for Always on Top
_UpdateAlwaysOnTop(IsDlgButtonChecked(hDlg, IDC_TRAYOPTONTOP));
//
// And change the Autohide state
fAutoHide = IsDlgButtonChecked(hDlg, IDC_TRAYOPTAUTOHIDE);
if (!SetAutoHideState(fAutoHide) && fAutoHide) {
// we tried and failed.
if (!(g_ts.uAutoHide & AH_ON)) {
CheckDlgButton(hDlg, IDC_TRAYOPTAUTOHIDE, FALSE);
ViewOptionsUpdateDisplay(hDlg);
}
}
// show/hide the clock
g_ts.fHideClock = !IsDlgButtonChecked(hDlg, IDC_TRAYOPTSHOWCLOCK);
SendMessage(g_ts.hwndNotify, TNM_HIDECLOCK, 0, g_ts.fHideClock);
Tray_SizeWindows();
// check if it's changed
fSmallPrev = (g_ts.fSMSmallIcons ? TRUE : FALSE);
fSmallNew = (IsDlgButtonChecked(hDlg, IDC_SMSMALLICONS) ? TRUE : FALSE);
if (fSmallPrev != fSmallNew)
{
g_ts.fSMSmallIcons = fSmallNew;
g_ts.fFavInvalid = TRUE;
SetTimer(v_hwndTray, IDT_FAVOURITE, 2*1000, NULL);
}
}
//---------------------------------------------------------------------------
void ViewOptionsInitBitmaps(HWND hDlg)
{
int i;
for (i = 0; i <= (IDB_VIEWOPTIONSLAST - IDB_VIEWOPTIONSFIRST); i++) {
HBITMAP hbm;
hbm = LoadImage(hinstCabinet,
MAKEINTRESOURCE(IDB_VIEWOPTIONSFIRST + i),
IMAGE_BITMAP, 0,0, LR_LOADMAP3DCOLORS);
hbm = (HBITMAP)SendDlgItemMessage(hDlg, IDC_VIEWOPTIONSICONSFIRST + i,
STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
if (hbm)
DeleteBitmap(hbm);
}
}
void ViewOptionsDestroyBitmaps(HWND hDlg)
{
int i;
for (i = 0; i <= (IDB_VIEWOPTIONSLAST - IDB_VIEWOPTIONSFIRST); i++) {
HBITMAP hbmOld;
hbmOld = (HBITMAP)SendDlgItemMessage(hDlg, IDC_VIEWOPTIONSICONSFIRST + i,
STM_GETIMAGE, 0,0);
if (hbmOld)
DeleteBitmap(hbmOld);
}
}
void ViewOptionsUpdateDisplay(HWND hDlg)
{
HWND hwnd;
BOOL fShown;
BOOL f;
// this works by having the background bitmap having the
// small menu, the tray in autohide/ontop mode and we lay other statics
// over it to give the effect we want.
SetWindowPos(GetDlgItem(hDlg, IDC_VOBASE), HWND_BOTTOM, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
ShowWindow(GetDlgItem(hDlg, IDC_VOLARGEMENU),
!IsDlgButtonChecked(hDlg, IDC_SMSMALLICONS) ? SW_SHOWNA : SW_HIDE);
ShowWindow(GetDlgItem(hDlg, IDC_VOTRAY),
!(f = IsDlgButtonChecked(hDlg, IDC_TRAYOPTAUTOHIDE)) ? SW_SHOWNA : SW_HIDE);
ShowWindow(GetDlgItem(hDlg, IDC_VOTRAYNOCLOCK),
!f && !IsDlgButtonChecked(hDlg, IDC_TRAYOPTSHOWCLOCK) ? SW_SHOWNA : SW_HIDE);
ShowWindow(hwnd = GetDlgItem(hDlg, IDC_VOWINDOW),
(FALSE != (fShown = !IsDlgButtonChecked(hDlg, IDC_TRAYOPTONTOP))) ? SW_SHOWNA : SW_HIDE);
if (fShown)
SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
#define CXVOBASE 274
#define CYVOBASE 130
#define XVOMENU 2
#define YVOMENU 0
#define CXVOMENU 150
#define CYVOMENU 98
#define XVOTRAY 2
#define YVOTRAY 100
#define CXVOTRAY 268
#define CYVOTRAY 28
#define XVOTRAYNOCLOCK (XVOTRAY + 184)
#define YVOTRAYNOCLOCK (YVOTRAY + 3)
#define CXVOTRAYNOCLOCK 79
#define CYVOTRAYNOCLOCK 22
#define XVOWINDOW 212
#define YVOWINDOW 100
#define CXVOWINDOW 61
#define CYVOWINDOW 6
// need to do this by hand because dialog units to pixels will change,
// but the bitmaps won't
void ViewOptionsSizeControls(HWND hDlg)
{
POINT ptBase; // coordinates of origin of VOBase.bmp
HWND hwnd, hwnd2;
ptBase.x = ptBase.y = 0;
hwnd = GetDlgItem(hDlg, IDC_VOBASE);
MapWindowPoints(hwnd, hDlg, &ptBase, 1);
// over it to give the effect we want.
SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, CXVOBASE, CYVOBASE,
SWP_NOMOVE | SWP_NOACTIVATE);
SetWindowPos(GetDlgItem(hDlg, IDC_VOLARGEMENU), NULL,
ptBase.x + XVOMENU, ptBase.y + YVOMENU, CXVOMENU, CYVOMENU, SWP_NOACTIVATE | SWP_NOZORDER);
SetWindowPos(hwnd2 = GetDlgItem(hDlg, IDC_VOTRAY), NULL,
ptBase.x + XVOTRAY, ptBase.y + YVOTRAY, CXVOTRAY, CYVOTRAY, SWP_NOACTIVATE);
SetWindowPos(hwnd = GetDlgItem(hDlg, IDC_VOTRAYNOCLOCK), HWND_TOP,
ptBase.x + XVOTRAYNOCLOCK, ptBase.y + YVOTRAYNOCLOCK, CXVOTRAYNOCLOCK, CYVOTRAYNOCLOCK, SWP_NOACTIVATE);
SetWindowPos(GetDlgItem(hDlg, IDC_VOWINDOW), NULL,
ptBase.x + XVOWINDOW, ptBase.y + YVOWINDOW, CXVOWINDOW, CYVOWINDOW, SWP_NOACTIVATE);
}
const static DWORD aTaskOptionsHelpIDs[] = { // Context Help IDs
IDC_VOBASE, IDH_TASKBAR_OPTIONS_BITMAP,
IDC_VOLARGEMENU, IDH_TASKBAR_OPTIONS_BITMAP,
IDC_VOTRAY, IDH_TASKBAR_OPTIONS_BITMAP,
IDC_VOWINDOW, IDH_TASKBAR_OPTIONS_BITMAP,
IDC_TRAYOPTONTOP, IDH_TRAY_TASKBAR_ONTOP,
IDC_TRAYOPTAUTOHIDE, IDH_TRAY_TASKBAR_AUTOHIDE,
IDC_SMSMALLICONS, IDH_STARTMENU_SMALLICONS,
IDC_TRAYOPTSHOWCLOCK, IDH_TRAY_SHOW_CLOCK,
0, 0
};
BOOL CALLBACK TrayViewOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPPROPSHEETPAGE psp = (LPPROPSHEETPAGE)GetWindowLong(hDlg, DWL_USER);
switch (uMsg) {
case WM_COMMAND:
ViewOptionsUpdateDisplay(hDlg);
SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
break;
case WM_INITDIALOG:
SetWindowLong(hDlg, DWL_USER, lParam);
if (g_ts.fAlwaysOnTop)
CheckDlgButton(hDlg, IDC_TRAYOPTONTOP, TRUE);
if (g_ts.uAutoHide & AH_ON)
CheckDlgButton(hDlg, IDC_TRAYOPTAUTOHIDE, TRUE);
if (g_ts.fSMSmallIcons)
CheckDlgButton(hDlg, IDC_SMSMALLICONS, TRUE);
if (!g_ts.fHideClock)
CheckDlgButton(hDlg, IDC_TRAYOPTSHOWCLOCK, TRUE);
ViewOptionsSizeControls(hDlg);
ViewOptionsInitBitmaps(hDlg);
ViewOptionsUpdateDisplay(hDlg);
break;
case WM_SYSCOLORCHANGE:
ViewOptionsInitBitmaps(hDlg);
return TRUE;
case WM_DESTROY:
ViewOptionsDestroyBitmaps(hDlg);
break;
case WM_NOTIFY:
switch (((NMHDR *)lParam)->code) {
case PSN_APPLY:
// save settings here
_ApplyViewOptionsFromDialog(psp, hDlg);
return TRUE;
case PSN_KILLACTIVE:
case PSN_SETACTIVE:
return TRUE;
}
break;
case WM_HELP:
WinHelp(((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP, (DWORD)(LPTSTR) aTaskOptionsHelpIDs);
break;
case WM_CONTEXTMENU:
WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU, (DWORD)(LPVOID)aTaskOptionsHelpIDs);
break;
}
return FALSE;
}
// this will open the special view info stream for the "tray" incarnation
// of tray, rather than the cabinet's incarnation of the tray directory
STDMETHODIMP CDeskTray_GetViewStateStream(IShellBrowser * psb, DWORD grfMode, LPSTREAM *pStrm)
{
CFileCabinet * this = IToClassN(CFileCabinet, sb, psb);
// Now lets try to save away the other information associated with view.
// We need to figure out where we will store the information.
// If it is a local drive, we will save it in the ini file associated
// with that directory. If it is remote and we are opening to write
// we will look in our cache. If it is remote and we are opening for
// reading, we will first see if it is in our cache and if not we
// will read it from the remote one.
// And call off to get the stream associated with the path.
*pStrm = Cabinet_GetViewStreamForPidl(this->pidl, grfMode, c_szViewStreamInfo);
return *pStrm ? S_OK : E_OUTOFMEMORY;
}
BOOL CALLBACK InitStartMenuDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
/*-------------------------------------------------------------
** Method to add view property sheet pages to the tray property
** sheet
**-------------------------------------------------------------*/
STDMETHODIMP CShellTray_AddViewPropertySheetPages(IShellBrowser * psb,
DWORD dwReserved, LPFNADDPROPSHEETPAGE lpfn, LPARAM lParam)
{
HPROPSHEETPAGE hpage;
PROPSHEETPAGE psp;
psp.dwSize = SIZEOF(psp);
psp.dwFlags = PSP_DEFAULT;
psp.hInstance = hinstCabinet;
psp.pszTemplate = MAKEINTRESOURCE(DLG_TRAY_VIEW_OPTIONS);
psp.pfnDlgProc = TrayViewOptionsDlgProc;
psp.lParam = (LPARAM)psb;
hpage = CreatePropertySheetPage(&psp);
if (hpage)
lpfn(hpage, lParam);
psp.pszTemplate = MAKEINTRESOURCE(DLG_STARTMENU_CONFIG);
psp.pfnDlgProc = InitStartMenuDlgProc;
psp.lParam = (LPARAM)psb;
hpage = CreatePropertySheetPage(&psp);
if (hpage)
lpfn(hpage, lParam);
return(S_OK);
}
void _SaveTrayAndDesktop(void)
{
WINDOWPLACEMENT wp;
TVSD tvsd;
FOLDERSETTINGS fs;
PFileCabinet pfc;
DebugMsg(DM_TRACE, TEXT("Saving desktop state"));
if (SHRestricted(REST_NOSAVESET))
{
return;
}
Cabinet_SaveState(v_hwndDesktop, NULL, TRUE, FALSE, FALSE);
pfc = GetPFC(v_hwndDesktop);
pfc->psv->lpVtbl->GetCurrentInfo(pfc->psv, &fs);
Reg_SetStruct(g_hkeyExplorer, c_szCabinetDeskView, c_szSettings, &fs, SIZEOF(fs));
// And now the tray.
DebugMsg(DM_TRACE, TEXT("Saving tray state"));
HotkeyList_Save();
wp.length = SIZEOF(wp);
GetWindowPlacement(v_hwndTray, &wp);
Cabinet_SaveState(v_hwndTray, &wp, TRUE, FALSE, FALSE);
// These have now been combined into one structure - Review how to put into stream
tvsd.cxScreen = g_cxScreen;
tvsd.cyScreen = g_cyScreen;
// Now get the sizes for the four edges.
tvsd.dyTop = g_ts.arStuckRects[STICK_TOP].bottom - tray_yScreen;
tvsd.dyBottom = tray_cyScreen - g_ts.arStuckRects[STICK_BOTTOM].top;
tvsd.dxLeft = g_ts.arStuckRects[STICK_LEFT].right - tray_xScreen;
tvsd.dxRight = tray_cxScreen - g_ts.arStuckRects[STICK_RIGHT].left;
// And also stuff for autohide
tvsd.uAutoHide = g_ts.uAutoHide;
tvsd.rclAutoHide.left = g_ts.rc.left;
tvsd.rclAutoHide.right = g_ts.rc.right;
tvsd.rclAutoHide.top = g_ts.rc.top;
tvsd.rclAutoHide.bottom = g_ts.rc.bottom;
// The rest.
tvsd.uStuckPlace = g_ts.uStuckPlace;
tvsd.dwFlags = g_ts.fAlwaysOnTop ? TVSD_TOPMOST : 0;
if (g_ts.fSMSmallIcons) tvsd.dwFlags |= TVSD_SMSMALLICONS;
if (g_ts.fHideClock) tvsd.dwFlags |= TVSD_HIDECLOCK;
// Sanity check.
tvsd.dwSize = SIZEOF(tvsd);
// Save for now in Stuck rects.
Reg_SetStruct(g_hkeyExplorer, c_szCabinetStuckRects, c_szSettings, &tvsd, SIZEOF(tvsd));
}
void SlideWindow(HWND hwnd, RECT *prc)
{
RECT rcOld;
RECT rcNew;
int x,y,dx,dy,dt,t,t0;
BOOL fShow;
HANDLE me;
int priority;
rcNew = *prc;
if (g_fDragFullWindows && g_dtSlideShow>0 && g_dtSlideHide>0) {
GetWindowRect(hwnd, &rcOld);
fShow = (rcNew.bottom-rcNew.top) > (rcOld.bottom-rcOld.top) ||
(rcNew.right-rcNew.left) > (rcOld.right-rcOld.left);
dx = (rcNew.right-rcOld.right) + (rcNew.left - rcOld.left);
dy = (rcNew.bottom-rcOld.bottom) + (rcNew.top - rcOld.top);
Assert((rcOld.right-rcNew.right)==0 || (rcOld.left-rcNew.left)==0);
Assert((rcOld.bottom-rcNew.bottom)==0 || (rcOld.top-rcNew.top)==0);
Assert(dx == 0 || dy == 0);
if (fShow)
{
rcOld = rcNew;
OffsetRect(&rcOld, -dx, -dy);
SetWindowPos(hwnd, NULL, rcOld.left, rcOld.top,
rcOld.right - rcOld.left, rcOld.bottom - rcOld.top,
SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME);
dt = g_dtSlideShow;
}
else
{
dt = g_dtSlideHide;
}
me = GetCurrentThread();
priority = GetThreadPriority(me);
SetThreadPriority(me, THREAD_PRIORITY_HIGHEST);
t0 = GetTickCount();
while ((t = GetTickCount()) < t0 + dt)
{
x = rcOld.left + (dx) * (t - t0) / dt;
y = rcOld.top + (dy) * (t - t0) / dt;
SetWindowPos(hwnd, NULL, x, y, 0, 0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
if (fShow)
UpdateWindow(hwnd);
}
SetThreadPriority(me, priority);
}
SetWindowPos(hwnd, NULL, rcNew.left, rcNew.top,
rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME);
StuckSizeChange();
AppBarNotifyAll(ABN_POSCHANGED, NULL, 0);
}
void DoTrayUnhide()
{
g_ts.fSelfSizing = TRUE;
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
SlideWindow(v_hwndTray, &g_ts.rc);
////MoveWindow(v_hwndTray, g_ts.rc.left, g_ts.rc.top, g_ts.rc.right - g_ts.rc.left, g_ts.rc.bottom - g_ts.rc.top, TRUE);
UpdateWindow(v_hwndTray);
DAD_ShowDragImage(TRUE); // restore the lock state.
g_ts.fSelfSizing = FALSE;
ClockCtl_HandleTrayHide(FALSE);
}
void TrayHide()
{
RECT rcNew, rcOld;
GetWindowRect(v_hwndTray, &rcOld);
rcNew = rcOld;
// bugbug, what we really want to do is to force a bigger size,
// not just punt out on saving this new size.
if ((STUCK_HORIZONTAL(g_ts.uStuckPlace) &&
(RECTHEIGHT(rcOld) > g_cyFrame)) ||
(!STUCK_HORIZONTAL(g_ts.uStuckPlace) &&
(RECTWIDTH(rcOld) > g_cxFrame)))
g_ts.rc = rcOld;
switch (g_ts.uStuckPlace) {
case STICK_LEFT:
rcNew.right = rcNew.left + g_cxFrame;
break;
case STICK_RIGHT:
rcNew.left = rcNew.right - g_cxFrame;
break;
case STICK_TOP:
rcNew.bottom = rcNew.top + g_cyFrame;
break;
case STICK_BOTTOM:
rcNew.top = rcNew.bottom - g_cyFrame;
break;
}
g_ts.uAutoHide = AH_ON | AH_HIDING;
g_ts.fSelfSizing = TRUE;
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
SlideWindow(v_hwndTray, &rcNew);
////MoveWindow(v_hwndTray, rcNew.left, rcNew.top, rcNew.right - rcNew.left, rcNew.bottom - rcNew.top, TRUE);
DAD_ShowDragImage(TRUE); // restore the lock state.
ClockCtl_HandleTrayHide(TRUE);
g_ts.fSelfSizing = FALSE;
}
BOOL SetAutoHideState (BOOL fAutoHide)
{
if (!IAppBarSetAutoHideBar(v_hwndTray, fAutoHide, g_ts.uStuckPlace)) {
// unable to set it because there's another one there already.
ShellMessageBox(hinstCabinet, v_hwndTray, MAKEINTRESOURCE(IDS_ALREADYAUTOHIDEBAR),
MAKEINTRESOURCE(IDS_TASKBAR),MB_OK|MB_ICONSTOP);
return FALSE;
}
if (fAutoHide && !(g_ts.uAutoHide & AH_ON)) {
TrayHide();
} else if (!fAutoHide & (g_ts.uAutoHide & AH_ON)) {
g_ts.uAutoHide = 0;
KillTimer(v_hwndTray, IDT_AUTOHIDE);
DoTrayUnhide();
LimitScreenSize(&g_ts.arStuckRects[g_ts.uStuckPlace]);
} else {
return TRUE;
}
AppBarNotifyAll(ABN_STATECHANGE, NULL, 0);
return TRUE;
}
void Tray_HandleEnterMenuLoop()
{
// kill the timer when we're in the menu loop so that we don't
// pop done while browsing the menus.
if (g_ts.uAutoHide & AH_ON) {
KillTimer(v_hwndTray, IDT_AUTOHIDE);
}
}
void SetAutoHideTimer()
{
if (g_ts.uAutoHide & AH_ON) {
SetTimer(v_hwndTray, IDT_AUTOHIDE, 500, NULL);
}
}
void Tray_HandleExitMenuLoop()
{
// when we leave the menu stuff, start checking again.
SetAutoHideTimer();
}
void TrayUnhide()
{
// handle autohide
if ((g_ts.uAutoHide & AH_ON) &&
(g_ts.uAutoHide & AH_HIDING)) {
DoTrayUnhide();
g_ts.uAutoHide &= ~AH_HIDING;
SetAutoHideTimer();
if (g_ts.fShouldResize) {
Assert(!(g_ts.uAutoHide & AH_HIDING));
Tray_SizeWindows();
g_ts.fShouldResize = FALSE;
}
}
}
void TraySetUnhideTimer(LONG x, LONG y)
{
// handle autohide
if ((g_ts.uAutoHide & AH_ON) &&
(g_ts.uAutoHide & AH_HIDING))
{
LONG dx = x-g_ts.ptLastHittest.x;
LONG dy = y-g_ts.ptLastHittest.y;
LONG rr = dx*dx + dy*dy;
LONG dd = GetSystemMetrics(SM_CXDOUBLECLK) * GetSystemMetrics(SM_CYDOUBLECLK);
if (rr > dd) {
SetTimer(v_hwndTray, IDT_AUTOUNHIDE, 50, NULL);
g_ts.ptLastHittest.x = x;
g_ts.ptLastHittest.y = y;
}
}
}
//---------------------------------------------------------------------------
void RebuildEntireMenu(PFileCabinet pfc)
{
DebugMsg(DM_IANELHK, TEXT("c.rfm: Cleaning up Frequent menu."));
// Delete all the start menu items.
pfc->bMainMenuInit = TRUE;
UnregisterNotify(g_ts.uFavNotify);
g_ts.uFavNotify = 0;
UnregisterNotify(g_ts.uCommonFavNotify);
g_ts.uCommonFavNotify = 0;
StartMenu_Destroy(pfc);
StartMenu_Build(pfc);
pfc->bMainMenuInit = FALSE;
DebugMsg(DM_IANELHK, TEXT("c.rfm: Done."));
g_ts.fFavInvalid = FALSE;
StartMenu_ControlBkgThread(SMCT_RESTART);
}
//----------------------------------------------------------------------------
void StartButton_ResetAndSize(PFileCabinet pfc)
{
HBITMAP hbmOld, hbmNew;
DebugMsg(DM_IANELHK, TEXT("c.sb_rs: Recreating start button."));
hbmOld = (HBITMAP)SendMessage(g_ts.hwndStart, BM_GETIMAGE, IMAGE_BITMAP, 0);
if (hbmOld)
{
hbmNew = CreateStartBitmap(pfc->hwndMain);
if (hbmNew)
{
SendMessage(g_ts.hwndStart, BM_SETIMAGE, IMAGE_BITMAP, (DWORD)hbmNew);
DeleteObject(hbmOld);
}
}
AlignStartButton(pfc->hwndToolbar);
Tray_SizeWindows();
}
//---------------------------------------------------------------------------
void Tray_OnDelayWinIniChange(PFileCabinet pfc)
{
DebugMsg(DM_TRACE, TEXT("c.t_odwic: Handling win ini change."));
TrayUnhide();
Tray_VerifySize(pfc, TRUE);
StartButton_ResetAndSize(pfc);
// We'll need to rebuild the whole menu before showing it again.
g_ts.fFavInvalid = TRUE;
// Use the "Update Favourite" timer to do it as
// soon as possible.
SetTimer(v_hwndTray, IDT_FAVOURITE, 2*1000, NULL);
}
//---------------------------------------------------------------------------
void Tray_HandleTimer(PFileCabinet pfc, WPARAM wTimerID)
{
POINT pt;
RECT rc;
switch (wTimerID) {
case IDT_PROGRAMS:
case IDT_RECENT:
if (!pfc->bMainMenuInit)
{
StartMenu_ControlBkgThread(SMCT_STOP);
KillTimer(v_hwndTray, wTimerID);
StartMenu_ControlBkgThread((wTimerID == IDT_PROGRAMS) ?
SMCT_FILLPROGRAMSONLY : SMCT_FILLRECENTONLY);
}
break;
case IDT_REBUILDMENU:
if (!pfc->bMainMenuInit)
{
DebugMsg(DM_TRACE, TEXT("c.ht: rebuilding start menu."));
StartMenu_ControlBkgThread(SMCT_STOP);
KillTimer(v_hwndTray, wTimerID);
RebuildEntireMenu(pfc);
} else {
DebugMsg(DM_TRACE, TEXT("c.ht: waiting to rebuild start menu."));
}
break;
case IDT_FAVOURITE:
if (!pfc->bMainMenuInit)
{
StartMenu_ControlBkgThread(SMCT_STOP);
RebuildEntireMenu(pfc);
}
if (!g_ts.fFavInvalid)
KillTimer(v_hwndTray, wTimerID);
break;
#ifdef DELAYWININICHANGE
case IDT_DELAYWININICHANGE:
KillTimer(pfc->hwndMain, wTimerID);
Tray_OnDelayWinIniChange(pfc);
break;
#endif
case IDT_DESKTOP:
DebugMsg(DM_TRACE, TEXT("c.t_ht: IDT_DESKTOP"));
StartMenu_ControlBkgThread(SMCT_STOP);
KillTimer(pfc->hwndMain, wTimerID);
StartMenu_ControlBkgThread(SMCT_DESKTOPHOTKEYSONLY);
break;
}
if (g_ts.uAutoHide & AH_ON) {
if (g_ts.fSysSizing)
return;
switch (wTimerID) {
case IDT_AUTOHIDE:
// handle autohide
if (!g_ts.fSysSizing && !(g_ts.uAutoHide & AH_HIDING)) {
HWND hwndA = GetActiveWindow();
GetCursorPos(&pt);
rc = g_ts.rc;
InflateRect(&rc, g_cxEdge * 4, g_cyEdge*4);
if (!PtInRect(&rc, pt) &&
hwndA != v_hwndTray &&
!SendMessage(pfc->hwndView, TM_SYSMENUCOUNT, 0, 0L) &&
(hwndA == NULL || GetWindowOwner(hwndA) != v_hwndTray)) {
KillTimer(v_hwndTray, wTimerID);
TrayHide();
}
}
break;
case IDT_AUTOUNHIDE:
// handle autounhide
KillTimer(v_hwndTray, wTimerID);
g_ts.ptLastHittest.x = -0x0fff;
g_ts.ptLastHittest.y = -0x0fff;
GetWindowRect(v_hwndTray, &rc);
if (g_ts.uAutoHide & AH_HIDING) {
GetCursorPos(&pt);
if (PtInRect(&rc, pt))
TrayUnhide();
}
break;
}
}
}
//---------------------------------------------------------------------------
BOOL Menu_GetItemData(HMENU hmenu, UINT iItem)
{
MENUITEMINFO mii;
mii.cbSize = SIZEOF(MENUITEMINFO);
mii.fMask = MIIM_DATA | MIIM_STATE;
mii.cch = 0; // just in case
if (GetMenuItemInfo(hmenu, iItem, TRUE, &mii))
{
return mii.dwItemData;
}
return 0;
}
//---------------------------------------------------------------------------
LRESULT Tray_HandleInitMenuPopup(HMENU hmenuPopup)
{
LPITEMIDLIST pidl, pidlAlt = NULL;
UINT wID;
int iSpecialID;
UINT uMsg = 0;
ULONG *puNotify = NULL;
LPFileCabinet pfc;
// DebugMsg(DM_TRACE, "hmenupopup = %d, id = %d", hmenuPopup, GetMenuItemID(hmenuPopup, 0));
if (!hmenuPopup)
return 1;
wID = GetMenuItemID(hmenuPopup, 0);
switch (wID)
{
case IDM_RECENT:
WaitForRecent();
case IDM_PROGRAMS:
if (FileMenu_InitMenuPopup(hmenuPopup))
break;
case IDM_RECENTINIT:
case IDM_PROGRAMSINIT:
if (wID == IDM_PROGRAMSINIT)
{
iSpecialID = CSIDL_PROGRAMS;
wID = IDM_PROGRAMS;
if (!g_ts.uProgNotify) {
uMsg = WMTRAY_PROGCHANGE;
puNotify = &g_ts.uProgNotify;
}
pidlAlt = SHCloneSpecialIDList(NULL, CSIDL_COMMON_PROGRAMS, FALSE);
}
else
{
wID = IDM_RECENT;
iSpecialID = CSIDL_RECENT;
if (!g_ts.uRecentNotify) {
uMsg = WMTRAY_RECCHANGE;
puNotify = &g_ts.uRecentNotify;
}
}
pidl = SHCloneSpecialIDList(NULL, iSpecialID, FALSE);
if (!pidl)
goto ExitAndFree;
// Make sure we get notified of changes.
if (puNotify)
{
pfc = g_pfcTray;
Assert(pfc);
if (pfc)
*puNotify = RegisterNotify(pfc->hwndMain, uMsg, pidl);
}
// Remove our fake initialisation menu item.
// NB It's possible to have a filemenu here so we have to be
// careful to check before we delete the initialisation item.
// We should have a FileMenu_IsFileMenu() API but this is
// good enough for now.
if (!Menu_GetItemData(hmenuPopup, 0))
{
DeleteMenu(hmenuPopup, 0, MF_BYPOSITION);
}
// Build the proper menu.
FileMenu_DeleteAllItems(hmenuPopup);
FileMenu_AddFilesForPidl(hmenuPopup, 0, wID, pidl, FMF_NONE, g_CabState.fMenuEnumFilter, FileMenu_Callback);
if (pidlAlt) {
if (!SHRestricted(REST_NOCOMMONGROUPS)) {
FileMenu_AppendFilesForPidl(hmenuPopup, pidlAlt, TRUE);
if (wID == IDM_PROGRAMS) {
if (!g_ts.uCommonProgNotify) {
if (g_pfcTray) {
g_ts.uCommonProgNotify = RegisterNotify(g_pfcTray->hwndMain,
WMTRAY_COMMONPROGCHANGE,
pidlAlt);
}
}
}
}
}
ExitAndFree:
if (pidlAlt)
ILFree(pidlAlt);
if (pidl)
ILFree(pidl);
break;
default:
{
FileMenu_InitMenuPopup(hmenuPopup);
break;
}
}
return 1;
}
//---------------------------------------------------------------------------
LRESULT Tray_HandleMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpmi)
{
return FileMenu_MeasureItem(hwnd, lpmi);
}
//---------------------------------------------------------------------------
LRESULT Tray_HandleDrawItem(HWND hwnd, LPDRAWITEMSTRUCT lpdi)
{
return FileMenu_DrawItem(hwnd, lpdi);
}
#if 0
const TCHAR rszRecent[] = TEXT("IDM_RECENT");
const TCHAR rszFind[] = TEXT("IDM_FIND");
const TCHAR rszHelp[] = TEXT("IDM_HELPSEARCH");
const TCHAR rszPrograms[] = TEXT("IDM_PROGRAMS");
const TCHAR rszControls[] = TEXT("IDM_CONTROLS");
const TCHAR rszExit[] = TEXT("IDM_EXITWIN");
const TCHAR rszPrinters[] = TEXT("IDM_PRINTERS");
const TCHAR rszStart[] = TEXT("IDM_STARTMENU");
const TCHAR rszMyComp[] = TEXT("IDM_MYCOMPUTER");
const TCHAR rszProgInit[] = TEXT("IDM_PROGRAMSINIT");
const TCHAR rszRecentInit[] = TEXT("IDM_RECENTINIT");
const TCHAR rszUnknown[] = TEXT("[UNKNOWN]");
LPCTSTR MenuName( UINT id )
{
switch( id )
{
case IDM_RECENT:
return rszRecent;
case IDM_FIND:
return rszFind;
case IDM_HELPSEARCH:
return rszHelp;
case IDM_PROGRAMS:
return rszPrograms;
case IDM_CONTROLS:
return rszControls;
case IDM_EXITWIN:
return rszExit;
case IDM_PRINTERS:
return rszPrinters;
case IDM_STARTMENU:
return rszStart;
case IDM_MYCOMPUTER:
return rszMyComp;
case IDM_PROGRAMSINIT:
return rszProgInit;
case IDM_RECENTINIT:
return rszRecentInit;
}
return rszUnknown;
}
#endif
//---------------------------------------------------------------------------
// Search for the first sub menu of the given menu, who's first item's ID
// is id. Returns NULL, if nothing is found.
HMENU Menu_FindSubMenuByFirstID(HMENU hmenu, UINT id)
{
int cMax, c;
HMENU hmenuSub;
MENUITEMINFO mii;
Assert(hmenu);
// REVIEW There's a bug in the thunks such that GMIC() returns
// 0x0000ffff for an invalid menu which gets us confused.
if (!IsMenu(hmenu))
return NULL;
// Search all items.
mii.cbSize = SIZEOF(mii);
mii.fMask = MIIM_ID;
cMax = GetMenuItemCount(hmenu);
for (c=0; c < cMax; c++)
{
// Is this item a submenu?
hmenuSub = GetSubMenu(hmenu, c);
if (hmenuSub && GetMenuItemInfo(hmenuSub, 0, TRUE, &mii))
{
if (mii.wID == id)
{
// Found it!
return hmenuSub;
}
}
}
return NULL;
}
//---------------------------------------------------------------------------
#define CMD_ID_FIRST 1
#define CMD_ID_LAST 0x7fff
//---------------------------------------------------------------------------
BOOL _ExecItemByPidls(HWND hwnd, LPITEMIDLIST pidlFolder, LPITEMIDLIST pidlItem)
{
IShellFolder *psf;
LPCONTEXTMENU pcm;
HMENU hmenu;
UINT idCmd;
BOOL fRes = FALSE;
TCHAR szPath[MAX_PATH];
if (pidlFolder && pidlItem)
{
if (SUCCEEDED(s_pshfRoot->lpVtbl->BindToObject(s_pshfRoot,
pidlFolder, NULL, &IID_IShellFolder, &psf)))
{
if (SUCCEEDED(psf->lpVtbl->GetUIObjectOf(psf, v_hwndTray, 1, &pidlItem, &IID_IContextMenu, 0, &pcm)))
{
if (pcm)
{
hmenu = CreatePopupMenu();
if (hmenu)
{
if (SUCCEEDED(pcm->lpVtbl->QueryContextMenu(pcm, hmenu, 0, CMD_ID_FIRST, CMD_ID_LAST,
CMF_DEFAULTONLY))) {
if (hmenu)
{
idCmd = GetMenuDefaultItem(hmenu, MF_BYCOMMAND, 0);
if (idCmd)
{
CMINVOKECOMMANDINFOEX ici = {
SIZEOF(CMINVOKECOMMANDINFOEX),
CMIC_MASK_ASYNCOK,
v_hwndTray,
(LPSTR)MAKEINTRESOURCE(idCmd - CMD_ID_FIRST),
NULL, NULL,
SW_NORMAL,
};
pcm->lpVtbl->InvokeCommand(pcm,
(LPCMINVOKECOMMANDINFO)&ici);
fRes = TRUE;
}
DestroyMenu(hmenu);
}
}
}
// Release our use of the context menu
pcm->lpVtbl->Release(pcm);
}
}
psf->lpVtbl->Release(psf);
} else {
SHGetPathFromIDList(pidlFolder, szPath);
ShellMessageBox(hinstCabinet, hwnd, MAKEINTRESOURCE(IDS_CANTFINDSPECIALDIR),
NULL, MB_ICONEXCLAMATION, szPath);
}
}
return fRes;
}
//---------------------------------------------------------------------------
LRESULT FileMenu_HandleCommand(HWND hwnd, WPARAM wparam)
{
LPITEMIDLIST pidlFolder = NULL;
LPITEMIDLIST pidlItem = NULL;
BOOL fRes;
HMENU hmenu;
DECLAREWAITCURSOR;
SetWaitCursor();
hmenu = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, wparam);
FileMenu_GetLastSelectedItemPidls(hmenu, &pidlFolder, &pidlItem);
fRes = _ExecItemByPidls(hwnd, pidlFolder, pidlItem);
ILFree(pidlFolder);
ILFree(pidlItem);
ResetWaitCursor();
#ifdef DEBUG
if (!fRes)
{
DebugMsg(DM_ERROR, TEXT("t.fm_hc: Can't exec command."));
}
#endif
return fRes;
}
//---------------------------------------------------------------------------
LRESULT Tray_HandleDestroy(PFileCabinet pfc)
{
HMENU hmenuSub;
MINIMIZEDMETRICS mm;
mm.cbSize = SIZEOF(mm);
SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, SIZEOF(mm), &mm, FALSE);
mm.iArrange &= ~ARW_HIDE;
SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, SIZEOF(mm), &mm, FALSE);
PrintNotify_Exit();
CStartDropTarget_Revoke(pfc);
// HotkeyList_Save();
if (g_ts.pPositions)
DestroySavedWindowPositions();
if (g_ts.hBIOS!=INVALID_HANDLE_VALUE)
CloseHandle(g_ts.hBIOS);
if (g_ts.hVPowerD!=INVALID_HANDLE_VALUE)
CloseHandle(g_ts.hVPowerD);
{
// Cleanup notify handlers.
UnregisterNotify(g_ts.uProgNotify);
UnregisterNotify(g_ts.uFavNotify);
UnregisterNotify(g_ts.uRecentNotify);
UnregisterNotify(g_ts.uDesktopNotify);
UnregisterNotify(g_ts.uCommonDesktopNotify);
UnregisterNotify(g_ts.uCommonProgNotify);
UnregisterNotify(g_ts.uCommonFavNotify);
// Cleanup programs
hmenuSub = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_PROGRAMS);
if (hmenuSub)
{
FileMenu_DeleteAllItems(hmenuSub);
}
else
{
DebugMsg(DM_TRACE, TEXT("c.t_hd: Can't find Programs menu."));
}
// Cleanup recent docs.
hmenuSub = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_RECENT);
if (hmenuSub)
{
FileMenu_DeleteAllItems(hmenuSub);
}
else
{
DebugMsg(DM_TRACE, TEXT("c.t_hd: Can't find RecentDocs."));
}
}
if (pfc) {
if (pfc->pcmFind)
pfc->pcmFind->lpVtbl->Release(pfc->pcmFind);
DeskTray_DestroyShellView(pfc);
}
if (g_ts.hwndTrayTips) {
DestroyWindow(g_ts.hwndTrayTips);
g_ts.hwndTrayTips = NULL;
}
// REVIEW
PostQuitMessage(0);
if (g_ts.hbmpStartBkg)
DeleteBitmap(g_ts.hbmpStartBkg);
v_hwndTray = NULL;
g_ts.hwndStart = NULL;
return 0;
}
void InvalidateRebuildMenu(WORD wID, HMENU hmenuSub)
{
if (hmenuSub)
{
PFileCabinet pfc = g_pfcTray;
if (pfc->bMainMenuInit) {
// HACK Don't destroy the menu if we're showing it - just nuke the whole thing.
SetTimer(v_hwndTray, IDT_REBUILDMENU, 1000, NULL);
} else {
StartMenu_ControlBkgThread(SMCT_STOP);
FileMenu_Invalidate(hmenuSub);
// set a timer to fill this in later...
// do it later in case of multiple changes and also
// because we want to return immediately and do the
// updates without blocking someone else (or the filesys notification)
// NB Use a lomger timeout if we're doing DDE. ExcelNT has a 5
// second timeout on DDE. If we're doing updates then sometimes we
// don't get back in time.
if (g_hwndDde)
SetTimer(v_hwndTray, wID, 10 * 1000, NULL);
else
SetTimer(v_hwndTray, wID, 3 * 1000, NULL);
}
}
}
void TrayProgramsInvalidateMenu(HMENU hmenuSub, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlPrograms)
{
LPITEMIDLIST pidlChild;
HMENU hmenu;
pidlChild = ILFindChild(pidlPrograms, pidl);
if (pidlChild) {
pidlChild = ILClone(pidlChild);
ILRemoveLastID(pidlChild);
hmenu = FileMenu_FindSubMenuByPidl(hmenuSub, pidlChild);
// doing this will catch the case of "everything else"
// and just nuke the whole menu tree if we couldn't find a menu
// for this pidl
if (!hmenu)
hmenu = hmenuSub;
InvalidateRebuildMenu(IDM_PROGRAMS, hmenu);
ILFree(pidlChild);
}
}
void TrayRevertMenuToInitial(HMENU hmenuSub, UINT idMenu, UINT idTimer)
{
ULONG *puNotify = (idMenu == IDM_PROGRAMSINIT ? &g_ts.uProgNotify : &g_ts.uRecentNotify);
if (idMenu == IDM_PROGRAMSINIT)
puNotify = &g_ts.uProgNotify;
else
puNotify = &g_ts.uRecentNotify;
UnregisterNotify(*puNotify);
*puNotify = 0;
FileMenu_DeleteAllItems(hmenuSub);
InsertMenu(hmenuSub, 0, MF_BYPOSITION, idMenu, c_szNULL);
SetTimer(v_hwndTray, idTimer, 10 * 1000, NULL);
}
void TrayUpdateProgramsMenu(LPARAM lEvent, LPCITEMIDLIST *ppidl, BOOL bCommon)
{
LPITEMIDLIST pidlPrograms;
HMENU hmenuSub;
DebugMsg(DM_IANELHK, TEXT("c.t_hfsn: Cleaning up Programs or Recent menu."));
hmenuSub = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_PROGRAMS);
if (hmenuSub) {
pidlPrograms = SHCloneSpecialIDList(NULL,
bCommon ? CSIDL_COMMON_PROGRAMS : CSIDL_PROGRAMS,
FALSE);
if (!pidlPrograms)
return;
if (ILIsEqual(pidlPrograms, ppidl[0]) ||
((lEvent & SHCNE_RENAMEFOLDER) && ILIsEqual(pidlPrograms, ppidl[1]))) {
DebugMsg(DM_TRACE, TEXT("Deleting all programs menus"));
TrayRevertMenuToInitial(hmenuSub, IDM_PROGRAMSINIT, IDM_PROGRAMS);
} else {
TrayProgramsInvalidateMenu(hmenuSub, ppidl[0], pidlPrograms);
if (lEvent & (SHCNE_RENAMEITEM | SHCNE_RENAMEFOLDER)) {
TrayProgramsInvalidateMenu(hmenuSub, ppidl[1], pidlPrograms);
}
}
ILFree(pidlPrograms);
}
}
//---------------------------------------------------------------------------
LRESULT Tray_HandleFSNotify(UINT uMsg, PFileCabinet pfc, LPITEMIDLIST * ppidl, LPARAM lEvent)
{
HMENU hmenuSub;
WORD wID = 0;
DebugMsg(DM_TRACE, TEXT("Tray_HandleFSNotify : enter!!"));
// Roach the start menu if the icon cache is getting re-ordered.
if ((lEvent == SHCNE_UPDATEIMAGE) && ppidl && ppidl[0])
{
if (*(int UNALIGNED *)((BYTE *)ppidl[0] + 2) == -1)
{
DebugMsg(DM_TRACE, TEXT("c.t_hfsn: Update image of -1."));
g_ts.fFavInvalid = TRUE;
SetTimer(v_hwndTray, IDT_FAVOURITE, 1000, NULL);
}
return 1;
}
switch (uMsg) {
case WMTRAY_PRINTCHANGE:
PrintNotify_HandleFSNotify(pfc->hwndMain, ppidl, lEvent);
break;
case WMTRAY_FAVCHANGE:
case WMTRAY_COMMONFAVCHANGE:
{
LPITEMIDLIST pidlProgs;
pidlProgs = SHCloneSpecialIDList(NULL,
((uMsg == WMTRAY_FAVCHANGE) ? CSIDL_PROGRAMS : CSIDL_COMMON_PROGRAMS),
TRUE);
// If the Programs folder is under the StartMenu (usual case) then we'll
// get a FAVCHANGE everytime something in the Programs folder changes.
// FAVCHANGES are kinda piggy so filter out spurious ones here.
if (pidlProgs && ppidl)
{
if ((ppidl[0] && !ILIsParent(pidlProgs, ppidl[0], FALSE))
|| (ppidl[1] && !ILIsParent(pidlProgs, ppidl[1], FALSE)))
{
DebugMsg(DM_TRACE, TEXT("WMTRAY_FAVCHANGE"));
g_ts.fFavInvalid = TRUE;
// the timer is to collect up the changes...
SetTimer(v_hwndTray, IDT_FAVOURITE, 1000, NULL);
}
ILFree(pidlProgs);
}
break;
}
case WMTRAY_RECCHANGE:
hmenuSub = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, IDM_RECENT);
if (hmenuSub) {
TrayRevertMenuToInitial(hmenuSub, IDM_RECENTINIT, IDM_RECENT);
}
break;
case WMTRAY_PROGCHANGE:
TrayUpdateProgramsMenu(lEvent, ppidl, FALSE);
break;
case WMTRAY_COMMONPROGCHANGE:
TrayUpdateProgramsMenu(lEvent, ppidl, TRUE);
break;
case WMTRAY_DESKTOPCHANGE:
DebugMsg(DM_TRACE, TEXT("c.t_hfs: Desktop change."));
SetTimer(v_hwndTray, IDT_DESKTOP, 2000, NULL);
break;
default:
Assert(0);
break;
}
return 1;
}
void Tray_ActAsSwitcher(PFileCabinet pfc)
{
if (g_ts.uModalMode) {
if (g_ts.uModalMode != MM_SHUTDOWN) {
SwitchToThisWindow(GetLastActivePopup(pfc->hwndMain), TRUE);
}
MessageBeep(0);
} else {
HWND hwndForeground;
#ifdef DEBUG
static int s_iRecurse = 0;
s_iRecurse++;
Assert(s_iRecurse < 100);
DebugMsg(DM_TRACE, TEXT("s_iRecurse = %d"), s_iRecurse);
#endif
hwndForeground = GetForegroundWindow();
// only do the button once we're the foreground dude.
if ((hwndForeground == v_hwndTray) && (GetActiveWindow() == v_hwndTray)) {
// This pushes the start button and causes the start menu to popup.
SendMessage(GetDlgItem(v_hwndTray, IDC_START), BM_SETSTATE, TRUE, 0);
#ifdef DEBUG
s_iRecurse = 0;
#endif
} else {
// until then, try to come forward.
Tray_HandleFullScreenApp(FALSE, NULL);
if (hwndForeground == v_hwndDesktop) {
SetFocus(g_ts.hwndStart);
if (GetFocus() != g_ts.hwndStart)
return;
}
SwitchToThisWindow(pfc->hwndMain, TRUE);
SetForegroundWindow(v_hwndTray);
Sleep(20); // give some time for other async activation messages to get posted
PostMessage(v_hwndTray, TM_ACTASTASKSW, 0, 0);
}
}
}
void RebuildMenu(WORD wID)
{
HMENU hmenuSub;
hmenuSub = Menu_FindSubMenuByFirstID(g_ts.hmenuStart, wID);
InvalidateRebuildMenu(wID, hmenuSub);
}
void Tray_SetFSMenuFilter(UINT fFilter)
{
if (fFilter != g_CabState.fMenuEnumFilter) {
g_CabState.fMenuEnumFilter = fFilter;
RebuildMenu(IDM_PROGRAMS);
}
}
//----------------------------------------------------------------------------
void Tray_OnWinIniChange(PFileCabinet pfc, HWND hWnd, WPARAM wParam, LPARAM 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, c_szMetrics) == 0))))
{
#ifdef DEBUG
if (wParam == SPI_SETNONCLIENTMETRICS)
DebugMsg(DM_TRACE, TEXT("c.t_owic: Non-client metrics (probably) changed."));
else
DebugMsg(DM_TRACE, TEXT("c.t_owic: Window metrics changed."));
#endif
Cabinet_InitGlobalMetrics(wParam, (LPTSTR)lParam);
#ifdef DELAYWININICHANGE
SetTimer(pfc->hwndMain, IDT_DELAYWININICHANGE, 2*1000, NULL);
#else
Tray_OnDelayWinIniChange(pfc);
#endif
}
// Handle old extensions.
if (!lParam || (lParam && (lstrcmpi((LPTSTR)lParam, c_szExtensions) == 0)))
{
DebugMsg(DM_TRACE, TEXT("t_owic: Extensions section change."));
CheckWinIniForAssocs();
}
// Get the printer thread to re-do the icon.
if (g_ts.htPrinterPoll && g_ts.idPrinterPoll)
{
PostThreadMessage(g_ts.idPrinterPoll, WM_USER+SHCNE_UPDATEITEM, 0, 0);
}
}
//---------------------------------------------------------------------------
HWND HotkeyList_HotkeyInUse(WORD wHK)
{
HWND hwnd;
LRESULT 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);
}
// else
// {
// GetWindowText(hwnd, sz, ARRAYSIZE(sz));
// DebugMsg(DM_IANELHK, "c.hkl_hiu: %s (%x) has no kotkey assigned.", sz, hwnd);
// }
#endif
hwnd = GetWindow(hwnd, GW_HWNDNEXT);
}
return NULL;
}
//---------------------------------------------------------------------------
void HotkeyList_HandleHotkey(PFileCabinet pfc, int nID)
{
PHOTKEYITEM phki;
BOOL fRes;
HWND hwnd;
DebugMsg(DM_TRACE, TEXT("c.hkl_hh: Handling hotkey (%d)."), nID);
// Find it in the list.
Assert(g_ts.hdsaHKI);
phki = DSA_GetItemPtr(g_ts.hdsaHKI, nID);
if (phki && phki->wGHotkey)
{
DebugMsg(DM_TRACE, TEXT("c.hkl_hh: Hotkey listed."));
// Are global hotkeys enabled?
if (!g_ts.fGlobalHotkeyDisable)
{
// Yep.
hwnd = HotkeyList_HotkeyInUse(phki->wGHotkey);
// Make sure this hotkey isn't already in use by someone.
if (hwnd)
{
DebugMsg(DM_TRACE, TEXT("c.hkl_hh: Hotkey is already in use."));
// Activate it.
SwitchToThisWindow(GetLastActivePopup(hwnd), TRUE);
}
else
{
DECLAREWAITCURSOR;
// Exec the item.
SetWaitCursor();
DebugMsg(DM_TRACE, TEXT("c.hkl_hh: Hotkey is not in use, execing item."));
Assert(phki->pidlFolder && phki->pidlItem);
fRes = _ExecItemByPidls(pfc->hwndMain, 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."));
}
}
//---------------------------------------------------------------------------
LRESULT Tray_UnregisterHotkey(HWND hwnd, int i)
{
DebugMsg(DM_TRACE, TEXT("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 Tray_ShortcutRegisterHotkey(HWND hwnd, WORD wHotkey, ATOM atom)
{
int i;
LPITEMIDLIST pidl;
TCHAR szPath[MAX_PATH];
Assert(atom);
if (GlobalGetAtomName(atom, szPath, MAX_PATH))
{
DebugMsg(DM_TRACE, TEXT("c.t_srh: Hotkey %d for %s"), wHotkey, szPath);
pidl = ILCreateFromPath(szPath);
if (pidl)
{
i = HotkeyList_AddCached(MapHotkeyToGlobalHotkey(wHotkey), pidl);
if (i != -1)
{
Tray_RegisterHotkey(v_hwndTray, i);
}
}
return TRUE;
}
else
{
return FALSE;
}
}
//---------------------------------------------------------------------------
// Remove hotkey from shell's list.
LRESULT Tray_ShortcutUnregisterHotkey(HWND hwnd, WORD wHotkey)
{
int i;
// DebugMsg(DM_TRACE, "c.t_suh: Hotkey %d", wHotkey);
i = HotkeyList_Remove(wHotkey);
if (i == -1)
i = HotkeyList_RemoveCached(MapHotkeyToGlobalHotkey(wHotkey));
if (i != -1)
Tray_UnregisterHotkey(hwnd, i);
return TRUE;
}
//---------------------------------------------------------------------------
LRESULT Tray_RegisterHotkey(HWND hwnd, int i)
{
PHOTKEYITEM phki;
WORD wGHotkey;
int iCached;
DebugMsg(DM_TRACE, TEXT("c.t_rh: Registering hotkey (%d)."), i);
phki = DSA_GetItemPtr(g_ts.hdsaHKI, i);
Assert(phki);
if (phki)
{
wGHotkey = phki->wGHotkey;
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.
iCached = HotkeyList_RemoveCached(wGHotkey);
Assert(iCached != i);
if (iCached != -1)
{
// Free up the hotkey for us.
Tray_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;
}
void AppBarGetTaskBarPos(PTRAYAPPBARDATA ptabd)
{
LPRECT lprc;
lprc = (LPRECT)SHLockShared(ptabd->hSharedRect, ptabd->dwProcId);
if (lprc)
{
*lprc = g_ts.arStuckRects[g_ts.uStuckPlace];
SHUnlockShared(lprc);
}
}
void NukeAppBar(int i)
{
Free(DPA_GetPtr(g_ts.hdpaAppBars, i));
DPA_DeletePtr(g_ts.hdpaAppBars, i);
}
void AppBarRemove(PTRAYAPPBARDATA ptabd)
{
if (g_ts.hdpaAppBars) {
int i = DPA_GetPtrCount(g_ts.hdpaAppBars);
while (i--) {
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(g_ts.hdpaAppBars, i);
if (ptabd->abd.hWnd == pab->hwnd) {
NukeAppBar(i);
}
}
}
}
PAPPBAR FindAppBar(HWND hwnd)
{
int i;
if (g_ts.hdpaAppBars) {
i = DPA_GetPtrCount(g_ts.hdpaAppBars);
while (i--) {
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(g_ts.hdpaAppBars, i);
if (hwnd == pab->hwnd) {
return pab;
}
}
}
return NULL;
}
void AppBarNotifyAll(UINT uMsg, HWND hwndExclude, LPARAM lParam)
{
if (g_ts.hdpaAppBars) {
int i = DPA_GetPtrCount(g_ts.hdpaAppBars);
while (i--) {
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(g_ts.hdpaAppBars, i);
if (hwndExclude != pab->hwnd) {
if (!IsWindow(pab->hwnd))
NukeAppBar(i);
SendMessage(pab->hwnd, pab->uCallbackMessage, uMsg, lParam);
}
}
}
}
BOOL AppBarNew(PTRAYAPPBARDATA ptabd)
{
PAPPBAR pab;
if (!g_ts.hdpaAppBars) {
g_ts.hdpaAppBars = DPA_Create(4);
if (!g_ts.hdpaAppBars)
return FALSE;
} else if (FindAppBar(ptabd->abd.hWnd)) {
// already have this hwnd
return FALSE;
}
pab = (PAPPBAR)LocalAlloc(LPTR, SIZEOF(APPBAR));
if (!pab)
return FALSE;
pab->hwnd = ptabd->abd.hWnd;
pab->uCallbackMessage = ptabd->abd.uCallbackMessage;
pab->uEdge = (UINT)-1;
return ( DPA_InsertPtr(g_ts.hdpaAppBars, 0x7fff, pab) != -1);
}
UINT AppBarGetState()
{
return (g_ts.uAutoHide ? ABS_AUTOHIDE : 0) |
(g_ts.fAlwaysOnTop ? ABS_ALWAYSONTOP : 0);
}
BOOL 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 AppBarQueryPos(PTRAYAPPBARDATA ptabd)
{
int i;
PAPPBAR pabReq = FindAppBar(ptabd->abd.hWnd);
if (pabReq) {
LPRECT lprc;
lprc = (LPRECT)SHLockShared(ptabd->hSharedRect, ptabd->dwProcId);
if (lprc)
{
*lprc = ptabd->abd.rc;
// always subtract off the tray
if (!g_ts.uAutoHide) {
APPBAR ab;
ab.uEdge = g_ts.uStuckPlace;
ab.rc = g_ts.arStuckRects[g_ts.uStuckPlace];
AppBarSubtractRect(&ab, lprc);
}
i = DPA_GetPtrCount(g_ts.hdpaAppBars);
while (i--) {
PAPPBAR pab = (PAPPBAR)DPA_GetPtr(g_ts.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.
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))
)
{
AppBarSubtractRect(pab, lprc);
}
}
SHUnlockShared(lprc);
}
}
}
void AppBarSetPos(PTRAYAPPBARDATA ptabd)
{
PAPPBAR pab = FindAppBar(ptabd->abd.hWnd);
if (pab) {
LPRECT lprc;
AppBarQueryPos(ptabd);
lprc = (LPRECT)SHLockShared(ptabd->hSharedRect, ptabd->dwProcId);
if (lprc)
{
if (!EqualRect(&pab->rc, lprc)) {
pab->rc = *lprc;
pab->uEdge = ptabd->abd.uEdge;
PostMessage(v_hwndTray, TM_RELAYPOSCHANGED, (WPARAM)ptabd->abd.hWnd, 0);
StuckSizeChange();
SendMessage(v_hwndDesktop, DTM_SIZEDESKTOP, 0, 0);
}
SHUnlockShared(lprc);
}
}
}
HWND AppBarGetAutoHideBar(UINT uEdge)
{
if (uEdge >= ABE_MAX)
return FALSE;
else {
HWND hwndAutoHide = g_hwndAutoHide[uEdge];
if (!IsWindow(hwndAutoHide)) {
g_hwndAutoHide[uEdge] = NULL;
}
return g_hwndAutoHide[uEdge];
}
}
BOOL IAppBarSetAutoHideBar(HWND hwnd, BOOL fSet, UINT uEdge)
{
HWND hwndAutoHide = g_hwndAutoHide[uEdge];
if (!IsWindow(hwndAutoHide)) {
g_hwndAutoHide[uEdge] = NULL;
}
// register
if (fSet) {
if (!g_hwndAutoHide[uEdge]) {
g_hwndAutoHide[uEdge] = hwnd;
}
return g_hwndAutoHide[uEdge] == hwnd;
} else {
// unregister
if (g_hwndAutoHide[uEdge] == hwnd) {
g_hwndAutoHide[uEdge] = NULL;
}
return TRUE;
}
}
BOOL AppBarSetAutoHideBar(PTRAYAPPBARDATA ptabd)
{
UINT uEdge = ptabd->abd.uEdge;
if (uEdge >= ABE_MAX)
return FALSE;
else {
return IAppBarSetAutoHideBar(ptabd->abd.hWnd, ptabd->abd.lParam, uEdge);
}
}
void IAppBarActivationChange(HWND hWnd, UINT uEdge)
{
HWND hwndAutoHide = AppBarGetAutoHideBar(uEdge);
if (hwndAutoHide &&
(hwndAutoHide != hWnd)) {
// this needs to be done on a postmessage so that USER will have a chance to
PostMessage(v_hwndTray, TM_BRINGTOTOP, (WPARAM)hwndAutoHide, uEdge);
}
}
void AppBarActivationChange(PTRAYAPPBARDATA ptabd)
{
PAPPBAR pab = FindAppBar(ptabd->abd.hWnd);
if (pab) {
IAppBarActivationChange(ptabd->abd.hWnd, pab->uEdge);
}
}
UINT TrayAppBarMessage(PFileCabinet pfc, PCOPYDATASTRUCT pcds)
{
PTRAYAPPBARDATA ptabd = (PTRAYAPPBARDATA)pcds->lpData;
Assert(pcds->cbData == SIZEOF(TRAYAPPBARDATA));
Assert(ptabd->abd.cbSize == SIZEOF(APPBARDATA));
switch (ptabd->dwMessage) {
case ABM_NEW:
return AppBarNew(ptabd);
case ABM_REMOVE:
AppBarRemove(ptabd);
AppBarNotifyAll(ABN_POSCHANGED, NULL, 0);
StuckSizeChange();
break;
case ABM_QUERYPOS:
AppBarQueryPos(ptabd);
break;
case ABM_SETPOS:
AppBarSetPos(ptabd);
break;
case ABM_GETSTATE:
return AppBarGetState();
case ABM_GETTASKBARPOS:
AppBarGetTaskBarPos(ptabd);
break;
case ABM_WINDOWPOSCHANGED:
case ABM_ACTIVATE:
AppBarActivationChange(ptabd);
break;
case ABM_GETAUTOHIDEBAR:
return (UINT)AppBarGetAutoHideBar(ptabd->abd.uEdge);
case ABM_SETAUTOHIDEBAR:
return AppBarSetAutoHideBar(ptabd);
default:
return FALSE;
}
return TRUE;
}
UINT TrayLoadInProc(PFileCabinet pfc, PCOPYDATASTRUCT pcds)
{
LPUNKNOWN punk;
HRESULT hres = SHCoCreateInstance(NULL, (CLSID *)pcds->lpData, NULL, &IID_IUnknown, &punk);
if (SUCCEEDED(hres))
{
punk->lpVtbl->Release(punk);
}
return (UINT)hres;
}
//---------------------------------------------------------------------------
// Allow the trays global hotkeys to be disabled for a while.
LRESULT Tray_SetHotkeyEnable(HWND hWnd, BOOL fEnable)
{
g_ts.fGlobalHotkeyDisable = (fEnable ? FALSE : TRUE);
return TRUE;
}
BOOL IsPosInHwnd(LPARAM lParam, HWND hwnd)
{
RECT r1;
POINT pt;
pt.x = LOWORD(lParam);
pt.y = HIWORD(lParam);
GetWindowRect(hwnd, &r1);
return PtInRect(&r1, pt);
}
void Tray_HandleWindowPosChanging(PFileCabinet pfc, LPWINDOWPOS lpwp)
{
//DebugMsg(DM_TRACE, "Tray -- WM_WINDOWPOSCHANGING %x, %d %d %d %d",
//lpwp->flags, lpwp->x, lpwp->y, lpwp->cx, lpwp->cy);
//the user could have hit esc, in which case, what we had
// in our g_ts.uMoveStuckPlace is bogus
Tray_WhichStuckRect(lpwp->x, lpwp->y, lpwp->x + lpwp->cx, lpwp->y + lpwp->cy);
if (g_ts.uMoveStuckPlace != (UINT)-1) {
if (pfc->hwndView)
Tray_HandleSizing(pfc, 0, &g_ts.arStuckRects[g_ts.uMoveStuckPlace], g_ts.uMoveStuckPlace);
Tray_DoneMoving(lpwp);
g_ts.uMoveStuckPlace = (UINT)-1;
} else if (!g_ts.fSysSizing && !g_ts.fSelfSizing) {
// if someone's trying to force us to move
lpwp->flags |= (SWP_NOMOVE | SWP_NOSIZE);
}
}
//---------------------------------------------------------------------------
LRESULT CALLBACK TrayWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT r1;
POINT pt;
DWORD dw;
PFileCabinet pfc = g_pfcTray;
switch (uMsg) {
case WMTRAY_PROGCHANGE:
case WMTRAY_RECCHANGE:
case WMTRAY_FAVCHANGE:
case WMTRAY_PRINTCHANGE:
case WMTRAY_DESKTOPCHANGE:
case WMTRAY_COMMONPROGCHANGE:
case WMTRAY_COMMONFAVCHANGE:
{
LPSHChangeNotificationLock pshcnl;
LPITEMIDLIST *ppidl;
LONG lEvent;
LRESULT lResult = 0;
pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
if (pshcnl)
{
lResult = Tray_HandleFSNotify(uMsg, pfc, ppidl, lEvent);
SHChangeNotification_Unlock(pshcnl);
}
return lResult;
}
case WMTRAY_PRINTICONNOTIFY:
PrintNotify_IconNotify(hWnd, (UINT)lParam);
break;
case WMTRAY_REGISTERHOTKEY:
return Tray_RegisterHotkey(hWnd, wParam);
case WMTRAY_UNREGISTERHOTKEY:
return Tray_UnregisterHotkey(hWnd, wParam);
case WMTRAY_SCREGISTERHOTKEY:
return Tray_ShortcutRegisterHotkey(hWnd, (WORD)wParam, (ATOM)lParam);
case WMTRAY_SCUNREGISTERHOTKEY:
return Tray_ShortcutUnregisterHotkey(hWnd, (WORD)wParam);
case WMTRAY_SETHOTKEYENABLE:
return Tray_SetHotkeyEnable(hWnd, (BOOL)wParam);
case WM_MENUCHAR:
return FileMenu_HandleMenuChar((HMENU)lParam, (TCHAR)LOWORD(wParam));
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:
dw = TrayNotify(g_ts.hwndNotify, (HWND)wParam, (PCOPYDATASTRUCT)lParam);
Tray_SizeWindows();
return(dw);
case TCDM_APPBAR:
return TrayAppBarMessage(pfc, (PCOPYDATASTRUCT)lParam);
case TCDM_LOADINPROC:
return TrayLoadInProc(pfc, (PCOPYDATASTRUCT)lParam);
}
}
return FALSE;
case WM_NCLBUTTONDBLCLK:
if (IsPosInHwnd(lParam, g_ts.hwndNotify)) {
TrayCommand(pfc, IDM_SETTIME);
}
break;
case WM_NCMOUSEMOVE:
if (IsPosInHwnd(lParam, g_ts.hwndNotify)) {
MSG msg;
msg.lParam = lParam;
msg.wParam = wParam;
msg.message = WM_NCMOUSEMOVE;
msg.hwnd = hWnd;
SendMessage(g_ts.hwndTrayTips, TTM_RELAYEVENT, 0, (LPARAM)(LPMSG)&msg);
}
goto DoDefault;
case WM_CREATE:
Tray_OnCreate(hWnd, (LPCREATESTRUCT)lParam);
break;
case WM_DESTROY:
return Tray_HandleDestroy(pfc);
case WM_ENDSESSION:
// save our settings if someone else is shutting things down
if (wParam) {
DebugMsg(DM_TRACE, TEXT("Tray WM_ENDSESSION"));
_SaveTrayAndDesktop();
ShowWindow(v_hwndTray, SW_HIDE);
ShowWindow(v_hwndDesktop, SW_HIDE);
RegisterShellHook(pfc->hwndView, FALSE);
}
break;
//
// always repaint the screen when the machine wakes up from
// a suspend. NOTE we dont need this for a standby suspend.
//
// a critical resume does not generate a WM_POWERBROADCAST
// to windows for some reason, but it does generate a old
// WM_POWER message.
//
case WM_POWER:
if (wParam != PWR_CRITICALRESUME)
goto DoDefault;
#ifndef WINNT // BUGBUG - Fix this when NT gets APM
wParam = PBT_APMRESUMECRITICAL;
#endif
// fall through to WM_POWERBROADCAST
case WM_POWERBROADCAST:
#ifndef WINNT // BUGBUG - Fix this when NT gets APM
switch (wParam)
{
case PBT_APMRESUMECRITICAL:
case PBT_APMRESUMESUSPEND:
ChangeDisplaySettings(NULL, CDS_RESET);
break;
}
#endif
goto DoDefault;
case WM_DEVICECHANGE:
if (wParam == DBT_CONFIGCHANGED)
{
UpdateDockingFlags();
g_ts.DockedState = GetDockedState();
if (IsEjectAllowed())
{
HandleDisplayChange(0,0,TRUE);
// Rebuild the entire start menu next chance we get.
g_ts.fFavInvalid = TRUE;
SetTimer(v_hwndTray, IDT_FAVOURITE, 2*1000, NULL);
}
}
else if (wParam == DBT_QUERYCHANGECONFIG)
{
if (IsEjectAllowed() && !IsDisplayChangeSafe())
{
if (ShellMessageBox(hinstCabinet, hWnd,
MAKEINTRESOURCE(IDS_DISPLAY_WARN),
MAKEINTRESOURCE(IDS_WINDOWS),
MB_ICONEXCLAMATION|MB_YESNO|MB_DEFBUTTON2) == IDNO)
{
return BROADCAST_QUERY_DENY;
}
}
//
// drop down to 640x480 (or the lowest res for all configs)
// before the config change. this makes sure we dont screw
// up some laptop display panels.
//
dw = GetMinDisplayRes();
HandleDisplayChange(LOWORD(dw), HIWORD(dw), FALSE);
}
else if (wParam == DBT_MONITORCHANGE)
{
//
// handle monitor change
//
HandleDisplayChange(LOWORD(lParam),HIWORD(lParam),TRUE);
}
else if (wParam == DBT_CONFIGCHANGECANCELED)
{
//
// if the config change was canceled go back
//
HandleDisplayChange(0,0,FALSE);
}
goto DoDefault;
case WM_NOTIFY:
switch (((NMHDR *)lParam)->code) {
case SEN_DDEEXECUTE:
return (DDEHandleViewFolderNotify(pfc, (LPNMVIEWFOLDER)lParam));
case NM_STARTWAIT:
case NM_ENDWAIT:
Cabinet_OnWaitCursorNotify(pfc, (NMHDR *)lParam);
SendMessage(v_hwndDesktop, uMsg, wParam, lParam); // forward it along
break;
#define lpttt ((LPTOOLTIPTEXT)lParam)
case TTN_NEEDTEXT:
GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, NULL, NULL, lpttt->szText, ARRAYSIZE(lpttt->szText));
return TRUE;
case TTN_SHOW:
SetWindowPos(g_ts.hwndTrayTips,
HWND_TOP,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
break;
}
break;
case WM_CLOSE:
DoExitWindows(hWnd);
return 0;
case WM_NCHITTEST:
GetClientRect(hWnd, &r1);
MapWindowPoints(hWnd, NULL, (LPPOINT)&r1, 2);
pt.x = LOWORD(lParam);
pt.y = HIWORD(lParam);
TraySetUnhideTimer(pt.x, pt.y);
// allow dragging if mouse is in client area of v_hwndTray
if (PtInRect(&r1, pt)) {
return HTCAPTION;
}
else {
switch (g_ts.uStuckPlace) {
case STICK_LEFT:
dw = ((pt.x > r1.right) ? HTRIGHT : HTBORDER);
break;
case STICK_TOP:
dw = ((pt.y > r1.bottom) ? HTBOTTOM : HTBORDER);
break;
case STICK_RIGHT:
dw = ((pt.x < r1.left) ? HTLEFT : HTBORDER);
break;
case STICK_BOTTOM:
default:
dw = ((pt.y < r1.top) ? HTTOP : HTBORDER);
break;
}
return dw;
}
break;
case WM_WINDOWPOSCHANGING:
Tray_HandleWindowPosChanging(pfc, (LPWINDOWPOS)lParam);
break;
// BUGBUG this needs to be changed with WM_MOVING
// trap the start and end of a sizing/moving operation and
// make sure that we don't actually do anything until done.
// this avoids some crazy resizing with full window dragging.
case WM_ENTERSIZEMOVE:
//DebugMsg(DM_TRACE, "Tray -- WM_ENTERSIZEMOVE");
g_ts.fSysSizing = TRUE;
break;
case WM_EXITSIZEMOVE:
//DebugMsg(DM_TRACE, "Tray -- WM_EXITSIZEMOVE");
g_ts.fSysSizing = FALSE;
PostMessage(hWnd, WM_SIZE, 0, 0L);
break;
case WM_MOVING:
//DebugMsg(DM_TRACE, "Tray -- WM_MOVING");
Tray_HandleMoving((LPRECT)lParam);
Tray_HandleSizing(pfc, wParam, (LPRECT)lParam, g_ts.uMoveStuckPlace);
break;
case WM_ENTERMENULOOP:
// DebugMsg(DM_TRACE, "c.twp: Enter menu loop.");
Tray_HandleEnterMenuLoop();
Cabinet_ForwardViewMsg(pfc, uMsg, wParam, lParam);
break;
case WM_EXITMENULOOP:
// DebugMsg(DM_TRACE, "c.twp: Exit menu loop.");
Tray_HandleExitMenuLoop();
Cabinet_ForwardViewMsg(pfc, uMsg, wParam, lParam);
break;
case WM_TIMER:
Tray_HandleTimer(pfc, wParam);
break;
case WM_SIZING:
//DebugMsg(DM_TRACE, "Tray -- WM_SIZING");
Tray_HandleSizing(pfc, wParam, (LPRECT)lParam, g_ts.uStuckPlace);
break;
case WM_SIZE:
if (pfc && ((GetWindowLong(hWnd, GWL_STYLE)) & WS_MINIMIZE)) {
ShowWindow(hWnd, SW_RESTORE);
}
if (!g_ts.fSysSizing || g_fDragFullWindows)
{
Tray_SizeWindows();
}
if (!g_ts.fSysSizing && !g_ts.fSelfSizing) {
// we get a couple size messages while being created.
// our window rect means nothing then, so punt out
if (IsWindowVisible(hWnd)) {
StuckSizeChange();
AppBarNotifyAll(ABN_POSCHANGED, NULL, 0);
}
}
break;
case WM_DISPLAYCHANGE:
Tray_ScreenSizeChange(hWnd);
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:
Cabinet_PropagateMessage(hWnd, uMsg, wParam, lParam);
Tray_OnWinIniChange(pfc, hWnd, wParam, lParam);
break;
case WM_TIMECHANGE:
Cabinet_PropagateMessage(hWnd, uMsg, wParam, lParam);
break;
case WM_SYSCOLORCHANGE:
StartButton_ResetAndSize(pfc);
Cabinet_PropagateMessage(hWnd, uMsg, wParam, lParam);
break;
case WM_MEASUREITEM:
return Tray_HandleMeasureItem(hWnd, (LPMEASUREITEMSTRUCT)lParam);
case WM_DRAWITEM:
return Tray_HandleDrawItem(hWnd, (LPDRAWITEMSTRUCT)lParam);
case WM_INITMENUPOPUP:
// DebugMsg(DM_TRACE, "c.twp: Init menu popup.");
// bugbug, does Tray_HandleInitMenuPopup return anything other than 1?
if (!Tray_HandleInitMenuPopup((HMENU)wParam))
Cabinet_ForwardViewMsg(pfc, uMsg, wParam, lParam);
break;
case WM_SETCURSOR:
if (pfc->iWaitCount) {
//DebugMsg(DM_TRACE,"########### SET WAIT CURSOR WM_SETCURSOR %d", pfc->iWaitCount);
SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
return TRUE;
} else
goto DoDefault;
case WM_SETFOCUS:
if (pfc && pfc->hwndView)
SetFocus(pfc->hwndView);
break;
// this keeps our window from comming to the front on button down
// instead, we activate the window on the up click
case WM_MOUSEACTIVATE:
if (LOWORD(lParam) == HTCLIENT)
return MA_NOACTIVATE;
else
goto DoDefault;
case WM_SYSCHAR:
if (wParam == TEXT(' ')) {
HMENU hmenu;
int idCmd;
SetWindowStyleBit(hWnd, 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);
idCmd = Tray_TrackMenu(pfc, hmenu, FALSE);
if (idCmd)
SendMessage(v_hwndTray, WM_SYSCOMMAND, idCmd, 0L);
}
SetWindowStyleBit(hWnd, WS_SYSMENU, 0L);
}
break;
case WM_SYSCOMMAND:
// if we are sizing, make the full screen accessible
switch (wParam & 0xFFF0) {
case SC_CLOSE:
DoExitWindows(hWnd);
break;
default:
goto DoDefault;
}
break;
case TM_ACTASTASKSW:
Tray_ActAsSwitcher(pfc);
break;
case TM_RELAYPOSCHANGED:
AppBarNotifyAll(ABN_POSCHANGED, (HWND)wParam, lParam);
break;
case TM_BRINGTOTOP:
SetWindowPos((HWND)wParam, HWND_TOP,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
break;
case TM_INVALIDATEREBUILDMENU:
InvalidateRebuildMenu((WORD)wParam, (HMENU)lParam);
break;
case WM_NCRBUTTONUP:
wParam = (WPARAM)pfc->hwndView;
case WM_CONTEXTMENU:
DebugMsg(DM_TRACE, TEXT("TRAY GOT CONTEXT MENU!"));
if (SHRestricted(REST_NOTRAYCONTEXTMENU)) {
break;
}
if (((HWND)wParam) == g_ts.hwndStart)
{
#if 0
/* The following test is bogus, as it stops the start context menu being displayed if
/ the find option is disabled, therefore we no longer perform it, we just display the menu
/ which filters out the options anyway. daviddv 27mar95 */
// put up the context menu for the start menu folder.
if (!SHRestricted(REST_NOFIND) && !SHRestricted(REST_NOSETTASKBAR))
#endif
StartMenuFolder_ContextMenu(pfc, lParam);
} else {
BOOL fIncludeTime;
// if it was done by keyboard or if click was inthe clock, include
// the time
fIncludeTime = (lParam == (DWORD)-1) || IsPosInHwnd(lParam, g_ts.hwndNotify);
Tray_ContextMenu(pfc, lParam, fIncludeTime);
}
break;
case WM_HOTKEY:
HotkeyList_HandleHotkey(pfc, (WORD)wParam);
break;
case WM_COMMAND:
TrayCommand(pfc, GET_WM_COMMAND_ID(wParam, lParam));
break;
case WM_WINDOWPOSCHANGED:
IAppBarActivationChange(hWnd, g_ts.uStuckPlace);
goto DoDefault;
case WM_ACTIVATE:
IAppBarActivationChange(hWnd, g_ts.uStuckPlace);
if (wParam != WA_INACTIVE)
TrayUnhide();
// Fall through
default:
DoDefault:
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
return 0;
}
//----------------------------------------------------------------------------
// Just like shells SHRestricted() only this put up a message if the restricion
// is in effect.
BOOL _Restricted(HWND hwnd, RESTRICTIONS rest)
{
if (SHRestricted(rest))
{
ShellMessageBox(hinstCabinet, hwnd, MAKEINTRESOURCE(IDS_RESTRICTIONS),
MAKEINTRESOURCE(IDS_RESTRICTIONSTITLE), MB_OK|MB_ICONSTOP);
return TRUE;
}
return FALSE;
}
//----------------------------------------------------------------------------
void DoExitWindows(HWND hwnd)
{
if (_Restricted(hwnd, REST_NOCLOSE))
return;
SetFocus(hwnd);
_SaveTrayAndDesktop();
g_ts.uModalMode = MM_SHUTDOWN;
ExitWindowsDialog(hwnd);
g_ts.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);
DebugMsg(DM_TRACE, TEXT("c.dew: Posting quit message for %#08x."), GetCurrentThreadId());
PostMessage(v_hwndDesktop, WM_QUIT, 0, 0);
}
}
#define MAX_FILE_PROP_PAGES 5 // More than enough
BOOL CALLBACK _TrayAddPropSheetPage(HPROPSHEETPAGE hpage, LPARAM lParam)
{
PROPSHEETHEADER * ppsh = (PROPSHEETHEADER *)lParam;
if (ppsh->nPages < MAX_FILE_PROP_PAGES)
{
ppsh->phpage[ppsh->nPages++] = hpage;
return TRUE;
}
return FALSE;
}
void RealTrayProperties(HWND hwndParent, PFileCabinet pfc)
{
HPROPSHEETPAGE ahpage[MAX_FILE_PROP_PAGES];
TCHAR szPath[MAX_PATH];
PROPSHEETHEADER psh;
LoadString(hinstCabinet, IDS_TASKBAR, szPath, ARRAYSIZE(szPath));
psh.dwSize = SIZEOF(psh);
psh.dwFlags = PSH_PROPTITLE;
psh.hInstance = hinstCabinet;
psh.hwndParent = hwndParent;
psh.pszCaption = szPath;
psh.nPages = 0; // incremented in callback
psh.nStartPage = 0;
psh.phpage = ahpage;
CShellTray_AddViewPropertySheetPages(&pfc->sb, 0L, _TrayAddPropSheetPage, (LPARAM)(LPPROPSHEETHEADER)&psh);
// Open the property sheet, only if we have some pages.
if (psh.nPages > 0)
{
//g_ts.uModalMode = MM_OTHER;
PropertySheet(&psh);
//g_ts.uModalMode = 0;
}
}
DWORD WINAPI TrayPropertiesThread(LPVOID lpData)
{
HWND hwnd;
RECT rc;
GetWindowRect(g_ts.hwndStart, &rc);
g_ts.hwndProp = hwnd = CreateWindowEx(WS_EX_TOOLWINDOW, c_szStatic, NULL, 0 ,
rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hinstCabinet, NULL);
if (g_ts.hwndProp) {
// SwitchToThisWindow(hwnd, TRUE);
// SetForegroundWindow(hwnd);
RealTrayProperties(hwnd, (PFileCabinet)lpData);
g_ts.hwndProp = NULL;
DestroyWindow(hwnd);
}
return TRUE;
}
void DoTrayProperties(PFileCabinet pfc)
{
HANDLE ht;
DWORD id;
if (!_Restricted(pfc->hwndMain, REST_NOSETTASKBAR))
{
int i = RUNWAITSECS;
while (g_ts.hwndProp == ((HWND)-1) &&i--) {
// we're in the process of coming up. wait
Sleep(SECOND);
}
// failed! blow it off.
if (g_ts.hwndProp == (HWND)-1)
g_ts.hwndProp = NULL;
if (g_ts.hwndProp)
{
// there's a window out there... activate it
SwitchToThisWindow(GetLastActivePopup(g_ts.hwndProp), TRUE);
} else {
g_ts.hwndProp = (HWND)-1;
ht = CreateThread(NULL, 0, TrayPropertiesThread, (LPVOID)pfc, 0, &id);
if (ht) {
CloseHandle(ht);
} else {
g_ts.hwndProp = 0;
}
}
}
}
void ShowFolder(HWND hwnd, WPARAM wparam, UINT uFlags)
{
LPITEMIDLIST pidl = NULL;
if (_Restricted(hwnd, REST_NOSETFOLDERS))
return;
switch(wparam)
{
case IDM_CONTROLS:
pidl = SHCloneSpecialIDList(NULL, CSIDL_CONTROLS, FALSE);
break;
case IDM_PRINTERS:
pidl = SHCloneSpecialIDList(NULL, CSIDL_PRINTERS, FALSE);
break;
case IDM_MYCOMPUTER:
pidl = SHCloneSpecialIDList(NULL, CSIDL_DRIVES, FALSE);
break;
}
if (pidl)
{
NEWFOLDERINFO fi;
fi.hwndCaller = NULL;
fi.pidl = pidl;
fi.uFlags = uFlags;
fi.nShow = SW_SHOWNORMAL;
fi.dwHotKey = 0;
Cabinet_OpenFolder(&fi);
ILFree(pidl);
}
}
void DoEjectPC()
{
#ifndef WINNT // BUGBUG - Fix this when NT gets docking capability
BIOSPARAMS bp;
DWORD cbOut;
DECLAREWAITCURSOR;
SetWaitCursor();
if (g_ts.hBIOS!=INVALID_HANDLE_VALUE)
DeviceIoControl(
g_ts.hBIOS,
PNPBIOS_SERVICE_SOFTUNDOCK,
&bp,
SIZEOF(bp),
&bp,
SIZEOF(bp),
&cbOut,
NULL);
ResetWaitCursor();
return;
#endif
}
BOOL Tray_IsAutoHide()
{
return g_ts.uAutoHide & AH_ON;
}
DWORD Tray_GetStuckPlace()
{
return g_ts.uStuckPlace;
}
BOOL CanMinimizeAll(HWND hwndView);
BOOL CanTileWindow(HWND hwnd, LPARAM lParam)
{
BOOL *pf = (BOOL*)lParam;
if (IsWindowVisible(hwnd) && !IsIconic(hwnd) && (hwnd != v_hwndTray) && hwnd != v_hwndDesktop) {
*pf = TRUE;
}
return !*pf;
}
BOOL CanTileAnyWindows()
{
BOOL f = FALSE;
EnumWindows(CanTileWindow, (LPARAM)&f);
return f;
}
void Tray_ContextMenu(PFileCabinet pfc, DWORD dwPos, BOOL fIncludeTime)
{
HMENU hmenu;
HMENU hmContext;
TCHAR szMenu[64];
TCHAR szTemplate[30];
TCHAR szCommand[30];
int idCmd;
if (dwPos == (DWORD)-1) {
POINT pt = {0,0};
ClientToScreen(pfc->hwndView, &pt);
dwPos = MAKELONG(pt.x, pt.y);
}
SwitchToThisWindow(pfc->hwndMain, TRUE);
SetForegroundWindow(pfc->hwndMain);
hmenu = LoadMenu(hinstCabinet, MAKEINTRESOURCE(MENU_TRAYCONTEXT));
if (hmenu) {
hmContext = GetSubMenu(hmenu, 0);
if (fIncludeTime) {
SetMenuDefaultItem(hmContext, IDM_SETTIME, MF_BYCOMMAND);
} else {
DeleteMenu(hmContext, IDM_SETTIME, MF_BYCOMMAND);
}
if (!g_ts.pPositions) {
DeleteMenu(hmContext, IDM_UNDO, MF_BYCOMMAND);
} else {
LoadString(hinstCabinet, IDS_UNDOTEMPLATE, szTemplate, ARRAYSIZE(szTemplate));
LoadString(hinstCabinet, g_ts.pPositions->idRes, szCommand, ARRAYSIZE(szCommand));
wsprintf(szMenu, szTemplate, szCommand);
ModifyMenu(hmContext, IDM_UNDO, MF_BYCOMMAND | MF_STRING, IDM_UNDO, szMenu);
}
if (!CanMinimizeAll(pfc->hwndView))
EnableMenuItem(hmContext, IDM_MINIMIZEALL, MFS_GRAYED | MF_BYCOMMAND);
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);
}
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
idCmd = TrackPopupMenu(hmContext, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
LOWORD(dwPos), HIWORD(dwPos), 0, v_hwndTray, NULL);
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
DestroyMenu(hmenu);
if (idCmd)
TrayCommand(pfc, idCmd);
}
}
//----------------------------------------------------------------------------
void _RunFileDlg(HWND hwnd, UINT idIcon, LPCITEMIDLIST pidlWorkingDir,
UINT idTitle, UINT idPrompt, DWORD dwFlags)
{
HICON hIcon = NULL;
LPCTSTR lpszTitle = NULL;
LPCTSTR lpszPrompt = NULL;
TCHAR szTitle[256];
TCHAR szPrompt[256];
TCHAR szWorkingDir[MAX_PATH];
int idDrive;
dwFlags |= RFD_USEFULLPATHDIR;
szWorkingDir[0] = 0;
if (idIcon)
{
hIcon = LoadIcon(hinstCabinet, MAKEINTRESOURCE(idIcon));
}
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).
SHGetSpecialFolderPath(hwnd, szWorkingDir, CSIDL_DESKTOPDIRECTORY,
FALSE);
}
// if it's a removable dir, make sure it's still there
if (szWorkingDir[0]) {
idDrive = PathGetDriveNumber(szWorkingDir);
if ((idDrive != -1))
{
UINT dtype = DriveType(idDrive);
if ( ( (dtype == DRIVE_REMOVABLE) || (dtype == DRIVE_CDROM) )
&& !PathFileExists(szWorkingDir) )
{
SHGetSpecialFolderPath(hwnd, szWorkingDir, CSIDL_DESKTOPDIRECTORY,
FALSE);
}
}
}
if (idTitle)
{
LoadString(hinstCabinet, idTitle, szTitle, ARRAYSIZE(szTitle));
lpszTitle = szTitle;
}
if (idPrompt)
{
LoadString(hinstCabinet, idPrompt, szPrompt, ARRAYSIZE(szPrompt));
lpszPrompt = szPrompt;
}
RunFileDlg(hwnd, hIcon, szWorkingDir, lpszTitle, lpszPrompt, dwFlags);
}
BOOL SavePosEnumProc(HWND hwnd, LPARAM lParam)
{
Assert(g_ts.pPositions);
if (IsWindowVisible(hwnd) &&
(hwnd != v_hwndTray) &&
(hwnd != v_hwndDesktop))
{
HWNDANDPLACEMENT hap;
hap.wp.length = SIZEOF(WINDOWPLACEMENT);
GetWindowPlacement(hwnd, &hap.wp);
DebugMsg(DM_TRACE, TEXT("SaveWindowPostitionsCallback %d %d"), hwnd, hap.wp.showCmd);
if (hap.wp.showCmd != SW_SHOWMINIMIZED) {
hap.hwnd = hwnd;
DSA_InsertItem(g_ts.pPositions->hdsaWP, 0x7FFF, &hap);
}
}
return TRUE;
}
void SaveWindowPositions(UINT idRes)
{
if (g_ts.pPositions) {
if (g_ts.pPositions->hdsaWP)
DSA_DeleteAllItems(g_ts.pPositions->hdsaWP);
} else {
g_ts.pPositions = (LPWINDOWPOSITIONS)LocalAlloc(LPTR, SIZEOF(WINDOWPOSITIONS));
if (!g_ts.pPositions)
return;
g_ts.pPositions->hdsaWP = DSA_Create(SIZEOF(HWNDANDPLACEMENT), 4);
}
g_ts.pPositions->idRes = idRes;
EnumWindows(SavePosEnumProc, 0);
}
void RestoreWindowPositions()
{
int i;
LPHWNDANDPLACEMENT phap;
LONG iAnimate;
ANIMATIONINFO ami;
if (!g_ts.pPositions)
return;
ami.cbSize = SIZEOF(ANIMATIONINFO);
SystemParametersInfo(SPI_GETANIMATION, SIZEOF(ami), &ami, FALSE);
iAnimate = ami.iMinAnimate;
ami.iMinAnimate = FALSE;
SystemParametersInfo(SPI_SETANIMATION, SIZEOF(ami), &ami, FALSE);
i = DSA_GetItemCount(g_ts.pPositions->hdsaWP) - 1;
for ( ; i >= 0; i--) {
phap = DSA_GetItemPtr(g_ts.pPositions->hdsaWP, i);
if (IsWindow(phap->hwnd)) {
#if (defined(DBCS) || defined(FE_IME))
// Word6/J relies on WM_SYSCOMMAND/SC_RESTORE to invalidate their
// MDI childrens' client area. If we just do SetWindowPlacement
// the app leaves its MDI children unpainted. I wanted to patch
// the app but couldn't afford to because the patch will remove
// its optimizing code (will affect performance).
// bug#11258-win95d.
//
#if !defined(WINNT)
if(ImmGetAppIMECompatFlags(GetWindowThreadProcessId(phap->hwnd, NULL)) & IMECOMPAT_SENDSC_RESTORE)
{
SendMessage(phap->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
continue;
}
#endif
#endif
phap->wp.length = SIZEOF(WINDOWPLACEMENT);
if ((phap->wp.showCmd) == SW_SHOWMAXIMIZED)
{
ShowWindowAsync(phap->hwnd, SW_MAXIMIZE);
}
else
{
// If the window to be undone is now iconic, we just need
// to restore it off the tray, otherwise (as in undoing from
// a tile) we need to reset its position
if (IsIconic(phap->hwnd))
{
ShowWindowAsync(phap->hwnd, SW_RESTORE);
}
else
{
SetWindowPos(phap->hwnd,
NULL,
phap->wp.rcNormalPosition.left,
phap->wp.rcNormalPosition.top,
phap->wp.rcNormalPosition.right - phap->wp.rcNormalPosition.left,
phap->wp.rcNormalPosition.bottom - phap->wp.rcNormalPosition.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_ASYNCWINDOWPOS);
}
}
}
}
ami.iMinAnimate = iAnimate;
SystemParametersInfo(SPI_SETANIMATION, SIZEOF(ami), &ami, FALSE);
DestroySavedWindowPositions();
}
void DestroySavedWindowPositions()
{
// free the global struct
DSA_Destroy(g_ts.pPositions->hdsaWP);
LocalFree(g_ts.pPositions);
g_ts.pPositions = 0;
}
void TrayHandleWindowDestroyed(HWND hwnd)
{
int i;
LPHWNDANDPLACEMENT phap;
Assert(g_ts.pPositions);
i = DSA_GetItemCount(g_ts.pPositions->hdsaWP) - 1;
for ( ; i >= 0; i--) {
phap = DSA_GetItemPtr(g_ts.pPositions->hdsaWP, i);
if (phap->hwnd == hwnd || !IsWindow(phap->hwnd)) {
DSA_DeleteItem(g_ts.pPositions->hdsaWP, i);
}
}
if (!DSA_GetItemCount(g_ts.pPositions->hdsaWP))
DestroySavedWindowPositions();
}
//----------------------------------------------------------------------------
// Allow us to bump the activation of the run dlg hidden window.
// Certain lame 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 CALLBACK RunDlgStaticSubclassWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == RDM_ACTIVATE) {
// there's a window out there... activate it
SwitchToThisWindow(GetLastActivePopup(hWnd), TRUE);
return 0;
} else if ((uMsg == WM_ACTIVATE) && (wParam == WA_ACTIVE))
{
// Bump the activation to the desktop.
if (v_hwndDesktop)
{
SetForegroundWindow(v_hwndDesktop);
return 0;
}
} else if (uMsg == WM_NOTIFY) {
// relay it to the tray
return SendMessage(v_hwndTray, uMsg, wParam, lParam);
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
const TCHAR c_szRunDlgReady[] = TEXT("MSShellRunDlgReady");
const TCHAR c_szWaitingThreadID[] = TEXT("WaitingThreadID");
DWORD WINAPI RunDlgThread(LPVOID data)
{
HWND hwnd;
RECT rc;
GetWindowRect(g_ts.hwndStart, &rc);
hwnd = CreateWindowEx(WS_EX_TOOLWINDOW, c_szStatic, NULL, 0 ,
rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hinstCabinet, NULL);
// Subclass it.
SetWindowLong(hwnd, GWL_WNDPROC, (LONG)(FARPROC)RunDlgStaticSubclassWndProc);
if (hwnd) {
// SwitchToThisWindow(hwnd, TRUE);
// SetForegroundWindow(hwnd);
HANDLE hMemWorkDir = NULL;
LPITEMIDLIST pidlWorkingDir = NULL;
#ifdef WINNT
TCHAR szDir[MAX_PATH];
TCHAR szPath[MAX_PATH];
BOOL fSimple;
#endif
if (data)
SetProp(hwnd, c_szWaitingThreadID, (HANDLE)data);
#ifdef WINNT
// On NT, we like to start apps in the HOMEPATH directory. This
// should be the current directory for the current process.
fSimple = FALSE;
GetEnvironmentVariable(TEXT("HOMEDRIVE"), szDir, ARRAYSIZE(szDir));
GetEnvironmentVariable(TEXT("HOMEPATH"), szPath, ARRAYSIZE(szPath));
if (PathAppend(szDir,szPath) && PathIsDirectory(szDir))
{
pidlWorkingDir = SHSimpleIDListFromPath(szDir);
fSimple = TRUE;
}
#endif
if (!pidlWorkingDir)
{
// If the last active window was a folder/explorer window with the
// desktop as root, use its as the current dir
if (g_ts.hwndLastActive && !IsMinimized(g_ts.hwndLastActive) &&
(Cabinet_IsExplorerWindow(g_ts.hwndLastActive) || Cabinet_IsFolderWindow(g_ts.hwndLastActive))
&& Desktop_IsSameRoot(g_ts.hwndLastActive,NULL))
{
// BUGBUG: BobDay - If the window is hung, shell hangs!
// Should ask OTRegister for appropriate COMPAREROOT data
hMemWorkDir = (HANDLE)SendMessage(g_ts.hwndLastActive, CWM_CLONEPIDL, GetCurrentProcessId(), 0L);
pidlWorkingDir = SHLockShared(hMemWorkDir,GetCurrentProcessId());
}
}
_RunFileDlg(hwnd, 0, pidlWorkingDir, 0, 0, 0);
if (pidlWorkingDir)
{
#ifdef WINNT
if (fSimple)
ILFree(pidlWorkingDir);
else
#endif
{
SHUnlockShared(pidlWorkingDir);
SHFreeShared(hMemWorkDir,GetCurrentProcessId());
}
}
if (data)
RemoveProp(hwnd, c_szWaitingThreadID);
DestroyWindow(hwnd);
}
return TRUE;
}
void Tray_RunDlg()
{
HANDLE ht;
DWORD id;
HANDLE hEvent;
LPVOID pvThreadParam;
if (!_Restricted(v_hwndTray, 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))
{
SetWindowPos(hwndOldRun, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE);
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, c_szRunDlgReady);
if (hEvent)
pvThreadParam = (LPVOID)GetCurrentThreadId();
else
pvThreadParam = NULL;
ht = CreateThread(NULL, 0, RunDlgThread, pvThreadParam, 0, &id);
if (ht) {
if (hEvent)
{
MsgWaitForMultipleObjectsLoop(hEvent, 10*1000);
DebugMsg(DM_TRACE, TEXT("c.t_rd: Done waiting."));
CloseHandle(hEvent);
}
CloseHandle(ht);
}
}
}
DWORD MsgWaitForMultipleObjectsLoop(HANDLE hEvent, DWORD dwTimeout)
{
MSG msg;
DWORD dwObject;
// DebugMsg(DM_TRACE, "c.t_rd: Waiting for run dlg...");
while (1)
{
// NB We need to let the run dialog become active so we have to half handle sent
// messages but we don't want to handle any input events or we'll swallow the
// type-ahead.
dwObject = MsgWaitForMultipleObjects(1, &hEvent, FALSE, dwTimeout, QS_SENDMESSAGE);
// Are we done waiting?
switch (dwObject) {
case WAIT_OBJECT_0:
case WAIT_FAILED:
return dwObject;
case WAIT_OBJECT_0 + 1:
// Almost.
// DebugMsg(DM_TRACE, "c.t_rd: Almost done waiting.");
PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
break;
}
}
// never gets here
// return dwObject;
}
void ExploreCommonStartMenu(BOOL bExplore)
{
STARTUPINFO si;
PROCESS_INFORMATION pi;
TCHAR szPath[MAX_PATH];
TCHAR szCmdLine[MAX_PATH + 50];
//
// Get the common start menu path.
//
if (!SHGetSpecialFolderPath(NULL, szPath, CSIDL_COMMON_STARTMENU, TRUE)) {
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
//
si.cb = sizeof(STARTUPINFO);
si.lpReserved = NULL;
si.lpTitle = NULL;
si.lpDesktop = NULL;
si.dwX = si.dwY = si.dwXSize = si.dwYSize = 0L;
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOWNORMAL;
si.lpReserved2 = NULL;
si.cbReserved2 = 0;
//
// Start explorer
//
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);
}
}
void StartMenuFolder_ContextMenu(PFileCabinet pfc, DWORD dwPos)
{
LPITEMIDLIST pidlStart = SHCloneSpecialIDList(v_hwndTray, CSIDL_STARTMENU, TRUE);
Tray_HandleFullScreenApp(FALSE, NULL);
SetForegroundWindow(pfc->hwndMain);
if (pidlStart) {
LPITEMIDLIST pidlLast = ILClone(ILFindLastID(pidlStart));
ILRemoveLastID(pidlStart);
if (pidlLast)
{
LPSHELLFOLDER psf;
if (SUCCEEDED(s_pshfRoot->lpVtbl->BindToObject(s_pshfRoot,
pidlStart, NULL, &IID_IShellFolder, &psf)))
{
HMENU hmenu = CreatePopupMenu();
if (hmenu)
{
LPCONTEXTMENU pcm;
HRESULT hres = psf->lpVtbl->GetUIObjectOf(psf, v_hwndTray,
1, &pidlLast, &IID_IContextMenu, NULL, &pcm);
if (SUCCEEDED(hres))
{
hres = pcm->lpVtbl->QueryContextMenu(pcm, hmenu, 0,
IDSYSPOPUP_FIRST, IDSYSPOPUP_LAST, CMF_VERBSONLY);
if (SUCCEEDED(hres))
{
int idCmd;
if (!SHRestricted(REST_NOCOMMONGROUPS)) {
TCHAR szCommon[50];
if (g_bIsUserAnAdmin) {
AppendMenu (hmenu, MF_SEPARATOR, 0, NULL);
LoadString (hinstCabinet, IDS_OPENCOMMON,
szCommon, 50);
AppendMenu (hmenu, MF_STRING, IDSYSPOPUP_LAST - 1,
szCommon);
LoadString (hinstCabinet, IDS_EXPLORECOMMON,
szCommon, 50);
AppendMenu (hmenu, MF_STRING, IDSYSPOPUP_LAST,
szCommon);
}
}
if (dwPos == (DWORD)-1)
{
idCmd = Tray_TrackMenu(pfc, hmenu, FALSE);
}
else
{
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, FALSE, 0L);
idCmd = TrackPopupMenu(hmenu,
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
LOWORD(dwPos), HIWORD(dwPos), 0, v_hwndTray, NULL);
SendMessage(g_ts.hwndTrayTips, TTM_ACTIVATE, TRUE, 0L);
}
if (idCmd)
{
if (idCmd == (IDSYSPOPUP_LAST - 1)) {
ExploreCommonStartMenu(FALSE);
} else if (idCmd == IDSYSPOPUP_LAST) {
ExploreCommonStartMenu(TRUE);
} else {
TCHAR szPath[MAX_PATH];
CMINVOKECOMMANDINFOEX ici = {
SIZEOF(CMINVOKECOMMANDINFOEX),
0L,
v_hwndTray,
(LPSTR)MAKEINTRESOURCE(idCmd - IDSYSPOPUP_FIRST),
NULL, NULL,
SW_NORMAL,
};
#ifdef UNICODE
CHAR szPathAnsi[MAX_PATH];
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->lpVtbl->InvokeCommand(pcm,
(LPCMINVOKECOMMANDINFO)&ici);
}
}
}
pcm->lpVtbl->Release(pcm);
}
DestroyMenu(hmenu);
}
psf->lpVtbl->Release(psf);
}
ILFree(pidlLast);
}
ILFree(pidlStart);
}
}
//----------------------------------------------------------------------------
void Tray_Suspend(void)
{
DECLAREWAITCURSOR;
SetWaitCursor();
#if 1
SetSystemPowerState(FALSE, FALSE);
#else
// See RemoveSuspendMenu comment as to why this is ifdef'd out but not
// (yet) deleted. 13-Oct-94
if (!SetSystemPowerState(FALSE, FALSE) &&
GetLastError() == ERROR_SET_POWER_STATE_FAILED)
RemoveSuspendMenu(pfc->hwndMain);
#endif
ResetWaitCursor();
}
#ifdef WINNT
// RunSystemMonitor
//
// Launches system monitor (taskmgr.exe), which is expected to be able
// to find any currently running instances of itself
void RunSystemMonitor(void)
{
STARTUPINFO startup;
PROCESS_INFORMATION pi;
TCHAR szName[] = TEXT("taskmgr.exe");
startup.cb = SIZEOF(startup);
startup.lpReserved = NULL;
startup.lpDesktop = NULL;
startup.lpTitle = NULL;
startup.dwFlags = 0L;
startup.cbReserved2 = 0;
startup.lpReserved2 = NULL;
startup.wShowWindow = SW_SHOWNORMAL;
if (CreateProcess(NULL, szName, NULL, NULL, FALSE, 0,
NULL, NULL, &startup, &pi))
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
#endif
void HandleGlobalHotkey(WPARAM wParam);
void TrayCommand(PFileCabinet pfc, UINT idCmd)
{
switch (idCmd) {
// NB Everything off the programs menu, cascades and all comes in as an IDM_PROGRAMS.
// Sim for recent docs.
case IDM_STARTMENU:
case IDM_RECENT:
case IDM_PROGRAMS:
FileMenu_HandleCommand(pfc->hwndMain, idCmd);
break;
case IDM_CONTROLS:
case IDM_PRINTERS:
// case IDM_PROGRAMSFOLDER:
// case IDM_FONTS:
ShowFolder(pfc->hwndMain, idCmd, COF_USEOPENSETTINGS);
break;
#ifndef WINNT // BUGBUG - Fix this when NT supports APM & Docking
case IDM_SUSPEND:
Tray_Suspend();
break;
case IDM_EJECTPC:
DoEjectPC();
break;
#endif
case IDM_EXITWIN:
DoExitWindows(pfc->hwndMain);
break;
case IDM_FILERUN:
Tray_RunDlg();
break;
case IDM_MINIMIZEALLHOTKEY:
HandleGlobalHotkey(GHID_MINIMIZEALL);
break;
case IDM_MINIMIZEALL:
// minimize all window
MinimizeAll(pfc->hwndView);
break;
case IDM_UNDO:
RestoreWindowPositions();
break;
case IDM_SETTIME:
// run the default applet in timedate.cpl
SHRunControlPanel( TEXT("timedate.cpl"), pfc->hwndMain );
break;
#ifdef WINNT
case IDM_SHOWTASKMAN:
RunSystemMonitor();
break;
#endif
case IDM_CASCADE:
case IDM_VERTTILE:
case IDM_HORIZTILE:
if (CanTileAnyWindows()) {
SaveWindowPositions((idCmd == IDM_CASCADE) ? IDS_CASCADE : IDS_TILE );
AppBarNotifyAll(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);
AppBarNotifyAll(ABN_WINDOWARRANGE, NULL, FALSE);
}
break;
case IDM_TRAYPROPERTIES:
DoTrayProperties(pfc);
break;
// REVIEW: windows.hlp should be a string table resource
case IDM_HELPSEARCH:
WinHelp(pfc->hwndMain, c_szWindowsHlp, HELP_FINDER, 0);
break;
// NB The Alt-s comes in here.
case IDC_KBSTART:
// This pushes the start button and causes the start menu to popup.
SendMessage(GetDlgItem(pfc->hwndMain, IDC_START), BM_SETSTATE, TRUE, 0);
// This forces the button back up.
SendMessage(GetDlgItem(pfc->hwndMain, IDC_START), BM_SETSTATE, FALSE, 0);
break;
case IDC_ASYNCSTART:
// Make sure the button is down.
// DebugMsg(DM_TRACE, "c.twp: IDC_START.");
// Make sure the Start button is down.
if (SendMessage(g_ts.hwndStart, BM_GETSTATE, 0, 0) & 0x0004)
{
// DebugMsg(DM_TRACE, "c.twp: Start button down.");
// Set the focus.
SetFocus(g_ts.hwndStart);
ToolbarMenu(pfc);
}
else
{
// DebugMsg(DM_TRACE, "c.twp: Start button up.");
}
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(pfc->hwndMain, WM_COMMAND, IDC_ASYNCSTART, 0);
break;
case FCIDM_FINDFILES:
SHFindFiles(NULL, NULL);
break;
case FCIDM_FINDCOMPUTER:
SHFindComputer(NULL, NULL);
break;
case FCIDM_REFRESH:
RebuildEntireMenu(pfc);
break;
case FCIDM_NEXTCTL:
{
HWND hwndFocus = GetFocus();
BOOL fShift = (GetAsyncKeyState(VK_SHIFT) < 0);
if (hwndFocus == pfc->hwndToolbar) {
SetFocus(fShift ? v_hwndDesktop : pfc->hwndView);
} else if (hwndFocus == pfc->hwndView || IsChild(pfc->hwndView, hwndFocus)) {
SetFocus(fShift ? pfc->hwndToolbar : v_hwndDesktop);
} else {
SetFocus(fShift ? pfc->hwndView : pfc->hwndToolbar);
}
break;
}
case IDM_RETURN:
DebugMsg(DM_TRACE, TEXT("c.tc: Return key hit."));
if (GetFocus() == g_ts.hwndStart)
{
PostMessage(pfc->hwndMain, WM_COMMAND, IDC_KBSTART, 0);
}
else
{
SendMessage(GetDlgItem(pfc->hwndView, IDC_FOLDERTABS), WM_KEYDOWN, VK_RETURN, 0);
}
break;
default:
if (IsInRange(idCmd, TRAY_IDM_FINDFIRST, TRAY_IDM_FINDLAST) && !_Restricted(v_hwndTray, REST_NOFIND)) {
CMINVOKECOMMANDINFOEX ici = {
SIZEOF(CMINVOKECOMMANDINFOEX),
0L,
pfc->hwndMain,
(LPSTR)MAKEINTRESOURCE(idCmd - TRAY_IDM_FINDFIRST),
NULL, NULL,
SW_NORMAL,
};
pfc->pcmFind->lpVtbl->InvokeCommand(pfc->pcmFind,
(LPCMINVOKECOMMANDINFO)&ici);
} else {
DebugMsg(DM_ERROR, TEXT("tray Unknown command (%x)"), idCmd);
}
break;
}
}
//// Start menu/Tray tab as a drop target
extern IDropTarget c_dtgtStart;
extern IDropTarget c_dtgtTab;
extern IDropTarget c_dtgtTray;
//=============================================================================
// CDVDropTarget : member
//=============================================================================
STDMETHODIMP CStartDropTarget_QueryInterface(LPDROPTARGET pdtgt, REFIID riid, LPVOID * ppvObj)
{
if (IsEqualIID(riid, &IID_IDropTarget) || IsEqualIID(riid, &IID_IUnknown))
{
*ppvObj = pdtgt;
return S_OK;
}
*ppvObj = NULL;
return (E_NOINTERFACE);
}
STDMETHODIMP_(ULONG) CStartDropTarget_AddRef(LPDROPTARGET pdtgt)
{
return 2;
}
STDMETHODIMP_(ULONG) CStartDropTarget_Release(LPDROPTARGET pdtgt)
{
return 1;
}
STDMETHODIMP CStartDropTarget_DragEnter(LPDROPTARGET pdtgt, LPDATAOBJECT pdtobj, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
HWND hwndLock = v_hwndTray;
RECT rcLockWindow;
POINT pt;
DebugMsg(DM_TRACE, TEXT("sh - TR CStartDropTarget::DragEnter called"));
TraySetUnhideTimer(ptl.x, ptl.y);
GetWindowRect(hwndLock, &rcLockWindow);
pt.x = ptl.x-rcLockWindow.left;
pt.y = ptl.y-rcLockWindow.top;
DAD_DragEnterEx(hwndLock, pt);
if (pdtgt==&c_dtgtStart) {
*pdwEffect = DROPEFFECT_LINK;
} else if (pdtgt==&c_dtgtTab) {
*pdwEffect = DROPEFFECT_MOVE | DROPEFFECT_SCROLL;
} else {
*pdwEffect = DROPEFFECT_NONE;
}
return S_OK;
}
STDMETHODIMP CStartDropTarget_DragOver(LPDROPTARGET pdtgt, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
POINT pt = { ptl.x, ptl.y };
TraySetUnhideTimer(ptl.x, ptl.y);
ScreenToClient(v_hwndTray, &pt);
DAD_DragMove(pt);
*pdwEffect = DROPEFFECT_LINK;
return S_OK;
}
#define MSEC_ACTIVATE (1*1000)
void CTabDropTarget_HitTest(BOOL fEnter, POINTL ptl)
{
extern int Task_HitTest(HWND hwndTask, POINTL ptl);
extern void Task_SetCurSel(HWND hwndTask, int i);
static int s_iHit = -1;
static DWORD s_dwBegin = 0;
static BOOL s_fWaiting = FALSE;
LPFileCabinet pfc = g_pfcTray;
if (!pfc) {
return;
}
if (fEnter) {
s_iHit = -1;
s_fWaiting = FALSE;
} else {
int iHitNew = Task_HitTest(pfc->hwndView, ptl);
if (s_iHit != iHitNew)
{
DebugMsg(DM_TRACE, TEXT("ca TR - CTDT::HitTest new target (%d->%d)"), s_iHit, iHitNew);
s_iHit = iHitNew;
if (iHitNew != -1)
{
s_dwBegin = GetCurrentTime();
s_fWaiting = TRUE;
}
else
{
s_fWaiting = FALSE;
}
}
else if (s_fWaiting)
{
DWORD dwWaited = GetCurrentTime()-s_dwBegin;
DebugMsg(DM_TRACE, TEXT("ca TR - CTDT::HitTest waiting... (%d on %x)"), dwWaited, s_iHit);
if (dwWaited > MSEC_ACTIVATE)
{
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
Task_SetCurSel(pfc->hwndView, s_iHit);
UpdateWindow(v_hwndTray);
DAD_ShowDragImage(TRUE); // restore the lock state.
s_fWaiting = FALSE;
}
}
}
}
STDMETHODIMP CTabDropTarget_DragEnter(LPDROPTARGET pdtgt, LPDATAOBJECT pdtobj, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
CTabDropTarget_HitTest(TRUE, ptl);
return CStartDropTarget_DragEnter(pdtgt, pdtobj, grfKeyState, ptl, pdwEffect);
}
STDMETHODIMP CTabDropTarget_DragOver(LPDROPTARGET pdtgt, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
{
CTabDropTarget_HitTest(FALSE, ptl);
CStartDropTarget_DragOver(pdtgt, grfKeyState, ptl, pdwEffect);
*pdwEffect = (pdtgt==&c_dtgtTab) ? (DROPEFFECT_MOVE|DROPEFFECT_SCROLL) : DROPEFFECT_NONE;
return S_OK;
}
STDMETHODIMP CStartDropTarget_DragLeave(LPDROPTARGET pdtgt)
{
DebugMsg(DM_TRACE, TEXT("sh - TR CStartDropTarget::DragLeave called"));
DAD_DragLeave();
return S_OK;
}
STDMETHODIMP CStartDropTarget_Drop(LPDROPTARGET pdtgt, LPDATAOBJECT pdtobj,
DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
{
LPITEMIDLIST pidlStart = SHCloneSpecialIDList(v_hwndTray, CSIDL_STARTMENU, TRUE);
LPSHELLFOLDER psf;
HRESULT hres = (E_OUTOFMEMORY);
if (pidlStart) {
hres = s_pshfRoot->lpVtbl->BindToObject(s_pshfRoot, pidlStart, NULL, &IID_IShellFolder, &psf);
if (SUCCEEDED(hres))
{
IDropTarget *pdrop;
hres = psf->lpVtbl->CreateViewObject(psf, v_hwndTray, &IID_IDropTarget, &pdrop);
if (SUCCEEDED(hres))
{
POINTL pt = { 0, 0 };
DWORD grfKeyState;
*pdwEffect &= DROPEFFECT_LINK;
grfKeyState = 0;
pdrop->lpVtbl->DragEnter(pdrop, pdtobj, grfKeyState, pt,
pdwEffect);
hres = pdrop->lpVtbl->Drop(pdrop, pdtobj, grfKeyState, pt,
pdwEffect);
if (SUCCEEDED(hres) && *pdwEffect) {
Sleep(SECOND);
g_ts.fFavInvalid = TRUE;
}
pdrop->lpVtbl->DragLeave(pdrop);
pdrop->lpVtbl->Release(pdrop);
}
psf->lpVtbl->Release(psf);
}
ILFree(pidlStart);
}
DAD_DragLeave();
return hres;
}
STDMETHODIMP CTabDropTarget_Drop(LPDROPTARGET pdtgt, LPDATAOBJECT pdtobj,
DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
{
if (pdtgt==&c_dtgtTab)
{
LPFileCabinet pfc = g_pfcTray;
DAD_DragLeave();
if (pfc)
{
ShellMessageBox(hinstCabinet, pfc->hwndMain,
MAKEINTRESOURCE(IDS_TASKDROP_ERROR),
MAKEINTRESOURCE(IDS_TASKBAR),
MB_ICONHAND | MB_OK);
}
//
// We should not return the 'move' bit.
//
if (*pdwEffect & DROPEFFECT_COPY) {
*pdwEffect = DROPEFFECT_COPY;
} else {
*pdwEffect &= DROPEFFECT_LINK;
}
}
return S_OK;
}
// store our drop target in pdtgtTree
//=============================================================================
// CStartDropTarget : Register and Revoke
//=============================================================================
void CStartDropTarget_Register(LPFileCabinet pfc)
{
g_cfIDList = RegisterClipboardFormat(CFSTR_SHELLIDLIST);
SHRegisterDragDrop(g_ts.hwndStart, &c_dtgtStart);
SHRegisterDragDrop(pfc->hwndView, &c_dtgtTab);
SHRegisterDragDrop(pfc->hwndMain, &c_dtgtTray);
}
void CStartDropTarget_Revoke(LPFileCabinet pfc)
{
SHRevokeDragDrop(pfc->hwndMain);
SHRevokeDragDrop(pfc->hwndView);
SHRevokeDragDrop(g_ts.hwndStart);
}
//=============================================================================
// CStartDropTarget : VTable
//=============================================================================
IDropTargetVtbl c_CStartDropTargetVtbl = {
CStartDropTarget_QueryInterface,
CStartDropTarget_AddRef,
CStartDropTarget_Release,
CStartDropTarget_DragEnter,
CStartDropTarget_DragOver,
CStartDropTarget_DragLeave,
CStartDropTarget_Drop
};
IDropTarget c_dtgtStart = { &c_CStartDropTargetVtbl };
IDropTargetVtbl c_CTabDropTargetVtbl = {
CStartDropTarget_QueryInterface,
CStartDropTarget_AddRef,
CStartDropTarget_Release,
CTabDropTarget_DragEnter,
CTabDropTarget_DragOver,
CStartDropTarget_DragLeave,
CTabDropTarget_Drop
};
IDropTarget c_dtgtTab = { &c_CTabDropTargetVtbl };
IDropTarget c_dtgtTray = { &c_CTabDropTargetVtbl };
//// end Start Drop target
////////////////////////////////////////////////////////////////////////////
// Begin Print Notify stuff
////////////////////////////////////////////////////////////////////////////
typedef BOOL (* PFNENUMPRINTERS) (DWORD, LPTSTR, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD);
typedef BOOL (* PFNENUMJOBS) (HANDLE, DWORD, DWORD, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD);
typedef BOOL (* PFNOPENPRINTER) (LPTSTR, LPHANDLE, LPVOID);
typedef BOOL (* PFNCLOSEPRINTER) (HANDLE);
PFNENUMPRINTERS g_pfnEnumPrinters = NULL;
PFNENUMJOBS g_pfnEnumJobs = NULL;
PFNOPENPRINTER g_pfnOpenPrinter = NULL;
PFNCLOSEPRINTER g_pfnClosePrinter = NULL;
TCHAR const c_szSpoolClass[] = TEXT("SpoolProcessClass");
void PrintNotify_Init(HWND hWnd)
{
g_ts.pidlPrintersFolder = SHCloneSpecialIDList(hWnd, CSIDL_PRINTERS, FALSE);
if (g_ts.pidlPrintersFolder)
{
SHChangeNotifyEntry fsne;
HWND hwndSpool;
fsne.pidl = g_ts.pidlPrintersFolder;
fsne.fRecursive = TRUE;
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - registering print notify icon"));
g_ts.uPrintNotify = SHChangeNotifyRegister(hWnd, SHCNRF_NewDelivery | SHCNRF_ShellLevel,
SHCNE_CREATE | SHCNE_UPDATEITEM | SHCNE_DELETE,
WMTRAY_PRINTCHANGE, 1, &fsne);
// Tell the spool subsystem to stop waiting for the printnotify icon..
// After this notification, the subsystem can start printing and our
// little printer icon will work. We need this so that deferred
// print jobs don't start printing before the icon is listening.
hwndSpool = FindWindow(c_szSpoolClass, NULL);
if (hwndSpool)
{
NMHDR nmhdr = {hWnd, 0, NM_ENDWAIT};
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Telling print subsystem we're here"));
SendMessage(hwndSpool, WM_NOTIFY, (WPARAM)NM_ENDWAIT, (LPARAM)&nmhdr);
}
}
}
typedef BOOL (*ENUMPROP)(LPVOID lpData, HANDLE hPrinter, DWORD dwLevel,
LPBYTE pEnum, DWORD dwSize, DWORD *lpdwNeeded, DWORD *lpdwNum);
LPVOID Printer_EnumProps(HANDLE hPrinter, DWORD dwLevel, DWORD *lpdwNum,
ENUMPROP lpfnEnum, LPVOID lpData)
{
DWORD dwSize, dwNeeded;
LPBYTE pEnum;
dwSize = 0;
SetLastError(0);
lpfnEnum(lpData, hPrinter, dwLevel, NULL, 0, &dwSize, lpdwNum);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
pEnum = NULL;
goto Error1;
}
Assert(dwSize < 0x100000L);
TryAgain:
pEnum = Alloc(dwSize);
if (!pEnum)
{
goto Error1;
}
SetLastError(0);
if (!lpfnEnum(lpData, hPrinter, dwLevel, pEnum, dwSize, &dwNeeded, lpdwNum))
{
Free(pEnum);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
dwSize = dwNeeded;
goto TryAgain;
}
pEnum = NULL;
}
Error1:
return(pEnum);
}
BOOL _EnumPrintersCB(LPVOID lpData, HANDLE hPrinter, DWORD dwLevel,
LPBYTE pEnum, DWORD dwSize, DWORD *lpdwNeeded, DWORD *lpdwNum)
{
return(g_pfnEnumPrinters((DWORD)lpData, NULL, dwLevel, pEnum, dwSize, lpdwNeeded, lpdwNum));
}
DWORD _EnumPrinters(DWORD dwType, DWORD dwLevel, LPVOID *ppPrinters)
{
DWORD dwNum = 0L;
*ppPrinters = Printer_EnumProps(NULL, dwLevel, &dwNum, _EnumPrintersCB, (LPVOID)dwType);
if (*ppPrinters==NULL)
{
dwNum=0;
}
return(dwNum);
}
BOOL _EnumJobsCB(LPVOID lpData, HANDLE hPrinter, DWORD dwLevel,
LPBYTE pEnum, DWORD dwSize, DWORD *lpdwNeeded, DWORD *lpdwNum)
{
return(g_pfnEnumJobs(hPrinter, 0, 0xffff, dwLevel, pEnum, dwSize, lpdwNeeded, lpdwNum));
}
DWORD _EnumJobs(HANDLE hPrinter, DWORD dwLevel, LPVOID *ppJobs)
{
DWORD dwNum = 0L;
*ppJobs = Printer_EnumProps(hPrinter, dwLevel, &dwNum, _EnumJobsCB, NULL);
if (*ppJobs==NULL)
{
dwNum=0;
}
return(dwNum);
}
// Thread_PrinterPoll is the worker thread for PrintNotify_HandleFSNotify.
// It keeps track of print jobs, polls the pinter, updates the icon, etc.
typedef struct _PRINTERPOLLDATA
{
HWND hWnd;
HANDLE heWakeUp;
} PRINTERPOLLDATA, *PPRINTERPOLLDATA;
DWORD WINAPI Thread_PrinterPoll(PPRINTERPOLLDATA pData)
{
PRINTERPOLLDATA data;
HANDLE hmodWinspool;
TCHAR szUserName[40];
TCHAR szFormat[60];
DWORD dwSize;
DWORD aArgs[2];
NOTIFYICONDATA IconData;
DWORD dwNotifyMessage = NIM_ADD;
UINT nIconShown = 0;
HICON hIconNormal = NULL;
HICON hIconError = NULL;
HANDLE haPrinterNames = NULL;
LPSHELLFOLDER psf = NULL;
DWORD dwTimeOut;
DWORD dwStatus;
int nFound;
MSG msg;
LPITEMIDLIST pidlFree = NULL;
static int s_cxSmIcon = 0;
static int s_cySmIcon = 0;
int cxSmIcon = 0;
int cySmIcon = 0;
// notify PrintNotify_StartThread that our message queue is up
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
data = *pData;
GlobalFree(pData);
SetEvent(data.heWakeUp);
if (!SFCInitializeThread())
{
goto Error0;
}
// load winspool functions we use
hmodWinspool = LoadLibrary(TEXT("winspool.drv"));
if (!hmodWinspool)
{
goto Error1;
}
// These are globals just so I don't have to pass them around
#ifdef UNICODE
g_pfnEnumPrinters = (PFNENUMPRINTERS)GetProcAddress(hmodWinspool, "EnumPrintersW");
g_pfnEnumJobs = (PFNENUMJOBS) GetProcAddress(hmodWinspool, "EnumJobsW");
g_pfnOpenPrinter = (PFNOPENPRINTER) GetProcAddress(hmodWinspool, "OpenPrinterW");
#else
g_pfnEnumPrinters = (PFNENUMPRINTERS)GetProcAddress(hmodWinspool, "EnumPrintersA");
g_pfnEnumJobs = (PFNENUMJOBS) GetProcAddress(hmodWinspool, "EnumJobsA");
g_pfnOpenPrinter = (PFNOPENPRINTER) GetProcAddress(hmodWinspool, "OpenPrinterA");
#endif
g_pfnClosePrinter = (PFNCLOSEPRINTER)GetProcAddress(hmodWinspool, "ClosePrinter");
if (!g_pfnEnumPrinters || !g_pfnEnumJobs
|| !g_pfnOpenPrinter || !g_pfnClosePrinter)
{
Assert(FALSE);
goto Error2;
}
// Get fixed data
dwSize = ARRAYSIZE(szUserName);
if (!GetUserName(szUserName, &dwSize))
{
// non repro bug 6853/5592 is probably caused by GetUserName failing.
// since this bug gets reported occasionally, see if this fixes it.
// Note: we may want to change the tip message to not include this
// empty user name.
DebugMsg(DM_TRACE, TEXT("sh TR - GetUserName failed!"));
Assert(0); // why would this fail?
szUserName[0] = TEXT('\0');
}
LoadString(hinstCabinet, IDS_NUMPRINTJOBS, szFormat, ARRAYSIZE(szFormat));
aArgs[0] = (DWORD)-1;
aArgs[1] = (DWORD)szUserName;
// Set up initial data
ZeroMemory(&IconData, SIZEOF(IconData));
IconData.cbSize = SIZEOF(IconData);
IconData.hWnd = data.hWnd;
//IconData.uID = 0;
IconData.uFlags = NIF_MESSAGE;
IconData.uCallbackMessage = WMTRAY_PRINTICONNOTIFY;
// IconData.hIcon filled in when message sent
// IconData.szTip filled in when message sent
dwNotifyMessage = NIM_ADD; // next operation for the icon
nIconShown = 0; // icon id of printer icon currently displayed
hIconNormal = NULL; // handle of ICO_PRINTER
hIconError = NULL; // handle of ICO_PRINTER_ERROR
haPrinterNames = NULL; // list of currently polled printers
psf = NULL; // IShellFolder of Printers Folder
dwTimeOut = POLLINTERVAL; // time before next poll
nFound = 0; // # jobs found after most recent poll
dwStatus = 0; // Status after most recent poll
// process messages
for ( ; TRUE ; )
{
int iPrinter, iJob;
JOB_INFO_1 *pJobs;
HANDLE hPrinter;
DWORD dwTime; // elapsed time for this wait
DWORD dw; // return value from this wait
dwTime = GetTickCount();
dw = MsgWaitForMultipleObjects(1, &(data.heWakeUp),
FALSE, dwTimeOut, QS_ALLINPUT);
dwTime = GetTickCount() - dwTime;
switch (dw)
{
case WAIT_OBJECT_0:
case WAIT_FAILED:
// the tray is shutting down
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Thread_PrinterPoll shutting down"));
goto exit;
case WAIT_TIMEOUT:
#ifndef WINNT
if (g_ts.uAutoHide & AH_HIDING)
{
// don't poll if the tray is hidden
dwTimeOut = MINPOLLINTERVAL;
break;
}
#endif
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Thread_PrinterPoll timeout polling"));
// we need to poll -- jump into the message loop
pidlFree = NULL;
goto poll;
default:
// we have messages
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
switch (msg.message - WM_USER)
{
// NOTE: These can't (& don't) conflict w/ our SHCNE_ messages
case WM_LBUTTONDBLCLK:
case WM_RBUTTONUP:
{
HMENU hmenu;
// REVIEW: why does Tray_ContextMenu do it this way?
// Don't we have a function to get the submenu?
hmenu = LoadMenu(hinstCabinet, MAKEINTRESOURCE(MENU_PRINTNOTIFYCONTEXT));
if (hmenu)
{
HMENU hmContext;
int idCmd;
int idDefCmd = IDM_PRINTNOTIFY_FOLDER;
hmContext = GetSubMenu(hmenu, 0);
// Append each printer we're polling
if (haPrinterNames)
{
MENUITEMINFO mii;
int i;
TCHAR szTemplate[60];
// If error, we'll need szTemplate
if (dwStatus & JOB_STATUS_ERROR_BITS)
{
LoadString(hinstCabinet, IDS_PRINTER_ERROR, szTemplate, ARRAYSIZE(szTemplate));
}
mii.cbSize = SIZEOF(MENUITEMINFO);
mii.fMask = MIIM_TYPE | MIIM_ID;
mii.fType = MF_STRING;
InsertMenu(hmContext, (UINT)-1, MF_SEPARATOR|MF_BYPOSITION, 0, NULL);
for (i = DSA_GetItemCount(haPrinterNames) - 1 ;
i >= 0 ; --i)
{
LPPRINTERNAME pPrinter;
TCHAR szBuf[MAXPRINTERBUFFER+60];
LPTSTR pName;
pPrinter = DSA_GetItemPtr(haPrinterNames,i);
// give it an id
mii.wID = i+IDM_PRINTNOTIFY_FOLDER+1;
// indicate error state via name
pName = pPrinter->szPrinterName;
if (pPrinter->fInErrorState)
{
wsprintf(szBuf, szTemplate, pName);
pName = szBuf;
// default to first error state printer
if (idDefCmd == IDM_PRINTNOTIFY_FOLDER)
idDefCmd = mii.wID;
}
// Name of the printer
mii.dwTypeData = pName;
mii.cch = lstrlen(pName);
InsertMenuItem(hmContext, (UINT)-1, MF_BYPOSITION, &mii);
}
} // if (haPrinterNames)
// show the context menu
if (msg.message == WM_USER + WM_RBUTTONUP)
{
HWND hwndOwner;
DWORD dwPos;
// We need an hwnd owned by this thread.
hwndOwner = CreateWindow(c_szStatic, NULL,
WS_DISABLED, 0, 0, 0, 0,
NULL, NULL, hinstCabinet, 0L);
dwPos = GetMessagePos();
SetMenuDefaultItem(hmContext, idDefCmd, MF_BYCOMMAND);
SetForegroundWindow(hwndOwner);
SetFocus(hwndOwner);
idCmd = TrackPopupMenu(hmContext,
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
LOWORD(dwPos), HIWORD(dwPos), 0, hwndOwner, NULL);
DestroyWindow(hwndOwner);
}
else
{
idCmd = idDefCmd;
}
if (idCmd != 0)
{
int iStart, iStop;
if (idCmd == IDM_PRINTNOTIFY_FOLDER)
{
iStart = 0;
iStop = DSA_GetItemCount(haPrinterNames);
}
else
{
iStart = idCmd - IDM_PRINTNOTIFY_FOLDER - 1;
iStop = iStart + 1;
}
for ( ; iStart < iStop ; iStart++)
{
LPPRINTERNAME pPrinter;
LPCONTEXTMENU pcm;
pPrinter = DSA_GetItemPtr(haPrinterNames,
iStart);
// open selected queue view
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Open '%s'"), pPrinter->szPrinterName);
psf->lpVtbl->GetUIObjectOf(psf, NULL, 1, &pPrinter->pidlPrinter,
&IID_IContextMenu, NULL, &pcm);
if (pcm)
{
//
// We need to call QueryContextMenu() so that CDefFolderMenu
// can initialize its dispatch table correctly.
//
HMENU hmenuTmp = CreatePopupMenu();
if (hmenuTmp)
{
HRESULT hres;
hres = pcm->lpVtbl->QueryContextMenu(pcm, hmenuTmp, 0,
0, 0x7FFF, CMF_DEFAULTONLY);
if (SUCCEEDED(hres))
{
CMINVOKECOMMANDINFOEX ici = {
SIZEOF(CMINVOKECOMMANDINFOEX),
0L,
NULL,
(LPSTR)MAKEINTRESOURCE(GetMenuDefaultItem(hmenuTmp, MF_BYCOMMAND, 0)),
NULL, NULL,
SW_NORMAL,
};
pcm->lpVtbl->InvokeCommand(pcm,
(LPCMINVOKECOMMANDINFO)&ici);
}
DestroyMenu(hmenuTmp);
}
pcm->lpVtbl->Release(pcm);
}
}
}
DestroyMenu(hmenu);
} // if (hmenu)
break;
}
case SHCNE_CREATE:
case SHCNE_DELETE:
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Thread_PrinterPoll SHCNE_CREATE/DELETE"));
PrintNotify_AddToQueue(&haPrinterNames, &psf, (LPCITEMIDLIST)msg.lParam);
//
// We need to free the pidl passed in.
//
pidlFree = (LPITEMIDLIST)msg.lParam;
poll:
dwTimeOut = POLLINTERVAL;
// just in case we failed AddToQueue
if (!haPrinterNames)
{
Assert(FALSE);
break;
}
nFound = 0;
dwStatus = 0;
for (iPrinter=DSA_GetItemCount(haPrinterNames)-1 ;
iPrinter>=0 ; --iPrinter)
{
LPPRINTERNAME pPrinter;
BOOL fFound;
BOOL fNetDown;
pPrinter = DSA_GetItemPtr(haPrinterNames,iPrinter);
// if the tray is shutting down while we're in the
// middle of polling, we might want to exit this loop
if (!g_pfnOpenPrinter(pPrinter->szPrinterName, &hPrinter, NULL))
{
// Can't open the printer? Remove it so we don't keep trying
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - can't open [%s]"), pPrinter->szPrinterName);
goto remove_printer;
}
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - polling [%s]"), pPrinter->szPrinterName);
fFound = FALSE;
iJob = _EnumJobs(hPrinter, 1, &pJobs) - 1;
fNetDown = GetLastError() == ERROR_BAD_NET_RESP;
pPrinter->fInErrorState = FALSE;
for ( ; iJob>=0 ; --iJob)
{
// if GetUserName failed, match all jobs
#ifdef WINNT
// Exclude jobs that are status PRINTED.
if ((!lstrcmpi(pJobs[iJob].pUserName, szUserName) ||
!szUserName[0]) &&
!(pJobs[iJob].Status & JOB_STATUS_PRINTED))
#else
if (!lstrcmpi(pJobs[iJob].pUserName, szUserName) ||
!szUserName[0])
#endif
{
// We found a job owned by the user,
// so continue to show the icon
++nFound;
dwStatus |= pJobs[iJob].Status;
if (pJobs[iJob].Status & JOB_STATUS_ERROR_BITS)
pPrinter->fInErrorState = TRUE;
fFound = TRUE;
}
}
g_pfnClosePrinter(hPrinter);
if (pJobs)
{
Free(pJobs);
}
// there may be local jobs (fFound), but if the net is down
// then we don't want to poll this printer again -- we have to
// wait for the net to timeout which is SLOW.
if (!fFound || fNetDown)
{
#ifdef DEBUG
if (fNetDown)
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - net is down for [%s]"), pPrinter->szPrinterName);
else
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - no jobs for [%s]"), pPrinter->szPrinterName);
#endif
remove_printer:
// no need to poll this printer any more
ILFree(pPrinter->pidlPrinter);
DSA_DeleteItem(haPrinterNames, iPrinter);
}
} // polling loop
#ifndef WINNT
update_icon:
#endif
if (nFound)
{
UINT nIcon = (dwStatus & JOB_STATUS_ERROR_BITS) ?
ICO_PRINTER_ERROR : ICO_PRINTER;
// Keep track of small icon sizes so we can redraw the
// icon whenever this changes.
cxSmIcon = GetSystemMetrics(SM_CXSMICON);
cySmIcon = GetSystemMetrics(SM_CYSMICON);
if ((nIconShown != nIcon) || cxSmIcon != s_cxSmIcon || cySmIcon != s_cySmIcon)
{
nIconShown = nIcon;
s_cxSmIcon = GetSystemMetrics(SM_CXSMICON);
s_cySmIcon = GetSystemMetrics(SM_CYSMICON);
// show an error printer icon if the print job is in
// an error state which "requires user intervention"
if (dwStatus & JOB_STATUS_ERROR_BITS)
{
if (hIconError == NULL)
hIconError = (HICON)LoadImage(hinstCabinet,
MAKEINTRESOURCE(nIcon), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON), 0);
IconData.hIcon = hIconError;
}
else
{
if (hIconNormal == NULL)
hIconNormal = (HICON)LoadImage(hinstCabinet,
MAKEINTRESOURCE(nIcon), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON), 0);
IconData.hIcon = hIconNormal;
}
IconData.uFlags |= NIF_ICON;
}
}
else
{
if (pidlFree)
{
ILGlobalFree(pidlFree);
pidlFree = NULL;
}
goto exit;
}
if (aArgs[0] != (DWORD)nFound)
{
aArgs[0] = nFound;
if (!FormatMessage(
FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
szFormat, 0, 0, IconData.szTip, ARRAYSIZE(IconData.szTip),
(va_list*)aArgs))
{
IconData.szTip[0] = TEXT('\0');
}
IconData.uFlags |= NIF_TIP;
}
// if the state has changed, update the tray notification area
if (IconData.uFlags)
{
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - updating icon area"));
Shell_NotifyIcon(dwNotifyMessage, &IconData);
dwNotifyMessage = NIM_MODIFY;
IconData.uFlags = 0;
}
break;
#ifndef WINNT
//
// WINNT is hacked only to send SHCNE_CREATE messages.
//
case SHCNE_UPDATEITEM:
//
// We need to free the pidl if one is passed in.
// (Currently one is not.)
//
pidlFree = (LPITEMIDLIST)msg.lParam;
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Thread_PrinterPoll SHCNE_UPDATEITEM"));
// if the JOB_STATUS_ERROR_BITS has
// changed, update the printer icon
if (((DWORD)msg.wParam ^ dwStatus) & JOB_STATUS_ERROR_BITS)
{
if ((DWORD)msg.wParam & JOB_STATUS_ERROR_BITS)
{
// A job just went into the error state, turn the
// icon on right away.
dwStatus |= JOB_STATUS_ERROR_BITS;
goto update_icon;
}
else
{
// Maybe the last job in an error state went
// out of the error state. Poll to find out.
// (But not more frequently than MINPOLLINTERVAL.)
if (dwTimeOut - dwTime < POLLINTERVAL - MINPOLLINTERVAL)
goto poll;
}
}
// Or if the icon size has changed.
if (s_cxSmIcon != cxSmIcon || s_cySmIcon != cySmIcon)
goto update_icon;
// don't wait as long next time
dwTimeOut -= dwTime;
if (dwTimeOut > POLLINTERVAL)
{
// oops, rollover; time to poll
goto poll;
}
break;
#endif
#ifdef DEBUG
default:
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Bogus PeekMessage 0x%X in Thread_PrinterPoll"), msg.message);
break;
#endif
}
if (pidlFree)
{
ILGlobalFree(pidlFree);
pidlFree = NULL;
}
} // while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
} // switch (dw)
} // for ( ; TRUE ; )
exit:
Error2:
FreeLibrary(hmodWinspool);
Error1:
SFCTerminateThread();
Error0:
{
HANDLE htPrinterPoll;
// Set g_ts.htPrinterPoll to null here and only here. we have a timing
// bug where someone sets this to null and we hang.
// Because g_ts.htPrinterPoll was null, we couldn't trace down what
// happened to the polling thread (it was lost).
ENTERCRITICAL;
htPrinterPoll = g_ts.htPrinterPoll;
g_ts.htPrinterPoll = NULL;
LEAVECRITICAL;
Assert(htPrinterPoll);
CloseHandle(htPrinterPoll);
}
if (psf)
{
psf->lpVtbl->Release(psf);
}
if (haPrinterNames)
{
int i;
for (i = DSA_GetItemCount(haPrinterNames) - 1 ; i >= 0 ; i--)
{
LPPRINTERNAME pPrinter = DSA_GetItemPtr(haPrinterNames,i);
ILFree(pPrinter->pidlPrinter);
}
DSA_Destroy(haPrinterNames);
}
if (nIconShown)
{
Shell_NotifyIcon(NIM_DELETE, &IconData);
}
if (hIconNormal)
{
DestroyIcon(hIconNormal);
}
if (hIconError)
{
DestroyIcon(hIconError);
}
return(0);
}
// This functions adds the printer name pointed to by pidl to the list
// of printers to poll by Thread_PrinterPoll
void PrintNotify_AddToQueue(LPHANDLE phaPrinterNames, LPSHELLFOLDER *ppsf, LPCITEMIDLIST pidlPrinter)
{
STRRET strret;
LPCTSTR pNewPrinter;
LPPRINTERNAME pPrinter;
int i;
LPOneTreeNode pnode;
LPSHELLFOLDER psf;
PRINTERNAME pn;
#ifdef UNICODE
LPCTSTR pszFree = NULL;
#endif
// We need the IShellFolder for the Printers Folder in order to get
// the display name of the printer
psf = *ppsf;
if (psf == NULL)
{
pnode = OTGetNodeFromIDList(g_ts.pidlPrintersFolder, OTGNF_TRYADD | OTGNF_VALIDATE);
if (!pnode)
{
goto exit;
}
psf = OTBindToFolder(pnode);
OTRelease(pnode);
if (!psf)
{
goto exit;
}
*ppsf = psf;
}
// all this work to get the name of the printer:
psf->lpVtbl->GetDisplayNameOf(psf, pidlPrinter, SHGDN_FORPARSING, &strret);
// we know how we implemented the printers GetDisplayNameOf function
#ifdef UNICODE
//
// pszFree saves a copy that will be freed on exit.
//
Assert(strret.uType == STRRET_OLESTR);
pszFree = pNewPrinter = strret.pOleStr;
#else
Assert(strret.uType == STRRET_OFFSET);
pNewPrinter = STRRET_OFFPTR(pidlPrinter, &strret);
#endif
if (*phaPrinterNames == NULL)
{
*phaPrinterNames = DSA_Create(SIZEOF(PRINTERNAME), 4);
if (*phaPrinterNames == NULL)
goto exit;
}
for (i=DSA_GetItemCount(*phaPrinterNames)-1 ; i>=0 ; --i)
{
pPrinter = DSA_GetItemPtr(*phaPrinterNames,i);
if (!lstrcmp(pPrinter->szPrinterName, pNewPrinter))
{
// printer already in list, no need to add it
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - [%s] already in poll list"), pNewPrinter);
goto exit;
}
}
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - adding [%s] to poll list"), pNewPrinter);
lstrcpy(pn.szPrinterName, pNewPrinter);
pn.fInErrorState = FALSE;
pn.pidlPrinter = ILClone(pidlPrinter);
DSA_InsertItem(*phaPrinterNames, 0x7fff, &pn);
exit:
#ifdef UNICODE
//
// Free the allocated string from GetDisplayNameOf in strret.
//
if (pszFree)
{
SHFree((LPVOID)pszFree);
}
#endif
return;
}
BOOL PrintNotify_StartThread(HWND hWnd)
{
PPRINTERPOLLDATA pPrinterPollData;
BOOL fRet;
if (g_ts.htPrinterPoll)
{
return TRUE;
}
ENTERCRITICAL;
// We check this again so that the above check will go very quickly,
// and almost always do the return
fRet = g_ts.htPrinterPoll != NULL;
if (fRet)
{
goto Error_Exit;
}
// We keep one event around to communicate with the polling thread so
// we don't need to keep re-creating it whenever the user prints.
// On the down side: this thing never does get freed up... Oh well.
if (!g_ts.heWakeUp)
{
g_ts.heWakeUp = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!g_ts.heWakeUp)
goto Error_Exit;
}
pPrinterPollData = (PPRINTERPOLLDATA)GlobalAlloc(GPTR, SIZEOF(PRINTERPOLLDATA));
if (!pPrinterPollData)
{
goto Error_Exit;
}
pPrinterPollData->hWnd = hWnd;
pPrinterPollData->heWakeUp = g_ts.heWakeUp;
g_ts.htPrinterPoll = CreateThread(NULL, 0, Thread_PrinterPoll,
pPrinterPollData, 0, &g_ts.idPrinterPoll);
fRet = g_ts.htPrinterPoll != NULL;
LEAVECRITICAL;
if (fRet)
{
// wait until the new thread's message queue is ready
// I had INFINITE here, but something funky happened once on a build
// machine which caused MSGSRV32 to hang waiting for this thread to
// unblock. If we timeout, the worst that will happen is our icon won't
// show and/or we'll keep destroying re-creating the polling thread
// until everything works.
WaitForSingleObject(g_ts.heWakeUp, ERRTIMEOUT);
DebugMsg(DM_TRACE, TEXT("sh PRINTNOTIFY - Thread_PrinterPoll started"));
}
else
{
GlobalFree(pPrinterPollData);
}
goto Exit;
Error_Exit:
LEAVECRITICAL;
Exit:
return fRet;
}
void PrintNotify_HandleFSNotify(HWND hWnd, LPCITEMIDLIST *ppidl, LONG lEvent)
{
LPITEMIDLIST pidl;
// Look at the pidl to determine if it's a Print Job notification. If it
// is, we may also need a copy of the relative Printer pidl. Pass the
// notification on to our polling thread so the tray isn't stuck waiting
// for a (net) print subsystem query (up to 15 seconds if net is funky).
pidl = ILClone(ppidl[0]);
if (pidl)
{
LPITEMIDLIST pidlPrintJob;
LPITEMIDLIST pidlPrinter;
LPITEMIDLIST pidlPrintersFolder;
USHORT cbPidlPrinter;
pidlPrintJob = ILFindLastID(pidl);
ILRemoveLastID(pidl);
pidlPrinter = ILFindLastID(pidl);
cbPidlPrinter = pidlPrinter->mkid.cb;
ILRemoveLastID(pidl);
pidlPrintersFolder = pidl;
if (ILIsEqual(pidlPrintersFolder, g_ts.pidlPrintersFolder))
{
if (PrintNotify_StartThread(hWnd))
{
LPCITEMIDLIST pidlPrinterName = NULL;
LPSHCNF_PRINTJOB_DATA pData;
// HACK: we know the format of this (internal) "temporary" pidl
// which exists only between SHChangeNotify and here
pData = (LPSHCNF_PRINTJOB_DATA)(pidlPrintJob->mkid.abID);
// PERFORMANCE: SHCNE_CREATE can just add one to the local count
// and SHCNE_DELETE will sub one from the local count and start
// polling this printer to get the net count.
// GOOD ENOUGH: poll on create and delete.
if (SHCNE_UPDATEITEM != lEvent)
{
// this was whacked with one of the above ILRemoveLastID()s
pidlPrinter->mkid.cb = cbPidlPrinter;
// this is freed in the polling thread
pidlPrinterName = ILGlobalClone(pidlPrinter);
}
// REVIEW: What if we PostThreadMessage to a dead thread?
// PrintNotify_StartThread can start the thread and give us
// the idPrinterPoll, but then under certain error conditions
// the new thread will terminate itself. This can happen
// after the above if and before this post.
PostThreadMessage(g_ts.idPrinterPoll, WM_USER+(UINT)lEvent,
(WPARAM)pData->Status, (LPARAM)pidlPrinterName);
}
}
ILFree(pidl);
}
}
void PrintNotify_Exit(void)
{
// PrintNotify_Init only initializes if it can get the pidlPrintsFolder
if (g_ts.pidlPrintersFolder)
{
if (g_ts.uPrintNotify)
{
SHChangeNotifyDeregister(g_ts.uPrintNotify);
}
if (g_ts.htPrinterPoll)
{
// Signal the PrinterPoll thread to exit
if (g_ts.heWakeUp)
{
SetEvent(g_ts.heWakeUp);
}
WaitForSingleObject(g_ts.htPrinterPoll, ERRTIMEOUT);
}
// Free this last just in case the htPrinterPoll thread was active
ILFree((LPITEMIDLIST)g_ts.pidlPrintersFolder);
}
}
void PrintNotify_IconNotify(HWND hWnd, UINT uMsg)
{
switch (uMsg)
{
case WM_LBUTTONDBLCLK:
case WM_RBUTTONUP:
// call off to worker thread to bring up the context menu --
// we need to access the list of polling printers for this
if (g_ts.htPrinterPoll && g_ts.idPrinterPoll)
{
PostThreadMessage(g_ts.idPrinterPoll, WM_USER+uMsg, 0, 0);
}
else if (uMsg == WM_LBUTTONDBLCLK)
{
ShowFolder(hWnd, IDM_PRINTERS, COF_USEOPENSETTINGS);
}
break;
}
}
////////////////////////////////////////////////////////////////////////////
// End Print Notify stuff
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//
// IsDisplayChangeSafe()
//
// make sure the display change is a safe thing to do.
//
// NOTE this code can easily be fooled if we are running on HW that will be
// gone after a undoc.
//
////////////////////////////////////////////////////////////////////////////
BOOL IsDisplayChangeSafe()
{
HDC hdc;
BOOL fSafe;
BOOL fVGA;
hdc = GetDC(NULL);
fVGA = GetDeviceCaps(hdc, PLANES) == 4 &&
GetDeviceCaps(hdc, BITSPIXEL) == 1 &&
GetDeviceCaps(hdc, HORZRES) == 640 &&
GetDeviceCaps(hdc, VERTRES) == 480;
fSafe = fVGA || (GetDeviceCaps(hdc, CAPS1) & C1_REINIT_ABLE);
ReleaseDC(NULL, hdc);
return fSafe;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
int BlueScreenMesssgeBox(TCHAR *szTitle, TCHAR *szText, int flags)
{
#ifndef WINNT
BLUESCREENINFO bsi = {szText, szTitle, flags};
int cb;
HANDLE h;
//BUGBUG
// AnsiToOEM(szTitle, szTitle);
// AnsiToOEM(szText, szText);
h = CreateFile(SHELLFILENAME, GENERIC_WRITE, FILE_SHARE_WRITE,
0, OPEN_EXISTING, 0, 0);
if (h != INVALID_HANDLE_VALUE)
{
DeviceIoControl(h, WSHIOCTL_BLUESCREEN, &bsi, SIZEOF(bsi),
&flags, SIZEOF(flags), &cb, 0);
CloseHandle(h);
}
return flags;
#else
// BUGBUG - We need to figure out what to do for NT here
return 0;
#endif
}
const TCHAR c_szConfig[] = REGSTR_KEY_CONFIG;
const TCHAR c_szSlashDisplaySettings[] = TEXT("\\") REGSTR_PATH_DISPLAYSETTINGS;
const TCHAR c_szResolution[] = REGSTR_VAL_RESOLUTION;
//
// GetMinDisplayRes
//
// walk all the configs and find the minimum display resolution.
//
// when doing a hot undock we have no idea what config we are
// going to undock into.
//
// we want to put the display into a "common" mode that all configs
// can handle so we dont "fry" the display when we wake up in the
// new mode.
//
DWORD GetMinDisplayRes(void)
{
TCHAR ach[128];
UINT cb;
HKEY hkey;
HKEY hkeyT;
int i,n;
int xres=0;
int yres=0;
if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szConfig, &hkey) == ERROR_SUCCESS)
{
for (n=0; RegEnumKey(hkey, n, ach, ARRAYSIZE(ach)) == ERROR_SUCCESS; n++)
{
lstrcat(ach,c_szSlashDisplaySettings); // 0000\Display\Settings
DebugMsg(DM_TRACE, TEXT("GetMinDisplayRes: found config %s"), ach);
if (RegOpenKey(hkey, ach, &hkeyT) == ERROR_SUCCESS)
{
cb = SIZEOF(ach);
ach[0] = 0;
RegQueryValueEx(hkeyT, c_szResolution, 0, NULL, (LPBYTE) &ach[0], &cb);
DebugMsg(DM_TRACE, TEXT("GetMinDisplayRes: found res %s"), ach);
if (ach[0])
{
i = StrToInt(ach);
if (i < xres || xres == 0)
xres = i;
for (i=1;ach[i] && ach[i-1]!=TEXT(','); i++)
;
i = StrToInt(ach + i);
if (i < yres || yres == 0)
yres = i;
}
else
{
xres = 640;
yres = 480;
}
RegCloseKey(hkeyT);
}
}
RegCloseKey(hkey);
}
DebugMsg(DM_TRACE, TEXT("GetMinDisplayRes: xres=%d yres=%d"), xres, yres);
if (xres == 0 || yres == 0)
return MAKELONG(640,480);
else
return MAKELONG(xres,yres);
}
//
// the user has done a un-doc or re-doc we may need to switch
// to a new display mode.
//
// if fCritical is set the mode switch is critical, show a error
// if it does not work.
//
void HandleDisplayChange(int x, int y, BOOL fCritical)
{
TCHAR ach[256];
DEVMODE dm;
LONG err;
HDC hdc;
//
// try to change into the mode specific to this config
// HKEY_CURRENT_CONFIG has already been updated by PnP
// so all we have to do is re-init the current display
//
// we cant default to current bpp because we may have changed configs.
// and the bpp may be different in the new config.
//
dm.dmSize = SIZEOF(dm);
dm.dmFields = DM_BITSPERPEL;
hdc = GetDC(NULL);
dm.dmBitsPerPel = GetDeviceCaps(hdc, PLANES) * GetDeviceCaps(hdc, BITSPIXEL);
ReleaseDC(NULL, hdc);
if (x + y)
{
dm.dmFields |= DM_PELSWIDTH|DM_PELSHEIGHT;
dm.dmPelsWidth = x;
dm.dmPelsHeight = y;
}
err = ChangeDisplaySettings(&dm, 0);
if (err != 0 && fCritical)
{
//
// if it fails make a panic atempt to try 640x480, if
// that fails also we should put up a big error message
// in text mode and tell the user he is screwed.
//
dm.dmFields = DM_PELSWIDTH|DM_PELSHEIGHT|DM_BITSPERPEL;
dm.dmPelsWidth = 640;
dm.dmPelsHeight = 480;
err = ChangeDisplaySettings(&dm, 0);
if (err != 0)
{
//
// if 640x480 fails we should put up a big error message
// in text mode and tell the user he is screwed. and
// offer to reboot his machine.
//
MessageBeep(0);
LoadString(hinstCabinet, IDS_DISPLAY_ERROR, ach, ARRAYSIZE(ach));
BlueScreenMesssgeBox(NULL, ach, MB_OK);
}
}
}
void HandleGlobalHotkey(WPARAM wParam)
{
PFileCabinet pfc = g_pfcTray;
switch(wParam)
{
case GHID_RUN:
Tray_RunDlg();
break;
case GHID_MINIMIZEALL:
if (CanMinimizeAll(pfc->hwndView))
MinimizeAll(pfc->hwndView);
SetForegroundWindow(v_hwndDesktop);
break;
case GHID_UNMINIMIZEALL:
RestoreWindowPositions();
break;
case GHID_HELP:
TrayCommand(pfc, IDM_HELPSEARCH);
break;
case GHID_EXPLORER:
ShowFolder(pfc->hwndMain, IDM_MYCOMPUTER, COF_CREATENEWWINDOW | COF_EXPLORE);
break;
case GHID_FINDFILES:
TrayCommand(pfc, FCIDM_FINDFILES);
break;
case GHID_FINDCOMPUTER:
TrayCommand(pfc, FCIDM_FINDCOMPUTER);
break;
case GHID_TASKTAB:
case GHID_TASKSHIFTTAB:
if (GetForegroundWindow() != v_hwndTray)
SetForegroundWindow(v_hwndTray);
SendMessage(pfc->hwndView, TM_TASKTAB, wParam == GHID_TASKTAB ? 1 : -1, 0L);
break;
case GHID_SYSPROPERTIES:
#define IDS_SYSDMCPL 0x2334 // from shelldll
SHRunControlPanel(MAKEINTRESOURCE(IDS_SYSDMCPL), pfc->hwndMain);
break;
}
}
void UnregisterGlobalHotkeys()
{
int i;
for (i = 0 ; i < GHID_MAX; i++) {
UnregisterHotKey(v_hwndDesktop, i);
};
}
void RegisterGlobalHotkeys()
{
int i;
for (i = 0 ; i < GHID_MAX; i++) {
RegisterHotKey(v_hwndDesktop, i, HIWORD(GlobalKeylist[i]), LOWORD(GlobalKeylist[i]));
};
}