You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2531 lines
118 KiB
2531 lines
118 KiB
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORPORATION, 1998
|
|
*
|
|
* TITLE: THRDMSG.CPP
|
|
*
|
|
* VERSION: 1.0
|
|
*
|
|
* AUTHOR: ShaunIv
|
|
*
|
|
* DATE: 9/28/1999
|
|
*
|
|
* DESCRIPTION: These classes are instantiated for each message posted to the
|
|
* background thread. Each is derived from CThreadMessage, and
|
|
* is sent to the thread message handler.
|
|
*
|
|
*******************************************************************************/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include "itranhlp.h"
|
|
#include "isuppfmt.h"
|
|
#include "wiadevdp.h"
|
|
#include "acqmgrcw.h"
|
|
#include "propstrm.h"
|
|
#include "uiexthlp.h"
|
|
#include "flnfile.h"
|
|
#include "resource.h"
|
|
#include "itranspl.h"
|
|
#include "svselfil.h"
|
|
#include "uniqfile.h"
|
|
#include "mboxex.h"
|
|
#include "wiaffmt.h"
|
|
|
|
#define FILE_CREATION_MUTEX_NAME TEXT("Global\\WiaScannerAndCameraWizardFileNameCreationMutex")
|
|
|
|
#define UPLOAD_PROGRESS_GRANULARITY 10
|
|
|
|
#ifndef S_CONTINUE
|
|
#define S_CONTINUE ((HRESULT)0x00000002L)
|
|
#endif
|
|
|
|
//
|
|
// The delete progress page goes by too quickly, so we will slow it down here
|
|
//
|
|
#define DELETE_DELAY_BEFORE 1000
|
|
#define DELETE_DELAY_DURING 3000
|
|
#define DELETE_DELAY_AFTER 1000
|
|
|
|
//
|
|
// Some APIs claim to set the thread's last error, but don't
|
|
// For those which don't, we will return E_FAIL. This function
|
|
// will not return S_OK
|
|
//
|
|
inline HRESULT MY_HRESULT_FROM_WIN32( DWORD gle )
|
|
{
|
|
if (!gle)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
return HRESULT_FROM_WIN32(gle);
|
|
}
|
|
|
|
// -------------------------------------------------
|
|
// CGlobalInterfaceTableThreadMessage
|
|
// -------------------------------------------------
|
|
CGlobalInterfaceTableThreadMessage::CGlobalInterfaceTableThreadMessage( int nMessage, HWND hWndNotify, DWORD dwGlobalInterfaceTableCookie )
|
|
: CNotifyThreadMessage( nMessage, hWndNotify ),
|
|
m_dwGlobalInterfaceTableCookie(dwGlobalInterfaceTableCookie)
|
|
{
|
|
}
|
|
|
|
DWORD CGlobalInterfaceTableThreadMessage::GlobalInterfaceTableCookie(void) const
|
|
{
|
|
return(m_dwGlobalInterfaceTableCookie);
|
|
}
|
|
|
|
|
|
// -------------------------------------------------
|
|
// CDownloadThumbnailThreadMessage
|
|
// -------------------------------------------------
|
|
CDownloadThumbnailsThreadMessage::CDownloadThumbnailsThreadMessage( HWND hWndNotify, const CSimpleDynamicArray<DWORD> &Cookies, HANDLE hCancelEvent )
|
|
: CNotifyThreadMessage( TQ_DOWNLOADTHUMBNAIL, hWndNotify ),
|
|
m_Cookies(Cookies),
|
|
m_hCancelEvent(NULL)
|
|
{
|
|
DuplicateHandle( GetCurrentProcess(), hCancelEvent, GetCurrentProcess(), &m_hCancelEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
}
|
|
|
|
CDownloadThumbnailsThreadMessage::~CDownloadThumbnailsThreadMessage(void)
|
|
{
|
|
if (m_hCancelEvent)
|
|
{
|
|
CloseHandle(m_hCancelEvent);
|
|
m_hCancelEvent = NULL;
|
|
}
|
|
}
|
|
|
|
// Helper function that gets the thumbnail data and creates a DIB from it
|
|
static HRESULT DownloadAndCreateThumbnail( IWiaItem *pWiaItem, PBYTE *ppBitmapData, LONG &nWidth, LONG &nHeight, LONG &nBitmapDataLength, GUID &guidPreferredFormat, LONG &nAccessRights, LONG &nImageWidth, LONG &nImageHeight, CAnnotationType &AnnotationType, CSimpleString &strDefExt )
|
|
{
|
|
#if 0 // defined(DBG)
|
|
Sleep(3000);
|
|
#endif
|
|
WIA_PUSH_FUNCTION((TEXT("DownloadAndCreateThumbnail")));
|
|
CComPtr<IWiaPropertyStorage> pIWiaPropertyStorage;
|
|
HRESULT hr = pWiaItem->QueryInterface(IID_IWiaPropertyStorage, (void**)&pIWiaPropertyStorage);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
AnnotationType = AnnotationNone;
|
|
CComPtr<IWiaAnnotationHelpers> pWiaAnnotationHelpers;
|
|
if (SUCCEEDED(CoCreateInstance( CLSID_WiaDefaultUi, NULL,CLSCTX_INPROC_SERVER, IID_IWiaAnnotationHelpers,(void**)&pWiaAnnotationHelpers )))
|
|
{
|
|
pWiaAnnotationHelpers->GetAnnotationType( pWiaItem, AnnotationType );
|
|
}
|
|
|
|
const int c_NumProps = 7;
|
|
PROPVARIANT PropVar[c_NumProps];
|
|
PROPSPEC PropSpec[c_NumProps];
|
|
|
|
PropSpec[0].ulKind = PRSPEC_PROPID;
|
|
PropSpec[0].propid = WIA_IPC_THUMB_WIDTH;
|
|
|
|
PropSpec[1].ulKind = PRSPEC_PROPID;
|
|
PropSpec[1].propid = WIA_IPC_THUMB_HEIGHT;
|
|
|
|
PropSpec[2].ulKind = PRSPEC_PROPID;
|
|
PropSpec[2].propid = WIA_IPC_THUMBNAIL;
|
|
|
|
PropSpec[3].ulKind = PRSPEC_PROPID;
|
|
PropSpec[3].propid = WIA_IPA_PREFERRED_FORMAT;
|
|
|
|
PropSpec[4].ulKind = PRSPEC_PROPID;
|
|
PropSpec[4].propid = WIA_IPA_ACCESS_RIGHTS;
|
|
|
|
PropSpec[5].ulKind = PRSPEC_PROPID;
|
|
PropSpec[5].propid = WIA_IPA_PIXELS_PER_LINE;
|
|
|
|
PropSpec[6].ulKind = PRSPEC_PROPID;
|
|
PropSpec[6].propid = WIA_IPA_NUMBER_OF_LINES;
|
|
|
|
hr = pIWiaPropertyStorage->ReadMultiple(ARRAYSIZE(PropSpec),PropSpec,PropVar );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Save the item type
|
|
//
|
|
if (VT_CLSID == PropVar[3].vt && PropVar[3].puuid)
|
|
{
|
|
guidPreferredFormat = *(PropVar[3].puuid);
|
|
}
|
|
else
|
|
{
|
|
guidPreferredFormat = IID_NULL;
|
|
}
|
|
|
|
//
|
|
// Get the extension for the default format
|
|
//
|
|
strDefExt = CWiaFileFormat::GetExtension( guidPreferredFormat, TYMED_FILE, pWiaItem );
|
|
|
|
//
|
|
// Save the access rights
|
|
//
|
|
nAccessRights = PropVar[4].lVal;
|
|
|
|
if ((PropVar[0].vt == VT_I4 || PropVar[0].vt == VT_UI4) &&
|
|
(PropVar[1].vt == VT_I4 || PropVar[1].vt == VT_UI4) &&
|
|
(PropVar[2].vt == (VT_UI1|VT_VECTOR)))
|
|
{
|
|
if (PropVar[2].caub.cElems >= PropVar[0].ulVal * PropVar[1].ulVal)
|
|
{
|
|
//
|
|
// Allocate memory for the bitmap data. It will be freed by the main thread.
|
|
//
|
|
*ppBitmapData = reinterpret_cast<PBYTE>(LocalAlloc( LPTR, PropVar[2].caub.cElems ));
|
|
if (*ppBitmapData)
|
|
{
|
|
WIA_TRACE((TEXT("We found a thumbnail!")));
|
|
CopyMemory( *ppBitmapData, PropVar[2].caub.pElems, PropVar[2].caub.cElems );
|
|
nWidth = PropVar[0].ulVal;
|
|
nHeight = PropVar[1].ulVal;
|
|
nImageWidth = PropVar[5].ulVal;
|
|
nImageHeight = PropVar[6].ulVal;
|
|
nBitmapDataLength = PropVar[2].caub.cElems;
|
|
WIA_TRACE((TEXT("nImageWidth = %d, nImageHeight = %d!"), nImageWidth, nImageHeight ));
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to allocate bitmap data")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
WIA_PRINTHRESULT((hr,TEXT("Invalid bitmap data returned")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
WIA_ERROR((TEXT("The bitmap data is in the wrong format! %d"),PropVar[2].vt));
|
|
}
|
|
//
|
|
// Free any properties the array contains
|
|
//
|
|
FreePropVariantArray( ARRAYSIZE(PropVar), PropVar );
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("ReadMultiple failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("QueryInterface on IID_IWiaPropertyStorage failed")));
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CDownloadThumbnailsThreadMessage::Download(void)
|
|
{
|
|
WIA_PUSHFUNCTION((TEXT("CDownloadThumbnailsThreadMessage::Download")));
|
|
//
|
|
// Tell the main thread we are going to start downloading thumbnails
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadThumbnailsThreadNotifyMessage::BeginDownloadAllMessage( m_Cookies.Size() ) );
|
|
|
|
//
|
|
// Get an instance of the GIT
|
|
//
|
|
CComPtr<IGlobalInterfaceTable> pGlobalInterfaceTable;
|
|
HRESULT hr = CoCreateInstance( CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, IID_IGlobalInterfaceTable, (VOID**)&pGlobalInterfaceTable );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// m_Cookies.Size() contains the number of thumbnails we need to get
|
|
//
|
|
for (int i=0;i<m_Cookies.Size() && hr == S_OK;i++)
|
|
{
|
|
//
|
|
// Check to see if we're cancelled. If we are, break out of the loop
|
|
//
|
|
if (m_hCancelEvent && WAIT_OBJECT_0==WaitForSingleObject(m_hCancelEvent,0))
|
|
{
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get the item from the global interface table
|
|
//
|
|
CComPtr<IWiaItem> pWiaItem = NULL;
|
|
hr = pGlobalInterfaceTable->GetInterfaceFromGlobal( m_Cookies[i], IID_IWiaItem, (void**)&pWiaItem );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get the bitmap data and other properties we are reading now
|
|
//
|
|
PBYTE pBitmapData = NULL;
|
|
GUID guidPreferredFormat;
|
|
LONG nAccessRights = 0, nWidth = 0, nHeight = 0, nPictureWidth = 0, nPictureHeight = 0, nBitmapDataLength = 0;
|
|
CAnnotationType AnnotationType = AnnotationNone;
|
|
CSimpleString strDefExt;
|
|
|
|
//
|
|
// Notify the main thread that we are beginning to download the thumbnail and other props
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadThumbnailsThreadNotifyMessage::BeginDownloadThumbnailMessage( i, m_Cookies[i] ) );
|
|
|
|
//
|
|
// Only send an End message if we were successful
|
|
//
|
|
if (SUCCEEDED(DownloadAndCreateThumbnail( pWiaItem, &pBitmapData, nWidth, nHeight, nBitmapDataLength, guidPreferredFormat, nAccessRights, nPictureWidth, nPictureHeight, AnnotationType, strDefExt )))
|
|
{
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadThumbnailsThreadNotifyMessage::EndDownloadThumbnailMessage( i, m_Cookies[i], pBitmapData, nWidth, nHeight, nBitmapDataLength, guidPreferredFormat, nAccessRights, nPictureWidth, nPictureHeight, AnnotationType, strDefExt ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Tell the main thread we are done
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadThumbnailsThreadNotifyMessage::EndDownloadAllMessage( hr ) );
|
|
return hr;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------
|
|
// CDownloadImagesThreadMessage
|
|
// -------------------------------------------------
|
|
CDownloadImagesThreadMessage::CDownloadImagesThreadMessage(
|
|
HWND hWndNotify,
|
|
const CSimpleDynamicArray<DWORD> &Cookies,
|
|
const CSimpleDynamicArray<int> &Rotation,
|
|
LPCTSTR pszDirectory,
|
|
LPCTSTR pszFilename,
|
|
const GUID &guidFormat,
|
|
HANDLE hCancelDownloadEvent,
|
|
bool bStampTime,
|
|
HANDLE hPauseDownloadEvent
|
|
)
|
|
: CNotifyThreadMessage( TQ_DOWNLOADIMAGE, hWndNotify ),
|
|
m_Cookies(Cookies),
|
|
m_Rotation(Rotation),
|
|
m_strDirectory(pszDirectory),
|
|
m_strFilename(pszFilename),
|
|
m_guidFormat(guidFormat),
|
|
m_hCancelDownloadEvent(NULL),
|
|
m_bStampTime(bStampTime),
|
|
m_nLastStatusUpdatePercent(-1),
|
|
m_bFirstTransfer(true),
|
|
m_hPauseDownloadEvent(NULL),
|
|
m_hFilenameCreationMutex(NULL)
|
|
{
|
|
DuplicateHandle( GetCurrentProcess(), hCancelDownloadEvent, GetCurrentProcess(), &m_hCancelDownloadEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
DuplicateHandle( GetCurrentProcess(), hPauseDownloadEvent, GetCurrentProcess(), &m_hPauseDownloadEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
m_hFilenameCreationMutex = CreateMutex( NULL, FALSE, FILE_CREATION_MUTEX_NAME );
|
|
}
|
|
|
|
|
|
CDownloadImagesThreadMessage::~CDownloadImagesThreadMessage(void)
|
|
{
|
|
if (m_hCancelDownloadEvent)
|
|
{
|
|
CloseHandle(m_hCancelDownloadEvent);
|
|
m_hCancelDownloadEvent = NULL;
|
|
}
|
|
if (m_hPauseDownloadEvent)
|
|
{
|
|
CloseHandle(m_hPauseDownloadEvent);
|
|
m_hPauseDownloadEvent = NULL;
|
|
}
|
|
if (m_hFilenameCreationMutex)
|
|
{
|
|
CloseHandle(m_hFilenameCreationMutex);
|
|
m_hFilenameCreationMutex = NULL;
|
|
}
|
|
}
|
|
|
|
int CDownloadImagesThreadMessage::ReportError( HWND hWndNotify, const CSimpleString &strMessage, int nMessageBoxFlags )
|
|
{
|
|
//
|
|
// How long should we wait to find out if this is being handled?
|
|
//
|
|
const UINT c_nSecondsToWaitForHandler = 10;
|
|
|
|
//
|
|
// Cancel is the default, in case nobody handles the message, or we are out of resources
|
|
//
|
|
int nResult = CMessageBoxEx::IDMBEX_CANCEL;
|
|
|
|
//
|
|
// This event will be signalled by the handler when it is going to display some UI
|
|
//
|
|
HANDLE hHandledMessageEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
|
|
if (hHandledMessageEvent)
|
|
{
|
|
//
|
|
// This event will be signalled when the user has responded
|
|
//
|
|
HANDLE hRespondedMessageEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
|
|
if (hRespondedMessageEvent)
|
|
{
|
|
//
|
|
// Create a notification message class and make sure it isn't NULL
|
|
//
|
|
CDownloadErrorNotificationMessage *pDownloadErrorNotificationMessage = CDownloadErrorNotificationMessage::ReportDownloadError( strMessage, hHandledMessageEvent, hRespondedMessageEvent, nMessageBoxFlags, nResult );
|
|
if (pDownloadErrorNotificationMessage)
|
|
{
|
|
//
|
|
// Send the message
|
|
//
|
|
CThreadNotificationMessage::SendMessage( hWndNotify, pDownloadErrorNotificationMessage );
|
|
|
|
//
|
|
// Wait c_nSecondsToWaitForHandler seconds for someone to decide to handle the message
|
|
//
|
|
if (WiaUiUtil::MsgWaitForSingleObject(hHandledMessageEvent,c_nSecondsToWaitForHandler*1000))
|
|
{
|
|
//
|
|
// Wait forever for user input
|
|
//
|
|
if (WiaUiUtil::MsgWaitForSingleObject(hRespondedMessageEvent,INFINITE))
|
|
{
|
|
//
|
|
// Nothing to do.
|
|
//
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Done with this event
|
|
//
|
|
CloseHandle(hRespondedMessageEvent);
|
|
}
|
|
//
|
|
// Done with this event
|
|
//
|
|
CloseHandle(hHandledMessageEvent);
|
|
}
|
|
return nResult;
|
|
}
|
|
|
|
|
|
//
|
|
// This function will sort of arbitrarily try to decide if a
|
|
// it is possible the user chose an area that is too large
|
|
//
|
|
static bool ScannerImageSizeSeemsExcessive( IWiaItem *pWiaItem )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("ScannerImageSizeSeemsExcessive"));
|
|
//
|
|
// Assume it isn't too large
|
|
//
|
|
bool bResult = false;
|
|
|
|
LONG nHorizontalExt=0, nVerticalExt=0;
|
|
if (PropStorageHelpers::GetProperty( pWiaItem, WIA_IPS_XEXTENT, nHorizontalExt ) && PropStorageHelpers::GetProperty( pWiaItem, WIA_IPS_YEXTENT, nVerticalExt ))
|
|
{
|
|
LONG nColorDepth=0;
|
|
if (PropStorageHelpers::GetProperty( pWiaItem, WIA_IPA_DEPTH, nColorDepth ))
|
|
{
|
|
WIA_TRACE((TEXT("Scan Size: %d"), (nHorizontalExt * nVerticalExt * nColorDepth) / 8 ));
|
|
//
|
|
// If an uncompressed scan is larger than 50 MB
|
|
//
|
|
if ((nHorizontalExt * nVerticalExt * nColorDepth) / 8 > 1024*1024*50)
|
|
{
|
|
bResult = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
int CDownloadImagesThreadMessage::ReportDownloadError( HWND hWndNotify, IWiaItem *pWiaItem, HRESULT &hr, bool bAllowContinue, bool bPageFeederActive, bool bUsableMultipageFileExists, bool bMultiPageTransfer )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CDownloadImagesThreadMessage::ReportDownloadError( hWndNotify: %p, pWiaItem: %p, hr: %08X, bAllowContinue: %d, bPageFeederActive: %d, bUsableMultipageFileExists: %d"), hWndNotify, pWiaItem, hr, bAllowContinue, bPageFeederActive, bUsableMultipageFileExists ));
|
|
WIA_PRINTHRESULT((hr,TEXT("HRESULT:")));
|
|
|
|
//
|
|
// Get the device type property
|
|
//
|
|
LONG lDeviceType = 0;
|
|
CComPtr<IWiaItem> pWiaItemRoot;
|
|
if (pWiaItem && SUCCEEDED(pWiaItem->GetRootItem(&pWiaItemRoot)))
|
|
{
|
|
PropStorageHelpers::GetProperty( pWiaItemRoot, WIA_DIP_DEV_TYPE, lDeviceType );
|
|
}
|
|
|
|
//
|
|
// Get the actual device type bits
|
|
//
|
|
lDeviceType = GET_STIDEVICE_TYPE(lDeviceType);
|
|
|
|
//
|
|
// Default message box buttons
|
|
//
|
|
int nMessageBoxFlags = 0;
|
|
|
|
//
|
|
// Default message
|
|
//
|
|
CSimpleString strMessage(TEXT(""));
|
|
|
|
//
|
|
// Take a first cut at getting the correct error message
|
|
//
|
|
switch (hr)
|
|
{
|
|
case WIA_ERROR_OFFLINE:
|
|
//
|
|
// The device is disconnected. Nothing we can do here, so just return.
|
|
//
|
|
return CMessageBoxEx::IDMBEX_CANCEL;
|
|
|
|
case WIA_ERROR_ITEM_DELETED:
|
|
//
|
|
// If the item has been deleted, just continue.
|
|
//
|
|
return CMessageBoxEx::IDMBEX_SKIP;
|
|
|
|
case WIA_ERROR_BUSY:
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_CANCELRETRY|CMessageBoxEx::MBEX_DEFBUTTON2|CMessageBoxEx::MBEX_ICONWARNING;
|
|
strMessage = CSimpleString( IDS_TRANSFER_DEVICEBUSY, g_hInstance );
|
|
break;
|
|
|
|
case WIA_ERROR_PAPER_EMPTY:
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_CANCELRETRY|CMessageBoxEx::MBEX_DEFBUTTON2|CMessageBoxEx::MBEX_ICONWARNING;
|
|
strMessage = CSimpleString( IDS_TRANSFER_PAPEREMPTY, g_hInstance );
|
|
break;
|
|
|
|
case E_OUTOFMEMORY:
|
|
if (StiDeviceTypeScanner == lDeviceType && ScannerImageSizeSeemsExcessive(pWiaItem))
|
|
{
|
|
//
|
|
// Handle the case where we think the user may have chosen an insane image size
|
|
//
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_OK|CMessageBoxEx::MBEX_ICONWARNING;
|
|
strMessage = CSimpleString( IDS_TRANSFER_SCANNEDITEMMAYBETOOLARGE, g_hInstance );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we still don't have an error message, see if this is a special case
|
|
//
|
|
if (!nMessageBoxFlags || !strMessage.Length())
|
|
{
|
|
if (bPageFeederActive)
|
|
{
|
|
if (bMultiPageTransfer)
|
|
{
|
|
if (bUsableMultipageFileExists)
|
|
{
|
|
switch (hr)
|
|
{
|
|
case WIA_ERROR_PAPER_JAM:
|
|
|
|
case WIA_ERROR_PAPER_PROBLEM:
|
|
//
|
|
// We can recover the rest of the file in these cases.
|
|
//
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_ICONINFORMATION|CMessageBoxEx::MBEX_YESNO;
|
|
strMessage = CSimpleString( IDS_MULTIPAGE_PAPER_PROBLEM, g_hInstance );
|
|
break;
|
|
|
|
default:
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_ICONERROR|CMessageBoxEx::MBEX_OK;
|
|
strMessage = CSimpleString( IDS_MULTIPAGE_FATAL_ERROR, g_hInstance );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_ICONERROR|CMessageBoxEx::MBEX_OK;
|
|
strMessage = CSimpleString( IDS_MULTIPAGE_FATAL_ERROR, g_hInstance );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we still don't have a message, use the default
|
|
//
|
|
if (!nMessageBoxFlags || !strMessage.Length())
|
|
{
|
|
if (bAllowContinue)
|
|
{
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_CANCELRETRYSKIPSKIPALL|CMessageBoxEx::MBEX_DEFBUTTON2|CMessageBoxEx::MBEX_ICONWARNING;
|
|
strMessage = CSimpleString( IDS_TRANSFER_GENERICFAILURE, g_hInstance );
|
|
}
|
|
else
|
|
{
|
|
nMessageBoxFlags = CMessageBoxEx::MBEX_CANCELRETRY|CMessageBoxEx::MBEX_DEFBUTTON1|CMessageBoxEx::MBEX_ICONWARNING;
|
|
strMessage = CSimpleString( IDS_TRANSFER_GENERICFAILURE_NO_CONTINUE, g_hInstance );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Report the error
|
|
//
|
|
int nResult = ReportError( hWndNotify, strMessage, nMessageBoxFlags );
|
|
|
|
//
|
|
// Special cases, give us a chance to change the hresult and return value
|
|
//
|
|
if (bPageFeederActive && !bUsableMultipageFileExists && (CMessageBoxEx::IDMBEX_SKIP == nResult || CMessageBoxEx::IDMBEX_SKIPALL == nResult))
|
|
{
|
|
hr = WIA_ERROR_PAPER_EMPTY;
|
|
nResult = CMessageBoxEx::IDMBEX_SKIP;
|
|
}
|
|
else if (bPageFeederActive && bUsableMultipageFileExists && (WIA_ERROR_PAPER_JAM == hr || WIA_ERROR_PAPER_PROBLEM == hr))
|
|
{
|
|
if (CMessageBoxEx::IDMBEX_YES == nResult)
|
|
{
|
|
hr = S_OK;
|
|
nResult = CMessageBoxEx::IDMBEX_SKIP;
|
|
}
|
|
else
|
|
{
|
|
nResult = CMessageBoxEx::IDMBEX_CANCEL;
|
|
}
|
|
}
|
|
|
|
return nResult;
|
|
}
|
|
|
|
static void GetIdealInputFormat( IWiaSupportedFormats *pWiaSupportedFormats, const GUID &guidOutputFormat, GUID &guidInputFormat )
|
|
{
|
|
//
|
|
// If we can get the input format and the output format to be the same, that is best
|
|
// If we cannot, we will use DIB, which we can convert to the output format
|
|
//
|
|
|
|
//
|
|
// Get the format count
|
|
//
|
|
LONG nCount = 0;
|
|
HRESULT hr = pWiaSupportedFormats->GetFormatCount(&nCount);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Search for the output format
|
|
//
|
|
for (LONG i=0;i<nCount;i++)
|
|
{
|
|
GUID guidCurrentFormat;
|
|
hr = pWiaSupportedFormats->GetFormatType( i, &guidCurrentFormat );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// If we've found the output format, save it as the input format and return
|
|
//
|
|
if (guidCurrentFormat == guidOutputFormat)
|
|
{
|
|
guidInputFormat = guidOutputFormat;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we've gotten this far, we have to use BMP
|
|
//
|
|
guidInputFormat = WiaImgFmt_BMP;
|
|
}
|
|
|
|
|
|
HRESULT CDownloadImagesThreadMessage::GetListOfTransferItems( IWiaItem *pWiaItem, CSimpleDynamicArray<CTransferItem> &TransferItems )
|
|
{
|
|
if (pWiaItem)
|
|
{
|
|
//
|
|
// Add this item
|
|
//
|
|
TransferItems.Append(CTransferItem(pWiaItem));
|
|
|
|
//
|
|
// If this item has attachments, enumerate and add them
|
|
//
|
|
LONG nItemType = 0;
|
|
if (SUCCEEDED(pWiaItem->GetItemType(&nItemType)) && (nItemType & WiaItemTypeHasAttachments))
|
|
{
|
|
CComPtr<IEnumWiaItem> pEnumWiaItem;
|
|
if (SUCCEEDED(pWiaItem->EnumChildItems( &pEnumWiaItem )))
|
|
{
|
|
CComPtr<IWiaItem> pWiaItem;
|
|
while (S_OK == pEnumWiaItem->Next(1,&pWiaItem,NULL))
|
|
{
|
|
TransferItems.Append(CTransferItem(pWiaItem));
|
|
pWiaItem = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TransferItems.Size() ? S_OK : E_FAIL;
|
|
}
|
|
|
|
static int Find( const CSimpleDynamicArray<CTransferItem> &TransferItems, const CSimpleString &strFilename )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("Find( %s )"),strFilename.String()));
|
|
for (int i=0;i<TransferItems.Size();i++)
|
|
{
|
|
WIA_TRACE((TEXT("Comparing %s to %s"), strFilename.String(), TransferItems[i].Filename().String()));
|
|
if (strFilename == TransferItems[i].Filename())
|
|
{
|
|
WIA_TRACE((TEXT("Returning %d"),i));
|
|
return i;
|
|
}
|
|
}
|
|
WIA_TRACE((TEXT("Returning -1")));
|
|
return -1;
|
|
}
|
|
|
|
HRESULT CDownloadImagesThreadMessage::ReserveTransferItemFilenames( CSimpleDynamicArray<CTransferItem> &TransferItems, LPCTSTR pszDirectory, LPCTSTR pszFilename, LPCTSTR pszNumberMask, bool bAllowUnNumberedFile, int &nPrevFileNumber )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CDownloadImagesThreadMessage::ReserveTransferItemFilenames")));
|
|
|
|
//
|
|
// The maximum number of identical attachments
|
|
//
|
|
int c_nMaxDuplicateFile = 1000;
|
|
|
|
//
|
|
// Assume success
|
|
//
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// We can only release the mutex if we were able to grab it.
|
|
//
|
|
bool bGrabbedMutex = false;
|
|
|
|
//
|
|
// It is not an error if we can't grab the mutex here
|
|
//
|
|
if (m_hFilenameCreationMutex && WiaUiUtil::MsgWaitForSingleObject(m_hFilenameCreationMutex,2000))
|
|
{
|
|
bGrabbedMutex = true;
|
|
}
|
|
//
|
|
// Get the root filename
|
|
//
|
|
TCHAR szFullPathname[MAX_PATH*2] = TEXT("");
|
|
int nFileNumber = NumberedFileName::GenerateLowestAvailableNumberedFileName( 0, szFullPathname, pszDirectory, pszFilename, pszNumberMask, TEXT(""), bAllowUnNumberedFile, nPrevFileNumber );
|
|
WIA_TRACE((TEXT("nFileNumber = %d"),nFileNumber));
|
|
|
|
//
|
|
// Make sure we got a valid file number
|
|
//
|
|
if (nFileNumber >= 0)
|
|
{
|
|
//
|
|
// Now loop through the transfer items for this item and create a unique filename for each
|
|
//
|
|
for (int nCurrTransferItem=0;nCurrTransferItem<TransferItems.Size();nCurrTransferItem++)
|
|
{
|
|
CSimpleString strFilename = CSimpleString(szFullPathname);
|
|
CSimpleString strExtension = CWiaFileFormat::GetExtension(TransferItems[nCurrTransferItem].OutputFormat(),TransferItems[nCurrTransferItem].MediaType(),TransferItems[nCurrTransferItem].WiaItem() );
|
|
|
|
//
|
|
// Now we are going to make sure there are no existing files with the same name
|
|
// in this transfer group. This could be caused by having multiple attachments of the same
|
|
// type. So we are going to loop until we find a filename that is unused. The first file
|
|
// will be named like this:
|
|
//
|
|
// File NNN.ext
|
|
//
|
|
// Subsequent files will be named like this:
|
|
//
|
|
// File NNN-X.ext
|
|
// File NNN-Y.ext
|
|
// File NNN-Z.ext
|
|
// ...
|
|
//
|
|
bool bFoundUniqueFile = false;
|
|
for (int nCurrDuplicateCheckIndex=1;nCurrDuplicateCheckIndex<c_nMaxDuplicateFile && !bFoundUniqueFile;nCurrDuplicateCheckIndex++)
|
|
{
|
|
//
|
|
// Append the extension, if there is one
|
|
//
|
|
if (strExtension.Length())
|
|
{
|
|
strFilename += TEXT(".");
|
|
strFilename += strExtension;
|
|
}
|
|
|
|
//
|
|
// If this filename exists in the transfer items list, append the new suffix, and remain in the loop.
|
|
//
|
|
WIA_TRACE((TEXT("Calling Find on %s"), strFilename.String()));
|
|
if (Find(TransferItems,strFilename) >= 0)
|
|
{
|
|
strFilename = szFullPathname;
|
|
strFilename += CSimpleString().Format(IDS_DUPLICATE_FILENAME_MASK,g_hInstance,nCurrDuplicateCheckIndex);
|
|
}
|
|
|
|
//
|
|
// Otherwise, we are done.
|
|
//
|
|
else
|
|
{
|
|
bFoundUniqueFile = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make sure we found a unique filename for this set of files
|
|
//
|
|
WIA_TRACE((TEXT("strFilename = %s"), strFilename.String()));
|
|
if (bFoundUniqueFile && strFilename.Length())
|
|
{
|
|
TransferItems[nCurrTransferItem].Filename(strFilename);
|
|
hr = TransferItems[nCurrTransferItem].OpenPlaceholderFile();
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we didn't find a valid name, exit the loop and set the return value to an error
|
|
//
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// Save this number so the next search starts here
|
|
//
|
|
nPrevFileNumber = nFileNumber;
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("NumberedFileName::GenerateLowestAvailableNumberedFileName returned %d"), nFileNumber ));
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
//
|
|
// If we grabbed the mutex, release it
|
|
//
|
|
if (bGrabbedMutex)
|
|
{
|
|
ReleaseMutex(m_hFilenameCreationMutex);
|
|
}
|
|
|
|
WIA_CHECK_HR(hr,"CDownloadImagesThreadMessage::ReserveTransferItemFilenames");
|
|
return hr;
|
|
}
|
|
|
|
BOOL CDownloadImagesThreadMessage::GetCancelledState()
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
//
|
|
// First, wait until we are not paused
|
|
//
|
|
if (m_hPauseDownloadEvent)
|
|
{
|
|
WiaUiUtil::MsgWaitForSingleObject(m_hPauseDownloadEvent,INFINITE);
|
|
}
|
|
|
|
//
|
|
// Then check to see if we have been cancelled
|
|
//
|
|
if (m_hCancelDownloadEvent && WAIT_TIMEOUT!=WaitForSingleObject(m_hCancelDownloadEvent,0))
|
|
{
|
|
bResult = TRUE;
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
static void CloseAndDeletePlaceholderFiles(CSimpleDynamicArray<CTransferItem> &TransferItems)
|
|
{
|
|
for (int nCurrTransferItem=0;nCurrTransferItem<TransferItems.Size();nCurrTransferItem++)
|
|
{
|
|
|
|
if (TransferItems[nCurrTransferItem].Filename().Length())
|
|
{
|
|
TransferItems[nCurrTransferItem].DeleteFile();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void SnapExtentToRotatableSize( IUnknown *pUnknown, const GUID &guidFormat )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("SnapExtentToRotatableSize")));
|
|
//
|
|
// Make sure we have a valid pointer
|
|
//
|
|
if (!pUnknown)
|
|
{
|
|
WIA_TRACE((TEXT("Invalid pointer")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure we have a JPEG file.
|
|
//
|
|
if (WiaImgFmt_JPEG != guidFormat)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure we can read the access flags
|
|
//
|
|
ULONG nHorizontalAccessFlags=0, nVerticalAccessFlags=0;
|
|
if (!PropStorageHelpers::GetPropertyAccessFlags( pUnknown, WIA_IPS_XEXTENT, nHorizontalAccessFlags ) ||
|
|
!PropStorageHelpers::GetPropertyAccessFlags( pUnknown, WIA_IPS_YEXTENT, nVerticalAccessFlags ))
|
|
{
|
|
WIA_TRACE((TEXT("Unable to read access flags")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure we have read/write access to the extent properties
|
|
//
|
|
if ((WIA_PROP_RW & nHorizontalAccessFlags)==0 || (WIA_PROP_RW & nVerticalAccessFlags)==0)
|
|
{
|
|
WIA_TRACE((TEXT("Invalid access flags")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the ranges
|
|
//
|
|
PropStorageHelpers::CPropertyRange HorizontalRange, VerticalRange;
|
|
if (!PropStorageHelpers::GetPropertyRange( pUnknown, WIA_IPS_XEXTENT, HorizontalRange ) ||
|
|
!PropStorageHelpers::GetPropertyRange( pUnknown, WIA_IPS_YEXTENT, VerticalRange ))
|
|
{
|
|
WIA_TRACE((TEXT("Unable to read ranges")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure they are valid ranges. We aren't going to mess with it if it doesn't have a step value of 1
|
|
//
|
|
if (!HorizontalRange.nMax || HorizontalRange.nStep != 1 || !VerticalRange.nMax || VerticalRange.nStep != 1)
|
|
{
|
|
WIA_TRACE((TEXT("Invalid ranges")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the current values
|
|
//
|
|
LONG nHorizontalExt=0, nVerticalExt=0;
|
|
if (!PropStorageHelpers::GetProperty( pUnknown, WIA_IPS_XEXTENT, nHorizontalExt ) ||
|
|
!PropStorageHelpers::GetProperty( pUnknown, WIA_IPS_YEXTENT, nVerticalExt ))
|
|
{
|
|
WIA_TRACE((TEXT("Can't read current extents")));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Round to the nearest 8, ensuring we don't go over the maximum extent (which is often not a multiple of 16, but oh well)
|
|
//
|
|
PropStorageHelpers::SetProperty( pUnknown, WIA_IPS_XEXTENT, WiaUiUtil::Min( WiaUiUtil::Align( nHorizontalExt, 16 ), HorizontalRange.nMax ) );
|
|
PropStorageHelpers::SetProperty( pUnknown, WIA_IPS_YEXTENT, WiaUiUtil::Min( WiaUiUtil::Align( nVerticalExt, 16 ), VerticalRange.nMax ) );
|
|
}
|
|
|
|
|
|
static void UpdateFolderTime( LPCTSTR pszFolder )
|
|
{
|
|
if (pszFolder && lstrlen(pszFolder))
|
|
{
|
|
FILETIME ftCurrent = {0};
|
|
GetSystemTimeAsFileTime(&ftCurrent);
|
|
|
|
//
|
|
// Private flag 0x100 lets us open a directory in write access
|
|
//
|
|
HANDLE hFolder = CreateFile( pszFolder, GENERIC_READ | 0x100, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL );
|
|
if (INVALID_HANDLE_VALUE != hFolder)
|
|
{
|
|
SetFileTime( hFolder, NULL, NULL, &ftCurrent );
|
|
CloseHandle( hFolder );
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool FileExistsAndContainsData( LPCTSTR pszFileName )
|
|
{
|
|
bool bResult = false;
|
|
|
|
//
|
|
// Make sure we have a filename
|
|
//
|
|
if (pszFileName && lstrlen(pszFileName))
|
|
{
|
|
//
|
|
// Make sure the file exists
|
|
//
|
|
if (NumberedFileName::DoesFileExist(pszFileName))
|
|
{
|
|
//
|
|
// Attempt to open the file
|
|
//
|
|
HANDLE hFile = CreateFile( pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
if (INVALID_HANDLE_VALUE != hFile)
|
|
{
|
|
//
|
|
// Get the file size and make sure we didn't have an error
|
|
//
|
|
ULARGE_INTEGER nFileSize = {0};
|
|
nFileSize.LowPart = GetFileSize( hFile, &nFileSize.HighPart );
|
|
if (nFileSize.LowPart != INVALID_FILE_SIZE && GetLastError() == NO_ERROR)
|
|
{
|
|
if (nFileSize.QuadPart != 0)
|
|
{
|
|
//
|
|
// Success
|
|
//
|
|
bResult = true;
|
|
}
|
|
}
|
|
|
|
CloseHandle( hFile );
|
|
}
|
|
}
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
HRESULT CDownloadImagesThreadMessage::Download(void)
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CDownloadImagesThreadMessage::Download")));
|
|
|
|
CDownloadedFileInformationList DownloadedFileInformationList;
|
|
|
|
//
|
|
// Will be set to true if the user cancels
|
|
//
|
|
bool bCancelled = false;
|
|
|
|
//
|
|
// Will be set to true if some error prevents us from continuing
|
|
//
|
|
bool bStopTransferring = false;
|
|
|
|
//
|
|
// Tell the notification window we are going to start downloading images
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::BeginDownloadAllMessage( m_Cookies.Size() ) );
|
|
|
|
//
|
|
// We will sometimes have more error information than we can fit in an HRESULT
|
|
//
|
|
CSimpleString strExtendedErrorInformation = TEXT("");
|
|
|
|
//
|
|
// Get an instance of the GIT
|
|
//
|
|
CComPtr<IGlobalInterfaceTable> pGlobalInterfaceTable;
|
|
HRESULT hr = CoCreateInstance( CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, IID_IGlobalInterfaceTable, (VOID**)&pGlobalInterfaceTable );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get an instance of our transfer helper classes
|
|
//
|
|
CComPtr<IWiaTransferHelper> pWiaTransferHelper;
|
|
hr = CoCreateInstance( CLSID_WiaDefaultUi, NULL, CLSCTX_INPROC_SERVER, IID_IWiaTransferHelper, (void**)&pWiaTransferHelper );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get an instance of our helper class for identifying supported formats
|
|
//
|
|
CComPtr<IWiaSupportedFormats> pWiaSupportedFormats;
|
|
hr = pWiaTransferHelper->QueryInterface( IID_IWiaSupportedFormats, (void**)&pWiaSupportedFormats );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// We (this) are an instance of the callback class. Get an interface pointer to it.
|
|
//
|
|
CComPtr<IWiaDataCallback> pWiaDataCallback;
|
|
hr = this->QueryInterface( IID_IWiaDataCallback, (void**)&pWiaDataCallback );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Initialize the uniqueness list
|
|
//
|
|
CFileUniquenessList FileUniquenessList( m_strDirectory );
|
|
|
|
//
|
|
// Skip all download errors?
|
|
//
|
|
bool bSkipAllDownloadErrors = false;
|
|
|
|
//
|
|
// If the most recent error was skipped, set this to true to ensure
|
|
// we don't pass back an error on the last image
|
|
//
|
|
bool bLastErrorSkipped = false;
|
|
|
|
//
|
|
// Save all or delete all duplicates?
|
|
//
|
|
int nPersistentDuplicateResult = 0;
|
|
|
|
//
|
|
// Save the previous file number, so we don't have to search the whole range of files
|
|
// to find an open section
|
|
//
|
|
int nPrevFileNumber = NumberedFileName::FindHighestNumberedFile( m_strDirectory, m_strFilename );
|
|
|
|
//
|
|
// Loop through all of the images
|
|
//
|
|
for ( int nCurrentImage=0; nCurrentImage<m_Cookies.Size() && !bCancelled && !bStopTransferring; nCurrentImage++ )
|
|
{
|
|
WIA_TRACE((TEXT("Preparing to transfer the %d'th image (Cookie %08X)"), nCurrentImage, m_Cookies[nCurrentImage] ));
|
|
|
|
//
|
|
// Assume we won't skip any transfer error that occurs
|
|
//
|
|
bLastErrorSkipped = false;
|
|
|
|
//
|
|
// Save the current cookie ID for the callback
|
|
//
|
|
m_nCurrentCookie = m_Cookies[nCurrentImage];
|
|
|
|
//
|
|
// If we have been cancelled, exit the loop
|
|
//
|
|
if (GetCancelledState())
|
|
{
|
|
hr = S_FALSE;
|
|
bCancelled = true;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get the IWiaItem interface pointer from the GIT
|
|
//
|
|
CComPtr<IWiaItem> pWiaItem;
|
|
hr = pGlobalInterfaceTable->GetInterfaceFromGlobal(m_Cookies[nCurrentImage], IID_IWiaItem, (void**)&pWiaItem );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bool bInPageFeederMode = false;
|
|
|
|
//
|
|
// Ensure the image is a multiple of eight pixels in size
|
|
//
|
|
SnapExtentToRotatableSize(pWiaItem,m_guidFormat);
|
|
|
|
//
|
|
// Get the root item
|
|
//
|
|
CComPtr<IWiaItem> pWiaItemRoot;
|
|
if (SUCCEEDED(pWiaItem->GetRootItem(&pWiaItemRoot)))
|
|
{
|
|
LONG nPaperSource = 0;
|
|
if (PropStorageHelpers::GetProperty( pWiaItemRoot, WIA_DPS_DOCUMENT_HANDLING_SELECT, static_cast<LONG>(nPaperSource)))
|
|
{
|
|
if (nPaperSource & FEEDER)
|
|
{
|
|
bInPageFeederMode = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Download the thumbnail, in case we haven't already
|
|
//
|
|
GUID guidPreferredFormat;
|
|
LONG nAccessRights;
|
|
PBYTE pBitmapData = NULL;
|
|
LONG nWidth = 0, nHeight = 0, nPictureWidth = 0, nPictureHeight = 0, nBitmapDataLength = 0;
|
|
CAnnotationType AnnotationType = AnnotationNone;
|
|
CSimpleString strDefExt;
|
|
if (SUCCEEDED(DownloadAndCreateThumbnail( pWiaItem, &pBitmapData, nWidth, nHeight, nBitmapDataLength, guidPreferredFormat, nAccessRights, nPictureWidth, nPictureHeight, AnnotationType, strDefExt )))
|
|
{
|
|
WIA_TRACE((TEXT("DownloadAndCreateThumbnail succeeded")));
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadThumbnailsThreadNotifyMessage::EndDownloadThumbnailMessage( nCurrentImage, m_Cookies[nCurrentImage], pBitmapData, nWidth, nHeight, nBitmapDataLength, guidPreferredFormat, nAccessRights, nPictureWidth, nPictureHeight, AnnotationType, strDefExt ) );
|
|
}
|
|
|
|
//
|
|
// If we are a scanner, and we are in feeder mode,
|
|
// determine whether or not the selected format is available
|
|
// in multipage format. This won't work if the requested
|
|
// format is IID_NULL, so it rules out cameras implicitly
|
|
// (since we only transfer camera items in their default
|
|
// format.
|
|
//
|
|
LONG nMediaType = TYMED_FILE;
|
|
if (m_guidFormat != IID_NULL && bInPageFeederMode)
|
|
{
|
|
//
|
|
// Initialize the supported format helper for multipage files
|
|
//
|
|
if (SUCCEEDED(pWiaSupportedFormats->Initialize( pWiaItem, TYMED_MULTIPAGE_FILE )))
|
|
{
|
|
//
|
|
// See if there are any multipage formats supported
|
|
//
|
|
LONG nFormatCount;
|
|
if (SUCCEEDED(pWiaSupportedFormats->GetFormatCount( &nFormatCount )))
|
|
{
|
|
//
|
|
// Loop through the formats looking for the requested format
|
|
//
|
|
for (LONG nCurrFormat = 0;nCurrFormat<nFormatCount;nCurrFormat++)
|
|
{
|
|
//
|
|
// Get the format
|
|
//
|
|
GUID guidCurrFormat = IID_NULL;
|
|
if (SUCCEEDED(pWiaSupportedFormats->GetFormatType(nCurrFormat,&guidCurrFormat)))
|
|
{
|
|
//
|
|
// If this is the same format, store the media type
|
|
//
|
|
if (guidCurrFormat == m_guidFormat)
|
|
{
|
|
nMediaType = TYMED_MULTIPAGE_FILE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Initialize the supported formats helper by telling it we are saving to a file or a multipage
|
|
// file
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,1,pWiaSupportedFormats->Initialize( pWiaItem, nMediaType ));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get the default format
|
|
//
|
|
GUID guidDefaultFormat = IID_NULL;
|
|
hr = pWiaSupportedFormats->GetDefaultClipboardFileFormat( &guidDefaultFormat );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get the output format. If the requested format is IID_NULL, we want to use the default format as the input format and output format (i.e., the preferrerd format).
|
|
//
|
|
GUID guidOutputFormat, guidInputFormat;
|
|
if (IID_NULL == m_guidFormat)
|
|
{
|
|
guidOutputFormat = guidInputFormat = guidDefaultFormat;
|
|
}
|
|
else
|
|
{
|
|
guidOutputFormat = m_guidFormat;
|
|
GetIdealInputFormat( pWiaSupportedFormats, m_guidFormat, guidInputFormat );
|
|
}
|
|
|
|
//
|
|
// Verify the rotation setting is legal. If it isn't, clear the rotation angle.
|
|
//
|
|
if (m_Rotation[nCurrentImage] && guidOutputFormat != IID_NULL && nPictureWidth && nPictureHeight && !WiaUiUtil::CanWiaImageBeSafelyRotated(guidOutputFormat,nPictureWidth,nPictureHeight))
|
|
{
|
|
m_Rotation[nCurrentImage] = 0;
|
|
}
|
|
//
|
|
// Number of pages per scan. We increment it at the end of each successful acquire.
|
|
// This way, if we get an out of paper error when we haven't scanned any pages,
|
|
// we can tell the user
|
|
//
|
|
int nPageCount = 0;
|
|
|
|
//
|
|
// We will store all of the successfully downloaded files for the following loop
|
|
// in this list.
|
|
//
|
|
// If this is a single image transfer, that will be one filename.
|
|
// If it is a multi-page transfer, it will be:
|
|
//
|
|
// (a) if the file format supports multi-page files (TIFF)--it will be one
|
|
// filename
|
|
// (b) if the file format doesn't support multi-page files (everything but TIFF)--
|
|
// it will be multiple files
|
|
//
|
|
CDownloadedFileInformationList CurrentFileInformationList;
|
|
|
|
//
|
|
// This is the loop where we keep scanning pages until either:
|
|
//
|
|
// (a) the ADF-active device returns out-of-paper or
|
|
// (b) we have retrieved one image from a non-ADF-active device
|
|
//
|
|
bool bContinueScanningPages = true;
|
|
while (bContinueScanningPages)
|
|
{
|
|
//
|
|
// Just before retrieving, let's make sure we've not been cancelled. If we are, break out of the loop
|
|
// and set the HRESULT to S_FALSE (which signifies cancel)
|
|
//
|
|
if (GetCancelledState())
|
|
{
|
|
hr = S_FALSE;
|
|
bCancelled = true;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get the item and the list of any attached items
|
|
//
|
|
CSimpleDynamicArray<CTransferItem> TransferItems;
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,2,GetListOfTransferItems( pWiaItem, TransferItems ));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Set the output format of the first item (the image) to the desired output format
|
|
//
|
|
TransferItems[0].InputFormat(guidInputFormat);
|
|
TransferItems[0].OutputFormat(guidOutputFormat);
|
|
TransferItems[0].MediaType(nMediaType);
|
|
|
|
//
|
|
// Try to create the sub-directory. Don't worry about failing. We will catch any failures on the next call.
|
|
//
|
|
CAcquisitionManagerControllerWindow::RecursiveCreateDirectory(m_strDirectory);
|
|
|
|
//
|
|
// Find the correct filename, and reserve it
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,3,ReserveTransferItemFilenames( TransferItems, m_strDirectory, m_strFilename, CSimpleString(IDS_NUMBER_MASK,g_hInstance), m_Cookies.Size()==1 && !bInPageFeederMode, nPrevFileNumber ));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Loop through each item in the transfer list
|
|
//
|
|
for (int nCurrentTransferItem=0;nCurrentTransferItem<TransferItems.Size();nCurrentTransferItem++)
|
|
{
|
|
//
|
|
// Save the final filename
|
|
//
|
|
CSimpleString strFinalFilename = TransferItems[nCurrentTransferItem].Filename();
|
|
|
|
//
|
|
// Create a temporary file to hold the unrotated/unconverted image
|
|
//
|
|
CSimpleString strIntermediateFilename = WiaUiUtil::CreateTempFileName();
|
|
|
|
//
|
|
// Make sure the filenames are valid
|
|
//
|
|
if (strFinalFilename.Length() && strIntermediateFilename.Length())
|
|
{
|
|
//
|
|
// Tell the notification window we are starting to download this item
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::BeginDownloadImageMessage( nCurrentImage, m_Cookies[nCurrentImage], strFinalFilename ) );
|
|
|
|
//
|
|
// We are going to repeat failed images in this loop until the user cancels or skips them
|
|
//
|
|
bool bRetry = false;
|
|
do
|
|
{
|
|
//
|
|
// If this is a multi-page file transfer, set the page count to 0 (transfer all pages)
|
|
//
|
|
if (TYMED_MULTIPAGE_FILE == TransferItems[nCurrentTransferItem].MediaType())
|
|
{
|
|
//
|
|
// Get the root item and set the page count to 0
|
|
//
|
|
CComPtr<IWiaItem> pWiaItemRoot;
|
|
if (SUCCEEDED(TransferItems[nCurrentTransferItem].WiaItem()->GetRootItem(&pWiaItemRoot)))
|
|
{
|
|
PropStorageHelpers::SetProperty( pWiaItemRoot, WIA_DPS_PAGES, 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Get the root item and set the page count to 1
|
|
//
|
|
CComPtr<IWiaItem> pWiaItemRoot;
|
|
if (SUCCEEDED(TransferItems[nCurrentTransferItem].WiaItem()->GetRootItem(&pWiaItemRoot)))
|
|
{
|
|
PropStorageHelpers::SetProperty( pWiaItemRoot, WIA_DPS_PAGES, 1 );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Turn off preview mode
|
|
//
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_DPS_PREVIEW, WIA_FINAL_SCAN );
|
|
|
|
//
|
|
// Download the file using our helper class
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,4,pWiaTransferHelper->TransferItemFile( TransferItems[nCurrentTransferItem].WiaItem(), NotifyWindow(), WIA_TRANSFERHELPER_NOPROGRESS|WIA_TRANSFERHELPER_PRESERVEFAILEDFILE, TransferItems[nCurrentTransferItem].InputFormat(), CSimpleStringConvert::WideString(strIntermediateFilename).String(), pWiaDataCallback, TransferItems[nCurrentTransferItem].MediaType()));
|
|
|
|
//
|
|
// Check to if the download was cancelled
|
|
//
|
|
if (GetCancelledState())
|
|
{
|
|
hr = S_FALSE;
|
|
bCancelled = true;
|
|
CloseAndDeletePlaceholderFiles(TransferItems);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// We handle this special return differently later on
|
|
//
|
|
if (nPageCount && WIA_ERROR_PAPER_EMPTY == hr)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// We will not treat this as an error
|
|
//
|
|
if (WIA_ERROR_ITEM_DELETED == hr)
|
|
{
|
|
break;
|
|
}
|
|
|
|
WIA_PRINTHRESULT((hr,TEXT("pWiaTransferHelper->TransferItemFile returned")));
|
|
|
|
//
|
|
// If there was a failure, we are going to aler the user
|
|
//
|
|
if (FAILED(hr))
|
|
{
|
|
int nResult;
|
|
|
|
bool bUsableMultipageFileExists = false;
|
|
if (bInPageFeederMode)
|
|
{
|
|
if (TYMED_MULTIPAGE_FILE == TransferItems[nCurrentTransferItem].MediaType())
|
|
{
|
|
if (FileExistsAndContainsData(strIntermediateFilename))
|
|
{
|
|
bUsableMultipageFileExists = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the user wants to skip all the images with download errors, set the result to SKIP
|
|
//
|
|
if (bSkipAllDownloadErrors)
|
|
{
|
|
nResult = CMessageBoxEx::IDMBEX_SKIP;
|
|
|
|
if (bInPageFeederMode && !bUsableMultipageFileExists)
|
|
{
|
|
hr = WIA_ERROR_PAPER_EMPTY;
|
|
}
|
|
else if (bInPageFeederMode && bUsableMultipageFileExists && (WIA_ERROR_PAPER_JAM == hr || WIA_ERROR_PAPER_PROBLEM == hr))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Tell the notification window about the failure, and get a user decision
|
|
//
|
|
|
|
nResult = ReportDownloadError( NotifyWindow(), pWiaItem, hr, (m_Cookies.Size() != 1 || bInPageFeederMode), bInPageFeederMode, bUsableMultipageFileExists, TYMED_MULTIPAGE_FILE == TransferItems[nCurrentTransferItem].MediaType() );
|
|
}
|
|
|
|
if (CMessageBoxEx::IDMBEX_CANCEL == nResult)
|
|
{
|
|
bCancelled = true;
|
|
break;
|
|
}
|
|
else if (CMessageBoxEx::IDMBEX_SKIP == nResult)
|
|
{
|
|
bRetry = false;
|
|
bLastErrorSkipped = true;
|
|
}
|
|
else if (CMessageBoxEx::IDMBEX_SKIPALL == nResult)
|
|
{
|
|
bSkipAllDownloadErrors = true;
|
|
bRetry = false;
|
|
}
|
|
else if (CMessageBoxEx::IDMBEX_RETRY == nResult)
|
|
{
|
|
bRetry = true;
|
|
}
|
|
else
|
|
{
|
|
bRetry = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bRetry = false;
|
|
}
|
|
|
|
//
|
|
// If the transfer returned S_FALSE, the user chose to cancel
|
|
//
|
|
if (S_FALSE == hr)
|
|
{
|
|
bCancelled = true;
|
|
}
|
|
}
|
|
while (bRetry);
|
|
|
|
//
|
|
// Close the file so we can overwrite it or delete it
|
|
//
|
|
TransferItems[nCurrentTransferItem].ClosePlaceholderFile();
|
|
|
|
//
|
|
// We only do this if and if the user didn't cancel and it didn't fail
|
|
//
|
|
if (S_OK == hr)
|
|
{
|
|
//
|
|
// If we need to rotate, and we are on the anchor image, perform the rotation
|
|
//
|
|
if (nCurrentTransferItem==0 && m_Rotation[nCurrentImage] != 0)
|
|
{
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,5,m_GdiPlusHelper.Rotate( CSimpleStringConvert::WideString(strIntermediateFilename).String(), CSimpleStringConvert::WideString(strFinalFilename).String(), m_Rotation[nCurrentImage], guidOutputFormat ));
|
|
}
|
|
else if (nCurrentTransferItem==0 && guidInputFormat != guidOutputFormat)
|
|
{
|
|
//
|
|
// Else if are saving as a different file type, use the conversion filter
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,6,m_GdiPlusHelper.Convert( CSimpleStringConvert::WideString(strIntermediateFilename).String(), CSimpleStringConvert::WideString(strFinalFilename).String(), guidOutputFormat ));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Otherwise copy/delete or move the actual file over
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,7,WiaUiUtil::MoveOrCopyFile( strIntermediateFilename, strFinalFilename ));
|
|
WIA_PRINTHRESULT((hr,TEXT("WiaUiUtil::MoveOrCopyFile returned")));
|
|
}
|
|
|
|
//
|
|
// If we hit an error here, we are going to stop transferring
|
|
//
|
|
if (FAILED(hr))
|
|
{
|
|
bStopTransferring = true;
|
|
switch (hr)
|
|
{
|
|
case HRESULT_FROM_WIN32(ERROR_DISK_FULL):
|
|
strExtendedErrorInformation.LoadString( IDS_DISKFULL, g_hInstance );
|
|
break;
|
|
|
|
default:
|
|
strExtendedErrorInformation.Format( IDS_UNABLE_TO_SAVE_FILE, g_hInstance, strFinalFilename.String() );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Save a flag that says whether or not this was a duplicate image. If it was, we don't want to delete
|
|
// it in case of an error or the user cancelling.
|
|
//
|
|
bool bDuplicateImage = false;
|
|
|
|
//
|
|
// Check to if the download was cancelled
|
|
//
|
|
if (GetCancelledState())
|
|
{
|
|
hr = S_FALSE;
|
|
bCancelled = true;
|
|
CloseAndDeletePlaceholderFiles(TransferItems);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Only check for duplicates if everything is OK AND
|
|
// we are not on page one of a multi-page scan AND
|
|
// we are on the anchor image (not an attachment).
|
|
//
|
|
// If we are on page 1 of a multipage scan, we have
|
|
// to save the first name, because we may be overwriting
|
|
// it with a multipage formatted file later. In other
|
|
// words, we may be changing the file after this point,
|
|
// which is not true in any other case.
|
|
//
|
|
if (nCurrentTransferItem==0 && TransferItems[nCurrentTransferItem].MediaType() == TYMED_FILE && S_OK == hr && !(bInPageFeederMode && !nPageCount))
|
|
{
|
|
//
|
|
// Check to see if this file has already been downloaded
|
|
//
|
|
int nIdenticalFileIndex = FileUniquenessList.FindIdenticalFile(strFinalFilename,true);
|
|
if (nIdenticalFileIndex != -1)
|
|
{
|
|
//
|
|
// Get the duplicate's name
|
|
//
|
|
CSimpleString strDuplicateName = FileUniquenessList.GetFileName(nIdenticalFileIndex);
|
|
|
|
//
|
|
// Make sure the name is not empty
|
|
//
|
|
if (strDuplicateName.Length())
|
|
{
|
|
//
|
|
// Create the message to give the user
|
|
//
|
|
CSimpleString strMessage;
|
|
strMessage.Format( IDS_DUPLICATE_FILE_WARNING, g_hInstance );
|
|
|
|
//
|
|
// Ask the user if they want to keep the new one
|
|
//
|
|
int nResult;
|
|
if (CMessageBoxEx::IDMBEX_YESTOALL == nPersistentDuplicateResult)
|
|
{
|
|
nResult = CMessageBoxEx::IDMBEX_YES;
|
|
}
|
|
else if (CMessageBoxEx::IDMBEX_NOTOALL == nPersistentDuplicateResult)
|
|
{
|
|
nResult = CMessageBoxEx::IDMBEX_NO;
|
|
}
|
|
else
|
|
{
|
|
nResult = ReportError( NotifyWindow(), strMessage, CMessageBoxEx::MBEX_YESYESTOALLNONOTOALL|CMessageBoxEx::MBEX_ICONQUESTION );
|
|
WIA_TRACE((TEXT("User's Response to \"Save Duplicate? %08X\""), nResult ));
|
|
}
|
|
|
|
//
|
|
// Save persistent responses
|
|
//
|
|
if (nResult == CMessageBoxEx::IDMBEX_YESTOALL)
|
|
{
|
|
nPersistentDuplicateResult = CMessageBoxEx::IDMBEX_YESTOALL;
|
|
nResult = CMessageBoxEx::IDMBEX_YES;
|
|
}
|
|
else if (nResult == CMessageBoxEx::IDMBEX_NOTOALL)
|
|
{
|
|
nPersistentDuplicateResult = CMessageBoxEx::IDMBEX_NOTOALL;
|
|
nResult = CMessageBoxEx::IDMBEX_NO;
|
|
}
|
|
|
|
//
|
|
// If the user doesn't want to keep new one, delete it, and save the filename
|
|
//
|
|
if (nResult == CMessageBoxEx::IDMBEX_NO)
|
|
{
|
|
DeleteFile( strFinalFilename );
|
|
strFinalFilename = strDuplicateName;
|
|
bDuplicateImage = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If everything is *still* OK
|
|
//
|
|
if (S_OK == hr)
|
|
{
|
|
//
|
|
// Save the audio, if any
|
|
//
|
|
CSimpleString strAudioFilename;
|
|
HRESULT hResAudio = WiaUiUtil::SaveWiaItemAudio( pWiaItem, strFinalFilename, strAudioFilename );
|
|
if (SUCCEEDED(hResAudio) && strAudioFilename.Length())
|
|
{
|
|
CurrentFileInformationList.Append(CDownloadedFileInformation(strAudioFilename,false,m_Cookies[nCurrentImage],false));
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hResAudio,TEXT("SaveWiaItemAudio failed!")));
|
|
}
|
|
|
|
//
|
|
// Set the file time to the item time
|
|
//
|
|
if (m_bStampTime)
|
|
{
|
|
HRESULT hResFileTime = WiaUiUtil::StampItemTimeOnFile( pWiaItem, strFinalFilename );
|
|
if (!SUCCEEDED(hResFileTime))
|
|
{
|
|
WIA_PRINTHRESULT((hResAudio,TEXT("StampItemTimeOnFile failed!")));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save the downloaded file information. Mark it "IncludeInFileCount" if it is the first image in the group.
|
|
//
|
|
CurrentFileInformationList.Append(CDownloadedFileInformation(strFinalFilename,bDuplicateImage==false,m_Cookies[nCurrentImage],nCurrentTransferItem==0));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Clean up the final filename, in case of failure
|
|
//
|
|
if (!DeleteFile( strFinalFilename ))
|
|
{
|
|
WIA_PRINTHRESULT((MY_HRESULT_FROM_WIN32(GetLastError()),TEXT("DeleteFile(%s) failed!"), strFinalFilename.String()));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make sure the intermediate file is removed
|
|
//
|
|
if (!DeleteFile( strIntermediateFilename ))
|
|
{
|
|
WIA_PRINTHRESULT((MY_HRESULT_FROM_WIN32(GetLastError()),TEXT("DeleteFile(%s) failed!"), strIntermediateFilename.String()));
|
|
}
|
|
|
|
//
|
|
// Tell the notify window we are done with this image
|
|
//
|
|
if (hr != WIA_ERROR_PAPER_EMPTY)
|
|
{
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::EndDownloadImageMessage( nCurrentImage, m_Cookies[nCurrentImage], strFinalFilename, hr ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStopTransferring = true;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Tell the user specifically why we couldn't create the placeholder file
|
|
//
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create a placeholder file")));
|
|
bStopTransferring = true;
|
|
switch (hr)
|
|
{
|
|
case E_ACCESSDENIED:
|
|
strExtendedErrorInformation.LoadString( IDS_ERROR_ACCESS_DENIED, g_hInstance );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create an output filename")));
|
|
bStopTransferring = true;
|
|
}
|
|
|
|
//
|
|
// Assume we will not be continuing
|
|
//
|
|
bContinueScanningPages = false;
|
|
|
|
//
|
|
// If we are out of paper, and we have one or more pages already, we are done, and there are no errors
|
|
//
|
|
if (nPageCount && WIA_ERROR_PAPER_EMPTY == hr)
|
|
{
|
|
//
|
|
// If we are doing single-page TIFF output, we can create a multi-page TIFF file
|
|
//
|
|
if (Gdiplus::ImageFormatTIFF == guidOutputFormat && TYMED_FILE == nMediaType)
|
|
{
|
|
//
|
|
// Get the list of all files we are going to concatenate
|
|
//
|
|
CSimpleDynamicArray<CSimpleStringWide> AllFiles;
|
|
if (SUCCEEDED(CurrentFileInformationList.GetAllFiles(AllFiles)) && AllFiles.Size())
|
|
{
|
|
//
|
|
// Create a temporary filename to save the images to, so we don't overwrite the original
|
|
//
|
|
CSimpleStringWide strwTempOutputFilename = CSimpleStringConvert::WideString(WiaUiUtil::CreateTempFileName(0));
|
|
if (strwTempOutputFilename.Length())
|
|
{
|
|
//
|
|
// Save the images as a multi-page TIFF file
|
|
//
|
|
if (SUCCEEDED(m_GdiPlusHelper.SaveMultipleImagesAsMultiPage( AllFiles, strwTempOutputFilename, Gdiplus::ImageFormatTIFF )))
|
|
{
|
|
//
|
|
// Save the first entry in the current list
|
|
//
|
|
CDownloadedFileInformation MultipageOutputFilename = CurrentFileInformationList[0];
|
|
|
|
//
|
|
// Mark the first entry as non-deletable
|
|
//
|
|
CurrentFileInformationList[0].DeleteOnError(false);
|
|
|
|
//
|
|
// Try to move the file from the temp folder to the final destination
|
|
//
|
|
if (SUCCEEDED(WiaUiUtil::MoveOrCopyFile( CSimpleStringConvert::NaturalString(strwTempOutputFilename), CurrentFileInformationList[0].Filename())))
|
|
{
|
|
//
|
|
// Delete all of the files (they are now part of the multi-page TIFF
|
|
//
|
|
CurrentFileInformationList.DeleteAllFiles();
|
|
|
|
//
|
|
// Destroy the list
|
|
//
|
|
CurrentFileInformationList.Destroy();
|
|
|
|
//
|
|
// Add the saved first image back to the list
|
|
//
|
|
CurrentFileInformationList.Append(MultipageOutputFilename);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If we can't move the file, we have to delete it, to make sure we don't leave
|
|
// abandoned files laying around
|
|
//
|
|
DeleteFile( CSimpleStringConvert::NaturalString(strwTempOutputFilename) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// WIA_ERROR_PAPER_EMPTY is not an error in this context, so clear it
|
|
//
|
|
hr = S_OK;
|
|
}
|
|
else if (hr == S_OK)
|
|
{
|
|
//
|
|
// if we are in page feeder mode, we should continue scanning since we didn't get any errors
|
|
//
|
|
if (bInPageFeederMode && TYMED_FILE == nMediaType)
|
|
{
|
|
bContinueScanningPages = true;
|
|
}
|
|
|
|
//
|
|
// One more page transferred
|
|
//
|
|
nPageCount++;
|
|
}
|
|
|
|
} // End while loop
|
|
|
|
//
|
|
// Add all of the successfully transferred files to the complete file list
|
|
//
|
|
DownloadedFileInformationList.Append(CurrentFileInformationList);
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pWiaSupportedFormats->GetDefaultClipboardFileFormat() failed")));
|
|
bStopTransferring = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("pWiaSupportedFormats->Initialize() failed")));
|
|
bStopTransferring = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to retrieve interface %08X from the global interface table"),m_Cookies[nCurrentImage]));
|
|
bStopTransferring = true;
|
|
}
|
|
|
|
//
|
|
// Do this at the end of the loop, so we can pick up the item cookie it failed on
|
|
// This is only for handling errors specially
|
|
//
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// Make sure we send a message to the UI to alert it to errors, so it can update progress.
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::EndDownloadImageMessage( nCurrentImage, m_Cookies[nCurrentImage], TEXT(""), hr ) );
|
|
|
|
} // end if (FAILED)
|
|
} // end for
|
|
|
|
//
|
|
// If there was a download error, but the user chose to suppress these errors
|
|
// AND there were some files downloaded, don't return an error.
|
|
//
|
|
if (FAILED(hr) && bLastErrorSkipped && DownloadedFileInformationList.Size())
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("QueryInterface failed on IID_IWiaDataCallback")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("QueryInterface failed on IID_IWiaSupportedFormats")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create the transfer helper class")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create the global interface table")));
|
|
}
|
|
|
|
//
|
|
// If the user cancelled, delete all the files we downloaded
|
|
//
|
|
if (FAILED(hr) || bCancelled)
|
|
{
|
|
DownloadedFileInformationList.DeleteAllFiles();
|
|
}
|
|
|
|
//
|
|
// Update the folder time, to cause the thumbnail to regenerate
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
UpdateFolderTime( m_strDirectory );
|
|
}
|
|
|
|
//
|
|
// Print the final result to the debugger
|
|
//
|
|
WIA_PRINTHRESULT((hr,TEXT("This is the result of downloading all of the images: %s"),strExtendedErrorInformation.String()));
|
|
|
|
//
|
|
// Tell the notification window we are done downloading images
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::EndDownloadAllMessage( hr, strExtendedErrorInformation, &DownloadedFileInformationList ) );
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
CSimpleString CDownloadImagesThreadMessage::GetDateString(void)
|
|
{
|
|
SYSTEMTIME LocalTime = {0};
|
|
GetLocalTime(&LocalTime);
|
|
TCHAR szDate[MAX_PATH] = {0};
|
|
if (GetDateFormat( LOCALE_USER_DEFAULT, DATE_LONGDATE, &LocalTime, NULL, szDate, ARRAYSIZE(szDate)))
|
|
{
|
|
return CSimpleString().Format( IDS_UPLOADED_STRING, g_hInstance, szDate );
|
|
}
|
|
return TEXT("");
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDownloadImagesThreadMessage::QueryInterface( REFIID riid, LPVOID *ppvObject )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CWiaDefaultUI::QueryInterface"));
|
|
if (IsEqualIID( riid, IID_IUnknown ))
|
|
{
|
|
*ppvObject = static_cast<IWiaDataCallback*>(this);
|
|
}
|
|
else if (IsEqualIID( riid, IID_IWiaDataCallback ))
|
|
{
|
|
*ppvObject = static_cast<IWiaDataCallback*>(this);
|
|
}
|
|
else
|
|
{
|
|
*ppvObject = NULL;
|
|
return(E_NOINTERFACE);
|
|
}
|
|
reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CDownloadImagesThreadMessage::AddRef(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDownloadImagesThreadMessage::Release(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHODIMP CDownloadImagesThreadMessage::BandedDataCallback(
|
|
LONG lReason,
|
|
LONG lStatus,
|
|
LONG lPercentComplete,
|
|
LONG lOffset,
|
|
LONG lLength,
|
|
LONG lReserved,
|
|
LONG lResLength,
|
|
PBYTE pbBuffer )
|
|
{
|
|
WIA_PUSH_FUNCTION(( TEXT("CDownloadImagesThreadMessage::BandedDataCallback(%X,%X,%d,%X,%X,%X,%X,%X"), lReason, lStatus, lPercentComplete, lOffset, lLength, lReserved, lResLength, pbBuffer ));
|
|
//
|
|
// First of all, check to see if we've been cancelled
|
|
//
|
|
if (m_hCancelDownloadEvent && WAIT_TIMEOUT!=WaitForSingleObject(m_hCancelDownloadEvent,0))
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
switch (lReason)
|
|
{
|
|
case IT_MSG_STATUS:
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::UpdateDownloadImageMessage( lPercentComplete ) );
|
|
break;
|
|
|
|
case IT_MSG_FILE_PREVIEW_DATA_HEADER:
|
|
//
|
|
// Get rid of the old one
|
|
//
|
|
m_MemoryDib.Destroy();
|
|
|
|
//
|
|
// Make sure we start a new one
|
|
//
|
|
m_bFirstTransfer = true;
|
|
m_nCurrentPreviewImageLine = 0;
|
|
|
|
break;
|
|
|
|
case IT_MSG_FILE_PREVIEW_DATA:
|
|
if (lStatus & IT_STATUS_TRANSFER_TO_CLIENT)
|
|
{
|
|
if (m_bFirstTransfer)
|
|
{
|
|
//
|
|
// Assuming there is no way we could get a lLength smaller than the image header size
|
|
//
|
|
m_bFirstTransfer = false;
|
|
m_MemoryDib.Initialize( reinterpret_cast<PBITMAPINFO>(pbBuffer) );
|
|
|
|
lLength -= WiaUiUtil::GetBmiSize(reinterpret_cast<PBITMAPINFO>(pbBuffer));
|
|
lOffset += WiaUiUtil::GetBmiSize(reinterpret_cast<PBITMAPINFO>(pbBuffer));
|
|
|
|
//
|
|
// We're getting a preview image
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::BeginPreviewMessage( m_nCurrentCookie, m_MemoryDib.Bitmap()) );
|
|
}
|
|
|
|
//
|
|
// Make sure we are dealing with valid data
|
|
//
|
|
if (m_MemoryDib.IsValid())
|
|
{
|
|
//
|
|
// This should be an even number of lines. If it isn't, things are going to get messed up
|
|
//
|
|
int nLineCount = lLength / m_MemoryDib.GetUnpackedWidthInBytes();
|
|
|
|
//
|
|
// Scroll the data up if we are out of room
|
|
//
|
|
WIA_TRACE((TEXT("nLineCount = %d, nCurrentLine = %d, m_MemoryDib.GetHeight() = %d"), nLineCount, m_nCurrentPreviewImageLine, m_MemoryDib.GetHeight() ));
|
|
if (nLineCount + m_nCurrentPreviewImageLine > m_MemoryDib.GetHeight())
|
|
{
|
|
int nNumberOfLinesToScroll = (nLineCount + m_nCurrentPreviewImageLine) - m_MemoryDib.GetHeight();
|
|
m_MemoryDib.ScrollDataUp(nNumberOfLinesToScroll);
|
|
m_nCurrentPreviewImageLine = m_MemoryDib.GetHeight() - nLineCount;
|
|
}
|
|
|
|
|
|
WIA_TRACE((TEXT("nCurrentLine: %d, nLineCount: %d"), m_nCurrentPreviewImageLine, nLineCount ));
|
|
|
|
//
|
|
// Copy the data to our bitmap
|
|
//
|
|
m_MemoryDib.SetUnpackedData( pbBuffer, m_nCurrentPreviewImageLine, nLineCount );
|
|
|
|
//
|
|
// This is where we'll start next time
|
|
//
|
|
m_nCurrentPreviewImageLine += nLineCount;
|
|
|
|
//
|
|
// Tell the UI we have an update
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::UpdatePreviewMessage( m_nCurrentCookie, m_MemoryDib.Bitmap() ) );
|
|
|
|
//
|
|
// If this is it for this preview, tell the UI
|
|
//
|
|
if (lPercentComplete == 100)
|
|
{
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDownloadImagesThreadNotifyMessage::EndPreviewMessage( m_nCurrentCookie ) );
|
|
}
|
|
}
|
|
} // IT_STATUS_TRANSFER_TO_CLIENT
|
|
break;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------
|
|
// CDeleteImagesThreadMessage
|
|
// -------------------------------------------------
|
|
CDeleteImagesThreadMessage::CDeleteImagesThreadMessage(
|
|
HWND hWndNotify,
|
|
const CSimpleDynamicArray<DWORD> &Cookies,
|
|
HANDLE hCancelDeleteEvent,
|
|
HANDLE hPauseDeleteEvent,
|
|
bool bSlowItDown
|
|
)
|
|
: CNotifyThreadMessage( TQ_DELETEIMAGES, hWndNotify ),
|
|
m_Cookies(Cookies),
|
|
m_hCancelDeleteEvent(NULL),
|
|
m_hPauseDeleteEvent(NULL),
|
|
m_bSlowItDown(bSlowItDown)
|
|
{
|
|
if (hCancelDeleteEvent)
|
|
{
|
|
DuplicateHandle( GetCurrentProcess(), hCancelDeleteEvent, GetCurrentProcess(), &m_hCancelDeleteEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
}
|
|
if (hPauseDeleteEvent)
|
|
{
|
|
DuplicateHandle( GetCurrentProcess(), hPauseDeleteEvent, GetCurrentProcess(), &m_hPauseDeleteEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
}
|
|
}
|
|
|
|
|
|
CDeleteImagesThreadMessage::~CDeleteImagesThreadMessage(void)
|
|
{
|
|
if (m_hCancelDeleteEvent)
|
|
{
|
|
CloseHandle(m_hCancelDeleteEvent);
|
|
m_hCancelDeleteEvent = NULL;
|
|
}
|
|
if (m_hPauseDeleteEvent)
|
|
{
|
|
CloseHandle(m_hPauseDeleteEvent);
|
|
m_hPauseDeleteEvent = NULL;
|
|
}
|
|
}
|
|
|
|
HRESULT CDeleteImagesThreadMessage::DeleteImages(void)
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CDeleteImagesThreadMessage::DeleteImages")));
|
|
//
|
|
// This is the result of downloading all of the images. If any errors
|
|
// occur, we will return an error. Otherwise, we will return S_OK
|
|
//
|
|
HRESULT hrFinalResult = S_OK;
|
|
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDeleteImagesThreadNotifyMessage::BeginDeleteAllMessage( m_Cookies.Size() ) );
|
|
|
|
//
|
|
// Pause a little while, so the user can read the wizard page
|
|
//
|
|
if (m_bSlowItDown)
|
|
{
|
|
Sleep(DELETE_DELAY_BEFORE);
|
|
}
|
|
|
|
|
|
//
|
|
// Get an instance of the GIT
|
|
//
|
|
CComPtr<IGlobalInterfaceTable> pGlobalInterfaceTable;
|
|
HRESULT hr = CoCreateInstance( CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, IID_IGlobalInterfaceTable, (VOID**)&pGlobalInterfaceTable );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (int i=0;i<m_Cookies.Size();i++)
|
|
{
|
|
//
|
|
// Tell the notification window which image we are deleting
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDeleteImagesThreadNotifyMessage::BeginDeleteImageMessage( i, m_Cookies[i] ) );
|
|
|
|
//
|
|
// Get the item from the GIT
|
|
//
|
|
CComPtr<IWiaItem> pWiaItem;
|
|
hr = pGlobalInterfaceTable->GetInterfaceFromGlobal(m_Cookies[i], IID_IWiaItem, (void**)&pWiaItem );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Wait forever if we are paused
|
|
//
|
|
if (m_hPauseDeleteEvent)
|
|
{
|
|
WiaUiUtil::MsgWaitForSingleObject(m_hPauseDeleteEvent,INFINITE);
|
|
}
|
|
|
|
//
|
|
// Check for a cancel
|
|
//
|
|
if (m_hCancelDeleteEvent && WAIT_OBJECT_0==WaitForSingleObject(m_hCancelDeleteEvent,0))
|
|
{
|
|
hr = hrFinalResult = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Delete the item. Note that we don't consider delete errors to be fatal, so we continue
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,8,WiaUiUtil::DeleteItemAndChildren(pWiaItem));
|
|
if (S_OK != hr)
|
|
{
|
|
hrFinalResult = hr;
|
|
WIA_PRINTHRESULT((hr,TEXT("DeleteItemAndChildren failed")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hrFinalResult = hr;
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to retrieve interface %08X from the global interface table"),m_Cookies[i]));
|
|
}
|
|
|
|
//
|
|
// Pause a little while, so the user can read the wizard page
|
|
//
|
|
if (m_bSlowItDown)
|
|
{
|
|
Sleep(DELETE_DELAY_DURING / m_Cookies.Size());
|
|
}
|
|
|
|
//
|
|
// Save any errors
|
|
//
|
|
if (FAILED(hr))
|
|
{
|
|
hrFinalResult = hr;
|
|
}
|
|
|
|
//
|
|
// If the device is disconnected, we may as well stop
|
|
//
|
|
if (WIA_ERROR_OFFLINE == hr)
|
|
{
|
|
break;
|
|
}
|
|
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDeleteImagesThreadNotifyMessage::EndDeleteImageMessage( i, m_Cookies[i], hr ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hrFinalResult = hr;
|
|
}
|
|
|
|
//
|
|
// Pause a little while, so the user can read the wizard page
|
|
//
|
|
if (m_bSlowItDown)
|
|
{
|
|
Sleep(DELETE_DELAY_AFTER);
|
|
}
|
|
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CDeleteImagesThreadNotifyMessage::EndDeleteAllMessage( hrFinalResult ) );
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------------
|
|
// CPreviewScanThreadMessage
|
|
// -------------------------------------------------
|
|
CPreviewScanThreadMessage::CPreviewScanThreadMessage(
|
|
HWND hWndNotify,
|
|
DWORD dwCookie,
|
|
HANDLE hCancelPreviewEvent
|
|
)
|
|
: CNotifyThreadMessage( TQ_SCANPREVIEW, hWndNotify ),
|
|
m_dwCookie(dwCookie),
|
|
m_bFirstTransfer(true)
|
|
{
|
|
DuplicateHandle( GetCurrentProcess(), hCancelPreviewEvent, GetCurrentProcess(), &m_hCancelPreviewEvent, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
}
|
|
|
|
|
|
CPreviewScanThreadMessage::~CPreviewScanThreadMessage()
|
|
{
|
|
if (m_hCancelPreviewEvent)
|
|
{
|
|
CloseHandle(m_hCancelPreviewEvent);
|
|
m_hCancelPreviewEvent = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Calculate the maximum scan size using the give DPI
|
|
//
|
|
static bool GetFullResolution( IWiaItem *pWiaItem, LONG nResX, LONG nResY, LONG &nExtX, LONG &nExtY )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CScannerItem::GetFullResolution"));
|
|
CComPtr<IWiaItem> pRootItem;
|
|
if (SUCCEEDED(pWiaItem->GetRootItem(&pRootItem)) && pRootItem)
|
|
{
|
|
LONG lBedSizeX, lBedSizeY, nPaperSource;
|
|
if (PropStorageHelpers::GetProperty( pRootItem, WIA_DPS_DOCUMENT_HANDLING_SELECT, static_cast<LONG>(nPaperSource)) && nPaperSource & FEEDER)
|
|
{
|
|
if (PropStorageHelpers::GetProperty( pRootItem, WIA_DPS_HORIZONTAL_SHEET_FEED_SIZE, lBedSizeX ) &&
|
|
PropStorageHelpers::GetProperty( pRootItem, WIA_DPS_VERTICAL_SHEET_FEED_SIZE, lBedSizeY ))
|
|
{
|
|
nExtX = WiaUiUtil::MulDivNoRound( nResX, lBedSizeX, 1000 );
|
|
nExtY = WiaUiUtil::MulDivNoRound( nResY, lBedSizeY, 1000 );
|
|
return(true);
|
|
}
|
|
}
|
|
if (PropStorageHelpers::GetProperty( pRootItem, WIA_DPS_HORIZONTAL_BED_SIZE, lBedSizeX ) &&
|
|
PropStorageHelpers::GetProperty( pRootItem, WIA_DPS_VERTICAL_BED_SIZE, lBedSizeY ))
|
|
{
|
|
nExtX = WiaUiUtil::MulDivNoRound( nResX, lBedSizeX, 1000 );
|
|
nExtY = WiaUiUtil::MulDivNoRound( nResY, lBedSizeY, 1000 );
|
|
return(true);
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
|
|
static bool CalculatePreviewResolution( IWiaItem *pWiaItem, LONG &nResX, LONG &nResY )
|
|
{
|
|
const LONG nDesiredResolution = 50;
|
|
PropStorageHelpers::CPropertyRange XResolutionRange, YResolutionRange;
|
|
if (PropStorageHelpers::GetPropertyRange( pWiaItem, WIA_IPS_XRES, XResolutionRange ) &&
|
|
PropStorageHelpers::GetPropertyRange( pWiaItem, WIA_IPS_YRES, YResolutionRange ))
|
|
{
|
|
nResX = WiaUiUtil::GetMinimum<LONG>( XResolutionRange.nMin, nDesiredResolution, XResolutionRange.nStep );
|
|
nResY = WiaUiUtil::GetMinimum<LONG>( YResolutionRange.nMin, nDesiredResolution, YResolutionRange.nStep );
|
|
return(true);
|
|
}
|
|
else
|
|
{
|
|
CSimpleDynamicArray<LONG> XResolutionList, YResolutionList;
|
|
if (PropStorageHelpers::GetPropertyList( pWiaItem, WIA_IPS_XRES, XResolutionList ) &&
|
|
PropStorageHelpers::GetPropertyList( pWiaItem, WIA_IPS_YRES, YResolutionList ))
|
|
{
|
|
for (int i=0;i<XResolutionList.Size();i++)
|
|
{
|
|
nResX = XResolutionList[i];
|
|
if (nResX >= nDesiredResolution)
|
|
break;
|
|
}
|
|
for (i=0;i<YResolutionList.Size();i++)
|
|
{
|
|
nResY = YResolutionList[i];
|
|
if (nResY >= nDesiredResolution)
|
|
break;
|
|
}
|
|
return(true);
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
HRESULT CPreviewScanThreadMessage::Scan(void)
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CPreviewScanThreadMessage::Download")));
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CPreviewScanThreadNotifyMessage::BeginDownloadMessage( m_dwCookie ) );
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IGlobalInterfaceTable> pGlobalInterfaceTable;
|
|
hr = CoCreateInstance( CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, IID_IGlobalInterfaceTable, (VOID**)&pGlobalInterfaceTable );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IWiaTransferHelper> pWiaTransferHelper;
|
|
hr = CoCreateInstance( CLSID_WiaDefaultUi, NULL, CLSCTX_INPROC_SERVER, IID_IWiaTransferHelper, (void**)&pWiaTransferHelper );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IWiaDataCallback> pWiaDataCallback;
|
|
hr = this->QueryInterface( IID_IWiaDataCallback, (void**)&pWiaDataCallback );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CComPtr<IWiaItem> pWiaItem;
|
|
hr = pGlobalInterfaceTable->GetInterfaceFromGlobal(m_dwCookie, IID_IWiaItem, (void**)&pWiaItem );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LONG nResX, nResY;
|
|
if (CalculatePreviewResolution(pWiaItem,nResX,nResY))
|
|
{
|
|
LONG nExtX, nExtY;
|
|
if (GetFullResolution(pWiaItem,nResX,nResY,nExtX,nExtY))
|
|
{
|
|
CPropertyStream SavedProperties;
|
|
hr = SavedProperties.AssignFromWiaItem( pWiaItem );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_XRES, nResX ) &&
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_YRES, nResY ) &&
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_XPOS, 0 ) &&
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_YPOS, 0 ) &&
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_XEXTENT, nExtX ) &&
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_IPS_YEXTENT, nExtY ))
|
|
{
|
|
//
|
|
// Set the preview property. Ignore failure (it is an optional property)
|
|
//
|
|
PropStorageHelpers::SetProperty( pWiaItem, WIA_DPS_PREVIEW, 1 );
|
|
hr = pWiaTransferHelper->TransferItemBanded( pWiaItem, NotifyWindow(), WIA_TRANSFERHELPER_NOPROGRESS, WiaImgFmt_MEMORYBMP, 0, pWiaDataCallback );
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
SavedProperties.ApplyToWiaItem( pWiaItem );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("Unable to calculate the preview resolution size")));
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("Unable to calculate the preview resolution")));
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to retrieve interface %08X from the global interface table"),m_dwCookie));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("QueryInterface failed on IID_IWiaDataCallback")));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create the transfer helper class")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTHRESULT((hr,TEXT("Unable to create the global interface table")));
|
|
}
|
|
if (FAILED(hr) || hr == S_FALSE)
|
|
{
|
|
m_MemoryDib.Destroy();
|
|
}
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CPreviewScanThreadNotifyMessage::EndDownloadMessage( m_dwCookie, m_MemoryDib.DetachBitmap(), hr ) );
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CPreviewScanThreadMessage::QueryInterface( REFIID riid, LPVOID *ppvObject )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CWiaDefaultUI::QueryInterface"));
|
|
if (IsEqualIID( riid, IID_IUnknown ))
|
|
{
|
|
*ppvObject = static_cast<IWiaDataCallback*>(this);
|
|
}
|
|
else if (IsEqualIID( riid, IID_IWiaDataCallback ))
|
|
{
|
|
*ppvObject = static_cast<IWiaDataCallback*>(this);
|
|
}
|
|
else
|
|
{
|
|
*ppvObject = NULL;
|
|
return(E_NOINTERFACE);
|
|
}
|
|
reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CPreviewScanThreadMessage::AddRef(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CPreviewScanThreadMessage::Release(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHODIMP CPreviewScanThreadMessage::BandedDataCallback(
|
|
LONG lReason,
|
|
LONG lStatus,
|
|
LONG lPercentComplete,
|
|
LONG lOffset,
|
|
LONG lLength,
|
|
LONG lReserved,
|
|
LONG lResLength,
|
|
PBYTE pbBuffer )
|
|
{
|
|
WIA_PUSH_FUNCTION(( TEXT("CPreviewScanThreadMessage::BandedDataCallback(%X,%X,%d,%X,%X,%X,%X,%X"), lReason, lStatus, lPercentComplete, lOffset, lLength, lReserved, lResLength, pbBuffer ));
|
|
if (m_hCancelPreviewEvent && WAIT_OBJECT_0==WaitForSingleObject(m_hCancelPreviewEvent,0))
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
switch (lReason)
|
|
{
|
|
case IT_MSG_DATA_HEADER:
|
|
{
|
|
m_bFirstTransfer = true;
|
|
break;
|
|
} // IT_MSG_DATA_HEADER
|
|
|
|
case IT_MSG_DATA:
|
|
if (lStatus & IT_STATUS_TRANSFER_TO_CLIENT)
|
|
{
|
|
if (m_bFirstTransfer)
|
|
{
|
|
//
|
|
// Assuming there is no way we could get a lLength smaller than the image header size
|
|
//
|
|
m_bFirstTransfer = false;
|
|
m_MemoryDib.Initialize( reinterpret_cast<PBITMAPINFO>(pbBuffer) );
|
|
lLength -= WiaUiUtil::GetBmiSize(reinterpret_cast<PBITMAPINFO>(pbBuffer));
|
|
lOffset += WiaUiUtil::GetBmiSize(reinterpret_cast<PBITMAPINFO>(pbBuffer));
|
|
}
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Don't bother unless we have some data
|
|
//
|
|
if (lLength)
|
|
{
|
|
//
|
|
// Figure out which line we are on
|
|
//
|
|
int nCurrentLine = (lOffset - m_MemoryDib.GetHeaderLength())/m_MemoryDib.GetUnpackedWidthInBytes();
|
|
|
|
//
|
|
// This should be an even number of lines. If it isn't, things are going to get messed up
|
|
//
|
|
int nLineCount = lLength / m_MemoryDib.GetUnpackedWidthInBytes();
|
|
|
|
//
|
|
// Copy the data to our bitmap
|
|
//
|
|
m_MemoryDib.SetUnpackedData( pbBuffer, nCurrentLine, nLineCount );
|
|
|
|
//
|
|
// Tell the notification window we have some data
|
|
//
|
|
CThreadNotificationMessage::SendMessage( NotifyWindow(), CPreviewScanThreadNotifyMessage::UpdateDownloadMessage( m_dwCookie, m_MemoryDib.Bitmap() ) );
|
|
}
|
|
}
|
|
} // IT_STATUS_TRANSFER_TO_CLIENT
|
|
break;
|
|
|
|
case IT_MSG_STATUS:
|
|
{
|
|
} // IT_MSG_STATUS
|
|
break;
|
|
|
|
case IT_MSG_TERMINATION:
|
|
{
|
|
} // IT_MSG_TERMINATION
|
|
break;
|
|
|
|
default:
|
|
WIA_ERROR((TEXT("ImageDataCallback, unknown lReason: %d"), lReason ));
|
|
break;
|
|
}
|
|
return(hr);
|
|
}
|
|
|