804 lines
26 KiB
C++
804 lines
26 KiB
C++
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORPORATION, 1998
|
|
*
|
|
* TITLE: COMFIN.CPP
|
|
*
|
|
* VERSION: 1.0
|
|
*
|
|
* AUTHOR: ShaunIv
|
|
*
|
|
* DATE: 9/28/1999
|
|
*
|
|
* DESCRIPTION: Transfer page. Gets the destination path and filename.
|
|
*
|
|
*******************************************************************************/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include "comfin.h"
|
|
#include "simcrack.h"
|
|
#include "resource.h"
|
|
#include "svselfil.h"
|
|
#include "simrect.h"
|
|
#include "movewnd.h"
|
|
#include "runnpwiz.h"
|
|
#include "mboxex.h"
|
|
#include <wininet.h>
|
|
|
|
#define STR_LOCAL_LINK_ID TEXT("LocalLinkId")
|
|
#define STR_REMOTE_LINK_ID TEXT("RemoteLinkId")
|
|
#define STR_DETAILED_DOWNLOAD_ERROR_ID TEXT("DetailedDownloadErrorId")
|
|
#define STR_DETAILED_UPLOAD_ERROR_ID TEXT("DetailedUploadErrorId")
|
|
|
|
#define ID_FINISHBUTTON 0x3025
|
|
|
|
//
|
|
// Sole constructor
|
|
//
|
|
CCommonFinishPage::CCommonFinishPage( HWND hWnd )
|
|
: m_hWnd(hWnd),
|
|
m_nWiaEventMessage(RegisterWindowMessage(STR_WIAEVENT_NOTIFICATION_MESSAGE)),
|
|
m_pControllerWindow(NULL),
|
|
m_hBigTitleFont(NULL)
|
|
{
|
|
}
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
CCommonFinishPage::~CCommonFinishPage(void)
|
|
{
|
|
m_hWnd = NULL;
|
|
m_pControllerWindow = NULL;
|
|
}
|
|
|
|
|
|
HRESULT CCommonFinishPage::GetManifestInfo( IXMLDOMDocument *pXMLDOMDocumentManifest, CSimpleString &strSiteName, CSimpleString &strSiteURL )
|
|
{
|
|
WCHAR wszSiteName[MAX_PATH] = {0};
|
|
WCHAR wszSiteURL[INTERNET_MAX_URL_LENGTH] = {0};
|
|
|
|
HRESULT hr;
|
|
if (pXMLDOMDocumentManifest)
|
|
{
|
|
//
|
|
// lets crack the manifest and work out whats what with the publish that
|
|
// we just performed.
|
|
//
|
|
CComPtr<IXMLDOMNode> pXMLDOMNodeUploadInfo;
|
|
hr = pXMLDOMDocumentManifest->selectSingleNode( L"transfermanifest/uploadinfo", &pXMLDOMNodeUploadInfo );
|
|
if (S_OK == hr)
|
|
{
|
|
//
|
|
// lets pick up the site name from the manifest, this will be an attribute on the
|
|
// upload info element.
|
|
//
|
|
CComPtr<IXMLDOMElement> pXMLDOMElement;
|
|
hr = pXMLDOMNodeUploadInfo->QueryInterface( IID_IXMLDOMElement, (void**)&pXMLDOMElement );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
VARIANT var = {0};
|
|
hr = pXMLDOMElement->getAttribute( L"friendlyname", &var );
|
|
if (S_OK == hr)
|
|
{
|
|
StrCpyNW( wszSiteName, var.bstrVal, ARRAYSIZE(wszSiteName) );
|
|
VariantClear(&var);
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMElement->getAttribute( \"friendlyname\" ) failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMNodeUploadInfo->QueryInterface( IID_IXMLDOMElement ) failed on line %d"), __LINE__ ));
|
|
}
|
|
|
|
//
|
|
// lets now try and pick up the site URL node, this is going to either
|
|
// be the file target, or HTML UI element.
|
|
//
|
|
CComPtr<IXMLDOMNode> pXMLDOMNodeURL;
|
|
hr = pXMLDOMNodeUploadInfo->selectSingleNode( L"htmlui", &pXMLDOMNodeURL);
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMDocumentManifest->selectSingleNode \"htmlui\" failed")));
|
|
hr = pXMLDOMNodeUploadInfo->selectSingleNode( L"netplace", &pXMLDOMNodeURL);
|
|
}
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMDocumentManifest->selectSingleNode \"target\" failed")));
|
|
hr = pXMLDOMNodeUploadInfo->selectSingleNode( L"target", &pXMLDOMNodeURL);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
CComPtr<IXMLDOMElement> pXMLDOMElement;
|
|
hr = pXMLDOMNodeURL->QueryInterface( IID_IXMLDOMElement, (void**)&pXMLDOMElement );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
//
|
|
// attempt to read the HREF attribute, if that is defined
|
|
// the we use it, otherwise (for compatibility with B2, we need
|
|
// to get the node text and use that instead).
|
|
//
|
|
VARIANT var = {0};
|
|
hr = pXMLDOMElement->getAttribute( L"href", &var );
|
|
if (hr != S_OK)
|
|
{
|
|
hr = pXMLDOMElement->get_nodeTypedValue( &var );
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
StrCpyNW(wszSiteURL, var.bstrVal, ARRAYSIZE(wszSiteURL) );
|
|
VariantClear(&var);
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMElement->getAttribute or pXMLDOMElement->get_nodeTypedValue failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMNodeUploadInfo->QueryInterface( IID_IXMLDOMElement ) failed on line %d"), __LINE__ ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMDocumentManifest->selectSingleNode \"target\" failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pXMLDOMDocumentManifest->selectSingleNode \"transfermanifest\\uploadinfo\" failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pXMLDOMDocumentManifest is NULL")));
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
strSiteName = CSimpleStringConvert::NaturalString( CSimpleStringWide( wszSiteName ) );
|
|
strSiteURL = CSimpleStringConvert::NaturalString( CSimpleStringWide( wszSiteURL ) );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
LRESULT CCommonFinishPage::OnInitDialog( WPARAM, LPARAM lParam )
|
|
{
|
|
//
|
|
// Make sure this starts out NULL
|
|
//
|
|
m_pControllerWindow = NULL;
|
|
|
|
//
|
|
// Get the PROPSHEETPAGE.lParam
|
|
//
|
|
PROPSHEETPAGE *pPropSheetPage = reinterpret_cast<PROPSHEETPAGE*>(lParam);
|
|
if (pPropSheetPage)
|
|
{
|
|
m_pControllerWindow = reinterpret_cast<CAcquisitionManagerControllerWindow*>(pPropSheetPage->lParam);
|
|
if (m_pControllerWindow)
|
|
{
|
|
m_pControllerWindow->m_WindowList.Add(m_hWnd);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Bail out
|
|
//
|
|
if (!m_pControllerWindow)
|
|
{
|
|
EndDialog(m_hWnd,IDCANCEL);
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Set the font size for the title
|
|
//
|
|
m_hBigTitleFont = WiaUiUtil::CreateFontWithPointSizeFromWindow( GetDlgItem(m_hWnd,IDC_FINISH_TITLE), 14, false, false );
|
|
if (m_hBigTitleFont)
|
|
{
|
|
SendDlgItemMessage( m_hWnd, IDC_FINISH_TITLE, WM_SETFONT, reinterpret_cast<WPARAM>(m_hBigTitleFont), MAKELPARAM(TRUE,0));
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
LRESULT CCommonFinishPage::OnWizFinish( WPARAM, LPARAM )
|
|
{
|
|
LRESULT nResult = FALSE;
|
|
|
|
//
|
|
// Open the shell folder containing the images
|
|
//
|
|
OpenLocalStorage();
|
|
return nResult;
|
|
}
|
|
|
|
/*
|
|
|
|
From finish page:
|
|
|
|
if (error_occurred)
|
|
{
|
|
if (no_images)
|
|
{
|
|
goto SelectionPage
|
|
}
|
|
else
|
|
{
|
|
goto DestinationPage
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto UploadQueryPage
|
|
}
|
|
|
|
*/
|
|
|
|
//
|
|
// handler for PSN_WIZBACK
|
|
//
|
|
LRESULT CCommonFinishPage::OnWizBack( WPARAM, LPARAM )
|
|
{
|
|
//
|
|
// If no errors occurred, go to the upload query page
|
|
//
|
|
HPROPSHEETPAGE hNextPage = NULL;
|
|
if (S_OK==m_pControllerWindow->m_hrDownloadResult && !m_pControllerWindow->m_bDownloadCancelled)
|
|
{
|
|
hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nUploadQueryPageIndex );
|
|
}
|
|
else
|
|
{
|
|
if (m_pControllerWindow->GetSelectedImageCount())
|
|
{
|
|
hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nDestinationPageIndex );
|
|
}
|
|
else
|
|
{
|
|
hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nSelectionPageIndex );
|
|
}
|
|
}
|
|
PropSheet_SetCurSel( GetParent(m_hWnd), hNextPage, -1 );
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// handler for PSN_SETACTIVE
|
|
//
|
|
LRESULT CCommonFinishPage::OnSetActive( WPARAM, LPARAM )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CCommonFinishPage::OnSetActive"));
|
|
|
|
//
|
|
// Make sure we have a valid controller window
|
|
//
|
|
if (!m_pControllerWindow)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Assume we are displaying a success message
|
|
//
|
|
int nPageTitle = IDS_FINISH_SUCCESS_TITLE;
|
|
|
|
//
|
|
// Assume we failed for this message
|
|
//
|
|
int nFinishPrompt = IDS_FINISH_PROMPT_FAILURE;
|
|
|
|
//
|
|
// Only disable the back button if (a) we are disconnected and (b) we hit an error or were cancelled
|
|
//
|
|
if (m_pControllerWindow->m_bDisconnected && (S_OK != m_pControllerWindow->m_hrDownloadResult || m_pControllerWindow->m_bDownloadCancelled))
|
|
{
|
|
//
|
|
// Basically, this disables the Cancel button.
|
|
//
|
|
PropSheet_CancelToClose( GetParent(m_hWnd) );
|
|
|
|
//
|
|
// Change the finish button to a close button
|
|
//
|
|
PropSheet_SetFinishText( GetParent(m_hWnd), CSimpleString( IDS_FINISH_TO_CLOSE_TITLE, g_hInstance ).String() );
|
|
|
|
//
|
|
// Disable back
|
|
//
|
|
PropSheet_SetWizButtons( GetParent(m_hWnd), PSWIZB_FINISH );
|
|
|
|
//
|
|
// Tell the user to use Close to close the wizard.
|
|
//
|
|
nFinishPrompt = IDS_FINISH_PROMPT_FAILURE_DISCONNECT;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Allow finish and back
|
|
//
|
|
PropSheet_SetWizButtons( GetParent(m_hWnd), PSWIZB_FINISH|PSWIZB_BACK );
|
|
|
|
}
|
|
|
|
|
|
#if defined(DBG)
|
|
//
|
|
// Display statistics for debugging
|
|
//
|
|
WIA_TRACE((TEXT("m_pControllerWindow->m_DownloadedFileList.Size(): %d"), m_pControllerWindow->m_DownloadedFileInformationList.Size()));
|
|
for (int i=0;i<m_pControllerWindow->m_DownloadedFileInformationList.Size();i++)
|
|
{
|
|
WIA_TRACE((TEXT(" m_pControllerWindow->m_DownloadedFileList[%d]==%s"), i, m_pControllerWindow->m_DownloadedFileInformationList[i].Filename().String()));
|
|
}
|
|
WIA_TRACE((TEXT("m_pControllerWindow->m_nFailedImagesCount: %d"), m_pControllerWindow->m_nFailedImagesCount ));
|
|
WIA_TRACE((TEXT("m_pControllerWindow->m_strErrorMessage: %s"), m_pControllerWindow->m_strErrorMessage.String()));
|
|
WIA_PRINTHRESULT((m_pControllerWindow->m_hrDownloadResult,TEXT("m_pControllerWindow->m_hrDownloadResult")));
|
|
WIA_PRINTHRESULT((m_pControllerWindow->m_hrUploadResult,TEXT("m_pControllerWindow->m_hrUploadResult")));
|
|
WIA_PRINTHRESULT((m_pControllerWindow->m_hrDeleteResult,TEXT("m_pControllerWindow->m_hrDeleteResult")));
|
|
#endif
|
|
|
|
CSimpleString strStatusMessage;
|
|
|
|
//
|
|
// If the transfer succeeded, and the user didn't cancel
|
|
//
|
|
if (S_OK==m_pControllerWindow->m_hrDownloadResult && !m_pControllerWindow->m_bDownloadCancelled)
|
|
{
|
|
|
|
CSimpleString strSuccessfullyDownloaded;
|
|
CSimpleString strSuccessfullyUploaded;
|
|
CSimpleString strSuccessfullyDeleted;
|
|
CSimpleString strHyperlinks;
|
|
|
|
CSimpleString strLocalHyperlink;
|
|
CSimpleString strRemoteHyperlink;
|
|
|
|
int nSuccessCount = 0;
|
|
|
|
|
|
//
|
|
// If we have successfully transferred images, display the count and show the associated controls
|
|
//
|
|
if (m_pControllerWindow->m_DownloadedFileInformationList.Size())
|
|
{
|
|
//
|
|
// Count up all of the "countable" files (we don't include attachments in the count)
|
|
//
|
|
for (int i=0;i<m_pControllerWindow->m_DownloadedFileInformationList.Size();i++)
|
|
{
|
|
if (m_pControllerWindow->m_DownloadedFileInformationList[i].IncludeInFileCount())
|
|
{
|
|
nSuccessCount++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we had any errors while deleting images, let the user know
|
|
//
|
|
if (m_pControllerWindow->m_bDeletePicturesIfSuccessful && FAILED(m_pControllerWindow->m_hrDeleteResult))
|
|
{
|
|
strSuccessfullyDeleted.LoadString( IDS_DELETION_FAILED, g_hInstance );
|
|
}
|
|
|
|
//
|
|
// If we uploaded to the web, set the destination text
|
|
//
|
|
if (m_pControllerWindow->m_bUploadToWeb)
|
|
{
|
|
//
|
|
// If we have a valid publishing wizard, get the manifest and hresult
|
|
//
|
|
if (m_pControllerWindow->m_pPublishingWizard)
|
|
{
|
|
//
|
|
// Get the transfer manifest
|
|
//
|
|
CComPtr<IXMLDOMDocument> pXMLDOMDocumentManifest;
|
|
if (SUCCEEDED(m_pControllerWindow->m_pPublishingWizard->GetTransferManifest( &m_pControllerWindow->m_hrUploadResult, &pXMLDOMDocumentManifest )))
|
|
{
|
|
WIA_PRINTHRESULT((m_pControllerWindow->m_hrUploadResult,TEXT("m_pControllerWindow->m_hrUploadResult")));
|
|
|
|
//
|
|
// Get the destination URL and friendly name out of the manifest
|
|
//
|
|
CSimpleString strUploadDestination;
|
|
if (S_OK==m_pControllerWindow->m_hrUploadResult && SUCCEEDED(CCommonFinishPage::GetManifestInfo( pXMLDOMDocumentManifest, strUploadDestination, m_strSiteUrl )))
|
|
{
|
|
//
|
|
// If we have a friendly name, use it. Otherwise, use the URL
|
|
//
|
|
strRemoteHyperlink = strUploadDestination;
|
|
if (!strRemoteHyperlink.Length())
|
|
{
|
|
strRemoteHyperlink = m_strSiteUrl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (HRESULT_FROM_WIN32(ERROR_CANCELLED) == m_pControllerWindow->m_hrUploadResult)
|
|
{
|
|
strSuccessfullyUploaded.LoadString( IDS_FINISH_UPLOAD_CANCELLED, g_hInstance );
|
|
}
|
|
else if (FAILED(m_pControllerWindow->m_hrUploadResult))
|
|
{
|
|
strSuccessfullyUploaded.LoadString( IDS_FINISH_UPLOAD_FAILED, g_hInstance );
|
|
}
|
|
}
|
|
|
|
if (nSuccessCount)
|
|
{
|
|
strLocalHyperlink = m_pControllerWindow->m_CurrentDownloadDestination.DisplayName(m_pControllerWindow->m_DestinationNameData).String();
|
|
|
|
nFinishPrompt = IDS_FINISH_PROMPT_SUCCESS;
|
|
}
|
|
}
|
|
|
|
|
|
int nCountOfSuccessfulDestinations = 0;
|
|
|
|
if (strLocalHyperlink.Length() || strRemoteHyperlink.Length())
|
|
{
|
|
strHyperlinks += TEXT("\n");
|
|
}
|
|
|
|
//
|
|
// Get the client rect for calculating the allowable size of the hyperlink string
|
|
//
|
|
RECT rcControl;
|
|
GetClientRect( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ), &rcControl );
|
|
|
|
if (strLocalHyperlink.Length())
|
|
{
|
|
nCountOfSuccessfulDestinations++;
|
|
strHyperlinks += CSimpleString( IDS_FINISH_LOCAL_LINK_PROMPT, g_hInstance );
|
|
strHyperlinks += TEXT("\n");
|
|
strHyperlinks += TEXT("<a id=\"") STR_LOCAL_LINK_ID TEXT("\">");
|
|
strHyperlinks += WiaUiUtil::TruncateTextToFitInRect( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ), strLocalHyperlink, rcControl, DT_END_ELLIPSIS|DT_NOPREFIX );
|
|
strHyperlinks += TEXT("</a>");
|
|
}
|
|
if (strRemoteHyperlink.Length())
|
|
{
|
|
nCountOfSuccessfulDestinations++;
|
|
strHyperlinks += TEXT("\n\n");
|
|
strHyperlinks += CSimpleString( IDS_FINISH_REMOTE_LINK_PROMPT, g_hInstance );
|
|
strHyperlinks += TEXT("\n");
|
|
strHyperlinks += TEXT("<a id=\"") STR_REMOTE_LINK_ID TEXT("\">");
|
|
strHyperlinks += WiaUiUtil::TruncateTextToFitInRect( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ), strRemoteHyperlink, rcControl, DT_END_ELLIPSIS|DT_NOPREFIX );
|
|
strHyperlinks += TEXT("</a>");
|
|
}
|
|
|
|
if (strHyperlinks.Length())
|
|
{
|
|
strHyperlinks += TEXT("\n");
|
|
}
|
|
|
|
//
|
|
// Format the success string
|
|
//
|
|
if (nCountOfSuccessfulDestinations)
|
|
{
|
|
strSuccessfullyDownloaded.Format( IDS_SUCCESSFUL_DOWNLOAD, g_hInstance, nSuccessCount );
|
|
}
|
|
|
|
|
|
//
|
|
// Append the individual status messages to the main status message
|
|
//
|
|
if (strSuccessfullyDownloaded.Length())
|
|
{
|
|
if (strStatusMessage.Length())
|
|
{
|
|
strStatusMessage += TEXT("\n");
|
|
}
|
|
strStatusMessage += strSuccessfullyDownloaded;
|
|
}
|
|
if (strHyperlinks.Length())
|
|
{
|
|
if (strStatusMessage.Length())
|
|
{
|
|
strStatusMessage += TEXT("\n");
|
|
}
|
|
strStatusMessage += strHyperlinks;
|
|
}
|
|
if (strSuccessfullyUploaded.Length())
|
|
{
|
|
if (strStatusMessage.Length())
|
|
{
|
|
strStatusMessage += TEXT("\n");
|
|
}
|
|
strStatusMessage += strSuccessfullyUploaded;
|
|
}
|
|
if (strSuccessfullyDeleted.Length())
|
|
{
|
|
if (strStatusMessage.Length())
|
|
{
|
|
strStatusMessage += TEXT("\n");
|
|
}
|
|
strStatusMessage += strSuccessfullyDeleted;
|
|
}
|
|
|
|
|
|
strStatusMessage.SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ) );
|
|
}
|
|
|
|
//
|
|
// Else if there was an offline error
|
|
//
|
|
else if (WIA_ERROR_OFFLINE == m_pControllerWindow->m_hrDownloadResult || m_pControllerWindow->m_bDisconnected)
|
|
{
|
|
nPageTitle = IDS_FINISH_FAILURE_TITLE;
|
|
|
|
(CSimpleString( IDS_DEVICE_DISCONNECTED, g_hInstance )).SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ) );
|
|
}
|
|
|
|
//
|
|
// Else, if the user cancelled
|
|
//
|
|
else if (m_pControllerWindow->m_bDownloadCancelled)
|
|
{
|
|
nPageTitle = IDS_FINISH_FAILURE_TITLE;
|
|
|
|
CSimpleString( IDS_USER_CANCELLED, g_hInstance ).SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ) );
|
|
}
|
|
|
|
//
|
|
// Otherwise there was an error
|
|
//
|
|
else
|
|
{
|
|
nPageTitle = IDS_FINISH_FAILURE_TITLE;
|
|
|
|
CSimpleString( IDS_FINISH_ERROR_MESSAGE, g_hInstance ).SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_STATUS ) );
|
|
}
|
|
|
|
//
|
|
// Display the finish title message
|
|
//
|
|
CSimpleString( nPageTitle, g_hInstance ).SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_TITLE ) );
|
|
|
|
//
|
|
// Display the finish prompt.
|
|
//
|
|
CSimpleString( nFinishPrompt, g_hInstance ).SetWindowText( GetDlgItem( m_hWnd, IDC_FINISH_PROMPT ) );
|
|
|
|
|
|
//
|
|
// Don't do anything on disconnect messages
|
|
//
|
|
m_pControllerWindow->m_OnDisconnect = 0;
|
|
|
|
//
|
|
// Get the focus off the stinkin' hyperlink control
|
|
//
|
|
PostMessage( m_hWnd, WM_NEXTDLGCTL, reinterpret_cast<WPARAM>(GetDlgItem(GetParent(m_hWnd),ID_FINISHBUTTON)), MAKELPARAM(TRUE,0));
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CCommonFinishPage::OnDestroy( WPARAM, LPARAM )
|
|
{
|
|
if (m_hBigTitleFont)
|
|
{
|
|
DeleteObject(m_hBigTitleFont);
|
|
m_hBigTitleFont = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CCommonFinishPage::OpenLocalStorage()
|
|
{
|
|
CWaitCursor wc;
|
|
|
|
//
|
|
// Assume we do need to open the shell folder
|
|
//
|
|
bool bNeedToOpenShellFolder = true;
|
|
|
|
//
|
|
// Special case for CD burning--attempt to open the CD burner folder
|
|
//
|
|
if (CDestinationData( CSIDL_CDBURN_AREA ) == m_pControllerWindow->m_CurrentDownloadDestination)
|
|
{
|
|
//
|
|
// Create the CD burner interface, so we can get the drive letter
|
|
//
|
|
CComPtr<ICDBurn> pCDBurn;
|
|
HRESULT hr = CoCreateInstance( CLSID_CDBurn, NULL, CLSCTX_SERVER, IID_ICDBurn, (void**)&pCDBurn );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get the drive letter of the available CD burner
|
|
//
|
|
WCHAR szDriveLetter[MAX_PATH];
|
|
hr = pCDBurn->GetRecorderDriveLetter( szDriveLetter, ARRAYSIZE(szDriveLetter) );
|
|
|
|
//
|
|
// Make sure the function returned success and that we have a string
|
|
//
|
|
if (S_OK == hr && szDriveLetter[0] != L'\0')
|
|
{
|
|
//
|
|
// Convert the drive to a TCHAR string
|
|
//
|
|
CSimpleString strShellLocation = CSimpleStringConvert::NaturalString(CSimpleStringWide(szDriveLetter));
|
|
if (strShellLocation.Length())
|
|
{
|
|
//
|
|
// Attempt to open the CD drive. If we can't, we will fail gracefully and open the staging area
|
|
//
|
|
SHELLEXECUTEINFO ShellExecuteInfo = {0};
|
|
ShellExecuteInfo.cbSize = sizeof(ShellExecuteInfo);
|
|
ShellExecuteInfo.hwnd = m_hWnd;
|
|
ShellExecuteInfo.nShow = SW_SHOW;
|
|
ShellExecuteInfo.lpVerb = TEXT("open");
|
|
ShellExecuteInfo.lpFile = const_cast<LPTSTR>(strShellLocation.String());
|
|
if (ShellExecuteEx( &ShellExecuteInfo ))
|
|
{
|
|
bNeedToOpenShellFolder = false;
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((HRESULT_FROM_WIN32(GetLastError()),TEXT("ShellExecuteEx failed")));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we still need to open the shell folder, do so.
|
|
//
|
|
if (bNeedToOpenShellFolder)
|
|
{
|
|
CSimpleDynamicArray<CSimpleString> DownloadedFiles;
|
|
if (SUCCEEDED(m_pControllerWindow->m_DownloadedFileInformationList.GetUniqueFiles(DownloadedFiles)))
|
|
{
|
|
OpenShellFolder::OpenShellFolderAndSelectFile( GetParent(m_hWnd), DownloadedFiles );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CCommonFinishPage::OpenRemoteStorage()
|
|
{
|
|
CWaitCursor wc;
|
|
if (m_strSiteUrl.Length())
|
|
{
|
|
SHELLEXECUTEINFO ShellExecuteInfo = {0};
|
|
ShellExecuteInfo.cbSize = sizeof(ShellExecuteInfo);
|
|
ShellExecuteInfo.fMask = SEE_MASK_FLAG_NO_UI;
|
|
ShellExecuteInfo.nShow = SW_SHOWNORMAL;
|
|
ShellExecuteInfo.lpFile = const_cast<LPTSTR>(m_strSiteUrl.String());
|
|
ShellExecuteInfo.lpVerb = TEXT("open");
|
|
ShellExecuteEx(&ShellExecuteInfo);
|
|
}
|
|
}
|
|
|
|
|
|
LRESULT CCommonFinishPage::OnEventNotification( WPARAM, LPARAM lParam )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CCommonFinishPage::OnEventNotification") ));
|
|
CGenericWiaEventHandler::CEventMessage *pEventMessage = reinterpret_cast<CGenericWiaEventHandler::CEventMessage *>(lParam);
|
|
if (pEventMessage)
|
|
{
|
|
if (pEventMessage->EventId() == WIA_EVENT_DEVICE_DISCONNECTED)
|
|
{
|
|
if (PropSheet_GetCurrentPageHwnd(GetParent(m_hWnd)) == m_hWnd)
|
|
{
|
|
//
|
|
// If there were any errors, disable back, since we can't upload
|
|
//
|
|
if (S_OK != m_pControllerWindow->m_hrDownloadResult || m_pControllerWindow->m_bDownloadCancelled)
|
|
{
|
|
//
|
|
// Disable "back"
|
|
//
|
|
PropSheet_SetWizButtons( GetParent(m_hWnd), PSWIZB_FINISH );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Don't delete the message, it is deleted in the controller window
|
|
//
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CCommonFinishPage::OnCommand( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
SC_BEGIN_COMMAND_HANDLERS()
|
|
{
|
|
}
|
|
SC_END_COMMAND_HANDLERS();
|
|
}
|
|
|
|
|
|
|
|
LRESULT CCommonFinishPage::OnHyperlinkClick( WPARAM, LPARAM lParam )
|
|
{
|
|
LRESULT lResult = FALSE;
|
|
NMLINK *pNmLink = reinterpret_cast<NMLINK*>(lParam);
|
|
if (pNmLink)
|
|
{
|
|
WIA_TRACE((TEXT("ID: %s"),pNmLink->item.szID));
|
|
switch (pNmLink->hdr.idFrom)
|
|
{
|
|
case IDC_FINISH_STATUS:
|
|
{
|
|
if (!lstrcmp(pNmLink->item.szID,STR_DETAILED_DOWNLOAD_ERROR_ID))
|
|
{
|
|
CSimpleString strMessage( IDS_TRANSFER_ERROR, g_hInstance );
|
|
strMessage += m_pControllerWindow->m_strErrorMessage;
|
|
CMessageBoxEx::MessageBox( m_hWnd, strMessage, CSimpleString( IDS_ERROR_TITLE, g_hInstance ), CMessageBoxEx::MBEX_OK|CMessageBoxEx::MBEX_ICONWARNING );
|
|
lResult = TRUE;
|
|
}
|
|
else if (!lstrcmp(pNmLink->item.szID,STR_DETAILED_UPLOAD_ERROR_ID))
|
|
{
|
|
CSimpleString strMessage( IDS_UPLOAD_ERROR, g_hInstance );
|
|
CSimpleString strError = WiaUiUtil::GetErrorTextFromHResult(m_pControllerWindow->m_hrUploadResult);
|
|
if (!strError.Length())
|
|
{
|
|
strError.Format( CSimpleString( IDS_TRANSFER_ERROR_OCCURRED, g_hInstance ), m_pControllerWindow->m_hrUploadResult );
|
|
}
|
|
strMessage += strError;
|
|
CMessageBoxEx::MessageBox( m_hWnd, strMessage, CSimpleString( IDS_ERROR_TITLE, g_hInstance ), CMessageBoxEx::MBEX_OK|CMessageBoxEx::MBEX_ICONWARNING );
|
|
lResult = TRUE;
|
|
}
|
|
else if (!lstrcmp(pNmLink->item.szID,STR_LOCAL_LINK_ID))
|
|
{
|
|
OpenLocalStorage();
|
|
lResult = TRUE;
|
|
}
|
|
else if (!lstrcmp(pNmLink->item.szID,STR_REMOTE_LINK_ID))
|
|
{
|
|
OpenRemoteStorage();
|
|
lResult = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return lResult;
|
|
}
|
|
|
|
LRESULT CCommonFinishPage::OnNotify( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
SC_BEGIN_NOTIFY_MESSAGE_HANDLERS()
|
|
{
|
|
SC_HANDLE_NOTIFY_MESSAGE_CONTROL(NM_RETURN,IDC_FINISH_STATUS,OnHyperlinkClick);
|
|
SC_HANDLE_NOTIFY_MESSAGE_CONTROL(NM_CLICK,IDC_FINISH_STATUS,OnHyperlinkClick);
|
|
SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_WIZBACK,OnWizBack);
|
|
SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_WIZFINISH,OnWizFinish);
|
|
SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_SETACTIVE,OnSetActive);
|
|
}
|
|
SC_END_NOTIFY_MESSAGE_HANDLERS();
|
|
}
|
|
|
|
INT_PTR CALLBACK CCommonFinishPage::DialogProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
SC_BEGIN_DIALOG_MESSAGE_HANDLERS(CCommonFinishPage)
|
|
{
|
|
SC_HANDLE_DIALOG_MESSAGE( WM_INITDIALOG, OnInitDialog );
|
|
SC_HANDLE_DIALOG_MESSAGE( WM_COMMAND, OnCommand );
|
|
SC_HANDLE_DIALOG_MESSAGE( WM_DESTROY, OnDestroy );
|
|
SC_HANDLE_DIALOG_MESSAGE( WM_NOTIFY, OnNotify );
|
|
}
|
|
SC_HANDLE_REGISTERED_DIALOG_MESSAGE( m_nWiaEventMessage, OnEventNotification );
|
|
SC_END_DIALOG_MESSAGE_HANDLERS();
|
|
}
|
|
|