937 lines
29 KiB
C
937 lines
29 KiB
C
/*
|
|
* WABMIG.C
|
|
*
|
|
* Migrate PAB to WAB
|
|
*
|
|
* Copyright 1996-1997 Microsoft Corporation. All Rights Reserved.
|
|
*/
|
|
|
|
#include "_comctl.h"
|
|
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <mapix.h>
|
|
#include <wab.h>
|
|
#include <wabguid.h>
|
|
#include <wabdbg.h>
|
|
#include <wabmig.h>
|
|
#include <emsabtag.h>
|
|
#define _WABMIG_C TRUE
|
|
#include "_wabmig.h"
|
|
#include "..\..\wab32res\resrc2.h"
|
|
#include "dbgutil.h"
|
|
#include <shlwapi.h>
|
|
|
|
#define WinMainT WinMain
|
|
|
|
const TCHAR szDescription[] = "description";
|
|
const TCHAR szDll[] = "dll";
|
|
const TCHAR szEntry[] = "entry";
|
|
const TCHAR szEXPORT[] = "EXPORT";
|
|
const TCHAR szIMPORT[] = "IMPORT";
|
|
const TCHAR szPROFILEID[] = "PID:";
|
|
const TCHAR szFILE[] = "File:";
|
|
const TCHAR szEmpty[] = "";
|
|
|
|
|
|
// Globals
|
|
WAB_IMPORT_OPTIONS ImportOptions = {WAB_REPLACE_PROMPT, // replace option
|
|
FALSE}; // No more errors
|
|
|
|
WAB_EXPORT_OPTIONS ExportOptions = {WAB_REPLACE_PROMPT, // replace option
|
|
FALSE}; // No more errors
|
|
|
|
const LPTSTR szWABKey = "Software\\Microsoft\\WAB";
|
|
LPTARGET_INFO rgTargetInfo = NULL;
|
|
|
|
|
|
HINSTANCE hInst;
|
|
HINSTANCE hInstApp;
|
|
|
|
BOOL fMigrating = FALSE;
|
|
BOOL fError = FALSE;
|
|
BOOL fExport = FALSE;
|
|
|
|
LPADRBOOK lpAdrBookWAB = NULL;
|
|
LPWABOBJECT lpWABObject = NULL;
|
|
|
|
LPTSTR lpImportDll = NULL;
|
|
LPTSTR lpImportFn = NULL;
|
|
LPTSTR lpImportDesc = NULL;
|
|
LPTSTR lpImportName = NULL;
|
|
LPTSTR lpExportDll = NULL;
|
|
LPTSTR lpExportFn = NULL;
|
|
LPTSTR lpExportDesc = NULL;
|
|
LPTSTR lpExportName = NULL;
|
|
|
|
|
|
//
|
|
// Global WAB Allocator access functions
|
|
//
|
|
typedef struct _WAB_ALLOCATORS {
|
|
LPWABOBJECT lpWABObject;
|
|
LPWABALLOCATEBUFFER lpAllocateBuffer;
|
|
LPWABALLOCATEMORE lpAllocateMore;
|
|
LPWABFREEBUFFER lpFreeBuffer;
|
|
} WAB_ALLOCATORS, *LPWAB_ALLOCATORS;
|
|
|
|
WAB_ALLOCATORS WABAllocators = {0};
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : SetGlobalBufferFunctions
|
|
|
|
Purpose : Set the global buffer functions based on methods from
|
|
the WAB object.
|
|
|
|
Parameters: lpWABObject = the open wab object
|
|
|
|
Returns : none
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
void SetGlobalBufferFunctions(LPWABOBJECT lpWABObject) {
|
|
if (lpWABObject && ! WABAllocators.lpWABObject) {
|
|
WABAllocators.lpAllocateBuffer = lpWABObject->lpVtbl->AllocateBuffer;
|
|
WABAllocators.lpAllocateMore = lpWABObject->lpVtbl->AllocateMore;
|
|
WABAllocators.lpFreeBuffer = lpWABObject->lpVtbl->FreeBuffer;
|
|
WABAllocators.lpWABObject = lpWABObject;
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : WABAllocateBuffer
|
|
|
|
Purpose : Use the WAB Allocator
|
|
|
|
Parameters: cbSize = size to allocate
|
|
lppBuffer = returned buffer
|
|
|
|
Returns : SCODE
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
SCODE WABAllocateBuffer(ULONG cbSize, LPVOID FAR * lppBuffer) {
|
|
if (WABAllocators.lpWABObject && WABAllocators.lpAllocateBuffer) {
|
|
return(WABAllocators.lpAllocateBuffer(WABAllocators.lpWABObject, cbSize, lppBuffer));
|
|
} else {
|
|
return(MAPI_E_INVALID_OBJECT);
|
|
DebugTrace("WAB Allocators not set up!\n");
|
|
Assert(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : WABAllocateMore
|
|
|
|
Purpose : Use the WAB Allocator
|
|
|
|
Parameters: cbSize = size to allocate
|
|
lpObject = existing allocation
|
|
lppBuffer = returned buffer
|
|
|
|
Returns : SCODE
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
SCODE WABAllocateMore(ULONG cbSize, LPVOID lpObject, LPVOID FAR * lppBuffer) {
|
|
if (WABAllocators.lpWABObject && WABAllocators.lpAllocateMore) {
|
|
return(WABAllocators.lpAllocateMore(WABAllocators.lpWABObject, cbSize, lpObject, lppBuffer));
|
|
} else {
|
|
DebugTrace("WAB Allocators not set up!\n");
|
|
Assert(FALSE);
|
|
return(MAPI_E_INVALID_OBJECT);
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : WABFreeBuffer
|
|
|
|
Purpose : Use the WAB Allocator
|
|
|
|
Parameters: lpBuffer = buffer to free
|
|
|
|
Returns : SCODE
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
SCODE WABFreeBuffer(LPVOID lpBuffer) {
|
|
if (WABAllocators.lpWABObject && WABAllocators.lpFreeBuffer) {
|
|
return(WABAllocators.lpFreeBuffer(WABAllocators.lpWABObject, lpBuffer));
|
|
} else {
|
|
DebugTrace("WAB Allocators not set up!\n");
|
|
Assert(FALSE);
|
|
return(MAPI_E_INVALID_OBJECT);
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : StrICmpN
|
|
|
|
Purpose : Compare strings, ignore case, stop at N characters
|
|
|
|
Parameters: szString1 = first string
|
|
szString2 = second string
|
|
N = number of characters to compare
|
|
|
|
Returns : 0 if first N characters of strings are equivalent.
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
int StrICmpN(LPTSTR szString1, LPTSTR szString2, ULONG N) {
|
|
int Result = 0;
|
|
|
|
if (szString1 && szString2) {
|
|
while (*szString1 && *szString2 && N)
|
|
{
|
|
N--;
|
|
|
|
if (toupper(*szString1) != toupper(*szString2)) {
|
|
Result = 1;
|
|
break;
|
|
}
|
|
szString1++;
|
|
szString2++;
|
|
}
|
|
} else {
|
|
Result = -1; // arbitrarily non-equal result
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : AllocRegValue
|
|
|
|
Purpose : Allocate space for and query the registry value
|
|
|
|
Parameters: hKey = registry key to query
|
|
lpValueName = name of value to query
|
|
lppString -> returned buffer string (caller must LocalFree)
|
|
|
|
Returns : TRUE on success, FALSE on error
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
BOOL AllocRegValue(HKEY hKey, LPTSTR lpValueName, LPTSTR * lppString) {
|
|
TCHAR szTemp[1];
|
|
ULONG ulSize = 1; // Expect ERROR_MORE_DATA
|
|
DWORD dwErr;
|
|
DWORD dwType;
|
|
|
|
if (dwErr = RegQueryValueEx(hKey,
|
|
(LPTSTR)lpValueName, // name of value
|
|
NULL,
|
|
&dwType,
|
|
szTemp,
|
|
&ulSize)) {
|
|
if (dwErr == ERROR_MORE_DATA) {
|
|
if (! (*lppString = LocalAlloc(LPTR, ulSize))) {
|
|
DebugTrace("AllocRegValue can't allocate string -> %u\n", GetLastError());
|
|
} else {
|
|
// Try again with sufficient buffer
|
|
if (! RegQueryValueEx(hKey,
|
|
lpValueName,
|
|
NULL,
|
|
&dwType,
|
|
*lppString,
|
|
&ulSize)) {
|
|
if (dwType != REG_SZ) {
|
|
LocalFree(*lppString);
|
|
*lppString = NULL;
|
|
} else {
|
|
return(TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
HRESULT ProgressCallback(HWND hwnd, LPWAB_PROGRESS lpProgress) {
|
|
MSG msg;
|
|
|
|
if (lpProgress->lpText) {
|
|
DebugTrace("Status Message: %s\n", lpProgress->lpText);
|
|
SetDlgItemText(hwnd, IDC_Message, lpProgress->lpText);
|
|
}
|
|
|
|
if (lpProgress->denominator) {
|
|
if (lpProgress->numerator == 0) {
|
|
ShowWindow(GetDlgItem(hwnd, IDC_Progress), SW_SHOW);
|
|
}
|
|
|
|
SendMessage(GetDlgItem(hwnd, IDC_Progress), PBM_SETRANGE, 0, MAKELPARAM(0, min(lpProgress->denominator, 32767)));
|
|
SendMessage(GetDlgItem(hwnd, IDC_Progress), PBM_SETSTEP, (WPARAM)1, 0);
|
|
SendMessage(GetDlgItem(hwnd, IDC_Progress), PBM_SETPOS, (WPARAM)min(lpProgress->numerator, lpProgress->denominator), 0);
|
|
}
|
|
|
|
// msgpump to process user moving window, or pressing cancel... :)
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
return(hrSuccess);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : SetDialogMessage
|
|
|
|
Purpose : Sets the message text for the dialog box item IDC_Message
|
|
|
|
Parameters: hwnd = window handle of dialog
|
|
ids = stringid of message resource
|
|
|
|
Returns : none
|
|
|
|
***************************************************************************/
|
|
void SetDialogMessage(HWND hwnd, int ids) {
|
|
TCHAR szBuffer[MAX_RESOURCE_STRING + 1];
|
|
|
|
if (LoadString(hInst, ids, szBuffer, sizeof(szBuffer))) {
|
|
DebugTrace("Status Message: %s\n", szBuffer);
|
|
if (! SetDlgItemText(hwnd, IDC_Message, szBuffer)) {
|
|
DebugTrace("SetDlgItemText -> %u\n", GetLastError());
|
|
}
|
|
} else {
|
|
DebugTrace("Cannot load resource string %u\n", ids);
|
|
Assert(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// GetWABDllPath - loads the WAB DLL path from the registry
|
|
// szPath - ptr to buffer
|
|
// cb - sizeof buffer
|
|
//
|
|
void GetWABDllPath(LPTSTR szPath, ULONG cb)
|
|
{
|
|
DWORD dwType = 0;
|
|
HKEY hKey = NULL;
|
|
TCHAR szPathT[MAX_PATH];
|
|
ULONG cbData = sizeof(szPathT);
|
|
if(szPath)
|
|
{
|
|
*szPath = '\0';
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, WAB_DLL_PATH_KEY, 0, KEY_READ, &hKey))
|
|
{
|
|
if(ERROR_SUCCESS == RegQueryValueEx( hKey, "", NULL, &dwType, (LPBYTE) szPathT, &cbData))
|
|
{
|
|
if (dwType == REG_EXPAND_SZ)
|
|
cbData = ExpandEnvironmentStrings(szPathT, szPath, cb / sizeof(TCHAR));
|
|
else
|
|
{
|
|
if(GetFileAttributes(szPathT) != 0xFFFFFFFF)
|
|
StrCpyN(szPath, szPathT, cb/sizeof(TCHAR));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(hKey) RegCloseKey(hKey);
|
|
return;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// LoadLibrary_WABDll() - Load the WAB library based on the WAB DLL path
|
|
//
|
|
HINSTANCE LoadLibrary_WABDll()
|
|
{
|
|
TCHAR szWABDllPath[MAX_PATH];
|
|
HINSTANCE hinst = NULL;
|
|
|
|
GetWABDllPath(szWABDllPath, sizeof(szWABDllPath));
|
|
|
|
return(hinst = LoadLibrary( (lstrlen(szWABDllPath)) ? szWABDllPath : WAB_DLL_NAME));
|
|
}
|
|
|
|
/*
|
|
-
|
|
- bSearchCmdLine - searches for given arg in given line and returns
|
|
* data after the arg
|
|
*/
|
|
BOOL bSearchCmdLine(LPTSTR lpCmdLine, LPTSTR szArg, LPTSTR szData, DWORD cchSize)
|
|
{
|
|
LPTSTR lpCmd = NULL, lp = NULL, lpTemp = NULL;
|
|
BOOL fRet = FALSE;
|
|
DWORD cchSizeCmd = 0;
|
|
|
|
if(!lpCmdLine || !lstrlen(lpCmdLine) || !szArg || !lstrlen(szArg))
|
|
return FALSE;
|
|
|
|
cchSizeCmd = lstrlen(lpCmdLine)+1;
|
|
if(!(lpCmd = LocalAlloc(LMEM_ZEROINIT, cchSizeCmd)))
|
|
return FALSE;
|
|
|
|
StrCpyN(lpCmd, lpCmdLine, cchSizeCmd);
|
|
|
|
lpTemp = lpCmd;
|
|
while(lpTemp && *lpTemp)
|
|
{
|
|
if (! StrICmpN(lpTemp, (LPTSTR)szArg, lstrlen(szArg)))
|
|
{
|
|
fRet = TRUE;
|
|
lpTemp += lstrlen(szArg); // move past the switch
|
|
if(szData)
|
|
{
|
|
lp = lpTemp;
|
|
while(lp && *lp && *lp!='\0' && *lp!='+') //delimiter is a '+' so we dont mess up long file names
|
|
lp++;
|
|
*lp = '\0';
|
|
if(lstrlen(lpTemp))
|
|
StrCpyN(szData, lpTemp, cchSize);
|
|
}
|
|
break;
|
|
}
|
|
lpTemp++;
|
|
}
|
|
|
|
LocalFree(lpCmd);
|
|
return fRet;
|
|
}
|
|
|
|
typedef HINSTANCE (STDAPICALLTYPE *PFNMLLOADLIBARY)(LPCTSTR lpLibFileName, HMODULE hModule, DWORD dwCrossCodePage);
|
|
|
|
static const TCHAR c_szShlwapiDll[] = TEXT("shlwapi.dll");
|
|
static const char c_szDllGetVersion[] = "DllGetVersion";
|
|
static const TCHAR c_szWABResourceDLL[] = TEXT("wab32res.dll");
|
|
static const TCHAR c_szWABDLL[] = TEXT("wab32.dll");
|
|
|
|
HINSTANCE LoadWABResourceDLL(HINSTANCE hInstWAB32)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
HINSTANCE hinstShlwapi;
|
|
PFNMLLOADLIBARY pfn;
|
|
DLLGETVERSIONPROC pfnVersion;
|
|
int iEnd;
|
|
DLLVERSIONINFO info;
|
|
HINSTANCE hInst = NULL;
|
|
|
|
hinstShlwapi = LoadLibrary(c_szShlwapiDll);
|
|
if (hinstShlwapi != NULL)
|
|
{
|
|
pfnVersion = (DLLGETVERSIONPROC)GetProcAddress(hinstShlwapi, c_szDllGetVersion);
|
|
if (pfnVersion != NULL)
|
|
{
|
|
info.cbSize = sizeof(DLLVERSIONINFO);
|
|
if (SUCCEEDED(pfnVersion(&info)))
|
|
{
|
|
if (info.dwMajorVersion >= 5)
|
|
{
|
|
#ifdef UNICODE
|
|
pfn = (PFNMLLOADLIBARY)GetProcAddress(hinstShlwapi, (LPCSTR)378);
|
|
#else
|
|
pfn = (PFNMLLOADLIBARY)GetProcAddress(hinstShlwapi, (LPCSTR)377);
|
|
#endif // UNICODE
|
|
if (pfn != NULL)
|
|
hInst = pfn(c_szWABResourceDLL, hInstWAB32, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeLibrary(hinstShlwapi);
|
|
}
|
|
|
|
if (NULL == hInst)
|
|
{
|
|
GetWABDllPath(szPath, sizeof(szPath));
|
|
iEnd = lstrlen(szPath);
|
|
if (iEnd > 0)
|
|
{
|
|
iEnd = iEnd - lstrlen(c_szWABDLL);
|
|
StrCpyN(&szPath[iEnd], c_szWABResourceDLL, sizeof(szPath)/sizeof(TCHAR)-iEnd);
|
|
hInst = LoadLibrary(szPath);
|
|
}
|
|
}
|
|
|
|
AssertSz(hInst, TEXT("Failed to LoadLibrary Lang Dll"));
|
|
|
|
return(hInst);
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : WinMain
|
|
|
|
Purpose :
|
|
|
|
Parameters: Command line parameters
|
|
"" - defaults to import for default wab
|
|
"filename" - defaults to import
|
|
"/import [filename]" - default wab or specified wab
|
|
"/export [filename]" - default wab or specified wab
|
|
|
|
|
|
Returns :
|
|
|
|
***************************************************************************/
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) {
|
|
MSG msg ;
|
|
int nRetVal;
|
|
LPSTR lpTemp = lpszCmdLine;
|
|
HINSTANCE hinstWAB;
|
|
|
|
WABMIGDLGPARAM wmdp = {0};
|
|
|
|
hInstApp = hInstance;
|
|
hInst = LoadWABResourceDLL(hInstApp);
|
|
|
|
DebugTrace("WABMIG cmdline = %s\n", lpszCmdLine);
|
|
|
|
fExport = bSearchCmdLine(lpszCmdLine, (LPTSTR)szEXPORT, NULL, 0);
|
|
bSearchCmdLine(lpszCmdLine, (LPTSTR)szPROFILEID, wmdp.szProfileID, ARRAYSIZE(wmdp.szProfileID));
|
|
bSearchCmdLine(lpszCmdLine, (LPTSTR)szFILE, wmdp.szFileName, ARRAYSIZE(wmdp.szFileName));
|
|
|
|
DebugTrace("%s: id=%s file=%s\n", fExport?szEXPORT:szIMPORT, wmdp.szProfileID, wmdp.szFileName);
|
|
|
|
// Load the WABDll and getprocaddress for WABOpen
|
|
hinstWAB = LoadLibrary_WABDll();
|
|
if(hinstWAB)
|
|
lpfnWABOpen = (LPWABOPEN) GetProcAddress(hinstWAB, TEXT("WABOpen"));
|
|
|
|
DebugTrace("WABMig got filename: %s\n", wmdp.szFileName);
|
|
|
|
if(lpfnWABOpen)
|
|
{
|
|
nRetVal = (int) DialogBoxParam(hInst,
|
|
MAKEINTRESOURCE(fExport ? IDD_ExportDialog : IDD_ImportDialog),
|
|
NULL,
|
|
fExport ? ExportDialogProc : ImportDialogProc,
|
|
(LPARAM) &wmdp);
|
|
switch(nRetVal) {
|
|
case -1: //some error occured
|
|
DebugTrace("Couldn't create import dialog -> %u\n", GetLastError());
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
TCHAR szTitle[MAX_PATH];
|
|
*szTitle = *sz = '\0';
|
|
LoadString(hInst, IDS_MESSAGE_TITLE, szTitle, sizeof(szTitle));
|
|
LoadString(hInst, IDS_NO_WAB, sz, sizeof(sz));
|
|
MessageBox(NULL, sz, szTitle, MB_OK | MB_ICONSTOP);
|
|
}
|
|
|
|
if(hinstWAB)
|
|
FreeLibrary(hinstWAB);
|
|
if(hInst)
|
|
FreeLibrary(hInst);
|
|
|
|
return(nRetVal == -1);
|
|
}
|
|
|
|
INT_PTR CALLBACK ErrorDialogProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
|
|
LPERROR_INFO lpEI = (LPERROR_INFO)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
switch (message) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
TCHAR szBuffer[MAX_RESOURCE_STRING + 1];
|
|
LPTSTR lpszMessage;
|
|
|
|
SetWindowLongPtr(hwnd, DWLP_USER, lParam); //Save this for future reference
|
|
lpEI = (LPERROR_INFO)lParam;
|
|
|
|
|
|
if (LoadString(hInst,
|
|
lpEI->ids,
|
|
szBuffer, sizeof(szBuffer))) {
|
|
LPTSTR lpszArg[2] = {lpEI->lpszDisplayName, lpEI->lpszEmailAddress};
|
|
|
|
if (! FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
szBuffer,
|
|
0, 0, //ignored
|
|
(LPTSTR)&lpszMessage,
|
|
0,
|
|
(va_list *)lpszArg)) {
|
|
DebugTrace("FormatMessage -> %u\n", GetLastError());
|
|
} else {
|
|
DebugTrace("Status Message: %s\n", lpszMessage);
|
|
if (! SetDlgItemText(hwnd, IDC_ErrorMessage, lpszMessage)) {
|
|
DebugTrace("SetDlgItemText -> %u\n", GetLastError());
|
|
}
|
|
LocalFree(lpszMessage);
|
|
}
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
case WM_COMMAND :
|
|
switch (wParam) {
|
|
case IDCANCEL:
|
|
lpEI->ErrorResult = ERROR_ABORT;
|
|
// fall through to close.
|
|
|
|
case IDCLOSE:
|
|
// Ignore the contents of the radio button
|
|
SendMessage(hwnd, WM_CLOSE, 0, 0L);
|
|
return(0);
|
|
|
|
case IDOK:
|
|
// Get the contents of the radio button
|
|
ImportOptions.fNoErrors = (IsDlgButtonChecked(hwnd, IDC_NoMoreError) == 1);
|
|
ExportOptions.fNoErrors = (IsDlgButtonChecked(hwnd, IDC_NoMoreError) == 1);
|
|
SendMessage(hwnd, WM_CLOSE, 0, 0);
|
|
return(0);
|
|
|
|
case IDM_EXIT:
|
|
SendMessage(hwnd, WM_DESTROY, 0, 0L);
|
|
return(0);
|
|
}
|
|
break ;
|
|
|
|
case IDCANCEL:
|
|
// treat it like a close
|
|
SendMessage(hwnd, WM_CLOSE, 0, 0);
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
EndDialog(hwnd, FALSE);
|
|
return(0);
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
bOutlookUsingWAB
|
|
|
|
if Outlook is installed on the machine and is setup to use the WAB
|
|
then there is no PAB on this machine - the PAB is the WAB and the
|
|
WAB import imports to itself ...
|
|
So we look for this case and if it is true, we drop the PAB importer
|
|
from the UI
|
|
|
|
****************************************************************************/
|
|
BOOL bOutlookUsingWAB()
|
|
{
|
|
HKEY hKey = NULL;
|
|
LPTSTR lpReg = "Software\\Microsoft\\Office\\8.0\\Outlook\\Setup";
|
|
LPTSTR lpOMI = "MailSupport";
|
|
BOOL bUsingWAB = FALSE;
|
|
|
|
if(ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
lpReg, 0, KEY_READ, &hKey))
|
|
{
|
|
DWORD dwType = 0, dwSize = sizeof(DWORD), dwData = 0;
|
|
if(ERROR_SUCCESS == RegQueryValueEx(hKey, lpOMI, NULL,
|
|
&dwType, (LPBYTE)&dwData, &dwSize))
|
|
{
|
|
if(dwType == REG_DWORD && dwData == 0) // the value must be one ..
|
|
bUsingWAB = TRUE;
|
|
}
|
|
}
|
|
|
|
if(hKey)
|
|
RegCloseKey(hKey);
|
|
|
|
return bUsingWAB;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : PopulateTargetList
|
|
|
|
Purpose : Fills in the list box with the import/exporters from the
|
|
registry.
|
|
|
|
Parameters: hwndLB = handle of Listbox
|
|
lpszSelection = NULL or name to set as default selection
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : This routine is a MESS! Should break it up when we get time.
|
|
|
|
***************************************************************************/
|
|
HRESULT PopulateTargetList(HWND hWndLB,
|
|
LPTSTR lpszSelection)
|
|
{
|
|
ULONG ulObjectType = 0;
|
|
ULONG i=0, j=0;
|
|
TCHAR szBuf[MAX_PATH];
|
|
ULONG ulItemCount = 0;
|
|
HRESULT hr = hrSuccess;
|
|
DWORD dwErr, cbBuf;
|
|
HKEY hKeyWAB = NULL;
|
|
HKEY hKeyImport = NULL;
|
|
HKEY hKey = NULL;
|
|
ULONG ulIndex;
|
|
ULONG ulNumImporters = 0;
|
|
ULONG ulExternals = 0;
|
|
BOOL bHidePAB = FALSE;
|
|
|
|
//
|
|
// We need to clear out the list list box if it has any entries ...
|
|
//
|
|
FreeLBItemData(hWndLB);
|
|
|
|
// If outlook is using the WAB as the PAB then we want to hide
|
|
// the PAB entry from the importer and exporter
|
|
//
|
|
bHidePAB = bOutlookUsingWAB();
|
|
|
|
// How big a target list do I need?
|
|
|
|
// Load all the entries from the registry
|
|
// Open WAB Import Key
|
|
if (! (dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, //HKEY_CURRENT_USER,
|
|
szWABKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKeyWAB))) {
|
|
|
|
// Yes, WAB Key open, get Import or Export Key
|
|
if (! (dwErr = RegOpenKeyEx(hKeyWAB,
|
|
fExport ? "Export" : "Import",
|
|
0,
|
|
KEY_READ,
|
|
&hKeyImport))) {
|
|
// Enumerate Importer/Exporter keys
|
|
// How many keys are there?
|
|
if (! (dwErr = RegQueryInfoKey(hKeyImport,
|
|
NULL, NULL, NULL,
|
|
&ulExternals, // how many importer/exporter keys are there?
|
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL))) {
|
|
}
|
|
}
|
|
}
|
|
|
|
ulNumImporters = ulExternals + ulItemCount;
|
|
|
|
if ((rgTargetInfo = LocalAlloc(LPTR, ulNumImporters * sizeof(TARGET_INFO)))) {
|
|
ulIndex = 0;
|
|
cbBuf= sizeof(szBuf);
|
|
} else {
|
|
DebugTrace("LocalAlloc of TargetInfoArray -> %u\n", GetLastError());
|
|
hr = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
|
|
if (ulExternals) {
|
|
// Add external importers/exporters to the list
|
|
while (ulIndex < ulExternals && ! (dwErr = RegEnumKeyEx(hKeyImport,
|
|
ulIndex,
|
|
szBuf,
|
|
&cbBuf,
|
|
NULL, NULL, NULL, NULL))) {
|
|
// Got another one,
|
|
DebugTrace("Found Importer: [%s]\n", szBuf);
|
|
|
|
// if we want to hide the pab and this is the pab then
|
|
// skip else add
|
|
//
|
|
if(!(bHidePAB && !lstrcmpi(szBuf, TEXT("PAB"))))
|
|
{
|
|
// Add it to the list
|
|
if (rgTargetInfo[ulItemCount].lpRegName = LocalAlloc(LPTR,
|
|
lstrlen(szBuf) + 1)) {
|
|
StrCpyN(rgTargetInfo[ulItemCount].lpRegName, szBuf, lstrlen(szBuf) + 1);
|
|
|
|
// Open the key
|
|
if (! (dwErr = RegOpenKeyEx(hKeyImport,
|
|
szBuf,
|
|
0,
|
|
KEY_READ,
|
|
&hKey))) {
|
|
|
|
AllocRegValue(hKey, (LPTSTR)szDescription, &rgTargetInfo[ulItemCount].lpDescription);
|
|
AllocRegValue(hKey, (LPTSTR)szDll, &rgTargetInfo[ulItemCount].lpDll);
|
|
AllocRegValue(hKey, (LPTSTR)szEntry, &rgTargetInfo[ulItemCount].lpEntry);
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
if (! rgTargetInfo[ulItemCount].lpDescription) {
|
|
// No Description, use reg name
|
|
if (rgTargetInfo[ulItemCount].lpDescription = LocalAlloc(LPTR,
|
|
lstrlen(szBuf) + 1)) {
|
|
StrCpyN(rgTargetInfo[ulItemCount].lpDescription, szBuf, strlen(szBuf) + 1);
|
|
}
|
|
}
|
|
|
|
// Add to the list
|
|
SendMessage(hWndLB, LB_SETITEMDATA, (WPARAM)
|
|
SendMessage(hWndLB, LB_ADDSTRING, (WPARAM)0,
|
|
(LPARAM)rgTargetInfo[ulItemCount].lpDescription),
|
|
(LPARAM)ulItemCount);
|
|
|
|
if (lpszSelection && !lstrcmpi(rgTargetInfo[ulItemCount].lpDescription, lpszSelection)) {
|
|
// Set the default selection to Windows Address Book
|
|
SendMessage(hWndLB, LB_SETCURSEL, (WPARAM)ulIndex, (LPARAM)0);
|
|
}
|
|
ulItemCount++;
|
|
}
|
|
} else {
|
|
DebugTrace("LocalAlloc of Importer Name -> %u\n", GetLastError());
|
|
}
|
|
}
|
|
cbBuf = sizeof(szBuf);
|
|
ulIndex++;
|
|
}
|
|
}
|
|
exit:
|
|
if (hKeyImport) {
|
|
RegCloseKey(hKeyImport);
|
|
}
|
|
if (hKeyWAB) {
|
|
RegCloseKey(hKeyWAB);
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : FreeLBItemData
|
|
|
|
Purpose : Frees the structures associated with the Target List box.
|
|
|
|
Parameters: hwndLB = handle of Listbox
|
|
|
|
Returns : none
|
|
|
|
Comment
|
|
|
|
***************************************************************************/
|
|
void FreeLBItemData(HWND hWndLB)
|
|
{
|
|
ULONG i = 0;
|
|
ULONG ulItemCount = 0;
|
|
LPTARGET_INFO lpTargetInfo = rgTargetInfo;
|
|
|
|
if (! hWndLB) {
|
|
return;
|
|
}
|
|
|
|
ulItemCount = (ULONG) SendMessage(hWndLB, LB_GETCOUNT, 0, 0);
|
|
|
|
if (lpTargetInfo != NULL) {
|
|
if (ulItemCount != 0) {
|
|
for(i = 0; i < ulItemCount; i++) {
|
|
if(lpTargetInfo->lpRegName) {
|
|
LocalFree(lpTargetInfo->lpRegName);
|
|
}
|
|
if (lpTargetInfo->lpDescription) {
|
|
LocalFree(lpTargetInfo->lpDescription);
|
|
}
|
|
if (lpTargetInfo->lpDll) {
|
|
LocalFree(lpTargetInfo->lpDll);
|
|
}
|
|
if (lpTargetInfo->lpEntry) {
|
|
LocalFree(lpTargetInfo->lpEntry);
|
|
}
|
|
lpTargetInfo++;
|
|
}
|
|
|
|
SendMessage(hWndLB, LB_RESETCONTENT, 0, 0);
|
|
}
|
|
|
|
// Free global array
|
|
LocalFree(rgTargetInfo);
|
|
rgTargetInfo = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : ShowMessageBoxParam
|
|
|
|
Purpose : Generic MessageBox displayer
|
|
|
|
Parameters: hWndParent - Handle of message box parent
|
|
MsgID - resource id of message string
|
|
ulFlags - MessageBox flags
|
|
... - format parameters
|
|
|
|
Returns : MessageBox return code
|
|
|
|
***************************************************************************/
|
|
int __cdecl ShowMessageBoxParam(HWND hWndParent, int MsgId, int ulFlags, ...)
|
|
{
|
|
TCHAR szBuf[MAX_RESOURCE_STRING + 1] = "";
|
|
TCHAR szCaption[MAX_PATH] = "";
|
|
LPTSTR lpszBuffer = NULL;
|
|
int iRet = 0;
|
|
va_list vl;
|
|
|
|
va_start(vl, ulFlags);
|
|
|
|
LoadString(hInst, MsgId, szBuf, sizeof(szBuf));
|
|
if (FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
szBuf,
|
|
0,0, // ignored
|
|
(LPTSTR)&lpszBuffer,
|
|
sizeof(szBuf), // MAX_UI_STR
|
|
(va_list *)&vl)) {
|
|
TCHAR szCaption[MAX_PATH];
|
|
GetWindowText(hWndParent, szCaption, sizeof(szCaption));
|
|
if (! lstrlen(szCaption)) { // if no caption get the parents caption - this is necessary for property sheets
|
|
GetWindowText(GetParent(hWndParent), szCaption, sizeof(szCaption));
|
|
if (! lstrlen(szCaption)) //if still not caption, use empty title
|
|
szCaption[0] = (TCHAR)'\0';
|
|
}
|
|
iRet = MessageBox(hWndParent, lpszBuffer, szCaption, ulFlags);
|
|
LocalFree(lpszBuffer);
|
|
}
|
|
va_end(vl);
|
|
return(iRet);
|
|
}
|
|
|
|
|
|
//$$//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// LoadAllocString - Loads a string resource and allocates enough
|
|
// memory to hold it.
|
|
//
|
|
// StringID - String identifier to load
|
|
//
|
|
// returns the LocalAlloc'd, null terminated string. Caller is responsible
|
|
// for LocalFree'ing this buffer. If the string can't be loaded or memory
|
|
// can't be allocated, returns NULL.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
LPTSTR LoadAllocString(int StringID) {
|
|
ULONG ulSize = 0;
|
|
LPTSTR lpBuffer = NULL;
|
|
TCHAR szBuffer[MAX_RESOURCE_STRING + 1];
|
|
|
|
ulSize = LoadString(hInst, StringID, szBuffer, sizeof(szBuffer));
|
|
|
|
if (ulSize && (lpBuffer = LocalAlloc(LPTR, ulSize + 1))) {
|
|
StrCpyN(lpBuffer, szBuffer, ulSize + 1);
|
|
}
|
|
|
|
return(lpBuffer);
|
|
}
|