831 lines
26 KiB
C++
831 lines
26 KiB
C++
///////////////////////////////////////////////////////////
|
|
//
|
|
//
|
|
// HHFinder.cpp : Implementation of CHHFinder
|
|
//
|
|
//
|
|
#include "header.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static const CHAR THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#include "resource.h"
|
|
#include "strtable.h"
|
|
|
|
#include "atlinc.h" // includes for ATL.
|
|
|
|
#include "HHFinder.h"
|
|
#include "cdlg.h"
|
|
#include "wwheel.h"
|
|
#include "secwin.h"
|
|
|
|
// Used to lock toplevel windows before displaying a dialog.
|
|
#include "lockout.h"
|
|
|
|
// defines
|
|
#define HH_VERSION_1_3 // define this is build HH 1.3 or newer
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Internal Structure Definition
|
|
//
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// HHREMOVEABLE
|
|
//
|
|
typedef struct _hhremovable
|
|
{
|
|
UINT uiDriveType;
|
|
PCSTR pszDriveLetter;
|
|
PCSTR pszVolumeName;
|
|
PSTR* ppszLocation;
|
|
} HHREMOVABLE;
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Globals
|
|
//
|
|
#ifdef _DEBUG
|
|
static BOOL g_bShowMessage = TRUE;
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Prototypes
|
|
//
|
|
INT_PTR CALLBACK RemovableMediaDialogProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Functions
|
|
//
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// GetPathAndFileName
|
|
//
|
|
PCSTR GetPathAndFileName( PCSTR pszFilename, PSTR pszPathBuffer, PSTR pszFilenameBuffer )
|
|
{
|
|
CHAR szPathname[MAX_PATH];
|
|
PSTR pszFile;
|
|
GetFullPathName( pszFilename, sizeof(szPathname), szPathname, &pszFile );
|
|
lstrcpyn( pszPathBuffer, szPathname, (int)(((DWORD_PTR)pszFile) - ((DWORD_PTR)&szPathname)) );
|
|
strcpy( pszFilenameBuffer, pszFile );
|
|
|
|
return( pszFilename );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CLocationNode
|
|
class CLocationNode {
|
|
public:
|
|
CLocationNode::CLocationNode( PCSTR pszLocationId )
|
|
{
|
|
m_pszLocationId = new CHAR[strlen(pszLocationId)+1];
|
|
strcpy( (PSTR) m_pszLocationId, pszLocationId );
|
|
m_pNext = NULL;
|
|
}
|
|
CLocationNode::~CLocationNode( )
|
|
{
|
|
delete [] (PSTR) m_pszLocationId;
|
|
}
|
|
CLocationNode* GetNext() { return m_pNext; }
|
|
CLocationNode* SetNext( CLocationNode* pNext ) { m_pNext = pNext; return m_pNext; }
|
|
PCSTR GetLocationId() { return m_pszLocationId; }
|
|
private:
|
|
PCSTR m_pszLocationId;
|
|
CLocationNode* m_pNext;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CLocationList
|
|
class CLocationList {
|
|
public:
|
|
CLocationList::CLocationList()
|
|
{
|
|
m_iCount = 0;
|
|
m_pHead = NULL;
|
|
m_pTail = NULL;
|
|
}
|
|
CLocationList::~CLocationList()
|
|
{
|
|
Free();
|
|
}
|
|
void CLocationList::Free()
|
|
{
|
|
CLocationNode* pNode = m_pHead;
|
|
for( int i=0; i < m_iCount; i++ ) {
|
|
CLocationNode* pNodeNext = pNode->GetNext();
|
|
delete pNode;
|
|
pNode = pNodeNext;
|
|
}
|
|
m_iCount = 0;
|
|
m_pHead = NULL;
|
|
m_pTail = NULL;
|
|
}
|
|
CLocationNode* CLocationList::Add( PCSTR pszLocationId )
|
|
{
|
|
CLocationNode* pNode = new CLocationNode( pszLocationId );
|
|
if( m_iCount )
|
|
m_pTail->SetNext( pNode );
|
|
else
|
|
m_pHead = pNode;
|
|
m_pTail = pNode;
|
|
m_iCount++;
|
|
return pNode;
|
|
}
|
|
CLocationNode* CLocationList::Find( PCSTR pszLocationId )
|
|
{
|
|
CLocationNode* pNode = m_pHead;
|
|
for( int i=0; i < m_iCount; i++ ) {
|
|
if( strcmp( pszLocationId, pNode->GetLocationId() ) == 0 )
|
|
break;
|
|
CLocationNode* pNodeNext = pNode->GetNext();
|
|
pNode = pNodeNext;
|
|
}
|
|
return pNode;
|
|
}
|
|
|
|
private:
|
|
int m_iCount;
|
|
CLocationNode* m_pHead;
|
|
CLocationNode* m_pTail;
|
|
};
|
|
|
|
CLocationList g_LocationSkipList;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CHHFinder
|
|
|
|
HRESULT STDMETHODCALLTYPE CHHFinder::FindThisFile(const WCHAR* pwszFileName,
|
|
WCHAR** ppwszPathName, BOOL* pfRecordPathInRegistry )
|
|
{
|
|
CExCollection* pCollection;
|
|
CExTitle* pTitle = NULL;
|
|
PCSTR pszPathName = NULL;
|
|
CStr PathName;
|
|
HRESULT hr = S_OK;
|
|
|
|
// guarantee that we never record this value in the registry since it can always change.
|
|
*pfRecordPathInRegistry = FALSE;
|
|
|
|
CHAR pszFileName[MAX_PATH];
|
|
WideCharToMultiByte(CP_ACP, 0, pwszFileName, -1, pszFileName, MAX_PATH, NULL, NULL);
|
|
|
|
// get a pointer to the title and use this to get the fullpathname
|
|
pCollection = GetCurrentCollection(NULL, pszFileName);
|
|
|
|
if( pCollection )
|
|
hr = pCollection->URL2ExTitle( pszFileName, &pTitle );
|
|
|
|
#if 0
|
|
// if this is not a collection or we could not find the title then give
|
|
// the ::FindThisFile function a try (since we know removable media
|
|
// is not supported for non-collections anyway)
|
|
|
|
if( !pCollection || !pTitle ) {
|
|
// check the directory where the master file of the current collection lives
|
|
CExCollection* pCurCollection = NULL;
|
|
|
|
if( g_pCurrentCollection )
|
|
pCurCollection = g_pCurrentCollection;
|
|
else if( g_phmData && g_phmData[0] )
|
|
pCurCollection = g_phmData[0]->m_pTitleCollection;
|
|
|
|
if( pCurCollection ) {
|
|
CHAR szPathName[_MAX_PATH];
|
|
CHAR szFileName[_MAX_FNAME];
|
|
CHAR szExtension[_MAX_EXT];
|
|
SplitPath((PSTR)pszFileName, NULL, NULL, szFileName, szExtension);
|
|
CHAR szMasterPath[_MAX_PATH];
|
|
CHAR szMasterDrive[_MAX_DRIVE];
|
|
SplitPath((PSTR)pCurCollection->m_csFile, szMasterDrive, szMasterPath, NULL, NULL);
|
|
strcpy( szPathName, szMasterDrive );
|
|
CatPath( szPathName, szMasterPath );
|
|
CatPath( szPathName, szFileName );
|
|
strcat( szPathName, szExtension );
|
|
if( (GetFileAttributes(szPathName) != HFILE_ERROR) ) {
|
|
PathName = szPathName;
|
|
pszPathName = PathName.psz;
|
|
}
|
|
}
|
|
|
|
if( !pszPathName ) {
|
|
if( ::FindThisFile( NULL, pszFileName, &PathName, FALSE ) ) {
|
|
pszPathName = PathName.psz;
|
|
}
|
|
else {
|
|
#ifdef _DEBUG
|
|
CHAR szMsg[1024];
|
|
wsprintf( szMsg, "HHFinder Debug Message\n\nCould not locate the file \"%s\".", pszFileName );
|
|
MsgBox( szMsg, MB_OK );
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Removable media support (Refresh bypasses BeforeNavigate so we need this here).
|
|
//
|
|
// Note, this must be one of the first things we do since the user can
|
|
// change the title's location
|
|
//
|
|
if( pTitle ) {
|
|
pszPathName = pTitle->GetPathName();
|
|
if( FAILED(hr = EnsureStorageAvailability( pTitle )) ) {
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
// if we made it here than this mean we found it (if is does exist)
|
|
// and pszPathName points to the full pathname
|
|
LPMALLOC pMalloc;
|
|
WCHAR pwszPathName[MAX_PATH];
|
|
*ppwszPathName = NULL;
|
|
if( pszPathName && *pszPathName ) {
|
|
MultiByteToWideChar(CP_ACP, 0, pszPathName, -1, pwszPathName, MAX_PATH);
|
|
|
|
// allocate and copy the pathname
|
|
if( SUCCEEDED(hr = CoGetMalloc(1, &pMalloc)) ) {
|
|
*ppwszPathName = (WCHAR*) pMalloc->Alloc( (wcslen(pwszPathName)+1)*sizeof(WCHAR) );
|
|
if( !*ppwszPathName ) {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else {
|
|
wcscpy( *ppwszPathName, pwszPathName );
|
|
hr = S_OK;
|
|
}
|
|
pMalloc->Release();
|
|
}
|
|
}
|
|
|
|
if (*ppwszPathName == NULL)
|
|
hr = STG_E_FILENOTFOUND;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// EnsureStorageAvailability
|
|
|
|
// Code to detect and handle Advanced Media Support issues (formerly RMS issues)
|
|
//
|
|
// Types are:
|
|
//
|
|
// HHRMS_TYPE_TITLE (default)
|
|
// HHRMS_TYPE_COMBINED_QUERY
|
|
// HHRMS_TYPE_ATTACHMENT // a.k.a Sample
|
|
//
|
|
// return values are as follows:
|
|
// S_OK - The storage is available (party on!)
|
|
// HHRMS_S_LOCATION_UPDATE - The user changed the location of the volume
|
|
// E_FAIL - The storage is unknown (caller should handle this failure condition)
|
|
// HHRMS_E_SKIP - User choose to skip this volume just this time
|
|
// HHRMS_E_SKIP_ALWAYS - User choose to skip this volume for this entire session
|
|
//
|
|
// For URL navigation, we should always volume check and always prompt.
|
|
//
|
|
// For Queries, we should volume check for chm files and not volume check for chq files
|
|
// and we will always prompt for the volume for this session unless the user
|
|
// selects cancel.
|
|
//
|
|
|
|
HRESULT EnsureStorageAvailability( CExTitle* pTitle, UINT uiFileType,
|
|
BOOL bVolumeCheckIn, BOOL bAlwaysPrompt,
|
|
BOOL bNeverPrompt )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// if we do not have a title pointer this indicates that the URL does not belong to a
|
|
// compressed title and thus we should claim the storage is available and let IE decide
|
|
// what to do with it
|
|
if( !pTitle )
|
|
return S_OK;
|
|
|
|
BOOL bVolumeCheck = bVolumeCheckIn;
|
|
|
|
// Get the location information
|
|
LOCATIONHISTORY* pLocationHistory = pTitle->GetUsedLocation();
|
|
|
|
// Get the collection
|
|
CExCollection* pCollection = pTitle->m_pCollection;
|
|
|
|
// Only check removable media when running in a collection
|
|
//
|
|
if(pCollection && pCollection->IsSingleTitle())
|
|
return S_OK;
|
|
|
|
// Get the location identifier
|
|
CHAR szLocationId[MAX_PATH];
|
|
CLocation* pLocation = NULL;
|
|
if( pLocationHistory ) {
|
|
|
|
switch( uiFileType ) {
|
|
|
|
case HHRMS_TYPE_TITLE:
|
|
strcpy( szLocationId, pLocationHistory->LocationId );
|
|
break;
|
|
|
|
case HHRMS_TYPE_COMBINED_QUERY:
|
|
if( pLocationHistory->QueryLocation && pLocationHistory->QueryLocation[0] )
|
|
strcpy( szLocationId, pLocationHistory->QueryLocation );
|
|
else if( pLocationHistory->LocationId && pLocationHistory->LocationId[0] )
|
|
strcpy( szLocationId, pLocationHistory->LocationId );
|
|
break;
|
|
|
|
case HHRMS_TYPE_ATTACHMENT:
|
|
if( pLocationHistory->SampleLocation && pLocationHistory->SampleLocation[0] )
|
|
strcpy( szLocationId, pLocationHistory->SampleLocation );
|
|
else if( pLocationHistory->LocationId && pLocationHistory->LocationId[0] )
|
|
strcpy( szLocationId, pLocationHistory->LocationId );
|
|
break;
|
|
|
|
default:
|
|
strcpy( szLocationId, pLocationHistory->LocationId );
|
|
break;
|
|
|
|
}
|
|
|
|
pLocation = pCollection->m_Collection.FindLocation( szLocationId );
|
|
}
|
|
|
|
// if we have location information then get the details about it
|
|
// otherwise never prompt or volume check (check existence only).
|
|
PCSTR pszVolumeLabel = NULL;
|
|
PCSTR pszVolumeName = NULL;
|
|
if( pLocation ) {
|
|
pszVolumeLabel = pLocation->GetVolume(); // Get the volume label
|
|
pszVolumeName = pLocation->GetTitle(); // Get volume's friendly name
|
|
}
|
|
else {
|
|
bVolumeCheck = FALSE;
|
|
bNeverPrompt = TRUE;
|
|
}
|
|
|
|
// Get the pathname
|
|
PCSTR pszPathname = NULL;
|
|
switch( uiFileType ) {
|
|
|
|
case HHRMS_TYPE_TITLE:
|
|
pszPathname = pTitle->GetPathName();
|
|
break;
|
|
|
|
case HHRMS_TYPE_COMBINED_QUERY:
|
|
pszPathname = pTitle->GetQueryName();
|
|
break;
|
|
|
|
case HHRMS_TYPE_ATTACHMENT:
|
|
pszPathname = pTitle->GetCurrentAttachmentName();
|
|
break;
|
|
|
|
default:
|
|
return E_FAIL;
|
|
break;
|
|
|
|
}
|
|
|
|
// Get the location path and filename
|
|
CHAR szPath[MAX_PATH];
|
|
CHAR szFilename[MAX_PATH];
|
|
PCSTR pszPath = szPath;
|
|
szPath[0]= 0;
|
|
szFilename[0]= 0;
|
|
if( pLocation ) {
|
|
strcpy( szPath, pLocation->GetPath() );
|
|
CHAR szExt[MAX_PATH];
|
|
CHAR szTmpPath[MAX_PATH];
|
|
CHAR szDrive[MAX_PATH];
|
|
CHAR szDir[MAX_PATH];
|
|
szTmpPath[0] = 0;
|
|
SplitPath( pszPathname, szDrive, szDir, szFilename, szExt );
|
|
strcat( szFilename, szExt );
|
|
// make sure that the filename includes and subdirs not part of the path
|
|
//
|
|
// for example the path may be e:\samples but the pathname is c:\samples\sfl\samp.sfl
|
|
// and thus the path is e:\samples but the filename should be sfl\samp.sfl and not
|
|
// just samp.sfl
|
|
if( szDrive[0] )
|
|
strcpy( szTmpPath, szDrive );
|
|
if( szDir )
|
|
strcat( szTmpPath, szDir );
|
|
// STang:
|
|
// Buggy, must make sure pszPath is a prefix of szTmpPath ( except the drive letter )
|
|
// if( strlen( szTmpPath ) != strlen( pszPath ) )
|
|
if( strnicmp(pszPath+1,szTmpPath+1,(int)strlen(pszPath)-1) == 0 && strlen( szTmpPath ) > strlen( pszPath ) )
|
|
{
|
|
CHAR sz[MAX_PATH];
|
|
strcpy( sz, &szTmpPath[strlen(pszPath)] );
|
|
strcat( sz, szFilename );
|
|
strcpy( szFilename, sz );
|
|
}
|
|
}
|
|
else
|
|
GetPathAndFileName( pszPathname, szPath, szFilename );
|
|
|
|
// make sure to disable the default error message the OS displays
|
|
// when doing a file check on removable media
|
|
UINT uiErrorMode = SetErrorMode( SEM_FAILCRITICALERRORS );
|
|
|
|
// get the drive of the path
|
|
CHAR szDriveRoot[4];
|
|
lstrcpyn( szDriveRoot, szPath, 4 );
|
|
#define mkupper(c) ((c)-'a'+'A')
|
|
if( szDriveRoot[0] >= 'a' )
|
|
szDriveRoot[0] = mkupper(szDriveRoot[0]); // make it upper case
|
|
|
|
// Make copies of various settings to support location updating
|
|
CHAR szVolumeLabelTry[MAX_PATH];
|
|
CHAR szPathTry[MAX_PATH];
|
|
CHAR szPathnameTry[MAX_PATH];
|
|
CHAR szDriveRootTry[4];
|
|
|
|
// setup the paths to try
|
|
strcpy( szPathTry, szPath );
|
|
strcpy( szPathnameTry, pszPathname );
|
|
strcpy( szDriveRootTry, szDriveRoot );
|
|
if( bVolumeCheck ) { //HH Bug 2521: Make sure pszVolumeLabel is non-null before copy.
|
|
ASSERT( pszVolumeLabel );
|
|
strcpy( szVolumeLabelTry, pszVolumeLabel );
|
|
}
|
|
else {
|
|
strcpy( szVolumeLabelTry, "" );
|
|
}
|
|
|
|
// Setup prompting loop starting conditions
|
|
BOOL bExistenceCheck = TRUE;
|
|
BOOL bPrompt = FALSE;
|
|
|
|
// === MAIN PROMPTING LOOP BEGINS HERE === //
|
|
|
|
while( TRUE ) {
|
|
|
|
// make sure to add a backslash if the second CHAR is a colon
|
|
// sometimes we will get just "d:" instead of "d:\" and thus
|
|
// GetDriveType will fail under this circumstance
|
|
if( szDriveRootTry[1] == ':' ) {
|
|
szDriveRootTry[2] = '\\';
|
|
szDriveRootTry[3] = 0;
|
|
}
|
|
|
|
// Get media type
|
|
UINT uiDriveType = DRIVE_UNKNOWN;
|
|
if( szDriveRootTry[1] == ':' && szDriveRootTry[2] == '\\' ) {
|
|
uiDriveType = GetDriveType(szDriveRootTry);
|
|
}
|
|
else if( szDriveRootTry[0] == '\\' && szDriveRootTry[1] == '\\' ) {
|
|
uiDriveType = DRIVE_REMOTE;
|
|
bVolumeCheck = FALSE; // never check volume label of network drives
|
|
}
|
|
|
|
// Determine and handle the drive types
|
|
bExistenceCheck = TRUE;
|
|
switch( uiDriveType ) {
|
|
|
|
case DRIVE_FIXED:
|
|
case DRIVE_RAMDISK:
|
|
uiDriveType = DRIVE_FIXED;
|
|
// fall thru
|
|
|
|
case DRIVE_REMOTE:
|
|
bVolumeCheck = FALSE;
|
|
break;
|
|
|
|
case DRIVE_REMOVABLE:
|
|
case DRIVE_CDROM:
|
|
case DRIVE_UNKNOWN:
|
|
case DRIVE_NO_ROOT_DIR:
|
|
if( bVolumeCheckIn )
|
|
bVolumeCheck = TRUE;
|
|
break;
|
|
|
|
default: // unknown types
|
|
bVolumeCheck = FALSE;
|
|
bExistenceCheck = FALSE;
|
|
break;
|
|
}
|
|
|
|
// Prompt for media
|
|
if( bPrompt ) {
|
|
CHAR szDriveLetter[4];
|
|
szDriveLetter[0] = szDriveRoot[0];
|
|
szDriveLetter[1] = szDriveRoot[1];
|
|
szDriveLetter[2] = 0;
|
|
|
|
HHREMOVABLE Removable;
|
|
Removable.uiDriveType = uiDriveType;
|
|
Removable.pszDriveLetter = szDriveLetter;
|
|
Removable.pszVolumeName = pszVolumeName;
|
|
PSTR pszPathTry = szPathTry;
|
|
Removable.ppszLocation = &pszPathTry;
|
|
|
|
HCURSOR hCursor = GetCursor();
|
|
|
|
// Disable all of the toplevel application windows, before we bring up the dialog.
|
|
CLockOut LockOut ;
|
|
LockOut.LockOut(GetActiveWindow()) ;
|
|
|
|
// Display the dialog box.
|
|
INT_PTR iReturn = DialogBoxParam( _Module.GetResourceInstance(),
|
|
MAKEINTRESOURCE(IDD_REMOVEABLE_MEDIA_PROMPT),
|
|
GetActiveWindow(), RemovableMediaDialogProc,
|
|
(LPARAM) &Removable );
|
|
|
|
// Enable all of the windows which we disabled.
|
|
LockOut.Unlock() ;
|
|
|
|
SetCursor( hCursor );
|
|
|
|
if( iReturn == IDOK ) {
|
|
strcpy( szPathnameTry, pszPathTry );
|
|
CatPath( szPathnameTry, szFilename );
|
|
lstrcpyn( szDriveRootTry, pszPathTry, 4 );
|
|
bPrompt = FALSE;
|
|
continue;
|
|
}
|
|
else if( iReturn == IDCANCEL ) {
|
|
if( !bAlwaysPrompt )
|
|
g_LocationSkipList.Add( szLocationId );
|
|
hr = HHRMS_E_SKIP;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Validate media is present using the volume label, if needed
|
|
if( bVolumeCheck ) {
|
|
CHAR szVolume[MAX_PATH];
|
|
szVolume[0] = 0;
|
|
CHAR szFileSystemName[MAX_PATH];
|
|
DWORD dwMaximumComponentLength = 0;
|
|
DWORD dwFileSystemFlags = 0;
|
|
BOOL bReturn = GetVolumeInformation( szDriveRootTry, szVolume, sizeof(szVolume),
|
|
NULL, &dwMaximumComponentLength, &dwFileSystemFlags, szFileSystemName, sizeof(szFileSystemName) );
|
|
if( bVolumeCheckIn && (!bReturn || (strcmp( szVolume, szVolumeLabelTry ) != 0)) )
|
|
bExistenceCheck = FALSE;
|
|
}
|
|
|
|
// if the file exists, and it matches the chi file (for title checks only) the we have the right media
|
|
if( bExistenceCheck && IsFile( szPathnameTry ) && ((uiFileType==HHRMS_TYPE_TITLE)?pTitle->EnsureChmChiMatch( szPathnameTry ):TRUE ) ) {
|
|
hr = S_OK;
|
|
|
|
// TODO: the version of MSDN that shipped with VS 6.0 is broken for net installs.
|
|
// For a network install, they erroneously set the volume label for CD2, also
|
|
// known as "98VS-1033-CD2", to "DN600ENU1" instead of "DN600ENU2". To fix this we
|
|
// need to ignore the language settings of "1033" or "ENU" and make the appropriate
|
|
// change to the volume label. We must do this before we call UpdateLocation since
|
|
// it could change the location information for CD1 when the user updates the CD2
|
|
// location information.
|
|
|
|
// Never change the volume label unless the new destination is
|
|
// removable media!
|
|
//
|
|
// Setup should adhere to the following rules:
|
|
//
|
|
// 1. Each local disk and network destination path must use a
|
|
// volume name unique for each set of titles from each CD source
|
|
// and they must be unique from the CD source volume label.
|
|
// It is advised that these volume names be the volume label name
|
|
// of the removable media (sahipped media) that the group came
|
|
// from appended with the destination type name and number such as
|
|
// "-LocalX" or "-NetX".
|
|
// 2. Volume names for CD "destinations" must be identical to the
|
|
// CD's volume name.
|
|
// 3. Note, locations with the same volume name will automatically
|
|
// get their path updated when any one of them changes.
|
|
//
|
|
|
|
// if the path did change then update the information, otherwise were done
|
|
if( lstrcmpi( szPathTry, szPath ) != 0 ) {
|
|
// STang
|
|
char * pcVolume = NULL;
|
|
if ( ( (uiDriveType == DRIVE_REMOVABLE) || (uiDriveType == DRIVE_CDROM) )
|
|
&& bVolumeCheck )
|
|
pcVolume = szVolumeLabelTry;
|
|
|
|
pCollection->UpdateLocation( (PSTR) szLocationId, szPathTry, pcVolume );
|
|
|
|
// pCollection->UpdateLocation( (PSTR) szLocationId, szPathTry,
|
|
// ( (uiDriveType == DRIVE_REMOVABLE) || (uiDriveType == DRIVE_CDROM)) ? szVolumeLabelTry : NULL );
|
|
hr = HHRMS_S_LOCATION_UPDATE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// Bail out if we never want to prompt for media
|
|
if( bNeverPrompt ) {
|
|
|
|
#ifdef _DEBUG
|
|
if( g_bShowMessage && (uiFileType != HHRMS_TYPE_COMBINED_QUERY) ) {
|
|
CHAR szMsg[1024];
|
|
wsprintf( szMsg, "HHFinder Debug Message\n\n"
|
|
"Could not find the file:\n \"%s\"\n"
|
|
"at the location specified.", szPathnameTry );
|
|
if( pTitle && pTitle->m_pTitle ) {
|
|
CHAR szMsg2[1024];
|
|
wsprintf( szMsg2, "\n\nTitle ID: \"%s\".", pTitle->m_pTitle->GetId() );
|
|
strcat( szMsg, szMsg2 );
|
|
}
|
|
strcat( szMsg, "\n\nPress 'OK' to continue or 'Cancel' to disable this warning.");
|
|
int iReturn = MsgBox( szMsg, MB_OKCANCEL );
|
|
if( iReturn == IDCANCEL )
|
|
g_bShowMessage = FALSE;
|
|
}
|
|
#endif
|
|
|
|
// if existence check was desired then this is a failure condition
|
|
if( bExistenceCheck ) {
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
// Bailout and let the caller know we are skipping this one
|
|
hr = HHRMS_E_SKIP;
|
|
break;
|
|
}
|
|
|
|
// If we do not require that we always prompt, check the volume against
|
|
// our skip list
|
|
if( !bAlwaysPrompt ) {
|
|
if( !bNeverPrompt )
|
|
if( g_LocationSkipList.Find( szLocationId ) ) {
|
|
hr = HHRMS_E_SKIP_ALWAYS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
// Let the user know that we could not find the title at the location specified
|
|
if( bPrompt ) {
|
|
CHAR szMsg[1024];
|
|
wsprintf( szMsg, "HHFinder Debug Message\n\n"
|
|
"Could not find the file:\n \"%s\"\n"
|
|
"at the location specified.", szFilename );
|
|
if( pTitle && pTitle->m_pTitle ) {
|
|
CHAR szMsg2[1024];
|
|
wsprintf( szMsg2, "\n\nTitle ID: \"%s\".", pTitle->m_pTitle->GetId() );
|
|
strcat( szMsg, szMsg2 );
|
|
}
|
|
MsgBox( szMsg, MB_OKCANCEL );
|
|
}
|
|
#endif
|
|
|
|
// restore the original path information, and continue
|
|
strcpy( szPathTry, szPath );
|
|
strcpy( szPathnameTry, pszPathname );
|
|
strcpy( szDriveRootTry, szDriveRoot );
|
|
if( bVolumeCheck ) { //HH Bug 2521: Make sure pszVolumeLabel is non-null before copy.
|
|
ASSERT( pszVolumeLabel );
|
|
strcpy( szVolumeLabelTry, pszVolumeLabel );
|
|
}
|
|
else {
|
|
strcpy( szVolumeLabelTry, "" );
|
|
}
|
|
bPrompt = TRUE;
|
|
|
|
}
|
|
|
|
// === MAIN PROMPTING LOOP ENDS HERE === //
|
|
|
|
// restore the previous error mode
|
|
SetErrorMode( uiErrorMode );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CD Swap Dialog
|
|
|
|
INT_PTR CALLBACK RemovableMediaDialogProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
static HHREMOVABLE* pRemovable = NULL;
|
|
static HWND hWndIcon = NULL;
|
|
|
|
switch( uMsg ) {
|
|
|
|
case WM_INITDIALOG: {
|
|
pRemovable = (HHREMOVABLE*) lParam;
|
|
|
|
// get and set our dialog title title
|
|
PCSTR pszTitle = GetStringResource( IDS_MSGBOX_TITLE );
|
|
SetWindowText( hDlg, pszTitle );
|
|
|
|
//get media name and icon
|
|
PCSTR pszMediaName = NULL;
|
|
PCSTR pszIcon = NULL;
|
|
DWORD dwFormatMessage = 0;
|
|
|
|
if( pRemovable->uiDriveType == DRIVE_REMOVABLE ) {
|
|
pszIcon = "IconDisk350";
|
|
pszMediaName = GetStringResource( IDS_REMOVABLE_MEDIA_DISK ); // "disk"
|
|
dwFormatMessage = IDS_REMOVABLE_MEDIA_MESSAGE_FORMAT;
|
|
}
|
|
#ifdef HH_VERSION_1_3
|
|
else if( pRemovable->uiDriveType == DRIVE_REMOTE ) {
|
|
pszIcon = "IconRemote";
|
|
pszMediaName = GetStringResource( IDS_REMOVABLE_MEDIA_REMOTE ); // "Network location"
|
|
dwFormatMessage = IDS_REMOVABLE_MEDIA_MESSAGE_FORMAT2;
|
|
}
|
|
else if( pRemovable->uiDriveType == DRIVE_FIXED ) {
|
|
pszIcon = "IconFixed";
|
|
pszMediaName = GetStringResource( IDS_REMOVABLE_MEDIA_FIXED ); // "local disk"
|
|
dwFormatMessage = IDS_REMOVABLE_MEDIA_MESSAGE_FORMAT2;
|
|
}
|
|
#endif
|
|
else /* if( pRemovable->uiDriveType == DRIVE_CDROM ) */ {
|
|
pszIcon = "IconCDROM";
|
|
pszMediaName = GetStringResource( IDS_REMOVABLE_MEDIA_CDROM ); // "CD-ROM disc"
|
|
dwFormatMessage = IDS_REMOVABLE_MEDIA_MESSAGE_FORMAT;
|
|
}
|
|
|
|
CHAR szMediaName[64];
|
|
strcpy( szMediaName, pszMediaName );
|
|
|
|
// set the icon
|
|
hWndIcon = CreateWindow( TEXT( "static" ), pszIcon,
|
|
WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_ICON,
|
|
15, 15, 0, 0, hDlg, NULL, _Module.GetModuleInstance(), NULL );
|
|
|
|
// get location message format string
|
|
PCSTR pszFormat = GetStringResource( dwFormatMessage );
|
|
CHAR szFormat[256];
|
|
strcpy( szFormat, pszFormat );
|
|
|
|
// format the location message
|
|
DWORD dwArgCount = 3;
|
|
#ifdef HH_VERSION_1_3
|
|
if( dwFormatMessage == IDS_REMOVABLE_MEDIA_MESSAGE_FORMAT2 )
|
|
dwArgCount = 2;
|
|
#endif
|
|
|
|
DWORD_PTR* pArg = new DWORD_PTR[dwArgCount];
|
|
|
|
pArg[0] = (DWORD_PTR) szMediaName;
|
|
pArg[1] = (DWORD_PTR) pRemovable->pszVolumeName;
|
|
if( dwArgCount == 3 )
|
|
pArg[2] = (DWORD_PTR) pRemovable->pszDriveLetter;
|
|
|
|
CHAR szMessage[1024];
|
|
|
|
FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
szFormat, 0, 0, szMessage, sizeof(szMessage), (va_list*) pArg );
|
|
|
|
delete [] pArg;
|
|
|
|
// set the location message
|
|
#ifdef HH_VERSION_1_3
|
|
::SendMessage(GetDlgItem( hDlg, IDC_LOCATION_NAME ), WM_SETFONT, (WPARAM) _Resource.GetUIFont(), FALSE);
|
|
#else
|
|
::SendMessage(GetDlgItem( hDlg, IDC_LOCATION_NAME ), WM_SETFONT, (WPARAM) _Resource.DefaultFont(), FALSE);
|
|
#endif
|
|
|
|
SetWindowText( GetDlgItem( hDlg, IDC_LOCATION_NAME ), szMessage );
|
|
|
|
// set the location path
|
|
#ifdef HH_VERSION_1_3
|
|
::SendMessage(GetDlgItem( hDlg, IDC_LOCATION_PATH ), WM_SETFONT, (WPARAM) _Resource.GetUIFont(), FALSE);
|
|
#else
|
|
::SendMessage(GetDlgItem( hDlg, IDC_LOCATION_PATH ), WM_SETFONT, (WPARAM) _Resource.DefaultFont(), FALSE);
|
|
#endif
|
|
|
|
SetWindowText( GetDlgItem( hDlg, IDC_LOCATION_PATH ), *(pRemovable->ppszLocation) );
|
|
|
|
// disable the location path for now
|
|
//EnableWindow( GetDlgItem( hDlg, IDC_LOCATION_PATH ), FALSE );
|
|
|
|
// center the dialog
|
|
CenterWindow( GetParent( hDlg ), hDlg );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
case WM_COMMAND:
|
|
if( LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL ) {
|
|
// return the path
|
|
GetWindowText( GetDlgItem( hDlg, IDC_LOCATION_PATH ), (PSTR) *(pRemovable->ppszLocation), MAX_PATH );
|
|
// make sure the returned path includes a trailing backslash
|
|
PSTR* ppsz = pRemovable->ppszLocation;
|
|
int iLen = (int)strlen(*ppsz);
|
|
if( (*ppsz)[iLen-1] != '\\' ) {
|
|
(*ppsz)[iLen] = '\\';
|
|
(*ppsz)[iLen+1] = 0;
|
|
}
|
|
DestroyWindow( hWndIcon );
|
|
pRemovable = NULL;
|
|
hWndIcon = NULL;
|
|
EndDialog( hDlg, LOWORD( wParam ) );
|
|
}
|
|
else if( LOWORD(wParam) == ID_BROWSE ) {
|
|
CStr strPath;
|
|
if( DlgOpenDirectory( hDlg, &strPath ) ) {
|
|
SetWindowText( GetDlgItem( hDlg, IDC_LOCATION_PATH ), strPath.psz );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|