/*******************************************************************************
 *
 *  (C) COPYRIGHT MICROSOFT CORPORATION, 1998
 *
 *  TITLE:       COMPROG.CPP
 *
 *  VERSION:     1.0
 *
 *  AUTHOR:      ShaunIv
 *
 *  DATE:        9/28/1999
 *
 *  DESCRIPTION: Download progress dialog.  Displays the thumbnail and download progress.
 *
 *******************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include <commctrl.h>
#include "comprog.h"
#include "resource.h"
#include "pviewids.h"
#include "simcrack.h"
#include "gwiaevnt.h"
#include "mboxex.h"
#include "runnpwiz.h"

#define PWM_SETDEFBUTTON (WM_USER+1)

CCommonProgressPage::CCommonProgressPage( HWND hWnd )
  : m_hWnd(hWnd),
    m_pControllerWindow(NULL),
    m_hCancelDownloadEvent(CreateEvent(NULL,TRUE,FALSE,TEXT(""))),
    m_nThreadNotificationMessage(RegisterWindowMessage(STR_THREAD_NOTIFICATION_MESSAGE)),
    m_nWiaEventMessage(RegisterWindowMessage(STR_WIAEVENT_NOTIFICATION_MESSAGE)),
    m_hSwitchToNextPage(NULL),
    m_bQueryingUser(false)
{
}

CCommonProgressPage::~CCommonProgressPage(void)
{
    m_hWnd = NULL;
    m_pControllerWindow = NULL;
    if (m_hCancelDownloadEvent)
    {
        CloseHandle(m_hCancelDownloadEvent);
        m_hCancelDownloadEvent = NULL;
    }
}


void CCommonProgressPage::UpdatePercentComplete( int nPercent, bool bUploading )
{
    if (nPercent >= 0)
    {
        int nPercentStringResId;
        if (bUploading)
        {
            nPercentStringResId = IDS_PERCENT_COMPLETE_UPLOADING;
        }
        else
        {
            // Assume copying is the appropropriate description
            nPercentStringResId = IDS_PERCENT_COMPLETE_COPYING;
            switch (m_pControllerWindow->m_DeviceTypeMode)
            {
            case CAcquisitionManagerControllerWindow::ScannerMode:
                nPercentStringResId = IDS_PERCENT_COMPLETE_SCANNING;
                break;
            };
        }

        SendDlgItemMessage( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS, PBM_SETPOS, nPercent, 0 );
        CSimpleString().Format( nPercentStringResId, g_hInstance, nPercent ).SetWindowText( GetDlgItem( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS_TEXT ) );
    }
    else
    {
        SendDlgItemMessage( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS, PBM_SETPOS, 0, 0 );
        SendDlgItemMessage( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS_TEXT, WM_SETTEXT, 0, reinterpret_cast<LPARAM>("") );
    }
}

void CCommonProgressPage::UpdateCurrentPicture( int nPicture )
{
    if (nPicture >= 0)
    {
        SendDlgItemMessage( m_hWnd, IDC_COMPROG_CURRENTIMAGE, PBM_SETPOS, nPicture, 0 );
        CSimpleString().Format( IDS_FILEN_OF_M, g_hInstance, nPicture+1, m_nPictureCount ).SetWindowText( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTIMAGE_TEXT ) );
    }
    else
    {
        SendDlgItemMessage( m_hWnd, IDC_COMPROG_CURRENTIMAGE, PBM_SETPOS, 0, 0 );
        SendDlgItemMessage( m_hWnd, IDC_COMPROG_CURRENTIMAGE_TEXT, WM_SETTEXT, 0, reinterpret_cast<LPARAM>("") );
    }
}

void CCommonProgressPage::UpdateThumbnail( HBITMAP hBitmap, CWiaItem *pWiaItem )
{
    WIA_PUSH_FUNCTION((TEXT("CCommonProgressPage::UpdateThumbnail( HBITMAP hBitmap=0x%08X, CWiaItem *pWiaItem=0x%08X )"), hBitmap, pWiaItem ));


    HWND hWndPreview = GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL );
    if (hWndPreview)
    {
        if (pWiaItem && m_pControllerWindow && hBitmap)
        {
            switch (m_pControllerWindow->m_DeviceTypeMode)
            {
            case CAcquisitionManagerControllerWindow::ScannerMode:
                {
                    //
                    // If the item has a bitmap image, it already has a preview scan available
                    //
                    WIA_TRACE((TEXT("pWiaItem->BitmapImage() = %08X"), pWiaItem->BitmapImage() ));
                    if (pWiaItem->BitmapImage())
                    {
                        //
                        // Hide the preview window while we are futzing with it
                        //
                        ShowWindow( hWndPreview, SW_HIDE );

                        //
                        // Crop the image to the selected region
                        //
                        WiaPreviewControl_SetResolution( hWndPreview, &pWiaItem->ScanRegionSettings().sizeResolution );
                        WiaPreviewControl_SetSelOrigin( hWndPreview, 0, FALSE, &pWiaItem->ScanRegionSettings().ptOrigin );
                        WiaPreviewControl_SetSelExtent( hWndPreview, 0, FALSE, &pWiaItem->ScanRegionSettings().sizeExtent );

                        //
                        // Set the control to preview mode
                        //
                        WiaPreviewControl_SetPreviewMode( hWndPreview, TRUE );

                        //
                        // If this is a scanner item, we don't want to let the preview control take ownership of the bitmap.
                        // We don't want it to be deleted
                        //
                        WiaPreviewControl_SetBitmap( hWndPreview, TRUE, TRUE, hBitmap );

                        //
                        // Show the preview window
                        //
                        ShowWindow( hWndPreview, SW_SHOW );
                    }
                    else
                    {
                        //
                        // This means we are getting a preview image from the driver
                        // We don't want to delete this image
                        //
                        WiaPreviewControl_SetBitmap( hWndPreview, TRUE, TRUE, hBitmap );

                        //
                        // Make sure the window is visible
                        //
                        ShowWindow( hWndPreview, SW_SHOW );
                    }
                }
                break;

            default:
                {
                    //
                    // Go ahead and rotate the bitmap, even if it isn't necessary.
                    //
                    HBITMAP hRotatedThumbnail = NULL;
                    if (SUCCEEDED(m_GdiPlusHelper.Rotate( hBitmap, hRotatedThumbnail, pWiaItem->Rotation())))
                    {
                        //
                        // Set it to the rotated bitmap, and ALLOW this bitmap to be deleted
                        //
                        WiaPreviewControl_SetBitmap( hWndPreview, TRUE, FALSE, hRotatedThumbnail );
                    }

                    //
                    // Make sure the window is visible
                    //
                    ShowWindow( hWndPreview, SW_SHOW );

                    //
                    // Delete the source bitmap
                    //
                    DeleteObject(hBitmap);
                }
            }
        }
        else
        {
            ShowWindow( hWndPreview, SW_HIDE );
            WiaPreviewControl_SetBitmap( hWndPreview, TRUE, TRUE, NULL );
        }
    }
}


LRESULT CCommonProgressPage::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;
    }


    //
    // Prepare the preview control
    //
    HWND hWndThumbnail = GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL );
    if (hWndThumbnail)
    {
        //
        // We only want to set the preview mode for scanners
        //
        if (CAcquisitionManagerControllerWindow::ScannerMode==m_pControllerWindow->m_DeviceTypeMode)
        {
            WiaPreviewControl_SetPreviewMode( hWndThumbnail, TRUE );
        }
        else
        {
            WiaPreviewControl_AllowNullSelection( hWndThumbnail, TRUE );
            WiaPreviewControl_ClearSelection( hWndThumbnail );
        }
        WiaPreviewControl_SetBgAlpha( hWndThumbnail, FALSE, 0xFF );
        WiaPreviewControl_DisableSelection( hWndThumbnail, TRUE );
        WiaPreviewControl_SetEnableStretch( hWndThumbnail, FALSE );
        WiaPreviewControl_SetBkColor( hWndThumbnail, FALSE, TRUE, GetSysColor(COLOR_WINDOW) );
        WiaPreviewControl_HideEmptyPreview( hWndThumbnail, TRUE );
        WiaPreviewControl_SetPreviewAlignment( hWndThumbnail, PREVIEW_WINDOW_CENTER, PREVIEW_WINDOW_CENTER, FALSE );

    }

    return 0;
}

void CCommonProgressPage::OnNotifyDownloadError( UINT nMsg, CThreadNotificationMessage *pThreadNotificationMessage )
{
    WIA_PUSH_FUNCTION((TEXT("CCommonProgressPage::OnNotifyDownloadError")));
    CDownloadErrorNotificationMessage *pDownloadErrorNotificationMessage = dynamic_cast<CDownloadErrorNotificationMessage*>(pThreadNotificationMessage);
    if (pDownloadErrorNotificationMessage && m_pControllerWindow)
    {
        pDownloadErrorNotificationMessage->Handled();
        if (m_pControllerWindow->m_bDisconnected)
        {
            pDownloadErrorNotificationMessage->Response( IDCANCEL );
        }
        else
        {
            WIA_TRACE((TEXT("MessageBox flags: %08X"), pDownloadErrorNotificationMessage->MessageBoxFlags() ));
            int nResponse = CMessageBoxEx::MessageBox( m_hWnd, pDownloadErrorNotificationMessage->Message(), CSimpleString( IDS_ERROR_TITLE, g_hInstance ), pDownloadErrorNotificationMessage->MessageBoxFlags() );
            pDownloadErrorNotificationMessage->Response( nResponse );
        }
    }
}

void CCommonProgressPage::OnNotifyDownloadImage( UINT nMsg, CThreadNotificationMessage *pThreadNotificationMessage )
{
    WIA_PUSHFUNCTION(TEXT("CCommonProgressPage::OnNotifyDownloadImage"));
    CDownloadImagesThreadNotifyMessage *pDownloadImageThreadNotifyMessage = dynamic_cast<CDownloadImagesThreadNotifyMessage*>(pThreadNotificationMessage);
    if (pDownloadImageThreadNotifyMessage && m_pControllerWindow)
    {
        switch (pDownloadImageThreadNotifyMessage->Status())
        {
        case CDownloadImagesThreadNotifyMessage::Begin:
            {
                switch (pDownloadImageThreadNotifyMessage->Operation())
                {
                case CDownloadImagesThreadNotifyMessage::DownloadAll:
                    {
                        //
                        // Store the number of images we'll be downloading
                        //
                        m_nPictureCount = pDownloadImageThreadNotifyMessage->PictureCount();

                        //
                        // Show the current picture controls if there are multiple pictures being downloaded
                        //
                        if (m_nPictureCount > 1)
                        {
                            ShowWindow( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTIMAGE_TEXT ), SW_SHOW );
                            ShowWindow( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTIMAGE ), SW_SHOW );
                        }

                        //
                        // Initialize current image count progress bar
                        //
                        SendDlgItemMessage( m_hWnd, IDC_COMPROG_CURRENTIMAGE, PBM_SETRANGE32, 0, m_nPictureCount);
                        UpdateCurrentPicture(0);

                        //
                        // Enable the file download progress controls
                        //
                        EnableWindow( GetDlgItem( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS_TEXT ), TRUE );
                        EnableWindow( GetDlgItem( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS ), TRUE );

                        //
                        // Initialize download progress bar
                        //
                        SendDlgItemMessage( m_hWnd, IDC_COMPROG_DOWNLOADPROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0,100));
                        UpdatePercentComplete(0,false);
                    }
                    break;

                case CDownloadImagesThreadNotifyMessage::DownloadImage:
                    {
                        //
                        // Display thumbnail
                        //
                        HBITMAP hBitmapThumbnail = NULL;
                        CWiaItem *pWiaItem = m_pControllerWindow->m_WiaItemList.Find( pDownloadImageThreadNotifyMessage->Cookie() );
                        if (pWiaItem)
                        {
                            //
                            // This will only work if it is a scanner item
                            //
                            hBitmapThumbnail = pWiaItem->BitmapImage();
                            if (!hBitmapThumbnail)
                            {
                                //
                                // Since it didn't work, this is a camera item, so create a thumbnail.
                                // We have to make sure we nuke this bitmap or it is a leak!
                                //
                                HDC hDC = GetDC(NULL);
                                if (hDC)
                                {
                                    hBitmapThumbnail = pWiaItem->CreateThumbnailBitmap(hDC);
                                    ReleaseDC( NULL, hDC );
                                }
                            }
                        }
                        else
                        {
                            WIA_ERROR((TEXT("Unable to find the item with the cookie %08X"), pDownloadImageThreadNotifyMessage->Cookie() ));
                        }

                        //
                        // Update the thumbnail in the progress window
                        //
                        UpdateThumbnail( hBitmapThumbnail, pWiaItem );

                        //
                        // Increment file queue progress
                        //
                        UpdateCurrentPicture(pDownloadImageThreadNotifyMessage->CurrentPicture());

                        //
                        // Clear file download progress
                        //
                        UpdatePercentComplete(0,false);

                        //
                        // Display the filename we are downloading
                        //
                        TCHAR szFileTitle[MAX_PATH] = TEXT("");
                        GetFileTitle( pDownloadImageThreadNotifyMessage->Filename(), szFileTitle, ARRAYSIZE(szFileTitle) );
                        SetDlgItemText( m_hWnd, IDC_COMPROG_IMAGENAME, szFileTitle );
                    }
                    break;

                case CDownloadImagesThreadNotifyMessage::PreviewImage:
                    {
                        CWiaItem *pWiaItem = m_pControllerWindow->m_WiaItemList.Find( pDownloadImageThreadNotifyMessage->Cookie() );
                        if (pWiaItem && !pWiaItem->BitmapImage() && !pWiaItem->BitmapData())
                        {
                            UpdateThumbnail( pDownloadImageThreadNotifyMessage->PreviewBitmap(), pWiaItem );
                        }
                    }
                    break;
                }
            }
            break;

        case CDownloadImagesThreadNotifyMessage::Update:
            {
                switch (pDownloadImageThreadNotifyMessage->Operation())
                {
                case CDownloadImagesThreadNotifyMessage::DownloadImage:
                    {
                        //
                        // Update file download progress
                        //
                        UpdatePercentComplete(pDownloadImageThreadNotifyMessage->PercentComplete(),false);
                    }
                    break;
                case CDownloadImagesThreadNotifyMessage::PreviewImage:
                    {
                        CWiaItem *pWiaItem = m_pControllerWindow->m_WiaItemList.Find( pDownloadImageThreadNotifyMessage->Cookie() );
                        if (pWiaItem && !pWiaItem->BitmapImage() && !pWiaItem->BitmapData())
                        {
                            WiaPreviewControl_RefreshBitmap( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ) );
                        }
                    }
                    break;
                }
            }
            break;

        case CDownloadImagesThreadNotifyMessage::End:
            switch (pDownloadImageThreadNotifyMessage->Operation())
            {
            case CDownloadImagesThreadNotifyMessage::DownloadImage:
                {
                    if (!SUCCEEDED(pDownloadImageThreadNotifyMessage->hr()))
                    {
                        //
                        // Clear the thumbnail in the progress window
                        //
                        UpdateThumbnail( NULL, NULL );
                        
                        //
                        // Clear file download progress
                        //
                        UpdatePercentComplete(0,false);

                        //
                        // Increment file queue progress
                        //
                        UpdateCurrentPicture(pDownloadImageThreadNotifyMessage->CurrentPicture());

                        //
                        // Clear the filename
                        //
                        SetDlgItemText( m_hWnd, IDC_COMPROG_IMAGENAME, TEXT("") );
                    }
                    else
                    {
                        //
                        // Update file download progress
                        //
                        UpdatePercentComplete(100,false);
                    }
                }
                break;

            case CDownloadImagesThreadNotifyMessage::DownloadAll:
                {
                    //
                    // Clear the filename when we are all done
                    //
                    SetDlgItemText( m_hWnd, IDC_COMPROG_IMAGENAME, TEXT("") );
                    
                    CSimpleString strMessage;

                    if (FAILED(pDownloadImageThreadNotifyMessage->hr()))
                    {
                        WIA_PRINTHRESULT((pDownloadImageThreadNotifyMessage->hr(),TEXT("CDownloadImagesThreadNotifyMessage::DownloadAll (%s)"), pDownloadImageThreadNotifyMessage->ExtendedErrorInformation().String()));
                        
                        //
                        // If we already have a good error message, let's use it
                        //
                        if (pDownloadImageThreadNotifyMessage->ExtendedErrorInformation().Length())
                        {
                            strMessage = pDownloadImageThreadNotifyMessage->ExtendedErrorInformation();
                        }
                        else
                        {
                            //
                            // If we haven't already created a good error message, and we think we can here, let's do it
                            //
                            switch (pDownloadImageThreadNotifyMessage->hr())
                            {
                            case HRESULT_FROM_WIN32(ERROR_DISK_FULL):
                                strMessage.LoadString( IDS_DISKFULL, g_hInstance );
                                break;

                            case HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE):
                                strMessage.LoadString( IDS_UNABLETOTRANSFER, g_hInstance );
                                break;

                            case WIA_ERROR_PAPER_JAM:
                                strMessage.LoadString( IDS_WIA_ERROR_PAPER_JAM, g_hInstance );
                                break;

                            case WIA_ERROR_PAPER_EMPTY:
                                strMessage.LoadString( IDS_WIA_ERROR_PAPER_EMPTY, g_hInstance );
                                break;

                            case WIA_ERROR_PAPER_PROBLEM:
                                strMessage.LoadString( IDS_WIA_ERROR_PAPER_PROBLEM, g_hInstance );
                                break;

                            case WIA_ERROR_OFFLINE:
                                strMessage.LoadString( IDS_WIA_ERROR_OFFLINE, g_hInstance );
                                break;

                            case WIA_ERROR_BUSY:
                                strMessage.LoadString( IDS_WIA_ERROR_BUSY, g_hInstance );
                                break;

                            case WIA_ERROR_WARMING_UP:
                                strMessage.LoadString( IDS_WIA_ERROR_WARMING_UP, g_hInstance );
                                break;

                            case WIA_ERROR_USER_INTERVENTION:
                                strMessage.LoadString( IDS_WIA_ERROR_USER_INTERVENTION, g_hInstance );
                                break;

                            case WIA_ERROR_ITEM_DELETED:
                                strMessage.LoadString( IDS_WIA_ERROR_ITEM_DELETED, g_hInstance );
                                break;

                            case WIA_ERROR_DEVICE_COMMUNICATION:
                                strMessage.LoadString( IDS_WIA_ERROR_DEVICE_COMMUNICATION, g_hInstance );
                                break;

                            case WIA_ERROR_INVALID_COMMAND:
                                strMessage.LoadString( IDS_WIA_ERROR_INVALID_COMMAND, g_hInstance );
                                break;

                            case WIA_ERROR_INCORRECT_HARDWARE_SETTING:
                                strMessage.LoadString( IDS_WIA_ERROR_INCORRECT_HARDWARE_SETTING, g_hInstance );
                                break;

                            case WIA_ERROR_DEVICE_LOCKED:
                                strMessage.LoadString( IDS_WIA_ERROR_DEVICE_LOCKED, g_hInstance );
                                break;

                            default:
                                strMessage = WiaUiUtil::GetErrorTextFromHResult(pDownloadImageThreadNotifyMessage->hr());
                                if (!strMessage.Length())
                                {
                                    strMessage.Format( CSimpleString( IDS_TRANSFER_ERROR_OCCURRED, g_hInstance ), pDownloadImageThreadNotifyMessage->hr() );
                                }
                                break;
                            }
                        }
                        WIA_TRACE((TEXT("strMessage: (%s)"), strMessage.String()));

                        //
                        // Tell the user something bad happened.  Save the error message.
                        //
                        m_pControllerWindow->m_strErrorMessage = strMessage;
                    }

                    //
                    // Save the hresult
                    //
                    m_pControllerWindow->m_hrDownloadResult = pDownloadImageThreadNotifyMessage->hr();

                    //
                    // Just to be sure we catch cancels
                    //
                    if (S_FALSE == m_pControllerWindow->m_hrDownloadResult)
                    {
                        m_pControllerWindow->m_bDownloadCancelled = true;
                    }

                    //
                    // Continue downloading thumbnails, in case it was paused
                    //
                    m_pControllerWindow->DownloadAllThumbnails();

                    //
                    // Go to the next page.  Assume it will be the upload query page.
                    //
                    HPROPSHEETPAGE hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nFinishPageIndex );

                    //
                    // If the transfer was successful
                    //
                    if (!m_pControllerWindow->m_bDownloadCancelled && S_OK==m_pControllerWindow->m_hrDownloadResult)
                    {
                        //
                        // If we are deleting from the device, send us to the delete progress page
                        //
                        if (m_pControllerWindow->m_bDeletePicturesIfSuccessful)
                        {
                            hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nDeleteProgressPageIndex );
                        }

                        //
                        // Otherwise, go to the upload query page
                        //
                        else
                        {
                            hNextPage = PropSheet_IndexToPage( GetParent(m_hWnd), m_pControllerWindow->m_nUploadQueryPageIndex );
                        }
                    }

                    //
                    // If there is a message box active, save this page till the message box is dismissed
                    //
                    if (m_bQueryingUser)
                    {
                        m_hSwitchToNextPage = hNextPage;
                    }
                    else
                    {
                        //
                        // Set the next page
                        //
                        PropSheet_SetCurSel( GetParent(m_hWnd), hNextPage, -1 );
                    }

                }
                break;

            case CDownloadImagesThreadNotifyMessage::PreviewImage:
                {
                    CWiaItem *pWiaItem = m_pControllerWindow->m_WiaItemList.Find( pDownloadImageThreadNotifyMessage->Cookie() );
                    UpdateThumbnail( NULL, pWiaItem );
                }
                break;
            }
        }
    }
}

LRESULT CCommonProgressPage::OnSetActive( WPARAM, LPARAM )
{
    //
    // Make sure we have a valid controller window
    //
    if (!m_pControllerWindow)
    {
        return -1;
    }

    //
    // Initialize the download error message
    //
    m_pControllerWindow->m_strErrorMessage = TEXT("");

    //
    // Initialize the download result
    //
    m_pControllerWindow->m_hrDownloadResult = S_OK;

    //
    // Initialize upload result to S_OK
    //
    m_pControllerWindow->m_hrUploadResult = S_OK;

    //
    // Initialize delete result to E_FAIL
    //
    m_pControllerWindow->m_hrDeleteResult = E_FAIL;

    //
    // Reset the cancelled flag
    //
    m_pControllerWindow->m_bDownloadCancelled = false;

    //
    // Clear the downloaded file list
    //
    m_pControllerWindow->m_DownloadedFileInformationList.Destroy();

    //
    // Clear all of the controls
    //
    UpdatePercentComplete(-1,false);
    UpdateCurrentPicture(-1);
    UpdateThumbnail(NULL,NULL);

    //
    // Reset the selected region, in case this is a scanner
    //
    WiaPreviewControl_SetResolution( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), NULL );
    WiaPreviewControl_SetSelOrigin( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), 0, FALSE, NULL );
    WiaPreviewControl_SetSelExtent( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), 0, FALSE, NULL );

    //
    // Set the control to preview mode
    //
    WiaPreviewControl_SetPreviewMode( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), TRUE );

    //
    // Reset the download event cancel
    //
    if (m_hCancelDownloadEvent)
    {
        ResetEvent(m_hCancelDownloadEvent);
    }

    //
    // Cancel thumbnail downloading
    //
    m_pControllerWindow->m_EventThumbnailCancel.Signal();


    //
    //  Start the download
    //
    if (!m_pControllerWindow->DownloadSelectedImages(m_hCancelDownloadEvent))
    {
        WIA_ERROR((TEXT("m_pControllerWindow->DownloadSelectedImages FAILED!")));
        MessageBox( m_hWnd, CSimpleString( IDS_UNABLETOTRANSFER, g_hInstance ), CSimpleString( IDS_ERROR_TITLE, g_hInstance ), MB_ICONHAND );
        return -1;
    }

    //
    // Tell the user where the pictures are going
    //
    CSimpleString strDestinationDisplayName = m_pControllerWindow->m_CurrentDownloadDestination.DisplayName(m_pControllerWindow->m_DestinationNameData);
    strDestinationDisplayName.SetWindowText( GetDlgItem( m_hWnd, IDC_COMPROG_DESTNAME) );
    SendDlgItemMessage( m_hWnd, IDC_COMPROG_DESTNAME, EM_SETSEL, strDestinationDisplayName.Length(), strDestinationDisplayName.Length() );
    SendDlgItemMessage( m_hWnd, IDC_COMPROG_DESTNAME, EM_SCROLLCARET, 0, 0 );

    //
    // Hide the current image controls in case there is only one image
    //
    ShowWindow( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTIMAGE_TEXT ), SW_HIDE );
    ShowWindow( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTIMAGE ), SW_HIDE );

    //
    // No next, back or finish
    //
    PropSheet_SetWizButtons( GetParent(m_hWnd), 0 );

    //
    // We do want to exit on disconnect if we are on this page
    //
    m_pControllerWindow->m_OnDisconnect = CAcquisitionManagerControllerWindow::OnDisconnectGotoLastpage|CAcquisitionManagerControllerWindow::OnDisconnectFailDownload|CAcquisitionManagerControllerWindow::OnDisconnectFailUpload|CAcquisitionManagerControllerWindow::OnDisconnectFailDelete|CAcquisitionManagerControllerWindow::DontAllowSuspend;

    return 0;
}


LRESULT CCommonProgressPage::OnWizNext( WPARAM, LPARAM )
{
    return 0;
}


LRESULT CCommonProgressPage::OnWizBack( WPARAM, LPARAM )
{
    return 0;
}

LRESULT CCommonProgressPage::OnReset( WPARAM, LPARAM )
{
    //
    // Cancel the current download
    //
    if (m_hCancelDownloadEvent)
    {
        SetEvent(m_hCancelDownloadEvent);
    }
    return 0;
}

LRESULT CCommonProgressPage::OnEventNotification( WPARAM, LPARAM lParam )
{
    WIA_PUSHFUNCTION(TEXT("CCommonFirstPage::OnEventNotification"));
    CGenericWiaEventHandler::CEventMessage *pEventMessage = reinterpret_cast<CGenericWiaEventHandler::CEventMessage *>(lParam);
    if (pEventMessage)
    {
        //
        // Don't delete the message, it is deleted in the controller window
        //
    }
    return 0;
}

bool CCommonProgressPage::QueryCancel(void)
{
    //
    //  Make sure this is the current page
    //
    if (PropSheet_GetCurrentPageHwnd(GetParent(m_hWnd)) != m_hWnd)
    {
        return true;
    }

    //
    // Pause the background thread
    //
    m_pControllerWindow->m_EventPauseBackgroundThread.Reset();

    //
    // Assume the user doesn't want to cancel
    //
    bool bResult = false;

    //
    // Set the querying user flag so the event handler won't change pages
    //
    m_bQueryingUser = true;

    //
    // We may be called on to switch pages when we are done here.  If so, this will be non-NULL then.
    //
    m_hSwitchToNextPage = NULL;

    //
    // Don't ask again if we've already asked
    //
    if (!m_pControllerWindow->m_bDownloadCancelled)
    {
        //
        // Ask the user if they want to cancel
        //
        if (CMessageBoxEx::IDMBEX_YES == CMessageBoxEx::MessageBox( m_hWnd, CSimpleString(IDS_CONFIRM_CANCEL_DOWNLOAD,g_hInstance), CSimpleString(IDS_ERROR_TITLE,g_hInstance), CMessageBoxEx::MBEX_YESNO|CMessageBoxEx::MBEX_ICONQUESTION ))
        {
            //
            // The user does want to cancel, so set the cancel event, set the cancel flag and return false
            //
            m_pControllerWindow->m_bDownloadCancelled = true;

            //
            // Tell the device to cancel the current operation
            //
            WiaUiUtil::IssueWiaCancelIO(m_pControllerWindow->m_pWiaItemRoot);
            
            //
            // Make sure the cancel button is disabled
            //
            EnableWindow( GetDlgItem( GetParent(m_hWnd), IDCANCEL ), FALSE );

            //
            // Set the event that tells the background thread to stop transferring images
            //
            if (m_hCancelDownloadEvent)
            {
                SetEvent(m_hCancelDownloadEvent);
            }

            //
            // Return true to indicate we are cancelling
            //
            bResult = true;
        }
    }

    //
    // If we are supposed to switch pages, switch now
    //
    if (m_hSwitchToNextPage)
    {
        PropSheet_SetCurSel( GetParent(m_hWnd), m_hSwitchToNextPage, -1 );
    }

    //
    // Reset the querying user flag so the event handler can change pages as needed
    //
    m_bQueryingUser = false;

    //
    // Unpause the background thread
    //
    m_pControllerWindow->m_EventPauseBackgroundThread.Signal();

    return bResult;
}

LRESULT CCommonProgressPage::OnQueryCancel( WPARAM, LPARAM )
{
    //
    // The user is not allowed to cancel out of this page
    //
    BOOL bResult = TRUE;

    //
    // Since we don't let them cancel in this page, just ignore the result
    //
    QueryCancel();


    return bResult;
}


LRESULT CCommonProgressPage::OnKillActive( WPARAM, LPARAM )
{
    //
    // If we cancelled, make sure we delete any already downloaded files here.
    //
    if (m_pControllerWindow->m_bDownloadCancelled)
    {
        m_pControllerWindow->m_DownloadedFileInformationList.DeleteAllFiles();
    }

    //
    // Make sure the cancel button is enabled
    //
    EnableWindow( GetDlgItem( GetParent(m_hWnd), IDCANCEL ), TRUE );

    return 0;
}


LRESULT CCommonProgressPage::OnQueryEndSession( WPARAM, LPARAM )
{
    bool bCancel = QueryCancel();
    if (bCancel)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

LRESULT CCommonProgressPage::OnSysColorChange( WPARAM wParam, LPARAM lParam )
{
    WiaPreviewControl_SetBkColor( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), TRUE, TRUE, GetSysColor(COLOR_WINDOW) );
    WiaPreviewControl_SetBkColor( GetDlgItem( m_hWnd, IDC_COMPROG_CURRENTTHUMBNAIL ), TRUE, FALSE, GetSysColor(COLOR_WINDOW) );
    return 0;
}

LRESULT CCommonProgressPage::OnCommand( WPARAM wParam, LPARAM lParam )
{
    SC_BEGIN_COMMAND_HANDLERS()
    {
    }
    SC_END_COMMAND_HANDLERS();
}

LRESULT CCommonProgressPage::OnThreadNotification( WPARAM wParam, LPARAM lParam )
{
    WTM_BEGIN_THREAD_NOTIFY_MESSAGE_HANDLERS()
    {
        WTM_HANDLE_NOTIFY_MESSAGE( TQ_DOWNLOADIMAGE, OnNotifyDownloadImage );
        WTM_HANDLE_NOTIFY_MESSAGE( TQ_DOWNLOADERROR, OnNotifyDownloadError );
    }
    WTM_END_THREAD_NOTIFY_MESSAGE_HANDLERS();
}

LRESULT CCommonProgressPage::OnNotify( WPARAM wParam, LPARAM lParam )
{
    SC_BEGIN_NOTIFY_MESSAGE_HANDLERS()
    {
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_WIZBACK,OnWizBack);
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_WIZNEXT,OnWizNext);
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_SETACTIVE,OnSetActive);
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_KILLACTIVE,OnKillActive);
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_RESET,OnReset);
        SC_HANDLE_NOTIFY_MESSAGE_CODE(PSN_QUERYCANCEL,OnQueryCancel);
    }
    SC_END_NOTIFY_MESSAGE_HANDLERS();
}

INT_PTR CALLBACK CCommonProgressPage::DialogProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    SC_BEGIN_DIALOG_MESSAGE_HANDLERS(CCommonProgressPage)
    {
        SC_HANDLE_DIALOG_MESSAGE( WM_INITDIALOG, OnInitDialog );
        SC_HANDLE_DIALOG_MESSAGE( WM_COMMAND, OnCommand );
        SC_HANDLE_DIALOG_MESSAGE( WM_NOTIFY, OnNotify );
        SC_HANDLE_DIALOG_MESSAGE( WM_QUERYENDSESSION, OnQueryEndSession );
        SC_HANDLE_DIALOG_MESSAGE( WM_SYSCOLORCHANGE, OnSysColorChange );
    }
    SC_HANDLE_REGISTERED_DIALOG_MESSAGE( m_nThreadNotificationMessage, OnThreadNotification );
    SC_HANDLE_REGISTERED_DIALOG_MESSAGE( m_nWiaEventMessage, OnEventNotification );
    SC_END_DIALOG_MESSAGE_HANDLERS();
}