able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/webcheck/propshts.cpp

2012 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "private.h"
#include "offl_cpp.h"
#include "propshts.h"
#include "subsmgrp.h"
#include <iehelpid.h>
#include <mluisupp.h>
#define INITGUID
#include <initguid.h>
#include "imnact.h"
#include "helper.h"
void WriteDefaultEmail(LPTSTR szBuf);
void WriteDefaultSMTPServer(LPTSTR szBuf);
const TCHAR c_szDefEmail[] = TEXT("DefaultEmail");
const TCHAR c_szDefServer[] = TEXT("DefaultSMTPServer");
TCHAR c_szHelpFile[] = TEXT("iexplore.hlp");
struct NEWSCHED_DATA
{
SYNCSCHEDULECOOKIE SchedCookie;
TCHAR szSchedName[MAX_PATH];
};
#define MIN_DOWNLOAD_K 50
#define MAX_DOWNLOAD_K UD_MAXVAL
#define DEF_DOWNLOAD_K 500
DWORD aHelpIDs[] = {
// Schedule page
IDC_SCHEDULE_TEXT, IDH_GROUPBOX,
IDC_MANUAL_SYNC, IDH_SUBPROPS_SCHEDTAB_MANUAL_SCHEDULE,
IDC_SCHEDULED_SYNC, IDH_SUBPROPS_SCHEDTAB_CUSTOM_SCHEDULE,
IDC_SCHEDULE_LIST, IDH_SUBPROPS_SCHEDTAB_SCHEDDESC,
IDC_SCHEDULE_NEW, IDH_NEW_OFFLINE_SCHED,
IDC_SCHEDULE_EDIT, IDH_EDIT_OFFLINE_SCHED,
IDC_SCHEDULE_REMOVE, IDH_REMOVE_OFFLINE_SCHED,
// IDC_IDLE_ONLY, IDH_SUBPROPS_SCHED_DONTUPDATE,
// Download page
IDC_CONTENT_GROUPBOX, IDH_GROUPBOX,
IDC_DOWNLOAD_PAGES_LABEL1, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_PAGES_DEEP,
IDC_LEVELS, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_PAGES_DEEP,
IDC_LEVELS_SPIN, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_PAGES_DEEP,
IDC_DOWNLOAD_PAGES_LABEL2, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_PAGES_DEEP,
IDC_FOLLOW_LINKS, IDH_SUBPROPS_RECTAB_ADVOPTS_FOLLOW_LINKS,
IDC_LIMIT_SPACE_CHECK, IDH_SUBPROPS_RECTAB_ADVOPTS_MAX_DOWNLOAD,
IDC_LIMIT_SPACE_EDIT, IDH_SUBPROPS_RECTAB_ADVOPTS_MAX_DOWNLOAD,
IDC_LIMIT_SPACE_SPIN, IDH_SUBPROPS_RECTAB_ADVOPTS_MAX_DOWNLOAD,
IDC_LIMIT_SPACE_TEXT, IDH_SUBPROPS_RECTAB_ADVOPTS_MAX_DOWNLOAD,
IDC_ADVANCED, IDH_SUBPROPS_RECTAB_ADVANCED,
IDC_EMAIL_GROUPBOX, IDH_SUBPROPS_RECTAB_EMAIL_NOTIFICATION,
IDC_EMAIL_NOTIFY, IDH_SUBPROPS_RECTAB_EMAIL_NOTIFICATION,
IDC_EMAIL_ADDRESS_TEXT, IDH_SUBPROPS_RECTAB_MAILOPTS_EMAIL_ADDRESS,
IDC_EMAIL_ADDRESS, IDH_SUBPROPS_RECTAB_MAILOPTS_EMAIL_ADDRESS,
IDC_EMAIL_SERVER_TEXT, IDH_SUBPROPS_RECTAB_MAILOPTS_EMAIL_SERVER,
IDC_EMAIL_SERVER, IDH_SUBPROPS_RECTAB_MAILOPTS_EMAIL_SERVER,
IDC_LOGIN_LABEL, IDH_SUBPROPS_RECTAB_CHANNEL_LOGIN,
IDC_LOGIN, IDH_SUBPROPS_RECTAB_CHANNEL_LOGIN,
IDC_DOWNLOAD_ALL, IDH_CHANNEL_DOWNLOAD_ALL,
IDC_DOWNLOAD_MIN, IDH_CHANNEL_DOWNLOAD_COVER_N_TOC,
// Advanced popup
IDC_ADVANCED_GROUPBOX, IDH_GROUPBOX,
IDC_DOWNLOAD_IMAGES, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_IMAGES,
IDC_DOWNLOAD_MEDIA, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_SOUND,
IDC_DOWNLOAD_APPLETS, IDH_SUBPROPS_RECTAB_ADVOPTS_DOWNLOAD_ACTIVEX,
IDC_DOWNLOAD_ONLY_HTML_LINKS, IDH_SUBPROPS_RECTAB_ADVOPTS_ONLY_HTML_LINKS,
// Login popup
IDC_USERNAME_LABEL, IDH_SUBPROPS_RECTAB_LOGINOPTS_USER_ID,
IDC_USERNAME, IDH_SUBPROPS_RECTAB_LOGINOPTS_USER_ID,
IDC_PASSWORD_LABEL, IDH_SUBPROPS_RECTAB_LOGINOPTS_PASSWORD,
IDC_PASSWORD, IDH_SUBPROPS_RECTAB_LOGINOPTS_PASSWORD,
IDC_PASSWORDCONFIRM_LABEL, IDH_SUBPROPS_RECTAB_LOGINOPTS_PASSWORD_CONFIRM,
IDC_PASSWORDCONFIRM, IDH_SUBPROPS_RECTAB_LOGINOPTS_PASSWORD_CONFIRM,
// New schedule popup
IDC_SCHEDULE_LABEL1, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_SCHEDULE_DAYS, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_SCHEDULE_DAYS_SPIN, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_SCHEDULE_LABEL2, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_SCHEDULE_TIME, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_SCHEDULE_NAME_TEXT, IDH_NEWSCHED_NAME,
IDC_SCHEDULE_NAME, IDH_NEWSCHED_NAME,
IDC_SCHEDULE_LABEL3, IDH_NEWSCHED_EVERY_AT_TIME,
IDC_WIZ_SCHEDULE_AUTOCONNECT, IDH_SUBPROPS_NEW_SCHEDULE_AUTOCONNECT,
// Summary page
IDC_NAME, IDH_SUBPROPS_SUBTAB_SUBSCRIBED_NAME,
IDC_URL_TEXT, IDH_SUBPROPS_SUBTAB_SUBSCRIBED_URL,
IDC_URL, IDH_SUBPROPS_SUBTAB_SUBSCRIBED_URL,
IDC_VISITS_TEXT, IDH_WEBDOC_VISITS,
IDC_VISITS, IDH_WEBDOC_VISITS,
IDC_MAKE_OFFLINE, IDH_MAKE_AVAIL_OFFLINE,
IDC_SUMMARY, IDH_GROUPBOX,
IDC_LAST_SYNC_TEXT, IDH_SUBPROPS_SUBTAB_LAST,
IDC_LAST_SYNC, IDH_SUBPROPS_SUBTAB_LAST,
IDC_DOWNLOAD_SIZE_TEXT, IDH_SUBPROPS_DLSIZE,
IDC_DOWNLOAD_SIZE, IDH_SUBPROPS_DLSIZE,
IDC_DOWNLOAD_RESULT_TEXT, IDH_SUBPROPS_SUBTAB_RESULT,
IDC_DOWNLOAD_RESULT, IDH_SUBPROPS_SUBTAB_RESULT,
// dah end
0, 0
};
/********************************************************************************
Property sheet helpers
*********************************************************************************/
inline POOEBuf GetBuf(HWND hdlg)
{
POOEBuf pBuf = (POOEBuf) GetWindowLongPtr(hdlg, DWLP_USER);
return pBuf;
}
void EnableControls(HWND hdlg, const int *pIDs, int nIDs, BOOL bEnable)
{
for (int i = 0; i < nIDs; i++)
{
EnableWindow(GetDlgItem(hdlg, *pIDs++), bEnable);
}
}
/********************************************************************************
Summary property sheet code
*********************************************************************************/
inline POOEBuf Summary_GetBuf(HWND hdlg)
{
CSubscriptionMgr *pSubsMgr = (CSubscriptionMgr*) GetWindowLongPtr(hdlg, DWLP_USER);
ASSERT(NULL != pSubsMgr);
return (NULL != pSubsMgr) ? pSubsMgr->m_pBuf : NULL;
}
void Summary_ShowOfflineSummary(HWND hdlg, POOEBuf pBuf, BOOL bShow)
{
static const int offSumIDs[] =
{
IDC_SUMMARY,
IDC_LAST_SYNC_TEXT,
IDC_LAST_SYNC,
IDC_DOWNLOAD_SIZE_TEXT,
IDC_DOWNLOAD_SIZE,
IDC_DOWNLOAD_RESULT,
IDC_DOWNLOAD_RESULT_TEXT,
IDC_FREESPACE_TEXT
};
if (bShow)
{
TCHAR szLastSync[128];
TCHAR szDownloadSize[128];
TCHAR szDownloadResult[128];
MLLoadString(IDS_VALUE_UNKNOWN, szLastSync, ARRAYSIZE(szLastSync));
StrCpyN(szDownloadSize, szLastSync, ARRAYSIZE(szDownloadSize));
StrCpyN(szDownloadResult, szLastSync, ARRAYSIZE(szDownloadResult));
ISubscriptionItem *psi;
if (SUCCEEDED(SubscriptionItemFromCookie(FALSE, &pBuf->m_Cookie, &psi)))
{
enum { spLastSync, spDownloadSize, spDownloadResult };
static const LPCWSTR pProps[] =
{
c_szPropCompletionTime,
c_szPropCrawlActualSize,
c_szPropStatusString
};
VARIANT vars[ARRAYSIZE(pProps)];
if (SUCCEEDED(psi->ReadProperties(ARRAYSIZE(pProps), pProps, vars)))
{
if (VT_DATE == vars[spLastSync].vt)
{
FILETIME ft, ft2;
DWORD dwFlags = FDTF_DEFAULT;
VariantTimeToFileTime(vars[spLastSync].date, ft);
LocalFileTimeToFileTime(&ft, &ft2);
SHFormatDateTime(&ft2, &dwFlags, szLastSync, ARRAYSIZE(szLastSync));
}
if (VT_I4 == vars[spDownloadSize].vt)
{
StrFormatByteSize(vars[spDownloadSize].lVal * 1024,
szDownloadSize, ARRAYSIZE(szDownloadSize));
}
if (VT_BSTR == vars[spDownloadResult].vt)
{
#ifdef UNICODE
wnsprintf(szDownloadResult, ARRAYSIZE(szDownloadResult),
TEXT("%s"), vars[spDownloadResult].bstrVal);
#else
wnsprintf(szDownloadResult, ARRAYSIZE(szDownloadResult),
TEXT("%S"), vars[spDownloadResult].bstrVal);
#endif
}
for (int i = 0; i < ARRAYSIZE(pProps); i++)
{
VariantClear(&vars[i]);
}
}
psi->Release();
}
SetDlgItemText(hdlg, IDC_LAST_SYNC, szLastSync);
SetDlgItemText(hdlg, IDC_DOWNLOAD_SIZE, szDownloadSize);
SetDlgItemText(hdlg, IDC_DOWNLOAD_RESULT, szDownloadResult);
}
for (int i = 0; i < ARRAYSIZE(offSumIDs); i++)
{
ShowWindow(GetDlgItem(hdlg, offSumIDs[i]), bShow ? SW_SHOW : SW_HIDE);
}
}
BOOL Summary_AddPageCallback(HPROPSHEETPAGE hpage, LPARAM lParam)
{
return PropSheet_AddPage((HWND)lParam, hpage) ? TRUE : FALSE;
}
BOOL Summary_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bResult = FALSE;
BOOL bChanged = FALSE;
POOEBuf pBuf = Summary_GetBuf(hdlg);
switch (wID)
{
case IDC_MAKE_OFFLINE:
if (BN_CLICKED == wNotifyCode)
{
CSubscriptionMgr *pSubsMgr = (CSubscriptionMgr*) GetWindowLongPtr(hdlg, DWLP_USER);
BOOL bShow = IsDlgButtonChecked(hdlg, IDC_MAKE_OFFLINE);
Summary_ShowOfflineSummary(hdlg, pBuf, bShow);
if (NULL != pSubsMgr)
{
if (bShow)
{
pSubsMgr->AddPages(Summary_AddPageCallback, (LPARAM)GetParent(hdlg));
}
else
{
pSubsMgr->RemovePages(GetParent(hdlg));
}
}
bChanged = TRUE;
}
bResult = TRUE;
break;
}
if (bChanged)
{
PropSheet_Changed(GetParent(hdlg), hdlg);
}
return bResult;
}
BOOL Summary_OnNotify(HWND hdlg, int idCtrl, LPNMHDR pnmh)
{
BOOL bResult = TRUE;
switch (pnmh->code)
{
case PSN_APPLY:
{
CSubscriptionMgr *pSubsMgr = (CSubscriptionMgr*) GetWindowLongPtr(hdlg, DWLP_USER);
POOEBuf pBuf = Summary_GetBuf(hdlg);
ASSERT(NULL != pSubsMgr);
ASSERT(NULL != pBuf);
if ((NULL != pSubsMgr) && (NULL != pBuf))
{
if (IsDlgButtonChecked(hdlg, IDC_MAKE_OFFLINE))
{
pBuf->dwFlags = PROP_WEBCRAWL_ALL;
SaveBufferChange(pBuf, TRUE);
}
else
{
WCHAR wszURL[INTERNET_MAX_URL_LENGTH];
MyStrToOleStrN(wszURL, ARRAYSIZE(wszURL), pBuf->m_URL);
pSubsMgr->DeleteSubscription(wszURL, NULL);
}
}
break;
}
default:
bResult = FALSE;
break;
}
return bResult;
}
BOOL Summary_OnInitDialog(HWND hdlg, HWND hwndFocus, LPARAM lParam)
{
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam));
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr(hdlg, DWLP_USER, ((LPPROPSHEETPAGE)lParam)->lParam);
// Now read in values and populate the dialog
POOEBuf pBuf = Summary_GetBuf(hdlg);
ISubscriptionItem *psi;
HICON hicon;
BOOL bSubscribed;
HRESULT hr = SubscriptionItemFromCookie(FALSE, &pBuf->m_Cookie, &psi);
if (SUCCEEDED(hr))
{
bSubscribed = TRUE;
hicon = LoadItemIcon(psi, TRUE);
psi->Release();
}
else
{
bSubscribed = FALSE;
hicon = LoadIcon(g_hInst, MAKEINTRESOURCE(IDI_WEBDOC));
}
SendDlgItemMessage(hdlg, IDC_ICONEX2, STM_SETICON, (WPARAM)hicon, 0);
if ((!IsHTTPPrefixed(pBuf->m_URL)) ||
(bSubscribed && SHRestricted2(REST_NoRemovingSubscriptions, pBuf->m_URL, 0)) ||
(!bSubscribed && SHRestricted2(REST_NoAddingSubscriptions, pBuf->m_URL, 0)))
{
EnableWindow(GetDlgItem(hdlg, IDC_MAKE_OFFLINE), FALSE);
}
SetDlgItemText(hdlg, IDC_NAME, pBuf->m_Name);
SetDlgItemText(hdlg, IDC_URL, pBuf->m_URL);
CheckDlgButton(hdlg, IDC_MAKE_OFFLINE, bSubscribed);
TCHAR szVisits[256];
BYTE cei[MY_MAX_CACHE_ENTRY_INFO];
LPINTERNET_CACHE_ENTRY_INFO pcei = (LPINTERNET_CACHE_ENTRY_INFO)cei;
DWORD cbcei = sizeof(cei);
if (GetUrlCacheEntryInfo(pBuf->m_URL, pcei, &cbcei))
{
wnsprintf(szVisits, ARRAYSIZE(szVisits), TEXT("%d"),
pcei->dwHitRate);
}
else
{
MLLoadString(IDS_VALUE_UNKNOWN, szVisits,
ARRAYSIZE(szVisits));
}
SetDlgItemText(hdlg, IDC_VISITS, szVisits);
Summary_ShowOfflineSummary(hdlg, pBuf, bSubscribed);
return TRUE;
}
void Summary_OnDestroy(HWND hdlg)
{
POOEBuf pBuf = Summary_GetBuf(hdlg);
if (NULL != pBuf && !(pBuf->m_dwPropSheetFlags & PSF_IS_ALREADY_SUBSCRIBED) &&
IsDlgButtonChecked(hdlg, IDC_MAKE_OFFLINE))
{
SendUpdateRequests(NULL, &pBuf->m_Cookie, 1);
}
}
INT_PTR CALLBACK SummaryPropDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
bHandled = Summary_OnInitDialog(hdlg, (HWND)wParam, lParam);
break;
case WM_COMMAND:
bHandled = Summary_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
case WM_DESTROY:
Summary_OnDestroy(hdlg);
break;
case WM_NOTIFY:
bHandled = Summary_OnNotify(hdlg, (int)wParam, (LPNMHDR)lParam);
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
/********************************************************************************
Schedule property sheet code
*********************************************************************************/
void Sched_EnableScheduleButtons(HWND hdlg)
{
POOEBuf pBuf = GetBuf(hdlg);
ASSERT(pBuf);
BOOL bEditAllowed = !(pBuf->m_dwPropSheetFlags &
(PSF_NO_EDITING_SCHEDULES | PSF_NO_SCHEDULED_UPDATES));
BOOL bEnable = (bEditAllowed) &&
ListView_GetSelectedCount(GetDlgItem(hdlg, IDC_SCHEDULE_LIST));
EnableWindow(GetDlgItem(hdlg, IDC_SCHEDULE_NEW), bEditAllowed);
EnableWindow(GetDlgItem(hdlg, IDC_SCHEDULE_EDIT), bEnable);
// TODO: Don't enable remove for publisher's schedule
EnableWindow(GetDlgItem(hdlg, IDC_SCHEDULE_REMOVE), bEnable);
}
struct SCHED_ENUM_DATA
{
HWND hwndSchedList;
POOEBuf pBuf;
SYNCSCHEDULECOOKIE customSchedule;
BOOL bHasAtLeastOneSchedule;
};
struct SCHED_LIST_DATA
{
SYNCSCHEDULECOOKIE SchedCookie;
BOOL bChecked;
BOOL bStartChecked;
};
inline int SchedList_GetIndex(HWND hwndSchedList, int index)
{
return (index != -1) ? index :
ListView_GetNextItem(hwndSchedList, -1, LVNI_ALL | LVNI_SELECTED);
}
void SchedList_GetName(HWND hwndSchedList, int index, TCHAR *pszSchedName, int cchSchedName)
{
LV_ITEM lvi = {0};
lvi.iItem = SchedList_GetIndex(hwndSchedList, index);
if (lvi.iItem != -1)
{
lvi.mask = LVIF_TEXT;
lvi.pszText = pszSchedName;
lvi.cchTextMax = cchSchedName;
ListView_GetItem(hwndSchedList, &lvi);
}
}
void SchedList_SetName(HWND hwndSchedList, int index, LPTSTR pszSchedName)
{
LV_ITEM lvi = {0};
lvi.iItem = SchedList_GetIndex(hwndSchedList, index);
if (lvi.iItem != -1)
{
lvi.mask = LVIF_TEXT;
lvi.pszText = pszSchedName;
ListView_SetItem(hwndSchedList, &lvi);
}
}
SCHED_LIST_DATA *SchedList_GetData(HWND hwndSchedList, int index)
{
SCHED_LIST_DATA *psld = NULL;
LV_ITEM lvi = {0};
lvi.iItem = SchedList_GetIndex(hwndSchedList, index);
if (lvi.iItem != -1)
{
lvi.mask = LVIF_PARAM;
if (ListView_GetItem(hwndSchedList, &lvi))
{
psld = (SCHED_LIST_DATA *)lvi.lParam;
}
}
return psld;
}
void SchedList_UncheckAll(HWND hwndSchedList)
{
int count = ListView_GetItemCount(hwndSchedList);
for (int i = 0; i < count; i++)
{
SCHED_LIST_DATA *psld = SchedList_GetData(hwndSchedList, i);
if (NULL != psld)
{
psld->bChecked = 0;
ListView_SetItemState(hwndSchedList, i, COMP_UNCHECKED, LVIS_STATEIMAGEMASK);
}
}
}
void SchedList_Select(HWND hwndSchedList, int index)
{
int curIndex = ListView_GetNextItem(hwndSchedList, -1, LVNI_ALL | LVNI_SELECTED);
if (curIndex != index)
{
ListView_SetItemState(hwndSchedList, curIndex, 0, LVIS_SELECTED | LVIS_FOCUSED);
ListView_SetItemState(hwndSchedList, index, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
}
}
void SchedList_DeleteData(HWND hwndSchedList, int index, BOOL bDeleteItem)
{
LV_ITEM lvi = {0};
lvi.iItem = SchedList_GetIndex(hwndSchedList, index);
if (lvi.iItem != -1)
{
SCHED_LIST_DATA *psld = SchedList_GetData(hwndSchedList, lvi.iItem);
lvi.mask = LVIF_PARAM;
lvi.lParam = NULL;
if ((NULL != psld) && ListView_SetItem(hwndSchedList, &lvi))
{
delete psld;
}
if (bDeleteItem)
{
ListView_DeleteItem(hwndSchedList, lvi.iItem);
}
}
}
void SchedList_DeleteAllData(HWND hwndSchedList)
{
int count = ListView_GetItemCount(hwndSchedList);
for (int i = 0; i < count; i++)
{
SchedList_DeleteData(hwndSchedList, i, FALSE);
}
}
BOOL Sched_EnumCallback(ISyncSchedule *pSyncSchedule,
SYNCSCHEDULECOOKIE *pSchedCookie,
LPARAM lParam)
{
BOOL bAdded = FALSE;
SCHED_ENUM_DATA *psed = (SCHED_ENUM_DATA *)lParam;
DWORD dwSyncScheduleFlags;
SCHED_LIST_DATA *psld = NULL;
if (SUCCEEDED(pSyncSchedule->GetFlags(&dwSyncScheduleFlags)))
{
// This checks to make sure we only add a publisher's schedule to the
// list if it belongs to this item.
if ((!(dwSyncScheduleFlags & SYNCSCHEDINFO_FLAGS_READONLY)) ||
(*pSchedCookie == psed->customSchedule))
{
psld = new SCHED_LIST_DATA;
if (NULL != psld)
{
WCHAR wszName[MAX_PATH];
DWORD cchName = ARRAYSIZE(wszName);
if (SUCCEEDED(pSyncSchedule->GetScheduleName(&cchName, wszName)))
{
TCHAR szName[MAX_PATH];
MyOleStrToStrN(szName, ARRAYSIZE(szName), wszName);
psld->SchedCookie = *pSchedCookie;
psld->bStartChecked = IsCookieOnSchedule(pSyncSchedule, &psed->pBuf->m_Cookie);
psld->bChecked = psld->bStartChecked;
if (psld->bStartChecked)
{
psed->bHasAtLeastOneSchedule = TRUE;
}
LV_ITEM lvItem = { 0 };
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.iItem = (*pSchedCookie == psed->customSchedule) ? 0 : 0x7FFFFFFF;
lvItem.lParam = (LPARAM)psld;
lvItem.pszText = szName;
int index = ListView_InsertItem(psed->hwndSchedList, &lvItem);
if (index != -1)
{
ListView_SetItemState(psed->hwndSchedList, index,
psld->bStartChecked ? COMP_CHECKED : COMP_UNCHECKED,
LVIS_STATEIMAGEMASK);
ListView_SetColumnWidth(psed->hwndSchedList, 0, LVSCW_AUTOSIZE);
bAdded = TRUE;
}
}
}
}
}
if (!bAdded)
{
SAFEDELETE(psld);
}
return TRUE;
}
BOOL Sched_FillScheduleList(HWND hdlg, POOEBuf pBuf)
{
SCHED_ENUM_DATA sed;
sed.hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
sed.pBuf = pBuf;
sed.customSchedule = GUID_NULL;
ISubscriptionItem *psi;
if (SUCCEEDED(SubscriptionItemFromCookie(FALSE, &pBuf->m_Cookie, &psi)))
{
SUBSCRIPTIONITEMINFO sii;
sii.cbSize = sizeof(SUBSCRIPTIONITEMINFO);
if (SUCCEEDED(psi->GetSubscriptionItemInfo(&sii)))
{
sed.customSchedule = sii.ScheduleGroup;
}
psi->Release();
}
sed.bHasAtLeastOneSchedule = FALSE;
EnumSchedules(Sched_EnumCallback, (LPARAM)&sed);
return sed.bHasAtLeastOneSchedule;
}
BOOL Sched_NewSchedule(HWND hdlg)
{
NEWSCHED_DATA nsd;
INT_PTR nResult = DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_NEW_SCHEDULE),
hdlg, NewScheduleDlgProc, (LPARAM)&nsd);
if (IDOK == nResult)
{
SCHED_LIST_DATA *psld;
LV_FINDINFO lvfi = { 0 };
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
lvfi.flags = LVFI_STRING;
lvfi.psz = nsd.szSchedName;
int index = ListView_FindItem(hwndSchedList, -1, &lvfi);
if (index == -1)
{
psld = new SCHED_LIST_DATA;
if (NULL != psld)
{
psld->SchedCookie = nsd.SchedCookie;
psld->bChecked = TRUE;
psld->bStartChecked = FALSE;
LV_ITEM lvItem = { 0 };
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.iItem = 0;
lvItem.lParam = (LPARAM)psld;
lvItem.pszText = nsd.szSchedName;
index = ListView_InsertItem(hwndSchedList, &lvItem);
}
}
else
{
psld = SchedList_GetData(hwndSchedList, index);
if (NULL != psld)
{
psld->bChecked = TRUE;
}
}
if (index != -1)
{
ListView_SetItemState(hwndSchedList, index, COMP_CHECKED, LVIS_STATEIMAGEMASK);
ListView_SetColumnWidth(hwndSchedList, 0, LVSCW_AUTOSIZE);
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC,
IDC_SCHEDULED_SYNC);
SchedList_Select(hwndSchedList, index);
Sched_EnableScheduleButtons(hdlg);
}
}
SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hdlg, IDC_SCHEDULE_LIST), TRUE);
return nResult == IDOK;
}
BOOL Sched_EditSchedule(HWND hdlg, POOEBuf pBuf)
{
HRESULT hr;
ISyncScheduleMgr *pSyncScheduleMgr;
ASSERT(NULL != pBuf);
hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_SyncMgr, NULL, CLSCTX_ALL,
IID_ISyncScheduleMgr, (void **)&pSyncScheduleMgr);
if (SUCCEEDED(hr))
{
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
int index = ListView_GetNextItem(hwndSchedList, -1, LVNI_ALL | LVNI_SELECTED);
SCHED_LIST_DATA *psld = SchedList_GetData(hwndSchedList, index);
if (NULL != psld)
{
ISyncSchedule *pSyncSchedule;
hr = pSyncScheduleMgr->OpenSchedule(&psld->SchedCookie, 0, &pSyncSchedule);
if (SUCCEEDED(hr))
{
if (psld->bChecked)
{
hr = pSyncSchedule->SetItemCheck(CLSID_WebCheckOfflineSync,
&pBuf->m_Cookie,
SYNCMGRITEMSTATE_CHECKED);
}
hr = pSyncSchedule->EditSyncSchedule(hdlg, 0);
if (S_OK == hr)
{
psld->bChecked = IsCookieOnSchedule(pSyncSchedule, &pBuf->m_Cookie);
if (psld->bChecked)
{
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC,
IDC_SCHEDULED_SYNC);
}
ListView_SetItemState(hwndSchedList, index,
psld->bChecked ? COMP_CHECKED : COMP_UNCHECKED,
LVIS_STATEIMAGEMASK);
}
WCHAR wszScheduleName[MAX_PATH];
DWORD cchScheduleName = ARRAYSIZE(wszScheduleName);
if (SUCCEEDED(pSyncSchedule->GetScheduleName(&cchScheduleName, wszScheduleName)))
{
#ifdef UNICODE
SchedList_SetName(hwndSchedList, index, wszScheduleName);
#else
char szScheduleName[MAX_PATH];
SHUnicodeToAnsi(wszScheduleName, szScheduleName, ARRAYSIZE(szScheduleName));
SchedList_SetName(hwndSchedList, index, wszScheduleName);
#endif
ListView_SetColumnWidth(hwndSchedList, 0, LVSCW_AUTOSIZE);
}
SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hwndSchedList, TRUE);
pSyncSchedule->Release();
}
pSyncScheduleMgr->Release();
}
}
CoUninitialize();
}
// This is not undoable by hitting cancel so don't say we changed.
return FALSE;
}
BOOL Sched_RemoveSchedule(HWND hdlg)
{
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
int index = ListView_GetNextItem(hwndSchedList, -1, LVNI_ALL | LVNI_SELECTED);
if (index >= 0)
{
SCHED_LIST_DATA *psld = SchedList_GetData(GetDlgItem(hdlg, IDC_SCHEDULE_LIST), index);
if (NULL != psld)
{
TCHAR szSchedName[MAX_PATH];
SchedList_GetName(hwndSchedList, index, szSchedName, ARRAYSIZE(szSchedName));
if (WCMessageBox(hdlg, IDS_CONFIRM_SCHEDULE_DELETE,
IDS_SCHEDULE_DELETE_CAPTION, MB_YESNO | MB_ICONQUESTION,
szSchedName) == IDYES)
{
HRESULT hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
ISyncScheduleMgr *pSyncScheduleMgr;
hr = CoCreateInstance(CLSID_SyncMgr, NULL, CLSCTX_ALL,
IID_ISyncScheduleMgr, (void **)&pSyncScheduleMgr);
if (SUCCEEDED(hr))
{
hr = pSyncScheduleMgr->RemoveSchedule(&psld->SchedCookie);
ASSERT(SUCCEEDED(hr));
if (SUCCEEDED(hr))
{
SchedList_DeleteData(hwndSchedList, -1, TRUE);
SchedList_Select(hwndSchedList, 0);
}
pSyncScheduleMgr->Release();
}
CoUninitialize();
}
}
SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hdlg, IDC_SCHEDULE_LIST), TRUE);
}
}
// This is not undoable by hitting cancel so don't say we changed.
return FALSE;
}
BOOL Sched_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bHandled = TRUE;
BOOL bChanged = FALSE;
POOEBuf pBuf = GetBuf(hdlg);
if (NULL != pBuf)
{
switch (wID)
{
case IDC_MANUAL_SYNC:
case IDC_SCHEDULED_SYNC:
// case IDC_IDLE_ONLY:
if (wNotifyCode == BN_CLICKED)
{
bChanged = TRUE;
}
break;
case IDC_SCHEDULE_NEW:
if (wNotifyCode == BN_CLICKED)
{
bChanged = Sched_NewSchedule(hdlg);
}
break;
case IDC_SCHEDULE_EDIT:
if (wNotifyCode == BN_CLICKED)
{
bChanged = Sched_EditSchedule(hdlg, pBuf);
}
break;
case IDC_SCHEDULE_REMOVE:
if (wNotifyCode == BN_CLICKED)
{
bChanged = Sched_RemoveSchedule(hdlg);
}
break;
default:
bHandled = FALSE;
break;
}
}
if (bChanged)
{
PropSheet_Changed(GetParent(hdlg), hdlg);
}
return bHandled;
}
BOOL Sched_Validate(HWND hdlg, POOEBuf pBuf)
{
/*
if (IsDlgButtonChecked(hdlg, IDC_IDLE_ONLY))
{
pBuf->grfTaskTrigger |= TASK_FLAG_START_ONLY_IF_IDLE;
}
else
{
pBuf->grfTaskTrigger &= ~TASK_FLAG_START_ONLY_IF_IDLE;
}
*/
if (IsDlgButtonChecked(hdlg, IDC_SCHEDULED_SYNC))
{
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
int count = ListView_GetItemCount(hwndSchedList);
BOOL bHaveASchedule = FALSE;
for (int i = 0; i < count; i++)
{
SCHED_LIST_DATA *psld = SchedList_GetData(hwndSchedList, i);
if (NULL != psld && psld->bChecked)
{
bHaveASchedule = TRUE;
break;
}
}
if (!bHaveASchedule)
{
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC,
IDC_MANUAL_SYNC);
}
}
return TRUE;
}
BOOL Sched_ApplyProps(HWND hdlg, POOEBuf pBuf)
{
BOOL bResult;
HRESULT hr;
pBuf->dwFlags = PROP_WEBCRAWL_ALL;
bResult = SUCCEEDED(SaveBufferChange(pBuf, TRUE));
if (bResult)
{
if (IsDlgButtonChecked(hdlg, IDC_MANUAL_SYNC))
{
SchedList_UncheckAll(GetDlgItem(hdlg, IDC_SCHEDULE_LIST));
hr = RemoveItemFromAllSchedules(&pBuf->m_Cookie);
ASSERT(SUCCEEDED(hr));
}
else
{
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
int count = ListView_GetItemCount(hwndSchedList);
for (int i = 0; i < count; i++)
{
SCHED_LIST_DATA *psld = SchedList_GetData(hwndSchedList, i);
ASSERT(NULL != psld);
if (NULL != psld)
{
if (psld->bChecked != psld->bStartChecked)
{
if (psld->bChecked)
{
ISubscriptionItem *psi;
if (SUCCEEDED(SubscriptionItemFromCookie(FALSE,
&pBuf->m_Cookie,
&psi)))
{
SYNC_HANDLER_ITEM_INFO shii;
shii.handlerID = CLSID_WebCheckOfflineSync;
shii.itemID = pBuf->m_Cookie;
shii.hIcon = NULL;
MyStrToOleStrN(shii.wszItemName,
ARRAYSIZE(shii.wszItemName),
pBuf->m_Name);
shii.dwCheckState = SYNCMGRITEMSTATE_CHECKED;
AddScheduledItem(&shii, &psld->SchedCookie);
}
}
else
{
RemoveScheduledItem(&pBuf->m_Cookie, &psld->SchedCookie);
}
psld->bStartChecked = psld->bChecked;
}
}
}
}
}
return bResult;
}
BOOL Sched_OnNotify(HWND hdlg, int idCtrl, LPNMHDR pnmh)
{
BOOL bHandled = TRUE;
POOEBuf pBuf = GetBuf(hdlg);
ASSERT(pBuf);
switch (pnmh->code)
{
case PSN_KILLACTIVE:
if (!Sched_Validate(hdlg, pBuf))
{
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
}
break;
case PSN_APPLY:
Sched_ApplyProps(hdlg, pBuf);
break;
case NM_DBLCLK:
if (IDC_SCHEDULE_LIST == pnmh->idFrom)
{
Sched_EditSchedule(hdlg, pBuf);
}
break;
case LVN_ITEMCHANGED:
{
NM_LISTVIEW *pnmlv = (NM_LISTVIEW *)pnmh;
if ((pnmlv->iItem != -1) &&
(pnmlv->uChanged & LVIF_STATE) &&
((pnmlv->uNewState ^ pnmlv->uOldState) & COMP_CHECKED))
{
SCHED_LIST_DATA *psld = SchedList_GetData(pnmh->hwndFrom, pnmlv->iItem);
if (NULL != psld)
{
psld->bChecked = (pnmlv->uNewState & COMP_CHECKED) ? TRUE : FALSE;
if (psld->bChecked)
{
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC,
IDC_SCHEDULED_SYNC);
}
PropSheet_Changed(GetParent(hdlg), hdlg);
}
}
if ((pnmlv->uChanged & LVIF_STATE) &&
((pnmlv->uNewState ^ pnmlv->uOldState) & LVIS_SELECTED))
{
Sched_EnableScheduleButtons(hdlg);
}
break;
}
default:
bHandled = FALSE;
break;
}
return bHandled;
}
void Sched_OnDestroy(HWND hdlg)
{
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
SchedList_DeleteAllData(hwndSchedList);
}
BOOL Sched_OnInitDialog(HWND hdlg, HWND hwndFocus, LPARAM lParam)
{
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam));
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr(hdlg, DWLP_USER, ((LPPROPSHEETPAGE)lParam)->lParam);
// Now read in values and populate the dialog
POOEBuf pBuf = (POOEBuf)((LPPROPSHEETPAGE)lParam)->lParam;
/* CheckDlgButton(hdlg, IDC_IDLE_ONLY,
pBuf->grfTaskTrigger & TASK_FLAG_START_ONLY_IF_IDLE ?
1 : 0);
*/
HWND hwndSchedList = GetDlgItem(hdlg, IDC_SCHEDULE_LIST);
ListView_SetExtendedListViewStyle(hwndSchedList, LVS_EX_CHECKBOXES);
LV_COLUMN lvc;
lvc.mask = LVCF_FMT | LVCF_SUBITEM;
lvc.fmt = LVCFMT_LEFT;
lvc.iSubItem = 0;
ListView_InsertColumn(hwndSchedList, 0, &lvc);
// Now handle restrictions
SetPropSheetFlags(pBuf, SHRestricted2W(REST_NoScheduledUpdates, NULL, 0), PSF_NO_SCHEDULED_UPDATES);
SetPropSheetFlags(pBuf, SHRestricted2W(REST_NoEditingScheduleGroups, NULL, 0), PSF_NO_EDITING_SCHEDULES);
BOOL bHasSchedules = Sched_FillScheduleList(hdlg, pBuf);
if (pBuf->m_dwPropSheetFlags & PSF_NO_SCHEDULED_UPDATES)
{
EnableWindow(GetDlgItem(hdlg, IDC_SCHEDULE_LIST), FALSE);
EnableWindow(GetDlgItem(hdlg, IDC_SCHEDULED_SYNC), FALSE);
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC, IDC_MANUAL_SYNC);
}
else
{
CheckRadioButton(hdlg, IDC_MANUAL_SYNC, IDC_SCHEDULED_SYNC,
bHasSchedules ? IDC_SCHEDULED_SYNC : IDC_MANUAL_SYNC);
}
SchedList_Select(hwndSchedList, 0);
// Finally, do the enable/disable controls thing...
Sched_EnableScheduleButtons(hdlg);
return TRUE;
}
INT_PTR CALLBACK SchedulePropDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
bHandled = Sched_OnInitDialog(hdlg, (HWND)wParam, lParam);
break;
case WM_COMMAND:
bHandled = Sched_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
case WM_NOTIFY:
bHandled = Sched_OnNotify(hdlg, (int)wParam, (LPNMHDR)lParam);
break;
case WM_DESTROY:
Sched_OnDestroy(hdlg);
// return 0
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
/********************************************************************************
Download property sheet code
*********************************************************************************/
void Download_EnableFollowLinks(HWND hdlg)
{
BOOL bTranslate;
int i = GetDlgItemInt(hdlg, IDC_LEVELS, &bTranslate, FALSE);
EnableWindow(GetDlgItem(hdlg, IDC_FOLLOW_LINKS), (bTranslate && i));
}
void Download_EnableLimitSpaceControls(HWND hdlg)
{
static const int IDs[] = { IDC_LIMIT_SPACE_EDIT, IDC_LIMIT_SPACE_SPIN, IDC_LIMIT_SPACE_TEXT };
EnableControls(hdlg, IDs, ARRAYSIZE(IDs), IsDlgButtonChecked(hdlg, IDC_LIMIT_SPACE_CHECK));
}
void Download_EnableEmailControls(HWND hdlg)
{
static const int IDs[] = { IDC_EMAIL_ADDRESS_TEXT, IDC_EMAIL_ADDRESS,
IDC_EMAIL_SERVER_TEXT, IDC_EMAIL_SERVER };
EnableControls(hdlg, IDs, ARRAYSIZE(IDs), IsDlgButtonChecked(hdlg, IDC_EMAIL_NOTIFY));
}
BOOL Download_OnInitDialog(HWND hdlg, HWND hwndFocus, LPARAM lParam)
{
POOEBuf pBuf;
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam));
ASSERT(NULL != ((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr(hdlg, DWLP_USER, ((LPPROPSHEETPAGE)lParam)->lParam);
// First do basic control setup
HWND hwndLimitSpin = GetDlgItem(hdlg, IDC_LIMIT_SPACE_SPIN);
SendMessage(hwndLimitSpin, UDM_SETRANGE, 0,
MAKELONG(MAX_DOWNLOAD_K, MIN_DOWNLOAD_K));
UDACCEL ua[] = { {0, 1}, {1, 10}, {2, 100}, {3, 1000} };
SendMessage(hwndLimitSpin, UDM_SETACCEL, ARRAYSIZE(ua), (LPARAM)ua);
Edit_LimitText(GetDlgItem(hdlg, IDC_LIMIT_SPACE_EDIT), 5);
// Now read in values and populate the dialog
pBuf = (POOEBuf)((LPPROPSHEETPAGE)lParam)->lParam;
SUBSCRIPTIONTYPE subType = GetItemCategory(pBuf);
switch (subType)
{
case SUBSTYPE_CHANNEL:
case SUBSTYPE_DESKTOPCHANNEL:
CheckRadioButton(hdlg, IDC_DOWNLOAD_ALL, IDC_DOWNLOAD_MIN,
pBuf->fChannelFlags & CHANNEL_AGENT_PRECACHE_ALL ?
IDC_DOWNLOAD_ALL : IDC_DOWNLOAD_MIN);
break;
case SUBSTYPE_URL:
case SUBSTYPE_DESKTOPURL:
case SUBSTYPE_EXTERNAL:
{
HWND hwndLevelsSpin = GetDlgItem(hdlg, IDC_LEVELS_SPIN);
SendMessage(hwndLevelsSpin, UDM_SETRANGE, 0, MAKELONG(MAX_WEBCRAWL_LEVELS, 0));
SendMessage(hwndLevelsSpin, UDM_SETPOS, 0, pBuf->m_RecurseLevels);
CheckDlgButton(hdlg, IDC_FOLLOW_LINKS,
(pBuf->m_RecurseFlags & WEBCRAWL_LINKS_ELSEWHERE) || (0 == pBuf->m_RecurseLevels)
? 1 : 0);
Download_EnableFollowLinks(hdlg);
break;
}
}
SendMessage(hwndLimitSpin, UDM_SETPOS, 0, pBuf->m_SizeLimit ? pBuf->m_SizeLimit : DEF_DOWNLOAD_K);
CheckDlgButton(hdlg, IDC_LIMIT_SPACE_CHECK, pBuf->m_SizeLimit ? 1 : 0);
CheckDlgButton(hdlg, IDC_EMAIL_NOTIFY, pBuf->bMail ? 1 : 0);
TCHAR szText[MAX_PATH];
ReadDefaultEmail(szText, ARRAYSIZE(szText));
Edit_LimitText(GetDlgItem(hdlg, IDC_EMAIL_ADDRESS), MAX_PATH - 1);
SetDlgItemText(hdlg, IDC_EMAIL_ADDRESS, szText);
ReadDefaultSMTPServer(szText, ARRAYSIZE(szText));
Edit_LimitText(GetDlgItem(hdlg, IDC_EMAIL_SERVER), MAX_PATH - 1);
SetDlgItemText(hdlg, IDC_EMAIL_SERVER, szText);
// Now handle restrictions
if (SHRestricted2W(REST_NoSubscriptionPasswords, NULL, 0))
{
EnableWindow(GetDlgItem(hdlg, IDC_LOGIN), FALSE);
}
// Finally, do the enable/disable controls thing...
Download_EnableLimitSpaceControls(hdlg);
Download_EnableEmailControls(hdlg);
return TRUE;
}
BOOL Download_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bHandled = TRUE;
BOOL bChanged = FALSE;
POOEBuf pBuf = GetBuf(hdlg);
if (NULL != pBuf)
{
switch (wID)
{
case IDC_LIMIT_SPACE_EDIT:
if (wNotifyCode == EN_CHANGE)
{
if (pBuf->m_SizeLimit !=
LOWORD(SendDlgItemMessage(hdlg, IDC_LIMIT_SPACE_SPIN, UDM_GETPOS, 0, 0)))
{
bChanged = TRUE;
}
}
else if (wNotifyCode == EN_KILLFOCUS)
{
KeepSpinNumberInRange(hdlg, IDC_LIMIT_SPACE_EDIT,
IDC_LIMIT_SPACE_SPIN,
MIN_DOWNLOAD_K, MAX_DOWNLOAD_K);
}
break;
case IDC_LEVELS:
if (wNotifyCode == EN_UPDATE)
{
int levels = KeepSpinNumberInRange(hdlg, IDC_LEVELS,
IDC_LEVELS_SPIN, 0, MAX_WEBCRAWL_LEVELS);
if (pBuf->m_RecurseLevels != levels)
{
bChanged = TRUE;
}
Download_EnableFollowLinks(hdlg);
}
break;
case IDC_LIMIT_SPACE_CHECK:
if (wNotifyCode == BN_CLICKED)
{
Download_EnableLimitSpaceControls(hdlg);
bChanged = TRUE;
}
break;
case IDC_FOLLOW_LINKS:
if (wNotifyCode == BN_CLICKED)
{
bChanged = TRUE;
}
break;
case IDC_EMAIL_NOTIFY:
if (wNotifyCode == BN_CLICKED)
{
Download_EnableEmailControls(hdlg);
bChanged = TRUE;
}
break;
case IDC_EMAIL_ADDRESS:
case IDC_EMAIL_SERVER:
if (wNotifyCode == EN_CHANGE)
{
bChanged = TRUE;
}
break;
case IDC_LOGIN:
if ((wNotifyCode == BN_CLICKED) &&
(DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SUBSPROPS_LOGIN),
hdlg, LoginOptionDlgProc, (LPARAM)pBuf) == IDOK))
{
bChanged = TRUE;
}
break;
case IDC_ADVANCED:
if ((wNotifyCode == BN_CLICKED) &&
(DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SUBSPROPS_ADVANCED),
hdlg, AdvancedDownloadDlgProc, (LPARAM)pBuf) == IDOK))
{
bChanged = TRUE;
}
break;
default:
bHandled = FALSE;
break;
}
}
if (bChanged)
{
PropSheet_Changed(GetParent(hdlg), hdlg);
}
return bHandled;
}
BOOL Download_Validate(HWND hdlg, POOEBuf pBuf)
{
pBuf->bMail = IsDlgButtonChecked(hdlg, IDC_EMAIL_NOTIFY);
if (pBuf->bMail)
{
TCHAR szEmail[MAX_PATH];
TCHAR szServer[MAX_PATH];
GetDlgItemText(hdlg, IDC_EMAIL_ADDRESS, szEmail, ARRAYSIZE(szEmail));
GetDlgItemText(hdlg, IDC_EMAIL_SERVER, szServer, ARRAYSIZE(szServer));
if (!szEmail[0] || !szServer[0])
{
SGMessageBox(hdlg, IDS_EMAIL_INCOMPLETE, MB_ICONWARNING);
return FALSE;
}
}
SUBSCRIPTIONTYPE subType = GetItemCategory(pBuf);
switch (subType)
{
case SUBSTYPE_CHANNEL:
case SUBSTYPE_DESKTOPCHANNEL:
pBuf->fChannelFlags &= ~(CHANNEL_AGENT_PRECACHE_SOME | CHANNEL_AGENT_PRECACHE_ALL);
if (IsDlgButtonChecked(hdlg, IDC_DOWNLOAD_ALL))
{
pBuf->fChannelFlags |= CHANNEL_AGENT_PRECACHE_ALL;
}
else
{
pBuf->fChannelFlags |= CHANNEL_AGENT_PRECACHE_SOME;
}
break;
case SUBSTYPE_URL:
case SUBSTYPE_DESKTOPURL:
case SUBSTYPE_EXTERNAL:
{
if (IsDlgButtonChecked(hdlg, IDC_FOLLOW_LINKS))
{
pBuf->m_RecurseFlags |= WEBCRAWL_LINKS_ELSEWHERE;
}
else
{
pBuf->m_RecurseFlags &= ~WEBCRAWL_LINKS_ELSEWHERE;
}
pBuf->m_RecurseLevels = LOWORD(SendDlgItemMessage(hdlg,
IDC_LEVELS_SPIN, UDM_GETPOS, 0, 0));
ASSERT((pBuf->m_RecurseLevels >= 0) &&
(pBuf->m_RecurseLevels <= MAX_WEBCRAWL_LEVELS));
}
}
pBuf->m_SizeLimit = IsDlgButtonChecked(hdlg, IDC_LIMIT_SPACE_CHECK) ?
(LONG)SendDlgItemMessage(hdlg, IDC_LIMIT_SPACE_SPIN,
UDM_GETPOS, 0, 0) :
0;
ASSERT((0 == pBuf->m_SizeLimit) ||
((pBuf->m_SizeLimit >= MIN_DOWNLOAD_K) &&
(pBuf->m_SizeLimit <= MAX_DOWNLOAD_K)));
return TRUE;
}
BOOL Download_ApplyProps(HWND hdlg, POOEBuf pBuf)
{
pBuf->dwFlags = PROP_WEBCRAWL_ALL;
if (IsDlgButtonChecked(hdlg, IDC_EMAIL_NOTIFY))
{
TCHAR szText[MAX_PATH];
GetDlgItemText(hdlg, IDC_EMAIL_ADDRESS, szText, ARRAYSIZE(szText));
WriteDefaultEmail(szText);
GetDlgItemText(hdlg, IDC_EMAIL_SERVER, szText, ARRAYSIZE(szText));
WriteDefaultSMTPServer(szText);
}
if (pBuf->bChannel)
{
pBuf->dwFlags |= PROP_WEBCRAWL_CHANNELFLAGS;
}
return SUCCEEDED(SaveBufferChange(pBuf, TRUE));
}
BOOL Download_OnNotify(HWND hdlg, int idCtrl, LPNMHDR pnmh)
{
BOOL bHandled = TRUE;
POOEBuf pBuf = GetBuf(hdlg);
ASSERT(pBuf);
switch (pnmh->code)
{
case PSN_KILLACTIVE:
if (!Download_Validate(hdlg, pBuf))
{
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
}
break;
case PSN_APPLY:
Download_ApplyProps(hdlg, pBuf);
break;
default:
bHandled = FALSE;
break;
}
return bHandled;
}
INT_PTR CALLBACK DownloadPropDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
bHandled = Download_OnInitDialog(hdlg, (HWND)wParam, lParam);
break;
case WM_COMMAND:
bHandled = Download_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
case WM_NOTIFY:
bHandled = Download_OnNotify(hdlg, (int)wParam, (LPNMHDR)lParam);
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
/********************************************************************************
New schedule popup code
*********************************************************************************/
BOOL NewSched_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bHandled = FALSE;
switch (wID)
{
case IDC_SCHEDULE_DAYS:
if (wNotifyCode == EN_UPDATE)
{
KeepSpinNumberInRange(hdlg, IDC_SCHEDULE_DAYS,
IDC_SCHEDULE_DAYS_SPIN, 1, 99);
}
#ifdef NEWSCHED_AUTONAME
else if (wNotifyCode == EN_CHANGE)
{
NewSched_AutoNameHelper(hdlg);
}
#endif
bHandled = TRUE;
break;
case IDOK:
{
TASK_TRIGGER trig;
NEWSCHED_DATA *pnsd = (NEWSCHED_DATA*) GetWindowLongPtr(hdlg, DWLP_USER);
ASSERT(NULL != pnsd);
if (NewSched_ResolveNameConflictHelper(hdlg, &trig, &pnsd->SchedCookie))
{
NewSched_CreateScheduleHelper(hdlg, &trig, &pnsd->SchedCookie);
GetDlgItemText(hdlg, IDC_SCHEDULE_NAME,
pnsd->szSchedName, ARRAYSIZE(pnsd->szSchedName));
EndDialog(hdlg, IDOK);
}
break;
}
case IDCANCEL:
EndDialog(hdlg, IDCANCEL);
break;
default:
break;
}
return bHandled;
}
#ifdef NEWSCHED_AUTONAME
BOOL NewSched_OnNotify(HWND hdlg, int idCtrl, LPNMHDR pnmh)
{
BOOL bHandled = TRUE;
switch (pnmh->code)
{
case DTN_DATETIMECHANGE:
NewSched_AutoNameHelper(hdlg);
break;
default:
bHandled = FALSE;
break;
}
return bHandled;
}
#endif
INT_PTR CALLBACK NewScheduleDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
{
SetWindowLongPtr(hdlg, DWLP_USER, lParam);
NewSched_OnInitDialogHelper(hdlg);
bHandled = TRUE;
break;
}
case WM_COMMAND:
bHandled = NewSched_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
#ifdef NEWSCHED_AUTONAME
case WM_NOTIFY:
bHandled = NewSched_OnNotify(hdlg, wParam, (LPNMHDR)lParam);
break;
#endif
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
/********************************************************************************
Advanced properties code
*********************************************************************************/
BOOL Advanced_OnInitDialog(HWND hdlg, HWND hwndFocus, LPARAM lParam)
{
POOEBuf pBuf;
ASSERT(NULL != (POOEBuf)lParam);
SetWindowLongPtr(hdlg, DWLP_USER, lParam);
pBuf = (POOEBuf)lParam;
UINT flags = pBuf->m_RecurseFlags;
CheckDlgButton(hdlg, IDC_DOWNLOAD_IMAGES, flags & WEBCRAWL_GET_IMAGES);
CheckDlgButton(hdlg, IDC_DOWNLOAD_APPLETS, flags & WEBCRAWL_GET_CONTROLS);
CheckDlgButton(hdlg, IDC_DOWNLOAD_MEDIA,
flags & (WEBCRAWL_GET_BGSOUNDS | WEBCRAWL_GET_VIDEOS));
CheckDlgButton(hdlg, IDC_DOWNLOAD_ONLY_HTML_LINKS, flags & WEBCRAWL_ONLY_LINKS_TO_HTML);
return TRUE;
}
void Advanced_SetFlag(HWND hdlg, POOEBuf pBuf, int ID, LONG flags)
{
if (IsDlgButtonChecked(hdlg, ID))
{
pBuf->m_RecurseFlags |= flags;
}
else
{
pBuf->m_RecurseFlags &= ~flags;
}
}
BOOL Advanced_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bHandled = TRUE;
POOEBuf pBuf = GetBuf(hdlg);
ASSERT(pBuf);
switch (wID)
{
case IDOK:
Advanced_SetFlag(hdlg, pBuf, IDC_DOWNLOAD_IMAGES, WEBCRAWL_GET_IMAGES);
Advanced_SetFlag(hdlg, pBuf, IDC_DOWNLOAD_APPLETS, WEBCRAWL_GET_CONTROLS);
Advanced_SetFlag(hdlg, pBuf, IDC_DOWNLOAD_MEDIA,
WEBCRAWL_GET_BGSOUNDS | WEBCRAWL_GET_VIDEOS);
Advanced_SetFlag(hdlg, pBuf, IDC_DOWNLOAD_ONLY_HTML_LINKS, WEBCRAWL_ONLY_LINKS_TO_HTML);
EndDialog(hdlg, IDOK);
break;
case IDCANCEL:
EndDialog(hdlg, IDCANCEL);
break;
case IDC_DOWNLOAD_IMAGES:
case IDC_DOWNLOAD_APPLETS:
case IDC_DOWNLOAD_MEDIA:
case IDC_DOWNLOAD_ONLY_HTML_LINKS:
break;
default:
bHandled = FALSE;
break;
}
return bHandled;
}
INT_PTR CALLBACK AdvancedDownloadDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
bHandled = Advanced_OnInitDialog(hdlg, (HWND)wParam, lParam);
break;
case WM_COMMAND:
bHandled = Advanced_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
/********************************************************************************
Login properties code
*********************************************************************************/
BOOL Login_OnInitDialog(HWND hdlg, HWND hwndFocus, LPARAM lParam)
{
POOEBuf pBuf;
ASSERT(NULL != (POOEBuf)lParam);
SetWindowLongPtr(hdlg, DWLP_USER, lParam);
pBuf = (POOEBuf)lParam;
Edit_LimitText(GetDlgItem(hdlg, IDC_USERNAME), ARRAYSIZE(pBuf->username) - 1);
SetDlgItemText(hdlg, IDC_USERNAME, pBuf->username);
Edit_LimitText(GetDlgItem(hdlg, IDC_PASSWORD), ARRAYSIZE(pBuf->password) - 1);
SetDlgItemText(hdlg, IDC_PASSWORD, pBuf->password);
Edit_LimitText(GetDlgItem(hdlg, IDC_PASSWORDCONFIRM), ARRAYSIZE(pBuf->password) - 1);
SetDlgItemText(hdlg, IDC_PASSWORDCONFIRM, pBuf->password);
return TRUE;
}
BOOL Login_OnCommand(HWND hdlg, WORD wNotifyCode, WORD wID, HWND hwndCtl)
{
BOOL bHandled = TRUE;
POOEBuf pBuf = GetBuf(hdlg);
ASSERT(pBuf);
switch (wID)
{
case IDOK:
{
TCHAR szUsername[ARRAYSIZE(pBuf->username) + 1];
TCHAR szPassword[ARRAYSIZE(pBuf->password) + 1];
TCHAR szPasswordConfirm[ARRAYSIZE(pBuf->password) + 1];
GetDlgItemText(hdlg, IDC_USERNAME, szUsername, ARRAYSIZE(szUsername));
GetDlgItemText(hdlg, IDC_PASSWORD, szPassword, ARRAYSIZE(szPassword));
GetDlgItemText(hdlg, IDC_PASSWORDCONFIRM, szPasswordConfirm, ARRAYSIZE(szPasswordConfirm));
if (!szUsername[0] && (szPassword[0] || szPasswordConfirm[0]))
{
SGMessageBox(hdlg,
(pBuf->bChannel ? IDS_NEEDCHANNELUSERNAME : IDS_NEEDUSERNAME),
MB_ICONWARNING);
}
else if (szUsername[0] && !szPassword[0])
{
SGMessageBox(hdlg,
(pBuf->bChannel ? IDS_NEEDCHANNELPASSWORD : IDS_NEEDPASSWORD),
MB_ICONWARNING);
}
else if (StrCmp(szPassword, szPasswordConfirm) != 0)
{
SGMessageBox(hdlg, IDS_MISMATCHED_PASSWORDS, MB_ICONWARNING);
}
else
{
StrCpyN(pBuf->username, szUsername, ARRAYSIZE(pBuf->username));
StrCpyN(pBuf->password, szPassword, ARRAYSIZE(pBuf->password));
pBuf->dwFlags |= (PROP_WEBCRAWL_UNAME | PROP_WEBCRAWL_PSWD);
EndDialog(hdlg, IDOK);
}
break;
}
case IDCANCEL:
EndDialog(hdlg, IDCANCEL);
break;
default:
bHandled = FALSE;
break;
}
return bHandled;
}
INT_PTR CALLBACK LoginOptionDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL bHandled = FALSE;
switch (message)
{
case WM_INITDIALOG:
bHandled = Login_OnInitDialog(hdlg, (HWND)wParam, lParam);
break;
case WM_COMMAND:
bHandled = Login_OnCommand(hdlg, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, c_szHelpFile,
HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
case WM_CONTEXTMENU:
SHWinHelpOnDemandWrap((HWND)wParam, c_szHelpFile, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs);
bHandled = TRUE;
break;
}
return bHandled;
}
//
// Read the users default email address and smtp from the Athena Account Mgr
//
// Expects lpszEmailAddress and lpszSMTPServer to pt to char buffers of
// CCHMAX_EMAIL_ADDRESS and CCHMAX_SERVER_NAME size, resp.
//
BOOL ReadAthenaMailSettings(LPSTR lpszEmailAddress, LPSTR lpszSMTPServer)
{
//
// This api gets called from threads that haven't used COM before so wrap
// in CoInitialize/CoUninitialize
//
HRESULT hr = CoInitialize(NULL);
ASSERT(SUCCEEDED(hr));
//
// Create an Internet Mail and News Account Manager
//
IImnAccountManager * pAccountManager;
hr = CoCreateInstance(
CLSID_ImnAccountManager,
NULL, // no aggregation
CLSCTX_INPROC_SERVER, // inproc server implemented in webcheck.dll
IID_IImnAccountManager, //
(void **)&pAccountManager);
if (SUCCEEDED(hr)) {
hr = pAccountManager->Init(NULL);
if (SUCCEEDED(hr)) {
//
// Get the default SMTP account
//
IImnAccount * pAccount;
hr = pAccountManager->GetDefaultAccount(ACCT_MAIL, &pAccount);
if (hr == S_OK) {
//
// Get the SMTP_SERVER name for this account
//
if (NULL != lpszSMTPServer)
{
hr = pAccount->GetPropSz(
AP_SMTP_SERVER,
lpszSMTPServer,
CCHMAX_SERVER_NAME);
}
//
// Get the Users email address for this account
//
if (NULL != lpszEmailAddress)
{
hr |= pAccount->GetPropSz(
AP_SMTP_EMAIL_ADDRESS,
lpszEmailAddress,
CCHMAX_EMAIL_ADDRESS);
}
pAccount->Release(); // done with IImnAccount
}
}
pAccountManager->Release(); // done with IImnAccountManager
}
//
// This api gets called from threads that haven't used COM before so wrap
// in CoInitialize/CoUninitialize
//
CoUninitialize();
if (hr == S_OK)
return TRUE;
else
return FALSE;
}
void ReadDefaultEmail(LPTSTR szBuf, UINT cch)
{
ASSERT(szBuf);
szBuf[0] = (TCHAR)0;
if(ReadRegValue(HKEY_CURRENT_USER, c_szRegKey, c_szDefEmail, szBuf, cch * sizeof(TCHAR)))
return;
// TODO: Look for eudora/netscape as well
CHAR szEmailAddress[CCHMAX_EMAIL_ADDRESS];
if (ReadAthenaMailSettings(szEmailAddress, NULL))
{
SHAnsiToTChar(szEmailAddress, szBuf, cch);
}
}
void WriteDefaultEmail(LPTSTR szBuf)
{
ASSERT(szBuf);
WriteRegValue(HKEY_CURRENT_USER, c_szRegKey, c_szDefEmail, szBuf, (lstrlen(szBuf) + 1) * sizeof(TCHAR), REG_SZ);
}
void ReadDefaultSMTPServer(LPTSTR szBuf, UINT cch)
{
ASSERT(szBuf);
szBuf[0] = (TCHAR)0;
if(ReadRegValue(HKEY_CURRENT_USER, c_szRegKey, c_szDefServer, szBuf, cch * sizeof(TCHAR)))
return;
// TODO: Look for eudora/netscape as well
CHAR szSMTPServer[CCHMAX_SERVER_NAME];
if (ReadAthenaMailSettings(NULL, szSMTPServer))
{
SHAnsiToTChar(szSMTPServer, szBuf, cch);
}
}
void WriteDefaultSMTPServer(LPTSTR szBuf)
{
ASSERT(szBuf);
WriteRegValue(HKEY_CURRENT_USER, c_szRegKey, c_szDefServer, szBuf, (lstrlen(szBuf) + 1) * sizeof(TCHAR), REG_SZ);
}
Reference in a new issue Copy permalink