|
|
/*******************************************************************************
* * (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);}
|
