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

1678 lines
48 KiB

#include "pch.hxx"
#include <prsht.h>
#include <mapi.h>
#include <mapix.h>
#include <comconv.h>
#include "abimport.h"
#define INITGUID
#include <ole2.h>
#include <initguid.h>
#include "newimp.h"
#include <impapi.h>
#include "import.h"
#include <eudrimp.h>
#include <mapiconv.h>
#include <netsimp.h> //Netscape
#include <commimp.h> //Communicator
#include <ImpAth16.h>
#include <oe4imp.h>
#include "strconst.h"
#include "demand.h"
ASSERTDATA
#define IDD_NEXT 0x3024
class CFolderImportProg : public IFolderImport
{
private:
ULONG m_cRef;
IFolderImport *m_pImportEx;
UINT m_iMsg;
UINT m_cMsg;
CImpProgress *m_pProgress;
TCHAR m_szFldrFmt[CCHMAX_STRINGRES];
TCHAR m_szMsgFmt[CCHMAX_STRINGRES];
TCHAR m_szFolder[MAX_PATH];
public:
CFolderImportProg(void);
~CFolderImportProg(void);
STDMETHODIMP QueryInterface(REFIID, LPVOID *);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
HRESULT Initialize(HWND hwnd);
void SetFolder(IFolderImport *pImport, TCHAR *szName, UINT cMsg);
void ReleaseFolder(void);
HRESULT UpdateProgress(void);
STDMETHODIMP SetMessageCount(ULONG cMsg);
STDMETHODIMP ImportMessage(MSGTYPE type, DWORD dwState, LPSTREAM pstm, const TCHAR **rgszAttach, DWORD cAttach);
STDMETHODIMP ImportMessage(IMSG *pimsg);
};
HRESULT GetFolderList(IMailImport *pMailImp, IMPFOLDERNODE **pplist);
void FreeFolderList(IMPFOLDERNODE *plist);
HRESULT ImportFolders(HWND hwnd, IMailImporter *pImporter, IMailImport *pMailImp, IMPFOLDERNODE *plist, CFolderImportProg *pImpProg);
HRESULT DoImportWizard(HWND hwnd, IMPWIZINFO *pinfo);
CFolderImportProg::CFolderImportProg()
{
m_cRef = 1;
m_pImportEx = NULL;
// m_iMsg
// m_cMsg
m_pProgress = NULL;
// m_szFldrFmt
// m_szMsgFmt
// m_szFolder
}
CFolderImportProg::~CFolderImportProg()
{
if (m_pImportEx != NULL)
m_pImportEx->Release();
if (m_pProgress != NULL)
m_pProgress->Release();
}
ULONG CFolderImportProg::AddRef()
{
m_cRef++;
return(m_cRef);
}
ULONG CFolderImportProg::Release()
{
ULONG cRef;
cRef = --m_cRef;
if (cRef == 0)
delete this;
return(cRef);
}
HRESULT CFolderImportProg::QueryInterface(REFIID riid, LPVOID *ppv)
{
HRESULT hr = S_OK;
if (ppv == NULL)
return(E_INVALIDARG);
*ppv = NULL;
if (IID_IFolderImport == riid)
*ppv = (IFolderImport *)this;
else if (IID_IUnknown == riid)
*ppv = (IUnknown *)this;
else
hr = E_NOINTERFACE;
if (*ppv != NULL)
((LPUNKNOWN)*ppv)->AddRef();
return(hr);
}
HRESULT CFolderImportProg::Initialize(HWND hwnd)
{
LoadString(g_hInstImp, idsImportingFolderFmt, m_szFldrFmt, ARRAYSIZE(m_szFldrFmt));
LoadString(g_hInstImp, idsImportingMessageFmt, m_szMsgFmt, ARRAYSIZE(m_szMsgFmt));
m_pProgress = new CImpProgress;
if (m_pProgress == NULL)
return(E_OUTOFMEMORY);
m_pProgress->Init(hwnd, TRUE);
return(S_OK);
}
void CFolderImportProg::SetFolder(IFolderImport *pImport, TCHAR *szName, UINT cMsg)
{
Assert(pImport != NULL);
Assert(m_pImportEx == NULL);
m_pImportEx = pImport;
m_pImportEx->AddRef();
m_iMsg = 0;
m_cMsg = cMsg;
lstrcpyn(m_szFolder, szName, ARRAYSIZE(m_szFolder));
}
void CFolderImportProg::ReleaseFolder()
{
Assert(m_pImportEx != NULL);
m_pImportEx->Release();
m_pImportEx = NULL;
}
HRESULT CFolderImportProg::SetMessageCount(ULONG cMsg)
{
m_cMsg = cMsg;
return(m_pImportEx->SetMessageCount(cMsg));
}
HRESULT CFolderImportProg::UpdateProgress()
{
TCHAR sz[CCHMAX_STRINGRES + MAX_PATH];
if (m_iMsg == 0)
{
wnsprintf(sz, ARRAYSIZE(sz), m_szFldrFmt, m_szFolder);
m_pProgress->SetMsg(sz, IDC_FOLDER_STATIC);
m_pProgress->Show(0);
m_pProgress->Reset();
m_pProgress->AdjustMax(m_cMsg);
}
m_iMsg++;
wnsprintf(sz, ARRAYSIZE(sz), m_szMsgFmt, m_iMsg, m_cMsg);
m_pProgress->SetMsg(sz, IDC_MESSAGE_STATIC);
return(m_pProgress->HrUpdate(1));
}
HRESULT CFolderImportProg::ImportMessage(MSGTYPE type, DWORD dwState, LPSTREAM pstm, const TCHAR **rgszAttach, DWORD cAttach)
{
HRESULT hr;
hr = UpdateProgress();
if (hr != hrUserCancel)
hr = m_pImportEx->ImportMessage(type, dwState, pstm, rgszAttach, cAttach);
return(hr);
}
HRESULT CFolderImportProg::ImportMessage(IMSG *pimsg)
{
HRESULT hr;
hr = UpdateProgress();
if (hr != hrUserCancel)
hr = m_pImportEx->ImportMessage(pimsg);
return(hr);
}
void PerformImport(HWND hwnd, IMailImporter *pImporter, DWORD dwFlags)
{
IMPWIZINFO wizinfo;
HRESULT hr;
Assert(dwFlags == 0);
ZeroMemory(&wizinfo, sizeof(IMPWIZINFO));
wizinfo.pImporter = pImporter;
hr = DoImportWizard(hwnd, &wizinfo);
if (wizinfo.pClsid != NULL)
MemFree(wizinfo.pClsid);
if (wizinfo.pList != NULL)
FreeFolderList(wizinfo.pList);
if (wizinfo.pImport != NULL)
wizinfo.pImport->Release();
ExchDeinit();
}
IMPFOLDERNODE *InsertFolderNode(IMPFOLDERNODE *plist, IMPFOLDERNODE *pnode)
{
BOOL fNodeNormal, fCurrNormal;
IMPFOLDERNODE *pprev, *pcurr;
Assert(pnode != NULL);
pnode->pnext = NULL;
if (plist == NULL)
return(pnode);
pprev = NULL;
pcurr = plist;
while (pcurr != NULL)
{
fNodeNormal = pnode->type == FOLDER_TYPE_NORMAL;
fCurrNormal = pcurr->type == FOLDER_TYPE_NORMAL;
if (!fNodeNormal &&
fCurrNormal)
break;
if (fNodeNormal == fCurrNormal &&
lstrcmpi(pnode->szName, pcurr->szName) <= 0)
break;
pprev = pcurr;
pcurr = pcurr->pnext;
}
if (pcurr == NULL)
{
// insert at end of list
Assert(pprev != NULL);
pprev->pnext = pnode;
}
else if (pprev == NULL)
{
// insert at beginning of list
pnode->pnext = plist;
plist = pnode;
}
else
{
pprev->pnext = pnode;
pnode->pnext = pcurr;
}
return(plist);
}
HRESULT GetSubFolderList(IMailImport *pMailImp, IMPFOLDERNODE *pparent, DWORD_PTR dwCookie, IMPFOLDERNODE **pplist)
{
HRESULT hr;
TCHAR *sz;
IMPORTFOLDER folder;
IEnumFOLDERS *pEnum;
IMPFOLDERNODE *pnode, *plist;
Assert(pMailImp != NULL);
Assert(pplist != NULL);
*pplist = NULL;
plist = NULL;
pEnum = NULL;
hr = pMailImp->EnumerateFolders(dwCookie, &pEnum);
if (FAILED(hr))
return(hr);
else if (hr == S_FALSE)
return(S_OK);
Assert(pEnum != NULL);
while (S_OK == (hr = pEnum->Next(&folder)))
{
if (!MemAlloc((void **)&pnode, sizeof(IMPFOLDERNODE) + MAX_PATH * sizeof(TCHAR)))
{
hr = E_OUTOFMEMORY;
break;
}
ZeroMemory(pnode, sizeof(IMPFOLDERNODE));
sz = (TCHAR *)((BYTE *)pnode + sizeof(IMPFOLDERNODE));
pnode->pparent = pparent;
pnode->depth = (pparent != NULL) ? (pparent->depth + 1) : 0;
pnode->szName = sz;
pnode->type = folder.type;
StrCpyN(sz, folder.szName, MAX_PATH);
pnode->lparam = (LPARAM)folder.dwCookie;
plist = InsertFolderNode(plist, pnode);
if (folder.fSubFolders > 0)
{
hr = GetSubFolderList(pMailImp, pnode, folder.dwCookie, &pnode->pchild);
if (FAILED(hr))
break;
}
}
if (hr == S_FALSE)
hr = S_OK;
pEnum->Release();
*pplist = plist;
return(hr);
}
HRESULT GetFolderList(IMailImport *pMailImp, IMPFOLDERNODE **pplist)
{
IMPFOLDERNODE *plist;
HRESULT hr;
Assert(pMailImp != NULL);
Assert(pplist != NULL);
plist = NULL;
hr = GetSubFolderList(pMailImp, NULL, COOKIE_ROOT, &plist);
if (FAILED(hr))
{
FreeFolderList(plist);
plist = NULL;
}
*pplist = plist;
return(hr);
}
void FreeFolderList(IMPFOLDERNODE *plist)
{
IMPFOLDERNODE *pnode;
while (plist != NULL)
{
if (plist->pchild != NULL)
FreeFolderList(plist->pchild);
pnode = plist;
plist = plist->pnext;
MemFree(pnode);
}
}
void FillFolderListview(HWND hwnd, IMPFOLDERNODE *plist, DWORD_PTR dwReserved)
{
LV_ITEM lvi;
int iret;
lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_INDENT;
lvi.iSubItem = 0;
for ( ; plist != NULL; plist = plist->pnext)
{
plist->dwReserved = dwReserved;
lvi.pszText = plist->szName;
lvi.lParam = (LPARAM)plist;
lvi.iIndent = plist->depth;
if (plist->type >= CFOLDERTYPE)
lvi.iImage = iFolderClosed;
else
lvi.iImage = (int)plist->type + iFolderClosed;
lvi.iItem = ListView_GetItemCount(hwnd);
iret = ListView_InsertItem(hwnd, &lvi);
Assert(iret != -1);
if (plist->pchild != NULL)
FillFolderListview(hwnd, plist->pchild, dwReserved);
}
}
void InitListViewImages(HWND hwnd)
{
HBITMAP hbm;
HIMAGELIST himl;
LV_COLUMN lvc;
RECT rc;
GetWindowRect(hwnd, &rc);
lvc.mask = LVCF_TEXT | LVCF_WIDTH;
lvc.pszText = (TCHAR *)c_szEmpty;
lvc.cx = rc.right - rc.left - 2 * GetSystemMetrics(SM_CXEDGE) - GetSystemMetrics(SM_CXVSCROLL);
lvc.iSubItem = 0;
ListView_InsertColumn(hwnd, 0, &lvc);
himl = ImageList_Create(16, 16, ILC_MASK, CFOLDERTYPE, 0);
if (himl != NULL)
{
hbm = LoadBitmap(g_hInstImp, MAKEINTRESOURCE(idbFolders));
Assert(hbm != NULL);
ImageList_AddMasked(himl, hbm, RGB(255, 0, 255));
DeleteObject((HGDIOBJ)hbm);
ListView_SetImageList(hwnd, himl, LVSIL_SMALL);
}
}
HRESULT ImportFolders(HWND hwnd, IMailImporter *pImporter, IMailImport *pMailImp, IMPFOLDERNODE *plist, CFolderImportProg *pImpProg)
{
HRESULT hr;
DWORD_PTR dwParent;
TCHAR szFmt[CCHMAX_STRINGRES], szError[CCHMAX_STRINGRES];
IMPFOLDERNODE *pnode, *pnodeT;
IFolderImport *pFldrImp;
Assert(pImporter != NULL);
Assert(pMailImp != NULL);
Assert(plist != NULL);
Assert(pImpProg != NULL);
pnode = plist;
while (pnode != NULL)
{
if (pnode->fImport)
{
dwParent = COOKIE_ROOT;
pnodeT = pnode->pparent;
while (pnodeT != NULL)
{
if (pnodeT->fImport)
{
dwParent = pnodeT->dwReserved;
break;
}
pnodeT = pnodeT->pparent;
}
hr = pImporter->OpenFolder(dwParent, pnode->szName, pnode->type, 0, &pFldrImp, &pnode->dwReserved);
if (hr == E_OUTOFMEMORY || hr == hrDiskFull)
return(hr);
else if (SUCCEEDED(hr))
{
Assert(pFldrImp != NULL);
pImpProg->SetFolder(pFldrImp, pnode->szName, pnode->cMsg);
hr = pMailImp->ImportFolder((DWORD)pnode->lparam, pImpProg);
pImpProg->ReleaseFolder();
pFldrImp->Release();
if (hr == E_OUTOFMEMORY || hr == hrDiskFull || hr == hrUserCancel)
return(hr);
else if (FAILED(hr))
{
// display an error, but keep trying to import the other folders
LoadString(g_hInstImp, idsFolderImportErrorFmt, szFmt, ARRAYSIZE(szFmt));
wnsprintf(szError, ARRAYSIZE(szError), szFmt, pnode->szName);
ImpErrorMessage(hwnd, MAKEINTRESOURCE(idsImportTitle), szError, hr);
}
}
}
if (pnode->pchild != NULL)
{
hr = ImportFolders(hwnd, pImporter, pMailImp, pnode->pchild, pImpProg);
if (hr == E_OUTOFMEMORY || hr == hrDiskFull || hr == hrUserCancel)
return(hr);
}
pnode = pnode->pnext;
}
return(S_OK);
}
void ImpErrorMessage(HWND hwnd, LPTSTR szTitle, LPTSTR szError, HRESULT hrDetail)
{
LPTSTR szDetail;
Assert(FAILED(hrDetail));
switch (hrDetail)
{
case E_OUTOFMEMORY:
szDetail = MAKEINTRESOURCE(idsMemory);
break;
case hrDiskFull:
szDetail = MAKEINTRESOURCE(idsDiskFull);
break;
case hrNoProfilesFound:
case hrMapiInitFail:
szDetail = MAKEINTRESOURCE(idsMAPIInitError);
break;
case hrFolderOpenFail:
szDetail = MAKEINTRESOURCE(idsFolderOpenFail);
break;
case hrFolderReadFail:
szDetail = MAKEINTRESOURCE(idsFolderReadFail);
break;
default:
szDetail = MAKEINTRESOURCE(idsGenericError);
break;
}
ImpMessageBox(hwnd, szTitle, szError, szDetail, MB_OK | MB_ICONEXCLAMATION);
}
int ImpMessageBox(HWND hwndOwner, LPTSTR szTitle, LPTSTR sz1, LPTSTR sz2, UINT fuStyle)
{
TCHAR rgchTitle[CCHMAX_STRINGRES];
TCHAR rgchText[2 * CCHMAX_STRINGRES + 2];
LPTSTR szText;
int cch;
Assert(sz1);
Assert(szTitle != NULL);
if (IS_INTRESOURCE(szTitle))
{
// its a string resource id
cch = LoadString(g_hInstImp, PtrToUlong(szTitle), rgchTitle, CCHMAX_STRINGRES);
if (cch == 0)
return(0);
szTitle = rgchTitle;
}
if (!(IS_INTRESOURCE(sz1)))
{
// its a pointer to a string
Assert(lstrlen(sz1) < CCHMAX_STRINGRES);
if (NULL == StrCpyN(rgchText, sz1, ARRAYSIZE(rgchText)))
return(0);
cch = lstrlen(rgchText);
}
else
{
// its a string resource id
cch = LoadString(g_hInstImp, PtrToUlong(sz1), rgchText, 2 * CCHMAX_STRINGRES);
if (cch == 0)
return(0);
}
if (sz2)
{
//$$REVIEW is this right??
//$$REVIEW will this work with both ANSI/UNICODE?
// there's another string that we need to append to the
// first string...
szText = &rgchText[cch];
*szText = *c_szNewline;
szText++;
*szText = *c_szNewline;
szText++;
cch = ARRAYSIZE(rgchText) - (int)(szText - rgchText);
if (!(IS_INTRESOURCE(sz2)))
{
// its a pointer to a string
Assert(lstrlen(sz2) < CCHMAX_STRINGRES);
if (NULL == StrCpyN(szText, sz2, cch))
return(0);
}
else
{
Assert((2 * CCHMAX_STRINGRES - (szText - rgchText)) > 0);
if (0 == LoadString(g_hInstImp, PtrToUlong(sz2), szText, cch))
return(0);
}
}
return(MessageBox(hwndOwner, rgchText, szTitle, MB_SETFOREGROUND | fuStyle));
}
int AutoDetectClients(MIGRATEINFO *pinfo, int cinfo)
{
TCHAR szDir[MAX_PATH];
Assert(pinfo != NULL);
Assert(cinfo >= 2);
cinfo = 0;
if (SUCCEEDED(GetClientDir(szDir, ARRAYSIZE(szDir), EUDORA)))
{
pinfo->clsid = CLSID_CEudoraImport;
pinfo->idDisplay = idsEudora;
pinfo->szfnImport = (TCHAR *)szEudoraImportEntryPt;
cinfo++;
pinfo++;
}
if (SUCCEEDED(GetClientDir(szDir, ARRAYSIZE(szDir), NETSCAPE)))
{
pinfo->clsid = CLSID_CNetscapeImport;
pinfo->idDisplay = idsNetscape;
pinfo->szfnImport = (TCHAR *)szNetscapeImportEntryPt;
cinfo++;
pinfo++;
}
if (SUCCEEDED(GetClientDir(szDir, ARRAYSIZE(szDir), COMMUNICATOR)))
{
pinfo->clsid = CLSID_CCommunicatorImport;
pinfo->idDisplay = idsCommunicator;
pinfo->szfnImport = (TCHAR *)szMessengerImportEntryPt;
cinfo++;
pinfo++;
}
if (SUCCEEDED(ExchInit()) && SUCCEEDED(MapiLogon(NULL, NULL)))
{
pinfo->clsid = CLSID_CExchImport;
pinfo->idDisplay = idsExchange;
pinfo->szfnImport = (TCHAR *)szPABImportEntryPt;
cinfo++;
pinfo++;
}
return(cinfo);
}
HRESULT PerformMigration(HWND hwnd, IMailImporter *pImporter, DWORD dwFlags)
{
HRESULT hr;
MIGRATEINFO info[4];
IMPWIZINFO wizinfo;
Assert(pImporter != NULL);
hr = S_OK;
ZeroMemory(&wizinfo, sizeof(IMPWIZINFO));
wizinfo.pImporter = pImporter;
wizinfo.cMigrate = AutoDetectClients(info, ARRAYSIZE(info));
if (wizinfo.cMigrate > 0)
{
wizinfo.pMigrate = info;
wizinfo.fMigrate = TRUE;
hr = DoImportWizard(hwnd, &wizinfo);
}
if (wizinfo.pClsid != NULL)
MemFree(wizinfo.pClsid);
if (wizinfo.pList != NULL)
FreeFolderList(wizinfo.pList);
if (wizinfo.pImport != NULL)
wizinfo.pImport->Release();
ExchDeinit();
return(hr);
}
int CALLBACK PropSheetProc(HWND hwndDlg, UINT uMsg, LPARAM lParam)
{
DLGTEMPLATE *pDlg;
if (uMsg == PSCB_PRECREATE)
{
pDlg = (DLGTEMPLATE *)lParam;
if (!!(pDlg->style & DS_CONTEXTHELP))
pDlg->style &= ~DS_CONTEXTHELP;
}
return(0);
}
const static PAGEINFO g_rgPageInfo[NUM_WIZARD_PAGES] =
{
{ iddMigrate, idsMigrate, MigrateInitProc, MigrateOKProc, NULL },
{ iddMigrateMode, idsMigrate, MigModeInitProc, MigModeOKProc, NULL },
{ iddMigrateIncomplete, idsMigIncomplete, MigIncInitProc, MigIncOKProc, NULL },
{ iddSelectClient, idsSelectClient, ClientInitProc, ClientOKProc, NULL },
{ iddLocation, idsLocation, LocationInitProc, LocationOKProc, LocationCmdProc },
{ iddSelectFolders, idsSelectFoldersHdr,FolderInitProc, FolderOKProc, NULL },
{ iddAddressComplete, idsAddressComplete, NULL, AddressOKProc, NULL },
{ iddCongratulations, idsCongratulations, CongratInitProc, CongratOKProc, NULL }
};
HRESULT DoImportWizard(HWND hwnd, IMPWIZINFO *pinfo)
{
int nPageIndex, cPages, iRet;
PROPSHEETPAGE psPage;
PROPSHEETHEADER psHeader;
HRESULT hr;
char sz[CCHMAX_STRINGRES];
HPROPSHEETPAGE rgPage[NUM_WIZARD_PAGES];
INITWIZINFO rgInit[NUM_WIZARD_PAGES];
Assert(pinfo != NULL);
ZeroMemory(&psPage, sizeof(PROPSHEETPAGE));
ZeroMemory(&psHeader, sizeof(PROPSHEETHEADER));
psPage.dwSize = sizeof(psPage);
psPage.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE;
psPage.hInstance = g_hInstImp;
psPage.pfnDlgProc = GenDlgProc;
hr = S_OK;
cPages = 0;
// create a property sheet page for each page in the wizard
for (nPageIndex = pinfo->fMigrate ? 0 : 3; nPageIndex < NUM_WIZARD_PAGES; nPageIndex++)
{
rgInit[cPages].pPageInfo = &g_rgPageInfo[nPageIndex];
rgInit[cPages].pWizInfo = pinfo;
psPage.lParam = (LPARAM)&rgInit[cPages];
psPage.pszTemplate = MAKEINTRESOURCE(g_rgPageInfo[nPageIndex].uDlgID);
LoadString(g_hInstImp, g_rgPageInfo[nPageIndex].uHdrID, sz, ARRAYSIZE(sz));
psPage.pszHeaderTitle = sz;
rgPage[cPages] = CreatePropertySheetPage(&psPage);
if (rgPage[cPages] == NULL)
{
hr = E_FAIL;
break;
}
cPages++;
}
if (!FAILED(hr))
{
psHeader.dwSize = sizeof(PROPSHEETHEADER);
psHeader.dwFlags = PSH_WIZARD97 | PSH_HEADER | PSH_WATERMARK | PSH_USECALLBACK;
psHeader.hwndParent = hwnd;
psHeader.hInstance = g_hInstImp;
psHeader.nPages = cPages;
psHeader.phpage = rgPage;
psHeader.pszbmWatermark = MAKEINTRESOURCE(idbGlobe);
psHeader.pszbmHeader = 0;
psHeader.pfnCallback = PropSheetProc;
iRet = (int) PropertySheet(&psHeader);
if (iRet == -1)
hr = E_FAIL;
else if (iRet == 0)
hr = S_FALSE;
else
hr = S_OK;
}
else
{
for (nPageIndex = 0; nPageIndex < cPages; nPageIndex++)
{
if (rgPage[nPageIndex] != NULL)
DestroyPropertySheetPage(rgPage[nPageIndex]);
}
}
return(hr);
}
/*******************************************************************
NAME: GenDlgProc
SYNOPSIS: Generic dialog proc for all wizard pages
NOTES: This dialog proc provides the following default behavior:
init: back and next buttons enabled
next btn: switches to page following current page
back btn: switches to previous page
cancel btn: prompts user to confirm, and cancels the wizard
dlg ctrl: does nothing (in response to WM_COMMANDs)
Wizard pages can specify their own handler functions
(in the PageInfo table) to override default behavior for
any of the above actions.
********************************************************************/
INT_PTR CALLBACK GenDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
INITWIZINFO *pInit;
IMPWIZINFO *pWizInfo;
BOOL fRet, fKeepHistory, fCancel;
HWND hwndParent;
LPPROPSHEETPAGE lpsp;
const PAGEINFO *pPageInfo;
NMHDR *lpnm;
NMLISTVIEW *lpnmlv;
UINT idPage;
fRet = TRUE;
hwndParent = GetParent(hDlg);
switch (uMsg)
{
case WM_INITDIALOG:
// get propsheet page struct passed in
lpsp = (LPPROPSHEETPAGE)lParam;
Assert(lpsp != NULL);
// fetch our private page info from propsheet struct
pInit = (INITWIZINFO *)lpsp->lParam;
Assert(pInit != NULL);
pWizInfo = pInit->pWizInfo;
Assert(pWizInfo != NULL);
SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pWizInfo);
pPageInfo = pInit->pPageInfo;
Assert(pPageInfo != NULL);
SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pPageInfo);
// initialize 'back' and 'next' wizard buttons, if
// page wants something different it can fix in init proc below
PropSheet_SetWizButtons(hwndParent, PSWIZB_NEXT | PSWIZB_BACK);
// call init proc for this page if one is specified
if (pPageInfo->InitProc != NULL)
{
if (!pPageInfo->InitProc(pWizInfo, hDlg, TRUE))
{
// send a 'cancel' message to ourselves
// TODO: handle this
Assert(FALSE);
}
}
break;
case WM_ENABLENEXT:
EnableWindow(GetDlgItem(GetParent(hDlg), IDD_NEXT), (BOOL)wParam);
break;
case WM_POSTSETFOCUS:
SetFocus((HWND)wParam);
break;
case WM_NOTIFY:
pWizInfo = (IMPWIZINFO *)GetWindowLongPtr(hDlg, DWLP_USER);
Assert(pWizInfo != NULL);
pPageInfo = (const PAGEINFO *)GetWindowLongPtr(hDlg, GWLP_USERDATA);
Assert(pPageInfo != NULL);
lpnm = (NMHDR *)lParam;
switch (lpnm->code)
{
case PSN_SETACTIVE:
// initialize 'back' and 'next' wizard buttons, if
// page wants something different it can fix in init proc below
PropSheet_SetWizButtons(hwndParent, PSWIZB_NEXT | PSWIZB_BACK);
// call init proc for this page if one is specified
if (pPageInfo->InitProc != NULL)
{
// TODO: what about the return value for this????
pPageInfo->InitProc(pWizInfo, hDlg, FALSE);
}
pWizInfo->idCurrentPage = pPageInfo->uDlgID;
break;
case PSN_WIZNEXT:
case PSN_WIZBACK:
case PSN_WIZFINISH:
Assert((ULONG)pWizInfo->idCurrentPage == pPageInfo->uDlgID);
fKeepHistory = TRUE;
idPage = 0;
Assert(pPageInfo->OKProc != NULL) ;
if (!pPageInfo->OKProc(pWizInfo, hDlg, (lpnm->code != PSN_WIZBACK), &idPage, &fKeepHistory))
{
// stay on this page
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
break;
}
if (lpnm->code != PSN_WIZBACK)
{
// 'next' pressed
Assert(pWizInfo->cPagesCompleted < NUM_WIZARD_PAGES);
// save the current page index in the page history,
// unless this page told us not to when we called
// its OK proc above
if (fKeepHistory)
{
pWizInfo->rgHistory[pWizInfo->cPagesCompleted] = pWizInfo->idCurrentPage;
pWizInfo->cPagesCompleted++;
}
}
else
{
// 'back' pressed
Assert(pWizInfo->cPagesCompleted > 0);
// get the last page from the history list
pWizInfo->cPagesCompleted--;
idPage = pWizInfo->rgHistory[pWizInfo->cPagesCompleted];
}
// set next page, only if 'next' or 'back' button was pressed
if (lpnm->code != PSN_WIZFINISH)
{
// tell the prop sheet mgr what the next page to display is
Assert(idPage != 0);
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, idPage);
}
break;
case PSN_QUERYCANCEL:
if (IDNO == ImpMessageBox(hDlg, MAKEINTRESOURCE(idsImportTitle), MAKEINTRESOURCE(idsCancelWizard), NULL, MB_YESNO|MB_ICONEXCLAMATION |MB_DEFBUTTON2))
{
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, TRUE);
}
break;
case LVN_ITEMCHANGED:
if (lpnm->idFrom == IDC_IMPFOLDER_LISTVIEW &&
((NMLISTVIEW *)lpnm)->iItem != -1)
{
SendDlgItemMessage(hDlg, IDC_IMPORTALL_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(hDlg, IDC_SELECT_RADIO, BM_SETCHECK, BST_CHECKED, 0);
}
break;
}
break;
case WM_COMMAND:
pWizInfo = (IMPWIZINFO *)GetWindowLongPtr(hDlg, DWLP_USER);
Assert(pWizInfo != NULL);
pPageInfo = (const PAGEINFO *)GetWindowLongPtr(hDlg, GWLP_USERDATA);
Assert(pPageInfo != NULL);
// if this page has a command handler proc, call it
if (pPageInfo->CmdProc != NULL)
{
pPageInfo->CmdProc(pWizInfo, hDlg, wParam, lParam);
}
break;
default:
fRet = FALSE;
break;
}
return(fRet);
}
BOOL CALLBACK MigrateInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
HWND hwnd;
TCHAR sz[CCHMAX_STRINGRES];
UINT idx, i;
Assert(pInfo != NULL);
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
if (fFirstInit)
{
pInfo->iMigrate = -1;
SendDlgItemMessage(hDlg, IDC_IMPORT_RADIO, BM_SETCHECK, BST_CHECKED, 0);
hwnd = GetDlgItem(hDlg, idcClientsListbox);
Assert(pInfo->cMigrate > 0);
for (i = 0; i < pInfo->cMigrate; i++)
{
LoadString(g_hInstImp, pInfo->pMigrate[i].idDisplay, sz, ARRAYSIZE(sz));
idx = (int) SendMessage(hwnd, LB_ADDSTRING, 0, (LPARAM)sz);
SendMessage(hwnd, LB_SETITEMDATA, (WPARAM)idx, (LPARAM)i);
}
SendMessage(hwnd, LB_SETCURSEL, 0, 0);
}
return(TRUE);
}
BOOL CALLBACK MigrateOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *fKeepHistory)
{
UINT idx;
HWND hwnd;
HRESULT hr;
IMPFOLDERNODE *pnode;
IMailImport *pMailImp;
Assert(pInfo != NULL);
if (fForward)
{
if (SendDlgItemMessage(hDlg, IDC_NO_IMPORT_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
*puNextPage = iddMigrateIncomplete;
return(TRUE);
}
hwnd = GetDlgItem(hDlg, idcClientsListbox);
idx = (int) SendMessage(hwnd, LB_GETCURSEL, 0, 0);
if (SendMessage(hwnd, LB_GETTEXTLEN, idx, 0) < CCHMAX_STRINGRES)
SendMessage(hwnd, LB_GETTEXT, idx, (LPARAM)pInfo->szClient); // save selected client name
else
*pInfo->szClient = 0;
idx = (int) SendMessage(hwnd, LB_GETITEMDATA, (WPARAM)idx, 0);
if (idx != pInfo->iMigrate)
{
pInfo->dwReload = PAGE_ALL;
pInfo->iMigrate = idx;
if (pInfo->pImport != NULL)
{
pInfo->pImport->Release();
pInfo->pImport = NULL;
}
}
*puNextPage = iddMigrateMode;
}
return(TRUE);
}
BOOL CALLBACK MigModeInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
HWND hwnd;
TCHAR sz[CCHMAX_STRINGRES];
UINT idx, i;
Assert(pInfo != NULL);
if (fFirstInit || !!(pInfo->dwReload & PAGE_MODE))
{
SendDlgItemMessage(hDlg, IDC_MSGS_AB_RADIO, BM_SETCHECK, BST_CHECKED, 0);
SendDlgItemMessage(hDlg, IDC_MSGS_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(hDlg, IDC_AB_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
pInfo->dwReload &= ~PAGE_MODE;
}
return(TRUE);
}
BOOL CALLBACK MigModeOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *fKeepHistory)
{
HWND hwnd;
HRESULT hr;
IMPFOLDERNODE *pnode;
IMailImport *pMailImp;
Assert(pInfo != NULL);
if (fForward)
{
if (SendDlgItemMessage(hDlg, IDC_MSGS_AB_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pInfo->fMessages = TRUE;
pInfo->fAddresses = TRUE;
}
else if (SendDlgItemMessage(hDlg, IDC_MSGS_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pInfo->fMessages = TRUE;
pInfo->fAddresses = FALSE;
}
else
{
pInfo->fMessages = FALSE;
pInfo->fAddresses = TRUE;
}
pMailImp = NULL;
if (!pInfo->fMessages)
{
if (pInfo->pImport != NULL)
{
pInfo->pImport->Release();
pInfo->pImport = NULL;
}
*puNextPage = iddAddressComplete;
}
else if (pInfo->pImport == NULL)
{
hr = CoCreateInstance(pInfo->pMigrate[pInfo->iMigrate].clsid, NULL, CLSCTX_INPROC_SERVER, IID_IMailImport, (void **)&pMailImp);
if (SUCCEEDED(hr))
{
Assert(pMailImp != NULL);
hr = pMailImp->InitializeImport(GetParent(hDlg));
if (hr == S_OK)
{
hr = pMailImp->GetDirectory(pInfo->szDir, ARRAYSIZE(pInfo->szDir));
if (hr == S_FALSE)
{
hr = GetFolderList(pMailImp, &pnode);
if (FAILED(hr) || pnode == NULL)
{
// TODO: error message
pMailImp->Release();
return(FALSE);
}
if (pInfo->pList != NULL)
FreeFolderList(pInfo->pList);
pInfo->pList = pnode;
pInfo->fLocation = FALSE;
}
else
{
pInfo->fLocation = TRUE;
}
}
else
{
pMailImp->Release();
return(FALSE);
}
pInfo->dwReload = PAGE_LOCATION | PAGE_FOLDERS;
pInfo->pImport = pMailImp;
*puNextPage = pInfo->fLocation ? iddLocation : iddSelectFolders;
}
}
else
{
*puNextPage = pInfo->fLocation ? iddLocation : iddSelectFolders;
}
}
return(TRUE);
}
BOOL CALLBACK MigIncInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_FINISH | PSWIZB_BACK);
return(TRUE);
}
BOOL CALLBACK MigIncOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *pfKeepHistory)
{
return(TRUE);
}
#define CCLSIDBUF 16
void InitListView(HWND hwndList, IMPWIZINFO *pinfo)
{
DWORD dwIndex, dwGuid, dwName;
TCHAR szName[MAX_PATH], szGuid[MAX_PATH], szDisp[16];
HKEY hkey, hkeyT;
HRESULT hr;
FILETIME ft;
UINT i, index, iClsid;
LPWSTR pwszCLSID;
Assert(pinfo != NULL);
Assert(pinfo->pClsid == NULL);
iClsid = 0;
pinfo->cClsid = CCLSIDBUF;
if (!MemAlloc((void **)&pinfo->pClsid, sizeof(CLSID) * pinfo->cClsid))
return;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegImport,
0, KEY_READ, &hkey))
{
dwIndex = 0;
dwGuid = ARRAYSIZE(szGuid);
while (ERROR_SUCCESS == RegEnumKeyEx(hkey, dwIndex, szGuid, &dwGuid,
NULL, NULL, NULL, &ft))
{
if (ERROR_SUCCESS == RegOpenKeyEx(hkey, szGuid, 0, KEY_READ, &hkeyT))
{
for (i = 1; i <= 9; i++)
{
wnsprintf(szDisp, ARRAYSIZE(szDisp), c_szDispFmt, i);
dwName = sizeof(szName);
if (ERROR_SUCCESS == RegQueryValueEx(hkeyT, szDisp, NULL, NULL,
(LPBYTE)szName, &dwName))
{
Assert(iClsid < pinfo->cClsid);
index = (int) SendMessage(hwndList, LB_ADDSTRING, 0, (LPARAM)szName);
SendMessage(hwndList, LB_SETITEMDATA, (WPARAM)index, (LPARAM)iClsid);
// We should be doing something different here. If PszToUnicode fails,
// it fails because of low memory. This is an error condition, not an assert.
pwszCLSID = PszToUnicode(CP_ACP, szGuid);
Assert(pwszCLSID != NULL);
hr = CLSIDFromString(pwszCLSID, &pinfo->pClsid[iClsid]);
Assert(!FAILED(hr));
MemFree(pwszCLSID);
iClsid++;
}
else
{
break;
}
}
RegCloseKey(hkeyT);
}
dwIndex++;
dwGuid = ARRAYSIZE(szGuid);
}
RegCloseKey(hkey);
}
SendMessage(hwndList, LB_SETCURSEL, 0, 0);
}
BOOL CALLBACK ClientInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
Assert(pInfo != NULL);
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
if (fFirstInit)
{
pInfo->iClsid = -1;
InitListView(GetDlgItem(hDlg, idcClientsListbox), pInfo);
}
return(TRUE);
}
BOOL CALLBACK ClientOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *fKeepHistory)
{
UINT i;
HWND hwnd;
HRESULT hr;
IMPFOLDERNODE *pnode;
IMailImport *pMailImp;
Assert(pInfo != NULL);
if (fForward)
{
pInfo->fMessages = TRUE;
pInfo->fAddresses = FALSE;
hwnd = GetDlgItem(hDlg, idcClientsListbox);
i = (int) SendMessage(hwnd, LB_GETCURSEL, 0, 0);
if (SendMessage(hwnd, LB_GETTEXTLEN, i, 0) < CCHMAX_STRINGRES)
SendMessage(hwnd, LB_GETTEXT, i, (LPARAM)pInfo->szClient); // save selected client name
else
*pInfo->szClient = 0;
i = (int) SendMessage(hwnd, LB_GETITEMDATA, (WPARAM)i, 0);
Assert(((int) i) >= 0 && i < pInfo->cClsid);
if (i != pInfo->iClsid)
{
hr = CoCreateInstance(pInfo->pClsid[i], NULL, CLSCTX_INPROC_SERVER, IID_IMailImport, (void **)&pMailImp);
if (FAILED(hr))
{
// TODO: error message
return(FALSE);
}
Assert(pMailImp != NULL);
hr = pMailImp->InitializeImport(GetParent(hDlg));
if (hr == S_OK)
{
hr = pMailImp->GetDirectory(pInfo->szDir, ARRAYSIZE(pInfo->szDir));
if (hr == S_FALSE)
{
hr = GetFolderList(pMailImp, &pnode);
if (FAILED(hr) || pnode == NULL)
{
// TODO: error message
pMailImp->Release();
return(FALSE);
}
if (pInfo->pList != NULL)
FreeFolderList(pInfo->pList);
pInfo->pList = pnode;
pInfo->fLocation = FALSE;
}
else
{
pInfo->fLocation = TRUE;
}
}
else
{
pMailImp->Release();
return(FALSE);
}
pInfo->dwReload = PAGE_ALL;
if (pInfo->pImport != NULL)
pInfo->pImport->Release();
pInfo->iClsid = i;
pInfo->pImport = pMailImp;
}
*puNextPage = pInfo->fLocation ? iddLocation : iddSelectFolders;
}
return(TRUE);
}
BOOL CALLBACK LocationInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
HWND hwnd;
DWORD cbSize;
TCHAR sz[CCHMAX_STRINGRES];
Assert(pInfo != NULL);
hwnd = GetDlgItem(hDlg, IDC_IMPFOLDER_EDIT);
if (fFirstInit || !!(pInfo->dwReload & PAGE_LOCATION))
{
if (*pInfo->szDir == 0)
{
LoadString(g_hInstImp, idsLocationUnknown, sz, ARRAYSIZE(sz));
SetDlgItemText(hDlg, IDC_LOCATION_STATIC, sz);
}
if (pInfo->pList != NULL)
{
FreeFolderList(pInfo->pList);
pInfo->pList = NULL;
}
SetWindowText(hwnd, pInfo->szDir);
pInfo->dwReload &= ~PAGE_LOCATION;
}
cbSize = GetWindowText(hwnd, sz, ARRAYSIZE(sz));
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
PostMessage(hDlg, WM_ENABLENEXT, (WPARAM)(cbSize != 0), 0);
return(TRUE);
}
BOOL CALLBACK LocationOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *pfKeepHistory)
{
IMPFOLDERNODE *pnode;
HRESULT hr;
TCHAR sz[MAX_PATH];
Assert(pInfo != NULL);
if (fForward)
{
GetDlgItemText(hDlg, IDC_IMPFOLDER_EDIT, sz, ARRAYSIZE(sz));
if (*sz == 0)
{
ImpMessageBox(hDlg, MAKEINTRESOURCE(idsImportTitle),
MAKEINTRESOURCE(idsLocationInvalid), NULL,
MB_OK | MB_ICONSTOP);
return(FALSE);
}
if (0 != lstrcmpi(sz, pInfo->szDir) || pInfo->pList == NULL)
{
hr = pInfo->pImport->SetDirectory(sz);
if (hr == S_FALSE)
{
ImpMessageBox(hDlg, MAKEINTRESOURCE(idsImportTitle),
MAKEINTRESOURCE(idsLocationInvalid), NULL,
MB_OK | MB_ICONSTOP);
return(FALSE);
}
Assert(hr == S_OK);
pnode = NULL;
hr = GetFolderList(pInfo->pImport, &pnode);
if (FAILED(hr) || pnode == NULL)
{
ImpMessageBox(hDlg, MAKEINTRESOURCE(idsImportTitle),
MAKEINTRESOURCE(idsLocationInvalid), NULL,
MB_OK | MB_ICONSTOP);
return(FALSE);
}
pInfo->dwReload |= PAGE_FOLDERS;
if (pInfo->pList != NULL)
FreeFolderList(pInfo->pList);
pInfo->pList = pnode;
StrCpyN(pInfo->szDir, sz, ARRAYSIZE(pInfo->szDir));
}
*puNextPage = iddSelectFolders;
}
return(TRUE);
}
BOOL CALLBACK LocationCmdProc(IMPWIZINFO *pInfo, HWND hDlg, WPARAM wParam, LPARAM lParam)
{
HRESULT hr;
DWORD cbSize;
char szDir[MAX_PATH];
Assert(pInfo != NULL);
if (LOWORD(wParam) == IDC_SELECTFOLDER_BUTTON)
{
GetDlgItemText(hDlg, IDC_IMPFOLDER_EDIT, szDir, ARRAYSIZE(szDir));
hr = DispDialog(hDlg, szDir, ARRAYSIZE(szDir));
if (hr == S_OK)
{
cbSize = lstrlen(szDir);
UlStripWhitespace(szDir, TRUE, TRUE, &cbSize);
SetDlgItemText(hDlg, IDC_IMPFOLDER_EDIT, szDir);
EnableWindow(GetDlgItem(GetParent(hDlg), IDD_NEXT), (cbSize != 0));
}
}
return(TRUE);
}
BOOL CALLBACK FolderInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
HWND hwndList;
Assert(pInfo != NULL);
Assert(pInfo->pList != NULL);
if (fFirstInit || !!(pInfo->dwReload & PAGE_FOLDERS))
{
Assert(pInfo->pList != NULL);
SendDlgItemMessage(hDlg, IDC_IMPORTALL_RADIO, BM_SETCHECK, BST_CHECKED, 0);
SendDlgItemMessage(hDlg, IDC_SELECT_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
hwndList = GetDlgItem(hDlg, IDC_IMPFOLDER_LISTVIEW);
if (fFirstInit)
InitListViewImages(hwndList);
ListView_DeleteAllItems(hwndList);
FillFolderListview(hwndList, pInfo->pList, (DWORD_PTR)INVALID_FOLDER_HANDLE);
pInfo->dwReload &= ~PAGE_FOLDERS;
}
return(TRUE);
}
BOOL CALLBACK FolderOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *pfKeepHistory)
{
BOOL fSel;
LV_ITEM lvi;
int ili;
IMPFOLDERNODE *pnode;
HWND hwndList;
CFolderImportProg *pImpProg;
HRESULT hr;
Assert(pInfo != NULL);
if (fForward)
{
fSel = (BST_CHECKED == SendDlgItemMessage(hDlg, IDC_SELECT_RADIO, BM_GETCHECK, 0, 0));
hwndList = GetDlgItem(hDlg, IDC_IMPFOLDER_LISTVIEW);
if (fSel && 0 == SendMessage(hwndList, LVM_GETSELECTEDCOUNT, 0, 0))
{
ImpMessageBox(hDlg, MAKEINTRESOURCE(idsImportTitle),
MAKEINTRESOURCE(idsSelectFolders), NULL,
MB_OK | MB_ICONSTOP);
return(FALSE);
}
lvi.mask = LVIF_PARAM;
lvi.iSubItem = 0;
ili = -1;
// First clear all state from possible previous imports. Bug; #
if(fSel)
{
while (-1 != (ili = ListView_GetNextItem(hwndList, ili, 0)))
{
lvi.iItem = ili;
ListView_GetItem(hwndList, &lvi);
pnode = (IMPFOLDERNODE *)lvi.lParam;
Assert(pnode != NULL);
pnode->fImport = FALSE;
}
}
ili = -1;
while (-1 != (ili = ListView_GetNextItem(hwndList, ili, fSel ? LVNI_SELECTED : 0)))
{
lvi.iItem = ili;
ListView_GetItem(hwndList, &lvi);
pnode = (IMPFOLDERNODE *)lvi.lParam;
Assert(pnode != NULL);
pnode->fImport = TRUE;
}
// TODO: error handling...
pImpProg = new CFolderImportProg;
if (pImpProg == NULL)
{
hr = E_OUTOFMEMORY;
}
else
{
hr = pImpProg->Initialize(GetParent(hDlg));
if (!FAILED(hr))
{
Assert(pInfo->fMessages || pInfo->fAddresses);
if (pInfo->fMessages)
{
hr = ImportFolders(hDlg, pInfo->pImporter, pInfo->pImport, pInfo->pList, pImpProg);
if (hr == hrUserCancel)
goto FoldDone;
else if (FAILED(hr))
ImpErrorMessage(hDlg, MAKEINTRESOURCE(idsImportTitle), MAKEINTRESOURCE(idsErrImport), hr);
}
if (pInfo->fAddresses)
{
Assert(pInfo->pMigrate != NULL);
if (pInfo->pMigrate[pInfo->iMigrate].szfnImport != NULL)
HrImportAB(hDlg, pInfo->pMigrate[pInfo->iMigrate].szfnImport);
}
}
FoldDone:
pImpProg->Release();
*puNextPage = iddCongratulations;
}
}
return(TRUE);
}
BOOL CALLBACK AddressOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *pfKeepHistory)
{
CFolderImportProg *pImpProg;
HRESULT hr;
Assert(pInfo != NULL);
Assert(!pInfo->fMessages && pInfo->fAddresses);
if (fForward)
{
// TODO: error handling...
pImpProg = new CFolderImportProg;
if (pImpProg == NULL)
{
hr = E_OUTOFMEMORY;
}
else
{
hr = pImpProg->Initialize(hDlg);
if (!FAILED(hr))
{
Assert(pInfo->pMigrate != NULL);
HrImportAB(hDlg, pInfo->pMigrate[pInfo->iMigrate].szfnImport);
}
pImpProg->Release();
*puNextPage = iddCongratulations;
}
}
return(TRUE);
}
BOOL CALLBACK CongratInitProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fFirstInit)
{
TCHAR sz[CCHMAX_STRINGRES*2];
TCHAR szFmt[CCHMAX_STRINGRES];
LoadString(g_hInstImp, idsCongratStr, szFmt, ARRAYSIZE(szFmt));
wnsprintf(sz, ARRAYSIZE(sz), szFmt, pInfo->szClient);
SetDlgItemText(hDlg, idcStatic1, sz);
if (fFirstInit)
{
if (!pInfo->fMigrate)
ShowWindow(GetDlgItem(hDlg, idcStatic2), SW_HIDE);
}
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_FINISH);
PropSheet_CancelToClose(GetParent(hDlg));
return(TRUE);
}
BOOL CALLBACK CongratOKProc(IMPWIZINFO *pInfo, HWND hDlg, BOOL fForward, UINT *puNextPage, BOOL *pfKeepHistory)
{
return(TRUE);
}