1373 lines
38 KiB
C++
1373 lines
38 KiB
C++
#include "private.h"
|
|
#include "chanmgr.h"
|
|
#include "chanmgrp.h"
|
|
#include "shguidp.h"
|
|
#include "resource.h"
|
|
#define DECL_CRTFREE
|
|
#include <crtfree.h>
|
|
|
|
|
|
#include <mluisupp.h>
|
|
|
|
#define TF_DUMPTRIGGER 0x80000000
|
|
|
|
#define PtrDifference(x,y) ((LPBYTE)(x)-(LPBYTE)(y))
|
|
|
|
// Invoke Command verb strings
|
|
const CHAR c_szOpen[] = "open";
|
|
const CHAR c_szDelete[] = "delete";
|
|
const CHAR c_szProperties[] = "properties";
|
|
const CHAR c_szCopy[] = "copy";
|
|
const CHAR c_szRename[] = "rename";
|
|
const CHAR c_szPaste[] = "paste";
|
|
|
|
static TCHAR szNone[40] = {0};
|
|
static TCHAR szUnknown[40] = {0};
|
|
|
|
// For each notification handler CLSID in the registry, send a single CommandId and Cookie to each handler.
|
|
void FireSubscriptionEvent(int nCmdID, const SUBSCRIPTIONCOOKIE UNALIGNED *pCookie_ua)
|
|
{
|
|
HKEY hkey;
|
|
SUBSCRIPTIONCOOKIE cookie_buf;
|
|
SUBSCRIPTIONCOOKIE *pCookie;
|
|
|
|
ASSERT( pCookie_ua );
|
|
|
|
if ( ! pCookie_ua )
|
|
{
|
|
TraceMsg(TF_ERROR, "FireSubscriptionEvent() - pCookie_ua is NULL!");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make an aligned copy of pCookie_ua and set a pointer to it.
|
|
//
|
|
|
|
cookie_buf = *pCookie_ua;
|
|
pCookie = &cookie_buf;
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WEBCHECK_REGKEY_NOTF, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
|
|
{
|
|
LPOLESTR pszCookie;
|
|
|
|
if (SUCCEEDED(StringFromCLSID(*pCookie, &pszCookie)))
|
|
{
|
|
VARIANT varCookie;
|
|
|
|
varCookie.vt = VT_BSTR;
|
|
varCookie.bstrVal = SysAllocString(pszCookie);
|
|
|
|
if (varCookie.bstrVal)
|
|
{
|
|
for (int i = 0; ; i++)
|
|
{
|
|
TCHAR szClsid[GUIDSTR_MAX];
|
|
DWORD cchClsid = ARRAYSIZE(szClsid);
|
|
DWORD dwType;
|
|
DWORD dwData;
|
|
DWORD cbData = sizeof(dwData);
|
|
|
|
int result = RegEnumValue(hkey, i, szClsid, &cchClsid, NULL, &dwType, (LPBYTE)&dwData, &cbData);
|
|
|
|
if (ERROR_NO_MORE_ITEMS == result)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ((ERROR_SUCCESS == result) && (dwData & nCmdID))
|
|
{
|
|
WCHAR wszClsid[GUIDSTR_MAX];
|
|
CLSID clsid;
|
|
|
|
SHTCharToUnicode(szClsid, wszClsid, ARRAYSIZE(wszClsid));
|
|
|
|
HRESULT hr = CLSIDFromString(wszClsid, &clsid);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IOleCommandTarget *pCmdTarget;
|
|
|
|
hr = CoCreateInstance(*(&clsid), NULL, CLSCTX_ALL, IID_IOleCommandTarget, (void **)&pCmdTarget);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pCmdTarget->Exec(&CLSID_SubscriptionMgr, nCmdID, 0, &varCookie, NULL);
|
|
pCmdTarget->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VariantClear(&varCookie);
|
|
}
|
|
|
|
CoTaskMemFree(pszCookie);
|
|
}
|
|
|
|
RegCloseKey( hkey );
|
|
}
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
HRESULT IExtractIcon_GetIconLocationThunk(IExtractIconW *peiw, UINT uFlags, LPSTR szIconFile, UINT cchMax, int * piIndex, UINT * pwFlags)
|
|
{
|
|
HRESULT hr;
|
|
WCHAR *pwszIconFile = new WCHAR[cchMax];
|
|
|
|
if (NULL != pwszIconFile)
|
|
{
|
|
hr = peiw->GetIconLocation(uFlags, pwszIconFile, cchMax, piIndex, pwFlags);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pwszIconFile, -1, szIconFile, cchMax, NULL, NULL);
|
|
}
|
|
|
|
delete [] pwszIconFile;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT IExtractIcon_ExtractThunk(IExtractIconW *peiw, LPCSTR pszFile, UINT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIconSize)
|
|
{
|
|
HRESULT hr;
|
|
int len = lstrlenA(pszFile) + 1;
|
|
WCHAR *pwszFile = new WCHAR[len];
|
|
|
|
if (NULL != pwszFile)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, pszFile, len, pwszFile, len);
|
|
|
|
hr = peiw->Extract(pwszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);
|
|
|
|
delete [] pwszFile;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
DWORD Random(DWORD nMax)
|
|
{
|
|
static DWORD dwSeed = GetTickCount();
|
|
|
|
if (nMax)
|
|
{
|
|
return dwSeed = (dwSeed * 214013L + 2531011L) % nMax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void CreateCookie(GUID UNALIGNED *pCookie_ua)
|
|
{
|
|
static DWORD dwCount = 0;
|
|
|
|
union CUCookie
|
|
{
|
|
GUID guidCookie;
|
|
struct XCookie {
|
|
FILETIME ft;
|
|
DWORD dwCount;
|
|
DWORD dwRand;
|
|
} x;
|
|
};
|
|
|
|
CUCookie uc;
|
|
GetSystemTimeAsFileTime(&uc.x.ft);
|
|
uc.x.dwCount = dwCount++;
|
|
uc.x.dwRand = Random(0xffffffff);
|
|
|
|
*pCookie_ua = uc.guidCookie;
|
|
}
|
|
|
|
void VariantTimeToFileTime(double dt, FILETIME& ft)
|
|
{
|
|
SYSTEMTIME st;
|
|
|
|
VariantTimeToSystemTime(dt, &st);
|
|
SystemTimeToFileTime(&st, &ft);
|
|
}
|
|
|
|
void FileTimeToVariantTime(FILETIME& ft, double *pdt)
|
|
{
|
|
SYSTEMTIME st;
|
|
|
|
FileTimeToSystemTime(&ft, &st);
|
|
SystemTimeToVariantTime(&st, pdt);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Cache helper functions
|
|
//
|
|
|
|
// Caller should MemFree *lpCacheConfigInfo when done. Should pass *lpCacheConfigInfo
|
|
// into SetCacheSize
|
|
HRESULT GetCacheInfo(
|
|
LPINTERNET_CACHE_CONFIG_INFOA *lplpCacheConfigInfo,
|
|
DWORD *pdwSizeInKB,
|
|
DWORD *pdwPercent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPINTERNET_CACHE_CONFIG_INFOA lpCCI = NULL;
|
|
DWORD dwSize;
|
|
|
|
dwSize = sizeof(INTERNET_CACHE_CONFIG_INFOA);
|
|
|
|
lpCCI = (LPINTERNET_CACHE_CONFIG_INFOA)MemAlloc(LPTR, dwSize);
|
|
|
|
if (!lpCCI)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
lpCCI->dwStructSize = sizeof(INTERNET_CACHE_CONFIG_INFOA);
|
|
|
|
if (!GetUrlCacheConfigInfoA(lpCCI, &dwSize, CACHE_CONFIG_CONTENT_PATHS_FC))
|
|
{
|
|
hr = E_FAIL; // HRESULT_FROM_WIN32(GetLastError());
|
|
goto cleanup;
|
|
}
|
|
|
|
// there should be at least one cache path structure
|
|
if (dwSize < sizeof(INTERNET_CACHE_CONFIG_INFOA) ||
|
|
lpCCI->dwNumCachePaths != 1)
|
|
{
|
|
// something is messed up
|
|
hr = E_FAIL;
|
|
goto cleanup;
|
|
}
|
|
|
|
*lplpCacheConfigInfo = lpCCI;
|
|
*pdwSizeInKB = lpCCI->dwQuota;
|
|
*pdwPercent = 10; // good faith estimate
|
|
|
|
ASSERT(*pdwSizeInKB); // Better not be 0...
|
|
|
|
cleanup:
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SAFELOCALFREE(lpCCI);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT SetCacheSize(
|
|
LPINTERNET_CACHE_CONFIG_INFOA lpCacheConfigInfo,
|
|
DWORD dwSizeInKB)
|
|
{
|
|
// lpCacheConfigInfo->dwNumCachePaths = 1;
|
|
// lpCacheConfigInfo->CachePaths[0].dwCacheSize = dwSizeInKB;
|
|
lpCacheConfigInfo->dwContainer = 0; // CONTENT;
|
|
lpCacheConfigInfo->dwQuota = dwSizeInKB;
|
|
|
|
if (!SetUrlCacheConfigInfoA(lpCacheConfigInfo, CACHE_CONFIG_QUOTA_FC))
|
|
{
|
|
return E_FAIL; // HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Registry helper functions
|
|
//
|
|
BOOL ReadRegValue(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue,
|
|
void *pData, DWORD dwBytes)
|
|
{
|
|
long lResult;
|
|
HKEY hkey;
|
|
DWORD dwType;
|
|
|
|
lResult = RegOpenKey(hkeyRoot, pszKey, &hkey);
|
|
if (lResult != ERROR_SUCCESS) {
|
|
return FALSE;
|
|
}
|
|
|
|
lResult = RegQueryValueEx(hkey, pszValue, NULL, &dwType, (BYTE *)pData,
|
|
&dwBytes);
|
|
RegCloseKey(hkey);
|
|
|
|
if (lResult != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
if(dwType == REG_SZ) {
|
|
// null terminate string
|
|
((TCHAR *)pData)[dwBytes] = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL WriteRegValue(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue,
|
|
void *pData, DWORD dwBytes, DWORD dwType)
|
|
{
|
|
HKEY hkey;
|
|
long lResult;
|
|
DWORD dwStatus;
|
|
|
|
lResult = RegCreateKeyEx(hkeyRoot, pszKey, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hkey, &dwStatus);
|
|
if (lResult != ERROR_SUCCESS) {
|
|
return FALSE;
|
|
}
|
|
|
|
lResult = RegSetValueEx(hkey, pszValue, 0, dwType, (BYTE *)pData, dwBytes);
|
|
RegCloseKey(hkey);
|
|
|
|
return (lResult == ERROR_SUCCESS) ? TRUE : FALSE;
|
|
}
|
|
|
|
DWORD ReadRegDWORD(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue)
|
|
{
|
|
DWORD dwData;
|
|
if (ReadRegValue(hkeyRoot, pszKey, pszValue, &dwData, sizeof(dwData)))
|
|
return dwData;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CreateShellFolderPath(LPCTSTR pszPath, LPCTSTR pszGUID, BOOL bUICLSID)
|
|
{
|
|
if (!PathFileExists(pszPath))
|
|
CreateDirectory(pszPath, NULL);
|
|
|
|
// Mark the folder as a system directory
|
|
if (SetFileAttributes(pszPath, FILE_ATTRIBUTE_READONLY))
|
|
{
|
|
TCHAR szDesktopIni[MAX_PATH];
|
|
// Write in the desktop.ini the cache folder class ID
|
|
PathCombine(szDesktopIni, pszPath, TEXT("desktop.ini"));
|
|
|
|
// If the desktop.ini already exists, make sure it is writable
|
|
if (PathFileExists(szDesktopIni))
|
|
SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_NORMAL);
|
|
|
|
// (First, flush the cache to make sure the desktop.ini
|
|
// file is really created.)
|
|
WritePrivateProfileString(NULL, NULL, NULL, szDesktopIni);
|
|
WritePrivateProfileString(TEXT(".ShellClassInfo"), bUICLSID ? TEXT("UICLSID") : TEXT("CLSID"), pszGUID, szDesktopIni);
|
|
WritePrivateProfileString(NULL, NULL, NULL, szDesktopIni);
|
|
|
|
// Hide the desktop.ini since the shell does not selectively
|
|
// hide it.
|
|
SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_HIDDEN);
|
|
|
|
return NOERROR;
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("Cannot make %s a system folder"), pszPath);
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
void CleanupShellFolder(LPCTSTR pszPath)
|
|
{
|
|
if (PathFileExists(pszPath))
|
|
{
|
|
TCHAR szDesktopIni[MAX_PATH];
|
|
|
|
// make the history a normal folder
|
|
SetFileAttributes(pszPath, FILE_ATTRIBUTE_NORMAL);
|
|
PathCombine(szDesktopIni, pszPath, TEXT("desktop.ini"));
|
|
|
|
// If the desktop.ini already exists, make sure it is writable
|
|
if (PathFileExists(szDesktopIni))
|
|
{
|
|
SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFile(szDesktopIni);
|
|
}
|
|
|
|
// remove the history directory
|
|
RemoveDirectory(pszPath);
|
|
}
|
|
}
|
|
|
|
BOOL GetSubscriptionFolderPath(LPTSTR pszPath)
|
|
{
|
|
DWORD dwDummy;
|
|
HKEY hk;
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_SUBSCRIPTION,
|
|
0, TEXT(""),
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_READ|KEY_WRITE, NULL, &hk, &dwDummy))
|
|
{
|
|
DWORD cbData = MAX_PATH * sizeof(TCHAR);
|
|
if (ERROR_SUCCESS != RegQueryValueEx(hk, REGSTR_VAL_DIRECTORY , NULL, NULL, (LPBYTE)pszPath, &cbData))
|
|
{
|
|
TCHAR szWindows[MAX_PATH];
|
|
GetWindowsDirectory(szWindows, ARRAYSIZE(szWindows));
|
|
PathCombine(pszPath, szWindows, TEXT("Offline Web Pages"));
|
|
}
|
|
RegCloseKey(hk);
|
|
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT GetChannelPath(LPCTSTR pszURL, LPTSTR pszPath, int cch,
|
|
IChannelMgrPriv** ppIChannelMgrPriv)
|
|
{
|
|
ASSERT(pszURL);
|
|
ASSERT(pszPath || 0 == cch);
|
|
ASSERT(ppIChannelMgrPriv);
|
|
|
|
HRESULT hr;
|
|
BOOL bCoinit = FALSE;
|
|
|
|
hr = CoCreateInstance(CLSID_ChannelMgr, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IChannelMgrPriv, (void**)ppIChannelMgrPriv);
|
|
|
|
if ((hr == CO_E_NOTINITIALIZED || hr == REGDB_E_IIDNOTREG) &&
|
|
SUCCEEDED(CoInitialize(NULL)))
|
|
{
|
|
bCoinit = TRUE;
|
|
hr = CoCreateInstance(CLSID_ChannelMgr, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IChannelMgrPriv, (void**)ppIChannelMgrPriv);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(*ppIChannelMgrPriv);
|
|
|
|
IChannelMgr* pIChannelMgr;
|
|
|
|
hr = (*ppIChannelMgrPriv)->QueryInterface(IID_IChannelMgr,
|
|
(void**)&pIChannelMgr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(pIChannelMgr);
|
|
|
|
WCHAR wszURL[INTERNET_MAX_URL_LENGTH];
|
|
MyStrToOleStrN(wszURL, ARRAYSIZE(wszURL), pszURL);
|
|
|
|
IEnumChannels* pIEnumChannels;
|
|
|
|
hr = pIChannelMgr->EnumChannels(CHANENUM_ALLFOLDERS | CHANENUM_PATH,
|
|
wszURL, &pIEnumChannels);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(pIEnumChannels);
|
|
|
|
CHANNELENUMINFO ci;
|
|
|
|
if (S_OK == pIEnumChannels->Next(1, &ci, NULL))
|
|
{
|
|
MyOleStrToStrN(pszPath, cch, ci.pszPath);
|
|
|
|
CoTaskMemFree(ci.pszPath);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
pIEnumChannels->Release();
|
|
}
|
|
|
|
pIChannelMgr->Release();
|
|
}
|
|
|
|
}
|
|
|
|
if (bCoinit)
|
|
CoUninitialize();
|
|
|
|
ASSERT((SUCCEEDED(hr) && *ppIChannelMgrPriv) || FAILED(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Caller is responsible for calling ILFree on *ppidl.
|
|
HRESULT ConvertPathToPidl(LPCTSTR path, LPITEMIDLIST * ppidl)
|
|
{
|
|
WCHAR wszPath[MAX_PATH];
|
|
IShellFolder * pDesktopFolder;
|
|
HRESULT hr;
|
|
|
|
ASSERT(path && ppidl);
|
|
* ppidl = NULL;
|
|
|
|
MyStrToOleStrN(wszPath, MAX_PATH, path);
|
|
hr = SHGetDesktopFolder(&pDesktopFolder);
|
|
if (hr != NOERROR)
|
|
return hr;
|
|
|
|
ULONG uChEaten;
|
|
|
|
hr = pDesktopFolder->ParseDisplayName(NULL, NULL, wszPath,
|
|
&uChEaten, ppidl, NULL);
|
|
SAFERELEASE(pDesktopFolder);
|
|
|
|
return hr;
|
|
}
|
|
|
|
LPITEMIDLIST GetSubscriptionFolderPidl(void)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
static LPITEMIDLIST pidlFolder = NULL; // We leak here.
|
|
|
|
if (!pidlFolder) {
|
|
if (!(GetSubscriptionFolderPath(szPath)))
|
|
return NULL;
|
|
if (FAILED(ConvertPathToPidl(szPath, &pidlFolder)))
|
|
return NULL;
|
|
ASSERT(pidlFolder);
|
|
}
|
|
return (LPITEMIDLIST)pidlFolder;
|
|
}
|
|
|
|
STDAPI OfflineFolderRegisterServer(void)
|
|
{
|
|
TCHAR szOldSubscriptionPath[MAX_PATH];
|
|
|
|
GetWindowsDirectory(szOldSubscriptionPath, ARRAYSIZE(szOldSubscriptionPath));
|
|
PathCombine(szOldSubscriptionPath, szOldSubscriptionPath, TEXT("Subscriptions"));
|
|
CleanupShellFolder(szOldSubscriptionPath);
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
if (!(GetSubscriptionFolderPath(szPath)))
|
|
goto CleanUp;
|
|
|
|
// we pass FALSE because history folder uses CLSID
|
|
if (FAILED(CreateShellFolderPath(szPath, TEXT("{F5175861-2688-11d0-9C5E-00AA00A45957}"), FALSE)))
|
|
goto CleanUp;
|
|
|
|
return NOERROR;
|
|
|
|
CleanUp: // cleanup stuff if any of our reg stuff fails
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDAPI OfflineFolderUnregisterServer(void)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
if (!(GetSubscriptionFolderPath(szPath)))
|
|
goto CleanUp;
|
|
|
|
// we pass FALSE because history folder uses CLSID
|
|
CleanupShellFolder(szPath);
|
|
|
|
return NOERROR;
|
|
|
|
CleanUp: // cleanup stuff if any of our reg stuff fails
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
|
|
HMENU LoadPopupMenu(UINT id, UINT uSubOffset)
|
|
{
|
|
HMENU hmParent, hmPopup;
|
|
|
|
hmParent = LoadMenu(MLGetHinst(), MAKEINTRESOURCE(id));
|
|
if (!hmParent)
|
|
return NULL;
|
|
|
|
hmPopup = GetSubMenu(hmParent, uSubOffset);
|
|
RemoveMenu(hmParent, uSubOffset, MF_BYPOSITION);
|
|
DestroyMenu(hmParent);
|
|
|
|
return hmPopup;
|
|
}
|
|
|
|
UINT MergePopupMenu(HMENU *phMenu, UINT idResource, UINT uSubOffset, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast)
|
|
{
|
|
HMENU hmMerge;
|
|
|
|
if (*phMenu == NULL)
|
|
{
|
|
*phMenu = CreatePopupMenu();
|
|
if (*phMenu == NULL)
|
|
return 0;
|
|
|
|
indexMenu = 0; // at the bottom
|
|
}
|
|
|
|
hmMerge = LoadPopupMenu(idResource, uSubOffset);
|
|
if (!hmMerge)
|
|
return 0;
|
|
|
|
idCmdLast = Shell_MergeMenus(*phMenu, hmMerge, indexMenu, idCmdFirst, idCmdLast, MM_ADDSEPARATOR);
|
|
|
|
DestroyMenu(hmMerge);
|
|
return idCmdLast;
|
|
}
|
|
|
|
HMENU GetMenuFromID(HMENU hmenu, UINT idm)
|
|
{
|
|
MENUITEMINFO mii = { sizeof(mii), MIIM_SUBMENU, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0 };
|
|
GetMenuItemInfo(hmenu, idm, FALSE, &mii);
|
|
return mii.hSubMenu;
|
|
}
|
|
|
|
UINT MergeMenuHierarchy(HMENU hmenuDst, HMENU hmenuSrc, UINT idcMin, UINT idcMax, BOOL bTop)
|
|
{
|
|
UINT idcMaxUsed = idcMin;
|
|
int imi = GetMenuItemCount(hmenuSrc);
|
|
|
|
while (--imi >= 0)
|
|
{
|
|
MENUITEMINFO mii = {
|
|
sizeof(MENUITEMINFO),
|
|
MIIM_ID | MIIM_SUBMENU,
|
|
0,/* fType */ 0,/* fState */ 0,/*wId*/ NULL,
|
|
NULL, NULL, 0,
|
|
NULL, 0 };
|
|
|
|
if (GetMenuItemInfo(hmenuSrc, imi, TRUE, &mii))
|
|
{
|
|
UINT idcT = Shell_MergeMenus(
|
|
GetMenuFromID(hmenuDst, mii.wID),
|
|
mii.hSubMenu, (bTop)?0:1024, idcMin, idcMax,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
idcMaxUsed = max(idcMaxUsed, idcT);
|
|
}
|
|
}
|
|
return idcMaxUsed;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Helper Fuctions for item.cpp and folder.cpp
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
int _CompareURL(LPMYPIDL pooi1, LPMYPIDL pooi2)
|
|
{
|
|
return UrlCompare(URL(&(pooi1->ooe)), URL(&(pooi2->ooe)), TRUE);
|
|
}
|
|
|
|
int _CompareShortName(LPMYPIDL pooi1, LPMYPIDL pooi2)
|
|
{
|
|
PCTSTR pszNameLocal1;
|
|
PCTSTR pszNameLocal2;
|
|
|
|
LPTSTR szNameUnaligned1 = NAME(&(pooi1->ooe));
|
|
LPTSTR szNameUnaligned2 = NAME(&(pooi2->ooe));
|
|
|
|
TSTR_ALIGNED_STACK_COPY( &pszNameLocal1, szNameUnaligned1 );
|
|
TSTR_ALIGNED_STACK_COPY( &pszNameLocal2, szNameUnaligned2 );
|
|
|
|
return StrCmp( pszNameLocal1, pszNameLocal2 );
|
|
}
|
|
|
|
int _CompareLastUpdate(LPMYPIDL pooi1, LPMYPIDL pooi2)
|
|
{
|
|
if (pooi1->ooe.m_LastUpdated - pooi2->ooe.m_LastUpdated > 0)
|
|
return 1;
|
|
return -1;
|
|
}
|
|
|
|
int _CompareCookie(REFCLSID cookie1, REFCLSID cookie2)
|
|
{
|
|
return memcmp(&cookie1, &cookie2, sizeof(CLSID));
|
|
}
|
|
|
|
int _CompareStatus(LPMYPIDL pooi1, LPMYPIDL pooi2)
|
|
{
|
|
return StrCmp(STATUS(&(pooi1->ooe)), STATUS(&(pooi2->ooe)));
|
|
}
|
|
|
|
int _CompareIdentities(LPMYPIDL pooi1, LPMYPIDL pooi2)
|
|
{
|
|
if (pooi1->ooe.clsidDest != pooi2->ooe.clsidDest)
|
|
return -1;
|
|
|
|
if (!IsNativeAgent(pooi1->ooe.clsidDest))
|
|
return _CompareCookie(pooi1->ooe.m_Cookie, pooi2->ooe.m_Cookie);
|
|
|
|
return _CompareURL(pooi1, pooi2);
|
|
}
|
|
|
|
BOOL _ValidateIDListArray(UINT cidl, LPCITEMIDLIST *ppidl)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < cidl; i++)
|
|
{
|
|
if (!IS_VALID_MYPIDL(ppidl[i]))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int _LaunchApp(HWND hwnd, LPCTSTR pszPath)
|
|
{
|
|
SHELLEXECUTEINFO ei = { 0 };
|
|
|
|
ei.cbSize = sizeof(SHELLEXECUTEINFO);
|
|
ei.hwnd = hwnd;
|
|
ei.lpFile = pszPath;
|
|
ei.nShow = SW_SHOWNORMAL;
|
|
|
|
return ShellExecuteEx(&ei);
|
|
}
|
|
|
|
void _GenerateEvent(LONG lEventId, LPITEMIDLIST pidlIn, LPITEMIDLIST pidlNewIn, BOOL bRefresh)
|
|
{
|
|
LPITEMIDLIST pidlFolder = GetSubscriptionFolderPidl();
|
|
if (!pidlFolder)
|
|
return;
|
|
|
|
LPITEMIDLIST pidl = ILCombine(pidlFolder, pidlIn);
|
|
if (pidl)
|
|
{
|
|
if (pidlNewIn)
|
|
{
|
|
LPITEMIDLIST pidlNew = ILCombine(pidlFolder, pidlNewIn);
|
|
if (pidlNew)
|
|
{
|
|
SHChangeNotify(lEventId, SHCNF_IDLIST, pidl, pidlNew);
|
|
ILFree(pidlNew);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SHChangeNotify(lEventId, SHCNF_IDLIST, pidl, NULL);
|
|
}
|
|
if (bRefresh)
|
|
SHChangeNotifyHandleEvents();
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
|
|
BOOL _InitComCtl32()
|
|
{
|
|
static BOOL fInitialized = FALSE;
|
|
|
|
if (!fInitialized)
|
|
{
|
|
INITCOMMONCONTROLSEX icc;
|
|
|
|
icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
icc.dwICC = ICC_NATIVEFNTCTL_CLASS | ICC_DATE_CLASSES;
|
|
fInitialized = InitCommonControlsEx(&icc);
|
|
}
|
|
return fInitialized;
|
|
}
|
|
|
|
const struct {
|
|
LPCSTR pszVerb;
|
|
UINT idCmd;
|
|
} rgcmds[] = {
|
|
{ c_szOpen, RSVIDM_OPEN },
|
|
{ c_szCopy, RSVIDM_COPY },
|
|
{ c_szRename, RSVIDM_RENAME},
|
|
{ c_szPaste, RSVIDM_PASTE},
|
|
{ c_szDelete, RSVIDM_DELETE },
|
|
{ c_szProperties, RSVIDM_PROPERTIES }
|
|
};
|
|
|
|
int _GetCmdID(LPCSTR pszCmd)
|
|
{
|
|
if (HIWORD(pszCmd))
|
|
{
|
|
int i;
|
|
for (i = 0; i < ARRAYSIZE(rgcmds); i++)
|
|
{
|
|
if (lstrcmpiA(rgcmds[i].pszVerb, pszCmd) == 0)
|
|
{
|
|
return rgcmds[i].idCmd;
|
|
}
|
|
}
|
|
|
|
return -1; // unknown
|
|
}
|
|
return (int)LOWORD(pszCmd);
|
|
}
|
|
|
|
BOOL CALLBACK _AddOnePropSheetPage(HPROPSHEETPAGE hpage, LPARAM lParam)
|
|
{
|
|
PROPSHEETHEADER * ppsh = (PROPSHEETHEADER *) lParam;
|
|
|
|
if (ppsh->nPages < MAX_PROP_PAGES)
|
|
{
|
|
ppsh->phpage[ppsh->nPages++] = hpage;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT _CreatePropSheet(HWND hwnd, POOEBuf pBuf)
|
|
{
|
|
ASSERT(pBuf);
|
|
|
|
ISubscriptionMgr * pSub= NULL;
|
|
HRESULT hr = CoInitialize(NULL);
|
|
RETURN_ON_FAILURE(hr);
|
|
|
|
hr = CoCreateInstance(CLSID_SubscriptionMgr, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_ISubscriptionMgr, (void **)&pSub);
|
|
CoUninitialize();
|
|
RETURN_ON_FAILURE(hr);
|
|
ASSERT(pSub);
|
|
|
|
BSTR bstrURL = NULL;
|
|
hr = CreateBSTRFromTSTR(&bstrURL, pBuf->m_URL);
|
|
if (S_OK == hr)
|
|
hr = pSub->ShowSubscriptionProperties(bstrURL, hwnd);
|
|
SAFERELEASE(pSub);
|
|
SAFEFREEBSTR(bstrURL);
|
|
return hr;
|
|
}
|
|
|
|
// Note:
|
|
// We return FALSE on illegal DATE data.
|
|
|
|
BOOL DATE2DateTimeString(CFileTime& ft, LPTSTR pszText)
|
|
{
|
|
SYSTEMTIME st;
|
|
|
|
if (ft == 0) {
|
|
if (szUnknown[0] == 0)
|
|
MLLoadString(IDS_UNKNOWN, szUnknown, ARRAYSIZE(szUnknown));
|
|
|
|
StrCpy(pszText, szUnknown);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!FileTimeToSystemTime(&ft, &st))
|
|
{
|
|
if (szNone[0] == 0)
|
|
MLLoadString(IDS_NONE, szNone, ARRAYSIZE(szNone));
|
|
|
|
StrCpy(pszText, szNone);
|
|
return FALSE;
|
|
}
|
|
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, pszText, 64);
|
|
pszText += lstrlen(pszText);
|
|
*pszText++ = ' ';
|
|
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, pszText, 64);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Date2LocalDateString(SYSTEMTIME * st, LPTSTR dtStr, int size)
|
|
{
|
|
ASSERT(dtStr);
|
|
|
|
return GetDateFormat(LOCALE_USER_DEFAULT, 0, st, NULL, dtStr, size);
|
|
}
|
|
|
|
void CopyToOOEBuf(POOEntry pooe, POOEBuf pBuf)
|
|
{
|
|
ASSERT(pooe);
|
|
ASSERT(pBuf);
|
|
|
|
pBuf->dwFlags = pooe->dwFlags;
|
|
pBuf->m_LastUpdated = pooe->m_LastUpdated;
|
|
pBuf->m_NextUpdate = pooe->m_NextUpdate;
|
|
pBuf->m_SizeLimit = pooe->m_SizeLimit;
|
|
pBuf->m_ActualSize = pooe->m_ActualSize;
|
|
pBuf->m_RecurseLevels = pooe->m_RecurseLevels;
|
|
pBuf->m_RecurseFlags = pooe->m_RecurseFlags;
|
|
pBuf->m_Priority = pooe->m_Priority;
|
|
pBuf->bDesktop = pooe->bDesktop;
|
|
pBuf->bChannel = pooe->bChannel;
|
|
pBuf->bMail = pooe->bMail;
|
|
pBuf->bGleam = pooe->bGleam;
|
|
pBuf->bChangesOnly = pooe->bChangesOnly;
|
|
pBuf->fChannelFlags = pooe->fChannelFlags;
|
|
pBuf->bNeedPassword = pooe->bNeedPassword;
|
|
pBuf->m_Cookie = pooe->m_Cookie;
|
|
pBuf->groupCookie = pooe->groupCookie;
|
|
pBuf->grfTaskTrigger = pooe->grfTaskTrigger;
|
|
pBuf->m_Trigger = pooe->m_Trigger;
|
|
pBuf->clsidDest = pooe->clsidDest;
|
|
pBuf->status = pooe->status;
|
|
|
|
StrCpyN(pBuf->m_URL, URL(pooe), MAX_URL);
|
|
StrCpyN(pBuf->m_Name, NAME(pooe), MAX_NAME);
|
|
StrCpyN(pBuf->username, UNAME(pooe), MAX_USERNAME);
|
|
StrCpyN(pBuf->password, PASSWD(pooe), MAX_PASSWORD);
|
|
StrCpyN(pBuf->statusStr, STATUS(pooe), MAX_STATUS);
|
|
}
|
|
|
|
void CopyToMyPooe(POOEBuf pBuf, POOEntry pooe)
|
|
{
|
|
UINT offset = sizeof(OOEntry);
|
|
UINT srcLen = lstrlen(pBuf->m_URL) + 1;
|
|
|
|
ASSERT(pooe);
|
|
ASSERT(pBuf);
|
|
|
|
pooe->dwFlags = pBuf->dwFlags;
|
|
pooe->m_LastUpdated = pBuf->m_LastUpdated;
|
|
pooe->m_NextUpdate = pBuf->m_NextUpdate;
|
|
pooe->m_SizeLimit = pBuf->m_SizeLimit;
|
|
pooe->m_ActualSize = pBuf->m_ActualSize;
|
|
pooe->m_RecurseLevels = pBuf->m_RecurseLevels;
|
|
pooe->m_Priority = pBuf->m_Priority;
|
|
pooe->m_RecurseFlags = pBuf->m_RecurseFlags;
|
|
pooe->bDesktop = pBuf->bDesktop;
|
|
pooe->bChannel = pBuf->bChannel;
|
|
pooe->bMail = pBuf->bMail;
|
|
pooe->bGleam = pBuf->bGleam;
|
|
pooe->bChangesOnly = pBuf->bChangesOnly;
|
|
pooe->fChannelFlags = pBuf->fChannelFlags;
|
|
pooe->bNeedPassword = pBuf->bNeedPassword;
|
|
pooe->m_Cookie = pBuf->m_Cookie;
|
|
pooe->groupCookie = pBuf->groupCookie;
|
|
pooe->m_Trigger = pBuf->m_Trigger;
|
|
pooe->grfTaskTrigger = pBuf->grfTaskTrigger;
|
|
pooe->clsidDest = pBuf->clsidDest;
|
|
pooe->status = pBuf->status;
|
|
|
|
pooe->m_URL = (LPTSTR)((LPBYTE)pooe + offset);
|
|
srcLen = lstrlen(pBuf->m_URL) + 1;
|
|
StrCpyN(pooe->m_URL, pBuf->m_URL, srcLen);
|
|
offset += srcLen * sizeof (TCHAR);
|
|
pooe->m_URL = (LPTSTR) PtrDifference(pooe->m_URL, pooe);
|
|
|
|
pooe->m_Name = (LPTSTR)((LPBYTE)pooe + offset);
|
|
srcLen = lstrlen(pBuf->m_Name) + 1;
|
|
StrCpyN(pooe->m_Name, pBuf->m_Name, srcLen);
|
|
offset += srcLen * sizeof (TCHAR);
|
|
pooe->m_Name = (LPTSTR) PtrDifference(pooe->m_Name, pooe);
|
|
|
|
pooe->username = (LPTSTR)((LPBYTE)pooe + offset);
|
|
srcLen = lstrlen(pBuf->username) + 1;
|
|
StrCpyN(pooe->username, pBuf->username, srcLen);
|
|
offset += srcLen * sizeof (TCHAR);
|
|
pooe->username = (LPTSTR) PtrDifference(pooe->username, pooe);
|
|
|
|
pooe->password = (LPTSTR)((LPBYTE)pooe + offset);
|
|
srcLen = lstrlen(pBuf->password) + 1;
|
|
StrCpyN(pooe->password, pBuf->password, srcLen);
|
|
offset += srcLen * sizeof (TCHAR);
|
|
pooe->password = (LPTSTR) PtrDifference(pooe->password, pooe);
|
|
|
|
pooe->statusStr = (LPTSTR)((LPBYTE)pooe + offset);
|
|
srcLen = lstrlen(pBuf->statusStr) + 1;
|
|
StrCpyN(pooe->statusStr, pBuf->statusStr, srcLen);
|
|
offset += srcLen * sizeof (TCHAR);
|
|
pooe->statusStr = (LPTSTR) PtrDifference(pooe->statusStr, pooe);
|
|
|
|
pooe->dwSize = offset;
|
|
}
|
|
|
|
UINT BufferSize(POOEBuf pBuf)
|
|
{
|
|
UINT strLen = 0;
|
|
ASSERT(pBuf);
|
|
|
|
strLen += lstrlen(pBuf->m_URL) + 1;
|
|
strLen += lstrlen(pBuf->m_Name) + 1;
|
|
strLen += lstrlen(pBuf->username) + 1;
|
|
strLen += lstrlen(pBuf->password) + 1;
|
|
strLen += lstrlen(pBuf->statusStr) + 1;
|
|
|
|
return strLen * sizeof(TCHAR);
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int cItems;
|
|
LPCTSTR pszName;
|
|
LPCTSTR pszUrl;
|
|
} DELETE_CONFIRM_INFO;
|
|
|
|
INT_PTR CALLBACK ConfirmDeleteDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
|
|
switch(message) {
|
|
|
|
case WM_INITDIALOG:
|
|
{
|
|
DELETE_CONFIRM_INFO* pInfo = (DELETE_CONFIRM_INFO*)lParam;
|
|
ASSERT (pInfo);
|
|
ASSERT(pInfo->cItems == 1);
|
|
|
|
SetListViewToString (GetDlgItem (hDlg, IDC_NAME), pInfo->pszName);
|
|
SetListViewToString (GetDlgItem (hDlg, IDC_LOCATION), pInfo->pszUrl);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDYES:
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, wParam);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
if (LOWORD(wParam) == IDC_LOCATION)
|
|
{
|
|
NM_LISTVIEW * pnmlv = (NM_LISTVIEW *)lParam;
|
|
ASSERT(pnmlv);
|
|
if (pnmlv->hdr.code == LVN_GETINFOTIP)
|
|
{
|
|
TCHAR szURL[MAX_URL];
|
|
LV_ITEM lvi = {0};
|
|
lvi.mask = LVIF_TEXT;
|
|
lvi.pszText = szURL;
|
|
lvi.cchTextMax = ARRAYSIZE(szURL);
|
|
if (!ListView_GetItem (GetDlgItem (hDlg, IDC_LOCATION), &lvi))
|
|
return FALSE;
|
|
|
|
NMLVGETINFOTIP * pTip = (NMLVGETINFOTIP *)pnmlv;
|
|
ASSERT(pTip->pszText);
|
|
StrCpyN(pTip->pszText, szURL, pTip->cchTextMax);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
|
|
default:
|
|
return FALSE;
|
|
|
|
} // end of switch
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConfirmDelete(HWND hwnd, UINT cItems, LPMYPIDL * ppidl)
|
|
{
|
|
ASSERT(ppidl);
|
|
INT_PTR iRet;
|
|
|
|
// Check if the user is restricted from deleting URLs.
|
|
// If they're deleting multiple, we'll fail if any can fail.
|
|
UINT i;
|
|
for (i = 0; i < cItems; i++)
|
|
{
|
|
if (ppidl[i]->ooe.bChannel)
|
|
{
|
|
if (SHRestricted2(REST_NoRemovingChannels, URL(&(ppidl[i]->ooe)), 0))
|
|
{
|
|
if (IsWindow(hwnd))
|
|
SGMessageBox(hwnd, IDS_RESTRICTED, MB_OK);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!ppidl[i]->ooe.bDesktop)
|
|
{
|
|
// FEATURE: What about desktop components?
|
|
if (SHRestricted2(REST_NoRemovingSubscriptions, URL(&(ppidl[i]->ooe)), 0))
|
|
{
|
|
if (IsWindow(hwnd))
|
|
SGMessageBox(hwnd, IDS_RESTRICTED, MB_OK);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsWindow(hwnd)) {
|
|
DELETE_CONFIRM_INFO dci = {0};
|
|
dci.cItems = cItems;
|
|
if (cItems == 1)
|
|
{
|
|
dci.pszName = NAME(&(ppidl[0]->ooe));
|
|
dci.pszUrl = URL(&(ppidl[0]->ooe));
|
|
iRet = DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_OBJECTDEL_WARNING),
|
|
hwnd, ConfirmDeleteDlgProc, (LPARAM)&dci);
|
|
}
|
|
else
|
|
{
|
|
|
|
TCHAR szFormat[200];
|
|
// Enough room for format string and int as string
|
|
TCHAR szBuf[ARRAYSIZE(szFormat) + 11];
|
|
|
|
MLLoadString(IDS_DEL_MULTIPLE_FMT, szFormat, ARRAYSIZE(szFormat));
|
|
wnsprintf(szBuf, ARRAYSIZE(szBuf), szFormat, cItems);
|
|
|
|
MLLoadString(IDS_DELETE_CAPTION, szFormat, ARRAYSIZE(szFormat));
|
|
|
|
MSGBOXPARAMS mbp;
|
|
|
|
mbp.cbSize = sizeof(MSGBOXPARAMS);
|
|
mbp.hwndOwner = hwnd;
|
|
mbp.hInstance = MLGetHinst();
|
|
mbp.lpszText = szBuf;
|
|
mbp.lpszCaption = szFormat;
|
|
mbp.dwStyle = MB_YESNO | MB_USERICON;
|
|
mbp.lpszIcon = MAKEINTRESOURCE(IDI_OBJECTDELETED);
|
|
iRet = MessageBoxIndirect(&mbp);
|
|
}
|
|
if (iRet == IDYES)
|
|
return TRUE;
|
|
return FALSE;
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL IsHTTPPrefixed(LPCTSTR szURL)
|
|
{
|
|
TCHAR szCanonicalURL[MAX_URL];
|
|
DWORD dwSize = MAX_URL;
|
|
URL_COMPONENTS uc;
|
|
|
|
memset(&uc, 0, sizeof(URL_COMPONENTS));
|
|
uc.dwStructSize = sizeof(URL_COMPONENTS);
|
|
|
|
// Note: We explicitly check for and allow the "about:home" URL to pass through here. This allows
|
|
// the Active Desktop "My Current Home Page" component to specify that URL when creating and managing
|
|
// it's subscription which is consistent with it's use of that form in the browser.
|
|
if (!InternetCanonicalizeUrl(szURL, szCanonicalURL, &dwSize, ICU_DECODE) ||
|
|
!InternetCrackUrl(szCanonicalURL, 0, 0, &uc) ||
|
|
((INTERNET_SCHEME_HTTP != uc.nScheme) && (INTERNET_SCHEME_HTTPS != uc.nScheme) && (0 != StrCmpI(TEXT("about:home"), szURL))))
|
|
{
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Checks if global state is offline
|
|
|
|
BOOL IsGlobalOffline(void)
|
|
{
|
|
DWORD dwState = 0, dwSize = sizeof(DWORD);
|
|
BOOL fRet = FALSE;
|
|
HANDLE hModuleHandle = LoadLibraryA("wininet.dll");
|
|
|
|
if(!hModuleHandle)
|
|
return FALSE;
|
|
|
|
if(InternetQueryOption(NULL, INTERNET_OPTION_CONNECTED_STATE, &dwState,
|
|
&dwSize))
|
|
{
|
|
if(dwState & INTERNET_STATE_DISCONNECTED_BY_USER)
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
void SetGlobalOffline(BOOL fOffline)
|
|
{
|
|
INTERNET_CONNECTED_INFO ci;
|
|
|
|
memset(&ci, 0, sizeof(ci));
|
|
if(fOffline) {
|
|
ci.dwConnectedState = INTERNET_STATE_DISCONNECTED_BY_USER;
|
|
ci.dwFlags = ISO_FORCE_DISCONNECTED;
|
|
} else {
|
|
ci.dwConnectedState = INTERNET_STATE_CONNECTED;
|
|
}
|
|
|
|
InternetSetOption(NULL, INTERNET_OPTION_CONNECTED_STATE, &ci, sizeof(ci));
|
|
}
|
|
|
|
|
|
//helper function to create one column in a ListView control, add one item to that column,
|
|
//size the column to the width of the control, and color the control like a static...
|
|
//basically, like SetWindowText for a ListView. Because we use a lot of ListViews to display
|
|
//urls that would otherwise be truncated... the ListView gives us automatic ellipsis and ToolTip.
|
|
void SetListViewToString (HWND hLV, LPCTSTR pszString)
|
|
{
|
|
ASSERT(hLV);
|
|
|
|
LV_COLUMN lvc = {0};
|
|
RECT lvRect;
|
|
GetClientRect (hLV, &lvRect);
|
|
lvc.mask = LVCF_WIDTH;
|
|
lvc.cx = lvRect.right - lvRect.left;
|
|
if (-1 == ListView_InsertColumn(hLV, 0, &lvc)) {
|
|
ASSERT(0);
|
|
}
|
|
|
|
SendMessage(hLV, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_INFOTIP, LVS_EX_INFOTIP);
|
|
|
|
LV_ITEM lvi = {0};
|
|
lvi.iSubItem = 0;
|
|
lvi.pszText = (LPTSTR)pszString;
|
|
lvi.mask = LVIF_TEXT;
|
|
ListView_InsertItem(hLV, &lvi);
|
|
ListView_EnsureVisible(hLV, 0, TRUE);
|
|
|
|
ListView_SetBkColor(hLV, GetSysColor(COLOR_BTNFACE));
|
|
ListView_SetTextBkColor(hLV, GetSysColor(COLOR_BTNFACE));
|
|
}
|
|
|
|
int WCMessageBox(HWND hwnd, UINT idTextFmt, UINT idCaption, UINT uType, ...)
|
|
{
|
|
TCHAR szCaption[256];
|
|
TCHAR szTextFmt[512];
|
|
LPTSTR pszText;
|
|
int result;
|
|
va_list va;
|
|
|
|
va_start(va, uType);
|
|
|
|
szCaption[0] = 0;
|
|
|
|
MLLoadString(idTextFmt, szTextFmt, ARRAYSIZE(szTextFmt));
|
|
|
|
if (idCaption <= 0)
|
|
{
|
|
if (NULL != hwnd)
|
|
{
|
|
GetWindowText(hwnd, szCaption, ARRAYSIZE(szCaption));
|
|
}
|
|
|
|
// This handles GetWindowText failure and a NULL hwnd
|
|
if (0 == szCaption[0])
|
|
{
|
|
#if IDS_DEFAULT_MSG_CAPTION < 1
|
|
#error IDS_DEFAULT_MSG_CAPTION is defined incorrectly
|
|
#endif
|
|
|
|
idCaption = IDS_DEFAULT_MSG_CAPTION;
|
|
}
|
|
}
|
|
|
|
if (idCaption > 0)
|
|
{
|
|
MLLoadString(idCaption, szCaption, ARRAYSIZE(szCaption));
|
|
}
|
|
|
|
ASSERT(0 != szCaption[0]);
|
|
|
|
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
|
|
szTextFmt, 0, 0, (LPTSTR)&pszText, 0, &va);
|
|
|
|
result = MessageBox(hwnd, pszText, szCaption, uType);
|
|
|
|
LocalFree(pszText);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// SGMessageBox
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
int SGMessageBox
|
|
(
|
|
HWND hwndParent,
|
|
UINT idStringRes,
|
|
UINT uType
|
|
)
|
|
{
|
|
ASSERT(hwndParent != NULL);
|
|
ASSERT(IsWindow(hwndParent));
|
|
|
|
TCHAR szError[512];
|
|
if (!MLLoadString(idStringRes, szError, ARRAYSIZE(szError)))
|
|
return 0;
|
|
|
|
TCHAR szTitle[128];
|
|
szTitle[0] = 0;
|
|
|
|
if (hwndParent != NULL)
|
|
GetWindowText(hwndParent, szTitle, ARRAYSIZE(szTitle));
|
|
|
|
return MessageBox( hwndParent,
|
|
szError,
|
|
((hwndParent != NULL) ? szTitle : NULL),
|
|
uType);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// DumpTaskTrigger
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void DumpTaskTrigger
|
|
(
|
|
TASK_TRIGGER * pTT
|
|
)
|
|
{
|
|
TraceMsg(TF_DUMPTRIGGER, "----- BEGIN DumpTaskTrigger -----");
|
|
|
|
TraceMsg(TF_DUMPTRIGGER, "cbTriggerSize = %d", pTT->cbTriggerSize);
|
|
TraceMsg(TF_DUMPTRIGGER, "Reserved1 = %d", pTT->Reserved1);
|
|
TraceMsg(TF_DUMPTRIGGER, "wBeginYear = %d", pTT->wBeginYear);
|
|
TraceMsg(TF_DUMPTRIGGER, "wBeginMonth = %d", pTT->wBeginMonth);
|
|
TraceMsg(TF_DUMPTRIGGER, "wBeginDay = %d", pTT->wBeginDay);
|
|
TraceMsg(TF_DUMPTRIGGER, "wEndYear = %d", pTT->wEndYear);
|
|
TraceMsg(TF_DUMPTRIGGER, "wEndMonth = %d", pTT->wEndMonth);
|
|
TraceMsg(TF_DUMPTRIGGER, "wEndDay = %d", pTT->wEndDay);
|
|
TraceMsg(TF_DUMPTRIGGER, "wStartHour = %d", pTT->wStartHour);
|
|
TraceMsg(TF_DUMPTRIGGER, "wStartMinute = %d", pTT->wStartMinute);
|
|
TraceMsg(TF_DUMPTRIGGER, "MinutesDuration = %d", pTT->MinutesDuration);
|
|
TraceMsg(TF_DUMPTRIGGER, "MinutesInterval = %d", pTT->MinutesInterval);
|
|
TraceMsg(TF_DUMPTRIGGER, "rgFlags = %d", pTT->rgFlags);
|
|
TraceMsg(TF_DUMPTRIGGER, "Reserved2 = %d", pTT->Reserved2);
|
|
TraceMsg(TF_DUMPTRIGGER, "wRandomMinutesInterval = %d", pTT->wRandomMinutesInterval);
|
|
|
|
switch (pTT->TriggerType)
|
|
{
|
|
case TASK_TIME_TRIGGER_DAILY:
|
|
{
|
|
TraceMsg(TF_DUMPTRIGGER, "DAILY");
|
|
TraceMsg(TF_DUMPTRIGGER, "DaysInterval = %d", pTT->Type.Daily.DaysInterval);
|
|
break;
|
|
}
|
|
|
|
case TASK_TIME_TRIGGER_WEEKLY:
|
|
{
|
|
TraceMsg(TF_DUMPTRIGGER, "WEEKLY");
|
|
TraceMsg(TF_DUMPTRIGGER, "WeeksInterval = %d", pTT->Type.Weekly.WeeksInterval);
|
|
TraceMsg(TF_DUMPTRIGGER, "rgfDaysOfTheWeek = %d", pTT->Type.Weekly.rgfDaysOfTheWeek);
|
|
break;
|
|
}
|
|
|
|
case TASK_TIME_TRIGGER_MONTHLYDATE:
|
|
{
|
|
TraceMsg(TF_DUMPTRIGGER, "MONTHLY DATE");
|
|
TraceMsg(TF_DUMPTRIGGER, "rgfDays = %d", pTT->Type.MonthlyDate.rgfDays);
|
|
TraceMsg(TF_DUMPTRIGGER, "rgfMonths = %d", pTT->Type.MonthlyDate.rgfMonths);
|
|
break;
|
|
}
|
|
|
|
case TASK_TIME_TRIGGER_MONTHLYDOW:
|
|
{
|
|
TraceMsg(TF_DUMPTRIGGER, "MONTHLY DOW");
|
|
TraceMsg(TF_DUMPTRIGGER, "wWhichWeek = %d", pTT->Type.MonthlyDOW.wWhichWeek);
|
|
TraceMsg(TF_DUMPTRIGGER, "rgfDaysOfTheWeek = %d", pTT->Type.MonthlyDOW.rgfDaysOfTheWeek);
|
|
TraceMsg(TF_DUMPTRIGGER, "rgfMonths = %d", pTT->Type.MonthlyDOW.rgfMonths);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
TraceMsg(TF_DUMPTRIGGER, "----- END DumpTaskTrigger -----");
|
|
}
|
|
#endif // DEBUG
|