1679 lines
48 KiB
C++
1679 lines
48 KiB
C++
#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);
|
|
}
|