Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

2700 lines
75 KiB

/*
* Author: t-franks
*
* Last Modified On: Oct 16, 1998
* Last Modified By: t-joshp
*
*/
#include "priv.h"
#include "resource.h"
#include "impexp.h"
#include "mluisupp.h" // for MLLoadString
#include "apithk.h"
//
// Indices into our imagelist
// (used for the open and closed folder icons on the tree view)
//
#define FOLDER_CLOSED 0
#define FOLDER_OPEN 1
#define ImportCookieFile ImportCookieFileW
#define ExportCookieFile ExportCookieFileW
BOOL ImportCookieFileW(IN LPCWSTR szFilename);
BOOL ExportCookieFileW(IN LPCWSTR szFilename, BOOL fAppend);
extern void SetListViewToString (HWND hLV, LPCTSTR pszString);
//
// used to display "file already exists" and "file not found" messages
//
int WarningMessageBox(HWND hwnd, UINT idTitle, UINT idMessage, LPCTSTR szFile, DWORD dwFlags);
//
// Strings that don't need localizing
//
#define NS3_COOKIE_REG_PATH TEXT("Software\\Netscape\\Netscape Navigator\\Cookies")
#define NS3_COOKIE_REG_KEY TEXT("Cookie File")
#ifndef UNIX
#define NS3_BOOKMARK_REG_PATH TEXT("Software\\Netscape\\Netscape Navigator\\Bookmark List")
#else
#define NS3_BOOKMARK_REG_PATH TEXT("SOFTWARE\\Microsoft\\Internet Explorer\\unix\\nsbookmarks")
#endif
#define NS3_BOOKMARK_REG_KEY TEXT("File Location")
#define NS4_USERS_REG_PATH TEXT("Software\\Netscape\\Netscape Navigator\\Users")
#define NS4_USERPATH_REG_KEY TEXT("DirRoot")
#define NS_FALLBACK_ROOT_REG_KEY TEXT("Software\\Netscape\\Netscape Navigator")
#define NS_FALLBACK_VERSION_REG_VAL TEXT("CurrentVersion")
#define NS_FALLBACK_MAIN_REG_VAL TEXT("Main")
#define NS_FALLBACK_INST_REG_VAL TEXT("Install Directory")
#ifndef UNIX
#define ALL_FILES_WILDCARD TEXT("\\*.*")
#else
#define ALL_FILES_WILDCARD TEXT("/*")
#endif
#define DOT_DIR TEXT(".")
#define DOT_DOT_DIR TEXT("..")
#ifdef UNIX
#define DIR_SEPARATOR_CHAR TEXT('/')
#else
#define DIR_SEPARATOR_CHAR TEXT('\\')
#endif
//*************************************************************
//
// class ListIterator
//
// Keeps hold on a position in a list. Allows basic access
//to a list. The list is set up to map a name to a value.
class NestedList;
class ListIterator
{
friend NestedList;
struct node
{
LPTSTR _sName;
LPTSTR _sValue;
DWORD _cNameSize, _cValueSize;
node* _pnNext;
node* _pnSublist;
};
// A position is held by pointing to the
//current node and the pointer that is directed
//to that node. The back pointer is kept so the
//list can be manipulated at the current element.
// when m_pnCurrent == NULL, the iterator is
//at the end of the list.
node** m_ppnPrev;
node* m_pnCurrent;
// The invariant could be broken if two iterators
//point to the same node, and one inserts or deletes
//an element. So only one iterator should exist in
//a branch of the list at a time.
BOOL invariant()
{
return *m_ppnPrev == m_pnCurrent;
}
public:
ListIterator( node** ppnPrev)
{
m_ppnPrev = ppnPrev;
m_pnCurrent = *m_ppnPrev;
}
BOOL Insert( LPCTSTR sName, DWORD cNameSize, LPCTSTR sValue, DWORD cValueSize);
BOOL Remove();
ListIterator GetSublist();
void DeleteSublist();
BOOL Next();
BOOL AtEndOfList();
LPCTSTR GetName();
DWORD GetNameSize();
LPCTSTR GetValue();
DWORD GetValueSize();
};
//*************************************************************
//
// class NestedList
// Keeps a pointer to a node which heads a list,
// and deletes that list on destruction.
class NestedList
{
ListIterator::node* m_pnRoot;
public:
NestedList();
~NestedList();
operator ListIterator();
};
NestedList::NestedList()
: m_pnRoot(NULL)
{
}
NestedList::~NestedList()
{
while( ((ListIterator)*this).Remove())
{
}
}
NestedList::operator ListIterator()
{
return ListIterator( &m_pnRoot);
}
//*************************************************************
//*************************************************************
//
// ListIterator functions
//
// Inserts an element before the current one,
//leaves iterator pointing at new node.
BOOL ListIterator::Insert(
LPCTSTR sName,
DWORD cNameSize,
LPCTSTR sValue,
DWORD cValueSize)
{
ASSERT( invariant());
node* pNewNode = (node*)(new BYTE[ sizeof(node)
+ (( cNameSize + cValueSize)
* sizeof(TCHAR))]);
if( pNewNode == NULL)
return FALSE;
// the name and value will be appended to the node.
pNewNode->_sName = (LPTSTR)((BYTE*)pNewNode + sizeof(node));
pNewNode->_sValue = pNewNode->_sName + cNameSize;
pNewNode->_cNameSize = cNameSize;
pNewNode->_cValueSize = cValueSize;
memcpy( pNewNode->_sName, sName, pNewNode->_cNameSize * sizeof(TCHAR));
memcpy( pNewNode->_sValue, sValue, pNewNode->_cValueSize * sizeof(TCHAR));
// insert new node in list
pNewNode->_pnNext = m_pnCurrent;
*m_ppnPrev = pNewNode;
// The iterator now points to the new element.
m_pnCurrent = *m_ppnPrev;
ASSERT( invariant());
return TRUE;
}
// Deletes the current node.
// Returns FALSE if at end of list.
BOOL ListIterator::Remove()
{
ASSERT( invariant());
// If this list is empty, or if the iterator
//points at the end of the list, there is nothing to
//delete.
if( m_pnCurrent == NULL)
return FALSE;
// remove sublist
DeleteSublist();
// Remember where target node is
//so it can be deleted once out of
//the list.
node* pOldNode = m_pnCurrent;
// take the target node out of the list.
//(iterator points to next node or end of list)
*m_ppnPrev = m_pnCurrent->_pnNext;
m_pnCurrent = *m_ppnPrev;
// Get rid of target node.
delete [] (BYTE*)pOldNode;
ASSERT( invariant());
return TRUE;
}
// Returns the sublist of the current node.
ListIterator ListIterator::GetSublist()
{
ASSERT( invariant());
return ListIterator( &(m_pnCurrent->_pnSublist));
}
// deletes the children of the current node.
void ListIterator::DeleteSublist()
{
ASSERT( invariant());
ListIterator sublist( &(m_pnCurrent->_pnSublist));
while( sublist.Remove())
{
}
ASSERT( invariant());
}
// Advances to the next node.
// Returns FALSE if already at end of list.
BOOL ListIterator::Next()
{
ASSERT( invariant());
if( m_pnCurrent == NULL)
return FALSE;
m_ppnPrev = &(m_pnCurrent->_pnNext);
m_pnCurrent = *m_ppnPrev;
ASSERT( invariant());
return m_pnCurrent != NULL;
}
//
BOOL ListIterator::AtEndOfList()
{
return ( m_pnCurrent == NULL) ? TRUE : FALSE;
};
//
LPCTSTR ListIterator::GetName()
{
ASSERT( invariant() && m_pnCurrent != NULL);
return m_pnCurrent->_sName;
}
//
DWORD ListIterator::GetNameSize()
{
ASSERT( invariant() && m_pnCurrent != NULL);
return m_pnCurrent->_cNameSize;
}
//
LPCTSTR ListIterator::GetValue()
{
ASSERT( invariant() && m_pnCurrent != NULL);
return m_pnCurrent->_sValue;
}
//
DWORD ListIterator::GetValueSize()
{
ASSERT( invariant() && m_pnCurrent != NULL);
return m_pnCurrent->_cValueSize;
}
//*************************************************************
//*************************************************************
//
// class ImpExpUserProcess
//
// maintains the description of an import/export process
// for an import/export wizard, and finally executes the
// the import/export.
enum ExternalType { INVALID_EXTERNAL = 0, COOKIES, BOOKMARKS};
enum TransferType { INVALID_TRANSFER = 0, IMPORT, EXPORT};
class ImpExpUserProcess
{
public:
ImpExpUserProcess();
~ImpExpUserProcess();
// the first step the wizard should do is identify the type of
//import/export process to be done.
void SelectExternalType( ExternalType selection) { m_ExternalType = selection; }
void SelectTransferType( TransferType selection) { m_TransferType = selection; }
ExternalType GetExternalType() { return m_ExternalType; }
TransferType GetTransferType() { return m_TransferType; }
BOOL PopulateComboBoxForExternalSelection( HWND hComboBox);
BOOL GetExternalManualDefault( LPTSTR sExternal, DWORD* pcSize);
//
// used to fill the listbox with names of netscape profiles
//
void purgeExternalList();
BOOL populateExternalList();
BOOL populateExternalListForCookiesOrBookmarks();
//
// for netscape 3.x
//
BOOL populateExternalListForCookiesOrBookmarksWithNS3Entry();
//
// for netscape 4.x
//
BOOL populateExternalListForCookiesOrBookmarksWithNS4Entries();
//
// fallback case for "funny" versions of netscape
//
BOOL populateExternalListFromFolders(LPTSTR pszPath);
BOOL populateExternalListWithNSEntriesFallBack();
// If the transfer is for favorites, the wizard needs to specify
//an internal folder to import to or export from.
LPCTSTR GetInternalSelection() { return m_pSelectedInternal; }
BOOL PopulateTreeViewForInternalSelection( HWND TreeView);
BOOL populateTreeViewWithInternalList( HWND hTreeView, ListIterator iterator, HTREEITEM hParent);
BOOL ExpandTreeViewRoot ( HWND hTreeView ) ;
BOOL SelectInternalSelection( HWND TreeView);
void purgeInternalList();
BOOL populateInternalList();
BOOL populateInternalListForBookmarks();
BOOL appendSubdirsToInternalList( LPTSTR sPath, ListIterator iterator);
// And then, the import/export can be completed.
void PerformImpExpProcess(HWND hwnd);
//
// The filename that we're exporting to or
// importing from.
//
TCHAR m_szFileName[MAX_PATH];
private:
ExternalType m_ExternalType;
TransferType m_TransferType;
// m_ExternalList is a flat list of names associated with files
//example: name = "Netscape 4.0 profile - Dr. Falken"
// value = "c:\netscapeprofiledir\DrFalken.chs"
NestedList m_ExternalList;
// m_InternalList is a nested list favorites' pathnames,
//associated with the complete path.
NestedList m_InternalList;
// Maintain synchronization between m_ExternalType/m_TransferType
//and m_InternalList
ExternalType m_InternalListExternalType;
TransferType m_InternalListTransferType;
// if ExternalType == BOOKMARKS,
//m_pSelectedInternal is the path of a Favorites folder,
//residing in m_InternalList somewhere, or NULL if a folder
//hasn't been selected yet.
LPTSTR m_pSelectedInternal;
};
ImpExpUserProcess::ImpExpUserProcess()
: m_ExternalType(INVALID_EXTERNAL), m_TransferType(INVALID_TRANSFER),
m_InternalListExternalType(INVALID_EXTERNAL), m_InternalListTransferType(INVALID_TRANSFER),
m_pSelectedInternal(0)
{
}
ImpExpUserProcess::~ImpExpUserProcess()
{
}
//*************************************************************
// PopulateComboBoxForExternal
//
// Loads content for list box into memory and into List Box,
//associating value of each element with the list element.
// returns FALSE if the list box is left empty
BOOL ImpExpUserProcess::PopulateComboBoxForExternalSelection( HWND hComboBox)
{
ASSERT ( m_ExternalType != INVALID_EXTERNAL ) ;
ComboBox_ResetContent(hComboBox);
// If ExternalList is invalid, the list box will be left empty.
if( !populateExternalList() )
return FALSE;
ListIterator iterator = m_ExternalList;
// Detect and notify if the list is empty.
if( iterator.AtEndOfList() )
return FALSE;
// add entries from the new ExternalList to the ComboBox.
do
{
int index = ComboBox_AddString( hComboBox, const_cast<LPTSTR>(iterator.GetName() ) );
ComboBox_SetItemData( hComboBox, index, const_cast<LPTSTR>(iterator.GetValue() ) );
} while( iterator.Next());
// set the first one as selected
ComboBox_SetCurSel( hComboBox, 0 );
return TRUE;
}
//*************************************************************
//
// GetExternalManualDefault
//
// Allows user interface to offer some sort of default
// filename/location.
//
BOOL ImpExpUserProcess::GetExternalManualDefault(LPTSTR sExternal, DWORD* pcSize)
{
ASSERT(NULL != pcSize);
//
// We only fill it in if it's blank
//
if (m_szFileName[0])
{
return FALSE;
}
ListIterator iterator = m_ExternalList;
TCHAR szFileName[MAX_PATH];
INT cchFileName;
if(m_ExternalType == BOOKMARKS)
MLLoadString(IDS_NETSCAPE_BOOKMARK_FILE,szFileName,ARRAYSIZE(szFileName));
else
MLLoadString(IDS_NETSCAPE_COOKIE_FILE,szFileName,ARRAYSIZE(szFileName));
cchFileName = lstrlen(szFileName) + 1;
// Grab the first item in the External List and use its value.
if( ((ListIterator)m_ExternalList).AtEndOfList() == FALSE
&& ((ListIterator)m_ExternalList).GetValue() != NULL
&& *pcSize >= ((ListIterator)m_ExternalList).GetValueSize())
{
StrCpyN( sExternal,
((ListIterator)m_ExternalList).GetValue(),
((ListIterator)m_ExternalList).GetValueSize());
*pcSize = ((ListIterator)m_ExternalList).GetValueSize();
return TRUE;
}
// If there is enough room, specify some file with the correct name
// in the "my documents" directory.
else
{
ASSERT(m_ExternalType == BOOKMARKS || m_ExternalType == COOKIES);
TCHAR szMyDocsPath[MAX_PATH];
SHGetSpecialFolderPath(NULL,szMyDocsPath,CSIDL_PERSONAL,TRUE);
*pcSize = wnsprintf(sExternal,MAX_PATH,TEXT("%s%c%s"),szMyDocsPath,DIR_SEPARATOR_CHAR,szFileName);
return *pcSize > 0;
}
}
//*************************************************************
//
//
// purgeExternalList
//
// Used to clear external target/source list loaded into memory
void ImpExpUserProcess::purgeExternalList()
{
// delete elements until they're all gone.
ListIterator iterator = m_ExternalList;
while( iterator.Remove())
{
}
}
//*************************************************************
//
// populeExternalList
//
// Used to load external target/source list into memory
BOOL ImpExpUserProcess::populateExternalList()
{
ASSERT(m_ExternalType != INVALID_EXTERNAL)
purgeExternalList();
if(!populateExternalListForCookiesOrBookmarks())
{
//
// If we didn't get any entries using the "standard"
// techniques, then (and only then) we try the "fallback"
//
if (!populateExternalListWithNSEntriesFallBack())
{
purgeExternalList();
return FALSE;
}
}
return TRUE;
}
//*************************************************************
//
// populateExternalListforCookiesOrBookmarks
//
// Used to lod external target/source list into memory
//in the case that the content to be transfered is cookies
//or bookmarks.
// returns TRUE if any elements have been added to the external list
BOOL ImpExpUserProcess::populateExternalListForCookiesOrBookmarks()
{
ASSERT( m_ExternalType == COOKIES || m_ExternalType == BOOKMARKS);
BOOL fHasAddedElements = FALSE;
if( populateExternalListForCookiesOrBookmarksWithNS3Entry())
fHasAddedElements = TRUE;
if( populateExternalListForCookiesOrBookmarksWithNS4Entries())
fHasAddedElements = TRUE;
return fHasAddedElements;
}
//*************************************************************
//
// populateExternalList..WithNS3Entry
//
// subfunc of populateExternalListForCookiesOrBookmarks.
// returns TRUE if any elements have been added to the external list
BOOL ImpExpUserProcess::populateExternalListForCookiesOrBookmarksWithNS3Entry()
{
BOOL retVal = FALSE;
// Determine where to look for reg key
LPTSTR sNS3RegPath;
LPTSTR sNS3RegKey;
if( m_ExternalType == BOOKMARKS)
{
sNS3RegPath = NS3_BOOKMARK_REG_PATH;
sNS3RegKey = NS3_BOOKMARK_REG_KEY;
}
else
{
sNS3RegPath = NS3_COOKIE_REG_PATH;
sNS3RegKey = NS3_COOKIE_REG_KEY;
}
// Get the file location and add it to the list
// The registry location has the complete path + filename.
TCHAR sFilePath[MAX_PATH];
DWORD cbFilePathSize = sizeof(sFilePath);
DWORD dwType;
if (ERROR_SUCCESS == SHGetValue(HKEY_CURRENT_USER, sNS3RegPath, sNS3RegKey,
&dwType, (BYTE*)sFilePath, &cbFilePathSize)
&& (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
{
TCHAR szBuffer[MAX_PATH];
MLLoadString(IDS_NS3_VERSION_CAPTION, szBuffer, MAX_PATH);
retVal = ((ListIterator)m_ExternalList).Insert(
szBuffer, lstrlen(szBuffer)+1,
sFilePath, cbFilePathSize / sizeof(TCHAR));
}
return retVal;
}
//*************************************************************
//
// populateExternalList..WithNS4Entries
//
// subfunc of populateExternalListForCookiesOrBookmarks.
// returns TRUE if any elements have been added to the external list
BOOL ImpExpUserProcess::populateExternalListForCookiesOrBookmarksWithNS4Entries()
{
BOOL retVal = FALSE;
// Get an iterator to advance position as items are inserted.
ListIterator iterator = (ListIterator)m_ExternalList;
// Get the filename to be attached and the associated string size.
TCHAR sFilename[MAX_PATH];
DWORD cFilenameLength;
if(m_ExternalType == BOOKMARKS)
MLLoadString(IDS_NETSCAPE_BOOKMARK_FILE,sFilename,ARRAYSIZE(sFilename));
else
MLLoadString(IDS_NETSCAPE_COOKIE_FILE,sFilename,ARRAYSIZE(sFilename));
cFilenameLength = lstrlen(sFilename);
// Get the reg key of the root of the NS profiles for enumeration.
HKEY hUserRootKey = NULL;
if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, NS4_USERS_REG_PATH,
0, KEY_READ, &hUserRootKey)
!= ERROR_SUCCESS)
{
hUserRootKey = NULL;
goto donePopulateExternalListForCookiesOrBookmarksWithNS4Entries;
}
DWORD dwNumberOfProfiles;
if( RegQueryInfoKey( hUserRootKey, NULL, NULL, NULL, &dwNumberOfProfiles,
NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
|| dwNumberOfProfiles == 0)
{
goto donePopulateExternalListForCookiesOrBookmarksWithNS4Entries;
}
// Enumerate over the NS profiles, getting their names and
//directory paths. Associated the profile name with the path
//of the desired files by appending the filename to the
//user's root.
TCHAR sProfileName[MAX_PATH];
DWORD cProfileNameSize;
cProfileNameSize = MAX_PATH;
DWORD iEnumIndex; iEnumIndex = 0;
while( RegEnumKeyEx( hUserRootKey, (iEnumIndex++), sProfileName,
&cProfileNameSize, NULL, NULL, NULL, NULL)
== ERROR_SUCCESS)
{
//RegEnumKeyEx gives us the ProfileNameSize w/out the '\0'.
cProfileNameSize = MAX_PATH;
HKEY hProfileKey = NULL;
if( RegOpenKeyEx( hUserRootKey, sProfileName, 0, KEY_READ, &hProfileKey)
!= ERROR_SUCCESS)
{
hProfileKey = NULL;
goto doneWithEntryInPopulateExternalListForCookiesOrBookmarksWithNS4Entries;
}
DWORD dwType; // should be REG_SZ when returned from QueryValue
TCHAR sProfilePath[MAX_PATH];
DWORD cProfilePathSize; cProfilePathSize = sizeof(sProfilePath);
if( (RegQueryValueEx( hProfileKey, NS4_USERPATH_REG_KEY, NULL, &dwType,
(LPBYTE)sProfilePath, &cProfilePathSize)
!= ERROR_SUCCESS)
|| dwType != REG_SZ)
{
goto doneWithEntryInPopulateExternalListForCookiesOrBookmarksWithNS4Entries;
}
cProfilePathSize /= sizeof(TCHAR);
if( (MAX_PATH - cProfilePathSize) < cFilenameLength)
{
goto doneWithEntryInPopulateExternalListForCookiesOrBookmarksWithNS4Entries;
}
// append "\\sFilename\0" to the path.
sProfilePath[ cProfilePathSize - 1] = TCHAR(FILENAME_SEPARATOR);
memcpy( &sProfilePath[cProfilePathSize],
sFilename, cFilenameLength * sizeof(TCHAR));
cProfilePathSize += cFilenameLength;
sProfilePath[cProfilePathSize++] = TCHAR('\0');
// we can only import files if they exist!
if( m_TransferType == IMPORT
&& GetFileAttributes(sProfilePath) == 0xFFFFFFFF)
goto doneWithEntryInPopulateExternalListForCookiesOrBookmarksWithNS4Entries;
//
// construct the string for the combo box
//
TCHAR sRawProfileName[MAX_PATH];
TCHAR sRealProfileName[MAX_PATH];
UINT cRealProfileName;
MLLoadString(IDS_NS4_FRIENDLY_PROFILE_NAME, sRawProfileName, MAX_PATH);
cRealProfileName =
wnsprintf(sRealProfileName, MAX_PATH,
sRawProfileName, sProfileName);
// Insert the profile into the list. If it inserts, thats
//enough to consider the whole functions call a success.
if( iterator.Insert(sRealProfileName, cRealProfileName + 1,
sProfilePath, cProfilePathSize))
retVal = TRUE;
doneWithEntryInPopulateExternalListForCookiesOrBookmarksWithNS4Entries:
if( hProfileKey != NULL)
RegCloseKey(hProfileKey);
}
donePopulateExternalListForCookiesOrBookmarksWithNS4Entries:
if( hUserRootKey != NULL)
RegCloseKey( hUserRootKey);
return retVal;
}
BOOL ImpExpUserProcess::populateExternalListFromFolders(LPTSTR pszPath)
{
BOOL retval = FALSE;
TCHAR szFileName[MAX_PATH];
TCHAR szPathWithWildcards[MAX_PATH];
ListIterator iterator = (ListIterator)m_ExternalList;
HANDLE hFind = NULL;
WIN32_FIND_DATA wfd;
//
// what are we looking for?
//
if(m_ExternalType == BOOKMARKS)
MLLoadString(IDS_NETSCAPE_BOOKMARK_FILE,szFileName,ARRAYSIZE(szFileName));
else
MLLoadString(IDS_NETSCAPE_COOKIE_FILE,szFileName,ARRAYSIZE(szFileName));
//
// prepare the path variable
//
StrCpyN(szPathWithWildcards,pszPath,MAX_PATH);
StrCatBuff(szPathWithWildcards,ALL_FILES_WILDCARD,MAX_PATH);
//
// start the find file thing
//
hFind = FindFirstFile(szPathWithWildcards,&wfd);
if (hFind == INVALID_HANDLE_VALUE)
goto Cleanup;
do
{
//
// the actual bookmark or cookie file
//
TCHAR szFullPath[MAX_PATH];
int cchFullPath;
//
// a "friendly" name for the corresponding profile
//
TCHAR szProfileFormat[MAX_PATH];
TCHAR szProfileName[MAX_PATH];
int cchProfileName;
//
// skip over "." and ".."
//
if(!StrCmp(wfd.cFileName, DOT_DIR) ||
!StrCmp(wfd.cFileName, DOT_DOT_DIR))
continue;
//
// skip over any non-directories
//
if (!(wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
continue;
//
// generate the path
//
#ifndef UNIX
cchFullPath = wnsprintf(szFullPath,MAX_PATH,TEXT("%s\\%s\\%s"),pszPath,wfd.cFileName,szFileName);
#else
cchFullPath = wnsprintf(szFullPath,MAX_PATH,TEXT("%s/%s/%s"),pszPath,wfd.cFileName,szFileName);
#endif
//
// see if the file actually exists
//
if (GetFileAttributes(szFullPath) == 0xFFFFFFFF)
continue;
//
// generate the profile name
//
MLLoadString(IDS_FB_FRIENDLY_PROFILE_NAME, szProfileFormat, MAX_PATH);
cchProfileName = wnsprintf(szProfileName, MAX_PATH, szProfileFormat, wfd.cFileName);
//
// add the entry to the list
//
iterator.Insert(
szProfileName,cchProfileName+1,
szFullPath,cchFullPath+1);
retval = TRUE;
} while(FindNextFile(hFind,&wfd));
Cleanup:
if (hFind)
FindClose(hFind);
return retval;
}
BOOL ImpExpUserProcess::populateExternalListWithNSEntriesFallBack()
{
BOOL retVal = FALSE;
HKEY hRoot = NULL;
HKEY hCurrentVersion = NULL;
HKEY hCurrentVersionMain = NULL;
TCHAR szUsersDir[64]; // will contain "..\\Users"
DWORD dwType;
TCHAR szVersion[64];
TCHAR szPath[MAX_PATH];
DWORD cbSize;
LONG result;
//
// Open the root of netscape's HKLM registry hierarchy
//
result = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
NS_FALLBACK_ROOT_REG_KEY,
0,
KEY_READ,
&hRoot);
if (result != ERROR_SUCCESS)
goto Cleanup;
//
// Retrieve the "CurrentVersion" value
//
cbSize = sizeof(szVersion);
result = RegQueryValueEx(
hRoot,
NS_FALLBACK_VERSION_REG_VAL,
NULL,
&dwType,
(LPBYTE)szVersion,
&cbSize);
if (result != ERROR_SUCCESS || dwType != REG_SZ)
goto Cleanup;
//
// Open the sub-hierarchy corresponding to the current version
//
result = RegOpenKeyEx(
hRoot,
szVersion,
0,
KEY_READ,
&hCurrentVersion);
if (result != ERROR_SUCCESS)
goto Cleanup;
//
// Open the "main" sub-hierarchy
//
result = RegOpenKeyEx(
hCurrentVersion,
NS_FALLBACK_MAIN_REG_VAL,
0,
KEY_READ,
&hCurrentVersionMain);
if (result != ERROR_SUCCESS)
goto Cleanup;
//
// Retrieve the "Install Directory" value
//
cbSize = sizeof(szPath);
result = RegQueryValueEx(
hCurrentVersionMain,
NS_FALLBACK_INST_REG_VAL,
NULL,
&dwType,
(LPBYTE)szPath,
&cbSize);
if (result != ERROR_SUCCESS || dwType != REG_SZ)
goto Cleanup;
//
// Take a wild guess at where the "Users" dir might be
//
MLLoadString(IDS_NETSCAPE_USERS_DIR,szUsersDir,ARRAYSIZE(szUsersDir));
StrCatBuff(szPath,szUsersDir,ARRAYSIZE(szPath));
//
// Fill in the list
//
if (populateExternalListFromFolders(szPath))
retVal = TRUE;
Cleanup:
if (hRoot)
RegCloseKey(hRoot);
if (hCurrentVersion)
RegCloseKey(hCurrentVersion);
if (hCurrentVersionMain)
RegCloseKey(hCurrentVersionMain);
return retVal;
}
//*************************************************************
//
// PopulateTreeViewForInternalSelection
//
// Load a nested list of the favorites folders into memory
//and then into a Tree View.
// returns FALSE if TreeView is left empty.
BOOL ImpExpUserProcess::PopulateTreeViewForInternalSelection( HWND hTreeView)
{
ASSERT( m_TransferType != INVALID_TRANSFER);
TreeView_DeleteAllItems( hTreeView);
if( !populateInternalList())
return FALSE;
return populateTreeViewWithInternalList
( hTreeView, (ListIterator)m_InternalList, TVI_ROOT);
}
//*************************************************************
//
// populateTreeViewWithInternalList
//
// Loads list entries at 'iterator' below tree view item 'hParent'
// into 'hTreeView'. Associates value of each list entry with
// the Param of the Tree View node.
//
BOOL ImpExpUserProcess::populateTreeViewWithInternalList
(
HWND hTreeView,
ListIterator iterator,
HTREEITEM hParent
)
{
BOOL retVal = FALSE;
if( iterator.AtEndOfList())
goto donePopulateTreeViewWithInternalList;
TVINSERTSTRUCT newTV;
HTREEITEM hNew;
// declare parent and intent to put at end of list.
newTV.hParent = hParent;
newTV.hInsertAfter = TVI_LAST;
// build info struct
newTV.itemex.mask = TVIF_TEXT
| TVIF_PARAM
| TVIF_CHILDREN
| TVIF_IMAGE
| TVIF_SELECTEDIMAGE;
// give name
newTV.itemex.cchTextMax = lstrlen( iterator.GetName()) + 1;
newTV.itemex.pszText = const_cast<LPTSTR>(iterator.GetName());
// associate the necessary data
newTV.itemex.lParam = (LPARAM)iterator.GetValue();
// tell tree view if there are any children.
newTV.itemex.cChildren =
iterator.GetSublist().AtEndOfList() == TRUE ? FALSE : TRUE;
// use correct icons
newTV.itemex.iSelectedImage = FOLDER_OPEN ;
newTV.itemex.iImage = FOLDER_CLOSED ;
hNew = TreeView_InsertItem( hTreeView, &newTV );
if( hNew == NULL)
goto donePopulateTreeViewWithInternalList;
// an element has been added, so we should return TRUE.
retVal = TRUE;
// add children
populateTreeViewWithInternalList( hTreeView, iterator.GetSublist(), hNew );
// add siblings
if( iterator.Next())
populateTreeViewWithInternalList( hTreeView, iterator, hParent );
donePopulateTreeViewWithInternalList:
return retVal;
}
BOOL ImpExpUserProcess::ExpandTreeViewRoot ( HWND hTreeView )
{
HTREEITEM hRoot ;
hRoot = TreeView_GetRoot ( hTreeView ) ;
if ( hRoot != NULL )
TreeView_Expand ( hTreeView, hRoot, TVE_EXPAND ) ;
else
return FALSE ;
return TRUE ;
}
//*************************************************************
//
// SelectInternalSelection
//
// Gets the data associated with the current selection of
//'hTreeView'.
BOOL ImpExpUserProcess::SelectInternalSelection( HWND hTreeView)
{
HTREEITEM hSelection = TreeView_GetSelection( hTreeView);
if( hSelection == NULL)
return FALSE;
//TVITEM is built up to query the lParam
//(the lParam has been associated with a pointer to the path value)
TVITEM TV;
TV.mask = TVIF_PARAM;
TV.hItem = hSelection;
if( !TreeView_GetItem( hTreeView, &TV))
return FALSE;
m_pSelectedInternal = (LPTSTR)TV.lParam;
ASSERT( m_pSelectedInternal != NULL);
return TRUE;
}
//*************************************************************
//
// purgeInternalList
//
// Wipes out whatever has been loaded in the internal
//target/source list.
void ImpExpUserProcess::purgeInternalList()
{
// clear the list.
ListIterator iterator = (ListIterator)m_InternalList;
while( iterator.Remove())
{
}
m_pSelectedInternal = NULL;
m_InternalListExternalType = INVALID_EXTERNAL;
m_InternalListTransferType = INVALID_TRANSFER;
}
//*************************************************************
//
// populateInternalList
//
// Builds the internal list for potential internal target/sources.
// This currently only makes sense for bookmarks, where a favorites
//directory has to be picked.
// returns TRUE if any elements have been added to the internal list
BOOL ImpExpUserProcess::populateInternalList()
{
ASSERT( m_ExternalType != INVALID_EXTERNAL);
if( m_InternalListExternalType == m_ExternalType
&& m_InternalListTransferType == m_TransferType)
return TRUE;
purgeInternalList();
// (could switch on different m_ExternalTypes here)
if( !populateInternalListForBookmarks())
{
purgeInternalList();
return FALSE;
}
m_InternalListExternalType = m_ExternalType;
m_InternalListTransferType = m_TransferType;
return TRUE;
}
//*************************************************************
//
// populateInternalListForBookmarks
// returns TRUE if any elements have been added to the internal list
BOOL ImpExpUserProcess::populateInternalListForBookmarks()
{
TCHAR szFavoritesPath[MAX_PATH];
if( SHGetSpecialFolderPath( NULL, szFavoritesPath, CSIDL_FAVORITES, FALSE)
&& appendSubdirsToInternalList( szFavoritesPath, m_InternalList))
{
return TRUE;
}
else return FALSE;
}
//*************************************************************
//
// appendSubdirsToInternalList
//
// Takes 'sPath' as a specification for a file search. All
//directories that match that are added to the internal list
//at 'iterator'.
// Recursively adds subdirectories found.
//
//typical usage:
// szPath is "c:\Root\Favorites",
// finds "c:\Root\Favorites",
// recursively calls itself with
// szPath = "c:\Root\Favorites\*.*"
// finding and recursing into all subdirs
// returns TRUE if any directories have been added to the internal list
// Edits the contents of the buffer past the last '\\'.
BOOL ImpExpUserProcess::appendSubdirsToInternalList
(
LPTSTR sPath,
ListIterator iterator
)
{
BOOL fHaveAddedDirectories = FALSE;
DWORD cPathLength = lstrlen(sPath);
HANDLE hEnum;
WIN32_FIND_DATA currentFile;
hEnum = FindFirstFile( sPath, &currentFile);
//example:
//given: "c:\root\*.*" (will find all dirs in root)
//want: "c:\root\"
//given: "c:\favorites" (will find favorites in root)
//want: "c:\"
// left search to '\\' to find the path of the files to be found.
while( cPathLength > 0
&& sPath[ --cPathLength] != TCHAR(FILENAME_SEPARATOR))
{
}
cPathLength++;
if( hEnum == INVALID_HANDLE_VALUE)
return FALSE;
do
{
DWORD cFileNameLength;
// we only handle directories
if( !(currentFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
continue;
// we don't want '.' and '..' to show up.
if( !StrCmp( currentFile.cFileName, DOT_DIR)
|| !StrCmp( currentFile.cFileName, DOT_DOT_DIR))
continue;
cFileNameLength = lstrlen( currentFile.cFileName);
memcpy( sPath + cPathLength, currentFile.cFileName, cFileNameLength * sizeof(TCHAR));
sPath[ cPathLength + cFileNameLength] = TCHAR('\0');
if( iterator.Insert( currentFile.cFileName, cFileNameLength + 1,
sPath, cPathLength + cFileNameLength + 1))
{
memcpy( sPath + cPathLength + cFileNameLength,
ALL_FILES_WILDCARD, sizeof(ALL_FILES_WILDCARD));
appendSubdirsToInternalList( sPath, iterator.GetSublist());
// we know now that a directory has been added
fHaveAddedDirectories = TRUE;
}
} while( FindNextFile( hEnum, &currentFile));
ASSERT(ERROR_NO_MORE_FILES == GetLastError());
FindClose(hEnum);
return fHaveAddedDirectories;
}
//*************************************************************
//
// PerformImpExpProcess
//
// Once everything is set up right, this should do the trick.
void ImpExpUserProcess::PerformImpExpProcess(HWND hwnd)
{
ASSERT( GetExternalType() != INVALID_EXTERNAL);
ASSERT( GetTransferType() != INVALID_TRANSFER);
ASSERT( (GetExternalType() == BOOKMARKS) ? (GetInternalSelection() != NULL) : TRUE);
HCURSOR hOldCursor;
//
// This could take a while, so show an hourglass cursor
//
hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
switch( GetExternalType())
{
case COOKIES:
switch( GetTransferType())
{
case IMPORT:
if (ImportCookieFile(m_szFileName))
{
MLShellMessageBox(
hwnd,
MAKEINTRESOURCE(IDS_IMPORTSUCCESS_COOK),
MAKEINTRESOURCE(IDS_CONFIRM_IMPTTL_COOK),
MB_OK);
}
else
{
MLShellMessageBox(
hwnd,
MAKEINTRESOURCE(IDS_IMPORTFAILURE_COOK),
MAKEINTRESOURCE(IDS_CONFIRM_IMPTTL_COOK),
MB_OK);
}
break;
case EXPORT:
if (SUCCEEDED(SHPathPrepareForWriteWrap(hwnd, NULL, m_szFileName, FO_COPY, (SHPPFW_DEFAULT | SHPPFW_IGNOREFILENAME))))
{
// FALSE specifies that we will overwrite cookies
if (ExportCookieFile(m_szFileName, FALSE ))
{
MLShellMessageBox(
hwnd,
MAKEINTRESOURCE(IDS_EXPORTSUCCESS_COOK),
MAKEINTRESOURCE(IDS_CONFIRM_EXPTTL_COOK),
MB_OK);
}
else
{
MLShellMessageBox(
hwnd,
MAKEINTRESOURCE(IDS_EXPORTFAILURE_COOK),
MAKEINTRESOURCE(IDS_CONFIRM_EXPTTL_COOK),
MB_OK);
}
}
break;
default:
ASSERT(0);
}
break;
case BOOKMARKS:
DoImportOrExport(
GetTransferType()==IMPORT,
m_pSelectedInternal,
m_szFileName,
FALSE);
break;
default:
ASSERT(0);
}
//
// Put the old cursor back when finished
//
SetCursor(hOldCursor);
}
//*************************************************************
//*************************************************************
//
// ImpExpUserDlg
//
// Handles the user interface side of things, building
// up an ImpExpUserProcess then executing it.
// The dialog procedures below will all have a return value
// which can be set to something besides FALSE if used, or left
// as FALSE if not used. Since only one section of code should
// attempt to give the return value a value before returning,
// class RetVal is set up to throw an assertion if two pieces
// of code intended to pass back a return value at the same
// time.
class ReturnValue
{
private:
BOOL_PTR m_value;
public:
ReturnValue()
{
m_value = FALSE;
}
BOOL_PTR operator =(BOOL_PTR newVal)
{
ASSERT( m_value == FALSE);
m_value = newVal;
return m_value;
}
operator BOOL_PTR ()
{
return m_value;
}
};
class ImpExpUserDlg
{
private:
static HIMAGELIST m_himl ;
static BOOL InitImageList ( HWND hwndTree ) ;
static BOOL DestroyImageList ( HWND hwndTree ) ;
static HFONT m_hfont ;
static BOOL InitFont ( HWND hwndStatic ) ;
static BOOL DestroyFont ( HWND hwndStatic ) ;
// A sheet knows its resource ID and what process
//it contributes to.
struct SheetData
{
int _idPage;
ImpExpUserProcess* _pImpExp;
SheetData( int idPage, ImpExpUserProcess* pImpExp )
: _idPage( idPage ), _pImpExp( pImpExp )
{
}
};
//
// InitializePropertySheetPage() will associate a dialog
// with an allocated copy of SheetData, which will be
// found at PSN_SETACTIVE with and stored with SetWindowLong.
// The allocated SheetData will be cleaned up by callback
// procedure PropertySheetPageProc().
//
// Callback functions sure are a drag for maintaining identity.
// GetWindowLong and SetWindowLong will be used to keep tabs
// on who is who, setting 'ghost' member variables.
//
// 'ghost' SheetData* This;
// 'ghost' ImpExpUserProcess* m_pImpExp;
// 'ghost' DWORD m_idPage;
//
// CommonDialogProc retrieves the 'ghost' values and does other
// shared behavior.
//
static DWORD CommonDialogProc
(
IN HWND hwndDlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam,
OUT ImpExpUserProcess** ppImpExp, OUT DWORD* pPageId,
IN OUT ReturnValue& retVal
);
static void InitializePropertySheetPage( PROPSHEETPAGE* psp, DWORD idDialogTemplate, DWORD idTitle, DWORD idSubTitle,DLGPROC dlgProc, ImpExpUserProcess* lParam);
static UINT CALLBACK PropertySheetPageProc( HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp);
// some dialog procedures
static BOOL_PTR CALLBACK Wizard97DlgProc( HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static BOOL_PTR CALLBACK TransferTypeDlg(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static BOOL_PTR CALLBACK InternalDlg(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static BOOL_PTR CALLBACK ExternalDlg(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static void HandleTransferTypeChange ( HWND hwndDlg, ImpExpUserProcess* m_pImpExp, UINT iSelect ) ;
public:
static BOOL RunNewDialogProcess( HWND hParent ) ;
};
HIMAGELIST ImpExpUserDlg::m_himl = NULL ;
BOOL ImpExpUserDlg::InitImageList ( HWND hwndTree )
{
//
// Code to retrieve icons for open and closed folders
// was based on code in private/samples/sampview/utility.cpp.
//
TCHAR szFolder[MAX_PATH];
SHFILEINFO sfi;
HIMAGELIST himlOld ;
DWORD dwRet ;
// create the image list
m_himl = ImageList_Create ( GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLORDDB, 2, 2 ) ;
if ( m_himl == NULL )
return FALSE ;
ImageList_SetBkColor( m_himl, GetSysColor(COLOR_WINDOW) ) ;
// add the closed folder icon
GetWindowsDirectory(szFolder, MAX_PATH);
SHGetFileInfo( szFolder,
0,
&sfi,
sizeof(sfi),
SHGFI_ICON | SHGFI_SMALLICON);
dwRet = ImageList_AddIcon(m_himl, sfi.hIcon);
ASSERT ( dwRet == FOLDER_CLOSED ) ;
// add the open folder icon
SHGetFileInfo( szFolder,
0,
&sfi,
sizeof(sfi),
SHGFI_ICON | SHGFI_SMALLICON | SHGFI_OPENICON);
dwRet = ImageList_AddIcon(m_himl, sfi.hIcon);
ASSERT ( dwRet == FOLDER_OPEN ) ;
himlOld = TreeView_SetImageList( hwndTree, m_himl, TVSIL_NORMAL );
if ( himlOld != NULL )
{
BOOL fOk ;
fOk = ImageList_Destroy ( himlOld ) ;
ASSERT ( fOk ) ;
}
return TRUE ;
}
BOOL ImpExpUserDlg::DestroyImageList ( HWND hwndTree )
{
HIMAGELIST himlOld ;
himlOld = TreeView_SetImageList( hwndTree, NULL, TVSIL_NORMAL );
if ( himlOld != NULL )
{
BOOL fOk ;
fOk = ImageList_Destroy ( himlOld ) ;
ASSERT ( fOk ) ;
}
return TRUE ;
}
HFONT ImpExpUserDlg::m_hfont = NULL ;
BOOL ImpExpUserDlg::InitFont ( HWND hwndStatic )
{
HDC hdc = GetDC ( hwndStatic ) ;
if ( hdc == NULL )
return FALSE ;
LOGFONT lf;
lf.lfEscapement = 0;
lf.lfOrientation = 0;
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfQuality = DEFAULT_QUALITY;
lf.lfPitchAndFamily = DEFAULT_PITCH;
lf.lfItalic = 0;
lf.lfWeight = FW_BOLD;
lf.lfStrikeOut = 0;
lf.lfUnderline = 0;
lf.lfWidth = 0;
lf.lfHeight = -MulDiv(13, GetDeviceCaps(hdc, LOGPIXELSY), 72);
LOGFONT lfTmp;
HFONT hFontOrig = (HFONT)SendMessage(hwndStatic, WM_GETFONT, (WPARAM)0, (LPARAM)0);
if (hFontOrig && GetObject(hFontOrig, sizeof(lfTmp), &lfTmp))
{
lf.lfCharSet = lfTmp.lfCharSet;
StrCpyN(lf.lfFaceName, lfTmp.lfFaceName, LF_FACESIZE);
}
else
{
lf.lfCharSet = GetTextCharset(hdc);
StrCpyN(lf.lfFaceName, TEXT("MS Shell Dlg"), LF_FACESIZE);
}
m_hfont = CreateFontIndirect(&lf);
if ( m_hfont == NULL )
{
ReleaseDC(hwndStatic, hdc);
return FALSE ;
}
SendMessage ( hwndStatic, WM_SETFONT, (WPARAM)m_hfont, MAKELPARAM(FALSE, 0) ) ;
ReleaseDC ( hwndStatic,hdc ) ;
return TRUE ;
}
BOOL ImpExpUserDlg::DestroyFont ( HWND hwndDlg )
{
if ( m_hfont )
DeleteObject ( m_hfont ) ;
return TRUE ;
}
void ImpExpUserDlg::InitializePropertySheetPage
(
PROPSHEETPAGE* psp,
DWORD idDialogTemplate,
DWORD idTitle,
DWORD idSubTitle,
DLGPROC dlgProc,
ImpExpUserProcess* lParam
)
{
psp->dwFlags |= PSP_USECALLBACK | PSP_USETITLE;
psp->hInstance = MLGetHinst();
psp->pszTemplate = MAKEINTRESOURCE(idDialogTemplate);
psp->pfnDlgProc = dlgProc;
psp->lParam = (LPARAM)(new SheetData(idDialogTemplate,lParam));
psp->pfnCallback = PropertySheetPageProc;
psp->pszHeaderTitle = MAKEINTRESOURCE(idTitle);
psp->pszHeaderSubTitle = MAKEINTRESOURCE(idSubTitle);
psp->pszTitle = MAKEINTRESOURCE(IDS_IMPEXP_CAPTION);
if ( idDialogTemplate == IDD_IMPEXPWELCOME ||
idDialogTemplate == IDD_IMPEXPCOMPLETE )
{
psp->dwFlags |= PSP_HIDEHEADER;
}
else
{
psp->dwFlags |= (PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE);
}
}
UINT CALLBACK ImpExpUserDlg::PropertySheetPageProc
(
HWND hwnd,
UINT uMsg,
LPPROPSHEETPAGE ppsp
)
{
switch(uMsg)
{
case PSPCB_CREATE:
break;
case PSPCB_RELEASE:
delete (SheetData*)ppsp->lParam;
ppsp->lParam = NULL;
break;
default:
break;
}
return TRUE ;
}
//*************************************************************
//
// RunNewDialogProcess
//
// Runs the Import Export Wizard.
BOOL_PTR CALLBACK TEMP(
HWND hwndDlg, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
return (uMsg==WM_INITDIALOG);
}
BOOL ImpExpUserDlg::RunNewDialogProcess(HWND hParent)
{
const int numPages = 9;
ImpExpUserProcess* pImpExp = new ImpExpUserProcess();
if( pImpExp == NULL)
return FALSE;
PROPSHEETPAGE pspOld[numPages];
PROPSHEETPAGE* psp = pspOld;
// dwSkip is set in Whistler_AllocatePropertySheetPage to whatever the size of Whistler's PROPSHEETPAGE
// is. 0x34 last I checked. (IE5 PROPSHEETPAGE is 0x30)
DWORD dwSkip = sizeof(PROPSHEETPAGE);
if (IsOS(OS_WHISTLERORGREATER))
{
PROPSHEETPAGE* psp2 = Whistler_AllocatePropertySheetPage(numPages, &dwSkip);
if (psp2)
{
psp = psp2;
}
}
if (psp==pspOld)
{
for (int i=0; i<numPages; i++)
{
memset(&psp[i], 0, sizeof(PROPSHEETPAGE));
psp[i].dwSize = sizeof(PROPSHEETPAGE);
}
}
PROPSHEETHEADER psh;
PBYTE pspNext = (PBYTE)psp;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPWELCOME, 0, 0, Wizard97DlgProc, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPTRANSFERTYPE, IDS_IMPEXPTRANSFERTYPE_TITLE, IDS_IMPEXPTRANSFERTYPE_SUBTITLE, TransferTypeDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPIMPFAVSRC, IDS_IMPEXPIMPFAVSRC_TITLE, IDS_IMPEXPIMPFAVSRC_SUBTITLE, ExternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPIMPFAVDES, IDS_IMPEXPIMPFAVDES_TITLE, IDS_IMPEXPIMPFAVDES_SUBTITLE, InternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPEXPFAVSRC, IDS_IMPEXPEXPFAVSRC_TITLE, IDS_IMPEXPEXPFAVSRC_SUBTITLE, InternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPEXPFAVDES, IDS_IMPEXPEXPFAVDES_TITLE, IDS_IMPEXPEXPFAVDES_SUBTITLE, ExternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPIMPCKSRC, IDS_IMPEXPIMPCKSRC_TITLE, IDS_IMPEXPIMPCKSRC_SUBTITLE, ExternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPEXPCKDES, IDS_IMPEXPEXPCKDES_TITLE, IDS_IMPEXPEXPCKDES_SUBTITLE, ExternalDlg, pImpExp );
pspNext += dwSkip;
InitializePropertySheetPage( (PROPSHEETPAGE*)pspNext, IDD_IMPEXPCOMPLETE, 0, 0, Wizard97DlgProc, pImpExp );
psh.dwSize = sizeof(PROPSHEETHEADER);
psh.dwFlags = PSH_WIZARD97 | PSH_PROPSHEETPAGE | PSH_HEADER | PSH_WATERMARK ;
psh.hwndParent = hParent;
psh.hInstance = MLGetHinst();
psh.pszCaption = MAKEINTRESOURCE(IDS_IMPEXP_CAPTION);
psh.nPages = numPages;
psh.nStartPage = 0;
psh.ppsp = psp;
psh.pszbmWatermark = MAKEINTRESOURCE(IDB_IMPEXPWATERMARK);
psh.pszbmHeader = MAKEINTRESOURCE(IDB_IMPEXPHEADER);
ULONG_PTR uCookie = 0;
SHActivateContext(&uCookie);
int iResult = (int)PropertySheet(&psh) ;
if (uCookie)
{
SHDeactivateContext(uCookie);
}
delete pImpExp;
if (psp!=pspOld)
{
HeapFree(GetProcessHeap(), NULL, psp);
}
return iResult;
}
//*************************************************************
//
// CommonDialogProc
//
// Prepares 'ghost' member variables of the user dialog process,
// handles ordering details of wizard pages and initializes common
// dialog elements.
//
// retVal passes through CommonDialogProc so that it can be set
// if necessary. Clients of CommonDialogProc should not need
// to specify a new return value if CommonDialogProc has specified
// a non-FALSE return value.
//
// If CommonDialogProc returns FALSE dialog procedure should
// considered 'msg' handled and return retVal immediately.
//
// If this dialog has yet to receive WM_INITDIALOG, the 'ghost'
// values will be zero (and invalid).
//
DWORD ImpExpUserDlg::CommonDialogProc
(
IN HWND hwndDlg,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam,
OUT ImpExpUserProcess** ppImpExp,
OUT DWORD* pPageId,
ReturnValue& retVal
)
{
SheetData* sheetData;
ImpExpUserProcess* m_pImpExp = NULL;
DWORD m_idPage = 0;
//
// Do init-dialog stuff
//
if ( WM_INITDIALOG == msg )
{
sheetData = (SheetData*)(((PROPSHEETPAGE*)lParam)->lParam);
SetWindowLongPtr( hwndDlg, DWLP_USER, (LONG_PTR)sheetData);
}
//
// Initialize the sheetData field
//
sheetData = (SheetData*)GetWindowLongPtr( hwndDlg, DWLP_USER ) ;
if ( sheetData != NULL )
{
m_pImpExp = *ppImpExp = sheetData->_pImpExp;
m_idPage = *pPageId = sheetData->_idPage;
}
//
// Next, we check to make sure we're on the correct page. If not, simply
// return -1 and the wizard will automatically advance to the next page.
//
if( WM_NOTIFY == msg && PSN_SETACTIVE == ((LPNMHDR)lParam)->code )
{
BOOL fPageValidation = TRUE ;
switch( m_idPage )
{
case IDD_IMPEXPWELCOME:
case IDD_IMPEXPTRANSFERTYPE:
case IDD_IMPEXPCOMPLETE:
break;
case IDD_IMPEXPIMPFAVSRC:
case IDD_IMPEXPIMPFAVDES:
if(m_pImpExp->GetTransferType() != IMPORT || m_pImpExp->GetExternalType() != BOOKMARKS)
fPageValidation = FALSE;
break;
case IDD_IMPEXPEXPFAVSRC:
case IDD_IMPEXPEXPFAVDES:
if(m_pImpExp->GetTransferType() != EXPORT || m_pImpExp->GetExternalType() != BOOKMARKS)
fPageValidation = FALSE;
break;
case IDD_IMPEXPIMPCKSRC:
if(m_pImpExp->GetTransferType() != IMPORT || m_pImpExp->GetExternalType() != COOKIES)
fPageValidation = FALSE;
break;
case IDD_IMPEXPEXPCKDES:
if(m_pImpExp->GetTransferType() != EXPORT || m_pImpExp->GetExternalType() != COOKIES)
fPageValidation = FALSE;
break;
}
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, fPageValidation ? 0 : -1 ) ;
retVal = TRUE ;
if ( ! fPageValidation )
return FALSE ;
}
//
// Initialize fonts and image lists (if needed)
//
if ( WM_NOTIFY == msg )
{
HWND hwndTitle = GetDlgItem ( hwndDlg, IDC_IMPEXPTITLETEXT ) ;
HWND hwndTree = GetDlgItem ( hwndDlg, IDC_IMPEXPFAVTREE ) ;
switch ( ((LPNMHDR)lParam)->code )
{
case PSN_SETACTIVE:
if ( hwndTitle )
InitFont ( hwndTitle ) ;
if ( hwndTree )
InitImageList( hwndTree ) ;
break ;
case PSN_KILLACTIVE:
case PSN_QUERYCANCEL:
if ( hwndTitle )
DestroyFont ( hwndTitle ) ;
if ( hwndTree )
DestroyImageList( hwndTree ) ;
break;
}
}
if( WM_NOTIFY == msg && PSN_SETACTIVE == ((LPNMHDR)lParam)->code )
{
HWND hwndParent = GetParent( hwndDlg);
switch( m_idPage )
{
case IDD_IMPEXPWELCOME:
PropSheet_SetWizButtons( hwndParent, PSWIZB_NEXT );
break;
case IDD_IMPEXPCOMPLETE:
{
UINT idText ;
const TCHAR *szInsert = m_pImpExp->m_szFileName ;
TCHAR szRawString[1024] ;
TCHAR szRealString[1024] ;
//
// First, we need to figure out which string should
// be used to describe what the wizard is going to
// do (for example "Import the cookies from...")
//
if ( m_pImpExp->GetTransferType() == IMPORT )
{
if ( m_pImpExp->GetExternalType() == COOKIES )
idText = IDS_IMPEXP_COMPLETE_IMPCK ;
else
idText = IDS_IMPEXP_COMPLETE_IMPFV ;
}
else
{
if ( m_pImpExp->GetExternalType() == COOKIES )
idText = IDS_IMPEXP_COMPLETE_EXPCK ;
else
idText = IDS_IMPEXP_COMPLETE_EXPFV ;
}
LoadString(MLGetHinst(), idText, szRawString, 1024);
wnsprintf(szRealString, 1024, szRawString, szInsert);
//
// Set the text in the listview, and do all the other magic to make
// the tooltips work, etc.
//
SetListViewToString(GetDlgItem(hwndDlg,IDC_IMPEXPCOMPLETECONFIRM), szRealString);
//
// The SetListViewToString function helpfully sets the background color to
// gray instead of the default (white). But we actually want it white, so
// let's reset it here.
//
ListView_SetBkColor(GetDlgItem(hwndDlg,IDC_IMPEXPCOMPLETECONFIRM), GetSysColor(COLOR_WINDOW));
ListView_SetTextBkColor(GetDlgItem(hwndDlg,IDC_IMPEXPCOMPLETECONFIRM), GetSysColor(COLOR_WINDOW));
PropSheet_SetWizButtons(hwndParent, PSWIZB_BACK|PSWIZB_FINISH);
}
break;
default:
PropSheet_SetWizButtons( hwndParent, PSWIZB_NEXT | PSWIZB_BACK );
break;
}
}
return TRUE ;
}
//*************************************************************
//
// Wizard97DlgProc
//
// Dialog proc for welcome and complete pages.
//
BOOL_PTR CALLBACK ImpExpUserDlg::Wizard97DlgProc
(
HWND hwndDlg,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
ReturnValue retVal;
ImpExpUserProcess* m_pImpExp = NULL;
DWORD m_idPage = 0;
if( !CommonDialogProc( hwndDlg, msg, wParam, lParam,
&m_pImpExp, &m_idPage, retVal))
{
return retVal;
}
if( m_idPage == IDD_IMPEXPCOMPLETE
&& msg == WM_NOTIFY
&& PSN_WIZFINISH == ((LPNMHDR)lParam)->code)
m_pImpExp->PerformImpExpProcess(hwndDlg);
return retVal;;
}
//*************************************************************
//
// TransferTypeDlg
//
// Dialog proc for dialog where user picks transfer type
// (import vs. export), (cookies vs. bookmarks)
BOOL_PTR CALLBACK ImpExpUserDlg::TransferTypeDlg
(
HWND hwndDlg,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
ReturnValue retVal;
ImpExpUserProcess* m_pImpExp = NULL;
DWORD m_idPage = 0;
if( !CommonDialogProc( hwndDlg, msg, wParam, lParam,
&m_pImpExp, &m_idPage, retVal))
{
return retVal;
}
HWND hwndDlgItem;
switch( msg)
{
case WM_INITDIALOG:
{
hwndDlgItem = GetDlgItem( hwndDlg, IDC_IMPEXPACTIONLISTBOX);
LRESULT index;
TCHAR szBuffer[MAX_PATH];
const DWORD cbSize = MAX_PATH;
if( MLLoadString( IDS_IMPFAVORITES, szBuffer, cbSize))
{
index = ListBox_AddString( hwndDlgItem, szBuffer);
ListBox_SetItemData( hwndDlgItem, index, IDS_IMPFAVORITES);
}
if( MLLoadString( IDS_EXPFAVORITES, szBuffer, cbSize))
{
index = ListBox_AddString( hwndDlgItem, szBuffer);
ListBox_SetItemData( hwndDlgItem, index, IDS_EXPFAVORITES);
}
if( MLLoadString( IDS_IMPCOOKIES, szBuffer, cbSize))
{
index = ListBox_AddString( hwndDlgItem, szBuffer);
ListBox_SetItemData( hwndDlgItem, index, IDS_IMPCOOKIES);
}
if( MLLoadString( IDS_EXPCOOKIES, szBuffer, cbSize))
{
index = ListBox_AddString( hwndDlgItem, szBuffer);
ListBox_SetItemData( hwndDlgItem, index, IDS_EXPCOOKIES);
}
// Select the first list item, by default
ListBox_SetCurSel(hwndDlgItem, 0);
HandleTransferTypeChange(hwndDlg, m_pImpExp, IDS_IMPFAVORITES);
} // end of WM_INITDIALOG
break;
case WM_COMMAND:
// when the user selects an option, choose it and
//and update the description box.
hwndDlgItem = GetDlgItem(hwndDlg, IDC_IMPEXPACTIONLISTBOX);
if(hwndDlgItem == (HWND)lParam
&& HIWORD(wParam) == LBN_SELCHANGE)
{
// find out which string resource was selected.
LRESULT index = ListBox_GetCurSel(hwndDlgItem);
LRESULT selection = ListBox_GetItemData(hwndDlgItem, index);
HandleTransferTypeChange ( hwndDlg, m_pImpExp, (UINT)selection ) ;
retVal = TRUE;
}
break;
case WM_NOTIFY:
//
// Prevent advancement until user has made valid choices
//
if( ((LPNMHDR)lParam)->code == PSN_WIZNEXT && m_pImpExp
&& (m_pImpExp->GetExternalType() == INVALID_EXTERNAL
|| m_pImpExp->GetTransferType() == INVALID_TRANSFER))
{
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, -1);
retVal = TRUE;
}
//
// otherwise, set the filename to nul (so we get the default)
// and allow default navigation behavior
//
if (m_pImpExp)
m_pImpExp->m_szFileName[0] = TEXT('\0');
break;
}
return retVal;
}
void ImpExpUserDlg::HandleTransferTypeChange ( HWND hwndDlg, ImpExpUserProcess* pImpExp, UINT iSelect )
{
TCHAR szBuffer[MAX_PATH];
const DWORD cbSize = MAX_PATH;
if (pImpExp)
{
//
// Note: The description of each option has a resource id
// which is one higher than the resource id of the option name.
//
switch( iSelect )
{
case IDS_IMPFAVORITES:
if( MLLoadString( IDS_IMPFAVORITES + 1, szBuffer, cbSize ) )
SetWindowText( GetDlgItem( hwndDlg, IDC_IMPEXPACTIONDESCSTATIC ),
szBuffer );
pImpExp->SelectExternalType( BOOKMARKS );
pImpExp->SelectTransferType( IMPORT );
break;
case IDS_EXPFAVORITES:
if( MLLoadString( IDS_EXPFAVORITES + 1, szBuffer, cbSize ) )
SetWindowText( GetDlgItem( hwndDlg, IDC_IMPEXPACTIONDESCSTATIC ),
szBuffer );
pImpExp->SelectExternalType( BOOKMARKS );
pImpExp->SelectTransferType( EXPORT );
break;
case IDS_IMPCOOKIES:
if( MLLoadString( IDS_IMPCOOKIES + 1, szBuffer, cbSize))
SetWindowText( GetDlgItem( hwndDlg, IDC_IMPEXPACTIONDESCSTATIC),
szBuffer);
pImpExp->SelectExternalType( COOKIES);
pImpExp->SelectTransferType( IMPORT);
break;
case IDS_EXPCOOKIES:
if( MLLoadString( IDS_EXPCOOKIES + 1, szBuffer, cbSize))
SetWindowText( GetDlgItem( hwndDlg, IDC_IMPEXPACTIONDESCSTATIC),
szBuffer);
pImpExp->SelectExternalType( COOKIES);
pImpExp->SelectTransferType( EXPORT);
break;
}
}
}
//*************************************************************
//
// InternalDlg
//
// Allows user to pick internal target/source from tree view.
BOOL_PTR CALLBACK ImpExpUserDlg::InternalDlg
(
HWND hwndDlg,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
ReturnValue retVal;
ImpExpUserProcess* m_pImpExp = NULL;
DWORD m_idPage = 0;
if( !CommonDialogProc( hwndDlg, msg, wParam, lParam,
&m_pImpExp, &m_idPage, retVal))
{
return retVal;
}
HWND hwndDlgItem;
switch( msg)
{
case WM_INITDIALOG:
//
// Populate the tree control
//
hwndDlgItem = GetDlgItem(hwndDlg, IDC_IMPEXPFAVTREE);
if ( hwndDlgItem )
{
if (m_pImpExp)
{
m_pImpExp->PopulateTreeViewForInternalSelection(hwndDlgItem);
m_pImpExp->ExpandTreeViewRoot ( hwndDlgItem ) ;
}
}
else
ASSERT(0);
return TRUE;
case WM_NOTIFY:
switch( ((LPNMHDR)lParam)->code)
{
case PSN_WIZNEXT:
// Only allow user to go to next if there is a valid selection.
if( !m_pImpExp->SelectInternalSelection(GetDlgItem(hwndDlg,IDC_IMPEXPFAVTREE)) )
{
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, -1);
retVal = TRUE;
}
}
}
return retVal;
}
BOOL IsValidFileOrURL(LPTSTR szFileOrURL)
{
if (szFileOrURL == NULL)
return FALSE;
//
// any URL is ok
//
if (PathIsURL(szFileOrURL))
return TRUE;
//
// just a directory is no good, we need a filename too
//
if (PathIsDirectory(szFileOrURL))
return FALSE;
//
// just a filename is no good, we need a directory too
//
if (PathIsFileSpec(szFileOrURL))
return FALSE;
//
// relative paths are no good
//
if (PathIsRelative(szFileOrURL))
return FALSE;
//
// now make sure it parses correctly
//
if (PathFindFileName(szFileOrURL) == szFileOrURL)
return FALSE;
return TRUE;
}
//*************************************************************
//
// ExternalDlg
//
// Allows user to pick external target/source from list box
//or manual browse.
BOOL_PTR CALLBACK ImpExpUserDlg::ExternalDlg
(
HWND hwndDlg,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
ReturnValue retVal;
ImpExpUserProcess* m_pImpExp = NULL;
DWORD m_idPage = 0;
if( !CommonDialogProc( hwndDlg, msg, wParam, lParam,
&m_pImpExp, &m_idPage, retVal))
{
return retVal;
}
HWND hwndDlgItem;
switch(msg)
{
case WM_COMMAND:
hwndDlgItem = (HWND) lParam;
if( HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_IMPEXPBROWSE)
{
OPENFILENAME ofn;
TCHAR szFile[MAX_PATH];
TCHAR szTitle[MAX_PATH];
TCHAR szFilter[MAX_PATH];
TCHAR szInitialPath[MAX_PATH];
int i;
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hwndDlg;
ofn.hInstance = MLGetHinst();
ofn.lpstrFilter = szFilter;
ofn.nFilterIndex = 1;
ofn.lpstrCustomFilter = NULL;
ofn.lpstrFile = szFile;
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFileTitle = NULL;
ofn.lpstrInitialDir = szInitialPath;
ofn.lpstrTitle = szTitle;
ofn.lpstrDefExt = (m_pImpExp->GetExternalType()==COOKIES) ? TEXT("txt") : TEXT("htm");
GetDlgItemText(hwndDlg, IDC_IMPEXPMANUAL, szInitialPath, ARRAYSIZE(szFile));
szFile[0] = 0;
if (PathIsDirectory(szInitialPath))
{
ofn.lpstrInitialDir = szInitialPath;
szFile[0] = TEXT('\0');
}
else
{
TCHAR *pchFilePart;
pchFilePart = PathFindFileName(szInitialPath);
if (pchFilePart == szInitialPath || pchFilePart == NULL)
{
if (PathIsFileSpec(szInitialPath))
StrCpyN(szFile,szInitialPath,MAX_PATH);
else
szFile[0] = TEXT('\0');
ofn.lpstrInitialDir = szInitialPath;
SHGetSpecialFolderPath(NULL,szInitialPath,CSIDL_DESKTOP,FALSE);
}
else
{
pchFilePart[-1] = TEXT('\0');
ofn.lpstrInitialDir = szInitialPath;
StrCpyN(szFile,pchFilePart,MAX_PATH);
}
}
//
// Work out the title and the filter strings
//
if (m_pImpExp->GetExternalType() == BOOKMARKS)
{
MLLoadShellLangString(IDS_IMPEXP_CHOSEBOOKMARKFILE,szTitle,MAX_PATH);
MLLoadShellLangString(IDS_IMPEXP_BOOKMARKFILTER,szFilter,MAX_PATH);
}
else
{
MLLoadShellLangString(IDS_IMPEXP_CHOSECOOKIEFILE,szTitle,MAX_PATH);
MLLoadShellLangString(IDS_IMPEXP_COOKIEFILTER,szFilter,MAX_PATH);
}
//
// Search and replace '@' with nul in the filter string
//
for (i=0; szFilter[i]; i++)
if (szFilter[i]==TEXT('@'))
szFilter[i]=TEXT('\0');
//
// Set the flags for openfilename
//
ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY ;
if (m_pImpExp->GetTransferType() == IMPORT)
ofn.Flags |= (OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST);
//
// Show the dialog
//
if(GetSaveFileName(&ofn))
if(SetWindowText(GetDlgItem(hwndDlg, IDC_IMPEXPMANUAL), ofn.lpstrFile))
{
Button_SetCheck(GetDlgItem( hwndDlg, IDC_IMPEXPRADIOFILE), BST_CHECKED);
Button_SetCheck(GetDlgItem( hwndDlg, IDC_IMPEXPRADIOAPP), BST_UNCHECKED);
}
retVal = TRUE;
}
break;
case WM_NOTIFY:
switch( ((LPNMHDR)lParam)->code )
{
case PSN_SETACTIVE:
{
TCHAR sBuffer[MAX_PATH];
DWORD cbSize = ARRAYSIZE(sBuffer);
hwndDlgItem = GetDlgItem( hwndDlg, IDC_IMPEXPEXTERNALCOMBO );
//
// Load the "application list" into the combo box.
// If the list is empty, then disable the combo box,
// disable the associated radio button, and select the
// "to/from file" option (the second radio button).
//
if( hwndDlgItem != NULL
&& m_pImpExp && m_pImpExp->PopulateComboBoxForExternalSelection( hwndDlgItem ) )
{
EnableWindow ( GetDlgItem(hwndDlg, IDC_IMPEXPRADIOAPP), TRUE ) ;
EnableWindow ( hwndDlgItem, TRUE ) ;
Button_SetCheck( GetDlgItem( hwndDlg, IDC_IMPEXPRADIOAPP), BST_CHECKED);
Button_SetCheck( GetDlgItem( hwndDlg, IDC_IMPEXPRADIOFILE), BST_UNCHECKED);
}
else if ( hwndDlgItem != NULL)
{
EnableWindow ( GetDlgItem(hwndDlg, IDC_IMPEXPRADIOAPP), FALSE ) ;
EnableWindow( hwndDlgItem, FALSE ) ;
Button_SetCheck( GetDlgItem( hwndDlg, IDC_IMPEXPRADIOFILE), BST_CHECKED);
Button_SetCheck( GetDlgItem( hwndDlg, IDC_IMPEXPRADIOAPP), BST_UNCHECKED);
}
// Put a default value in the browse option.
if(m_pImpExp->GetExternalManualDefault(sBuffer, &cbSize))
SetDlgItemText(hwndDlg, IDC_IMPEXPMANUAL, sBuffer);
SHAutoComplete(GetDlgItem(hwndDlg, IDC_IMPEXPMANUAL), SHACF_FILESYSTEM);
}
break;
case PSN_WIZNEXT:
// If the application radio button is checked,
// select the selection from the application combo box. If
// the manual button is checked, select the selection
// using the manual edit box.
retVal = TRUE;
if (Button_GetCheck(GetDlgItem(hwndDlg,IDC_IMPEXPRADIOAPP)) == BST_CHECKED)
{
HWND hwndComboBox = GetDlgItem(hwndDlg,IDC_IMPEXPEXTERNALCOMBO);
if (hwndComboBox != NULL)
{
// Find out the index of the selected item
INT nIndex = ComboBox_GetCurSel(hwndDlg);
if (nIndex != CB_ERR)
{
// Retrieve a pointer to the filename
LPTSTR pszFileName = (LPTSTR)ComboBox_GetItemData(hwndComboBox, nIndex);
if (pszFileName != NULL)
StrCpyN(m_pImpExp->m_szFileName,pszFileName,MAX_PATH);
}
}
}
else if (Button_GetCheck(GetDlgItem(hwndDlg,IDC_IMPEXPRADIOFILE)) == BST_CHECKED)
{
// just get the text from the edit box
GetDlgItemText(hwndDlg,IDC_IMPEXPMANUAL,m_pImpExp->m_szFileName,MAX_PATH);
//
// Don't allow "next" if the edit control contains a bogus filename
//
if (!IsValidFileOrURL(m_pImpExp->m_szFileName))
{
TCHAR szFmt[128];
TCHAR szMsg[INTERNET_MAX_URL_LENGTH+128];
MLLoadShellLangString(IDS_INVALIDURLFILE, szFmt, ARRAYSIZE(szFmt));
wnsprintf(szMsg, INTERNET_MAX_URL_LENGTH+40, szFmt, m_pImpExp->m_szFileName);
MLShellMessageBox(
hwndDlg,
szMsg,
(IMPORT == m_pImpExp->GetTransferType()) ?
MAKEINTRESOURCE(IDS_CONFIRM_IMPTTL_FAV) :
MAKEINTRESOURCE(IDS_CONFIRM_EXPTTL_FAV),
MB_OK);
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
return retVal;
}
//
// If the user doesn't type an extension, then we add ".htm"
// or ".txt" as appropriate. Otherwise, we don't touch it.
//
if (*PathFindExtension(m_pImpExp->m_szFileName) == TEXT('\0'))
{
PathRenameExtension(
m_pImpExp->m_szFileName,
(m_pImpExp->GetExternalType()==COOKIES) ? TEXT(".txt") : TEXT(".htm"));
}
}
else
{
ASSERT(0);
m_pImpExp->m_szFileName[0] = TEXT('\0');
}
//
// Finally, show an overwrite or file-not-found message
// (but supress it if importing or exporting to a web address)
//
if (m_pImpExp->GetExternalType() == COOKIES ||
!PathIsURL(m_pImpExp->m_szFileName))
{
if ( EXPORT == m_pImpExp->GetTransferType() &&
GetFileAttributes(m_pImpExp->m_szFileName) != 0xFFFFFFFF )
{
int answer ;
UINT idTitle ;
if ( m_pImpExp->GetExternalType() == COOKIES )
idTitle = IDS_EXPCOOKIES ;
else if ( m_pImpExp->GetExternalType() == BOOKMARKS )
idTitle = IDS_EXPFAVORITES ;
else
ASSERT(0);
answer = WarningMessageBox(
hwndDlg,
idTitle,
IDS_IMPEXP_FILEEXISTS,
m_pImpExp->m_szFileName,
MB_YESNO | MB_ICONEXCLAMATION);
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (IDYES==answer)?0:-1);
}
else
{
if (IMPORT == m_pImpExp->GetTransferType())
{
BOOL fError;
fError = FALSE;
if (PathIsUNC(m_pImpExp->m_szFileName))
;
else
// Give the user a chance to insert the floppy if it's not already in.
fError = FAILED(SHPathPrepareForWriteWrap(hwndDlg,
NULL,
m_pImpExp->m_szFileName,
FO_COPY,
(SHPPFW_DEFAULT | SHPPFW_IGNOREFILENAME)));
if (!fError)
fError = (0xFFFFFFFF == GetFileAttributes(m_pImpExp->m_szFileName));
if (fError)
{
UINT idTitle ;
if ( m_pImpExp->GetExternalType() == COOKIES )
idTitle = IDS_IMPCOOKIES ;
else if ( m_pImpExp->GetExternalType() == BOOKMARKS )
idTitle = IDS_IMPFAVORITES ;
else
ASSERT(0);
WarningMessageBox(
hwndDlg,
idTitle,
IDS_IMPEXP_FILENOTFOUND,
m_pImpExp->m_szFileName,
MB_OK | MB_ICONEXCLAMATION);
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
}
}
}
}
break; // PSN_WIZNEXT
} // WM_NOTIFY
break;
} // switch(msg)
return retVal;
}
BOOL WINAPI RunImportExportFavoritesWizard(HWND hDlg)
{
ImpExpUserDlg::RunNewDialogProcess(hDlg);
return TRUE;
}
int WarningMessageBox(HWND hwnd, UINT idTitle, UINT idMessage, LPCTSTR szFile, DWORD dwFlags)
{
TCHAR szBuffer[1024];
TCHAR szFormat[1024];
//
// load the string (must contain "%s")
//
MLLoadShellLangString(idMessage, szFormat, 1024);
//
// insert the filename
//
wnsprintf(szBuffer,1024,szFormat,szFile);
//
// display the messagebox
//
return MLShellMessageBox(
hwnd,
szBuffer,
MAKEINTRESOURCE(idTitle),
dwFlags);
}