able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/stuff/hhctrl/hhfinder.cpp

831 lines
26 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
///////////////////////////////////////////////////////////
//
//
// 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;
}
Reference in a new issue Copy permalink