mirror of https://github.com/tongzx/nt5src
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.
2185 lines
79 KiB
2185 lines
79 KiB
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORPORATION, 1998
|
|
*
|
|
* TITLE: ACQMGRCW.CPP
|
|
*
|
|
* VERSION: 1.0
|
|
*
|
|
* AUTHOR: ShaunIv
|
|
*
|
|
* DATE: 9/27/1999
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
*******************************************************************************/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include <windows.h>
|
|
#include <simcrack.h>
|
|
#include <commctrl.h>
|
|
#include <wiatextc.h>
|
|
#include <pviewids.h>
|
|
#include <commctrl.h>
|
|
#include "resource.h"
|
|
#include "acqmgrcw.h"
|
|
#include "wia.h"
|
|
#include "wiadevdp.h"
|
|
#include "evntparm.h"
|
|
#include "itranhlp.h"
|
|
#include "bkthread.h"
|
|
#include "wiaitem.h"
|
|
#include "errors.h"
|
|
#include "isuppfmt.h"
|
|
#include "uiexthlp.h"
|
|
#include "gphelper.h"
|
|
#include "svselfil.h"
|
|
#include "gwiaevnt.h"
|
|
#include "modlock.h"
|
|
#include "comfin.h"
|
|
#include "comprog.h"
|
|
#include "upquery.h"
|
|
#include "comdelp.h"
|
|
#include "devprop.h"
|
|
#include "mboxex.h"
|
|
#include "dumpprop.h"
|
|
#include "psutil.h"
|
|
|
|
#undef TRY_SMALLER_THUMBNAILS
|
|
|
|
#if defined(TRY_SMALLER_THUMBNAILS)
|
|
|
|
static const int c_nDefaultThumbnailWidth = 80;
|
|
static const int c_nDefaultThumbnailHeight = 80;
|
|
|
|
static const int c_nMaxThumbnailWidth = 80;
|
|
static const int c_nMaxThumbnailHeight = 80;
|
|
|
|
static const int c_nMinThumbnailWidth = 80;
|
|
static const int c_nMinThumbnailHeight = 80;
|
|
|
|
#else
|
|
|
|
static const int c_nDefaultThumbnailWidth = 90;
|
|
static const int c_nDefaultThumbnailHeight = 90;
|
|
|
|
static const int c_nMaxThumbnailWidth = 120;
|
|
static const int c_nMaxThumbnailHeight = 120;
|
|
|
|
static const int c_nMinThumbnailWidth = 80;
|
|
static const int c_nMinThumbnailHeight = 80;
|
|
|
|
|
|
#endif
|
|
|
|
//
|
|
// Property sheet pages' window class declarations
|
|
//
|
|
#include "comfirst.h"
|
|
#include "camsel.h"
|
|
#include "comtrans.h"
|
|
#include "scansel.h"
|
|
|
|
// -------------------------------------------------
|
|
// CAcquisitionManagerControllerWindow
|
|
// -------------------------------------------------
|
|
CAcquisitionManagerControllerWindow::CAcquisitionManagerControllerWindow( HWND hWnd )
|
|
: m_hWnd(hWnd),
|
|
m_pEventParameters(NULL),
|
|
m_DeviceTypeMode(UnknownMode),
|
|
m_hWizardIconSmall(NULL),
|
|
m_hWizardIconBig(NULL),
|
|
m_guidOutputFormat(IID_NULL),
|
|
m_bDeletePicturesIfSuccessful(false),
|
|
m_nThreadNotificationMessage(RegisterWindowMessage(STR_THREAD_NOTIFICATION_MESSAGE)),
|
|
m_nWiaEventMessage(RegisterWindowMessage(STR_WIAEVENT_NOTIFICATION_MESSAGE)),
|
|
m_bDisconnected(false),
|
|
m_pThreadMessageQueue(NULL),
|
|
m_bStampTimeOnSavedFiles(true),
|
|
m_bOpenShellAfterDownload(true),
|
|
m_bSuppressFirstPage(false),
|
|
m_nFailedImagesCount(0),
|
|
m_nDestinationPageIndex(-1),
|
|
m_nFinishPageIndex(-1),
|
|
m_nDeleteProgressPageIndex(-1),
|
|
m_nSelectionPageIndex(-1),
|
|
m_hWndWizard(NULL),
|
|
m_bTakePictureIsSupported(false),
|
|
m_nWiaWizardPageCount(0),
|
|
m_nUploadWizardPageCount(0),
|
|
m_bUploadToWeb(false),
|
|
m_cRef(1),
|
|
m_nScannerType(ScannerTypeUnknown),
|
|
m_OnDisconnect(0),
|
|
m_dwLastEnumerationTickCount(0)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::CAcquisitionManagerControllerWindow"));
|
|
|
|
// This sets up the map that maps thread messages to message handlers, which are declared to be static
|
|
// member functions.
|
|
static CThreadMessageMap s_MsgMap[] =
|
|
{
|
|
{ TQ_DESTROY, OnThreadDestroy},
|
|
{ TQ_DOWNLOADIMAGE, OnThreadDownloadImage},
|
|
{ TQ_DOWNLOADTHUMBNAIL, OnThreadDownloadThumbnail},
|
|
{ TQ_SCANPREVIEW, OnThreadPreviewScan},
|
|
{ TQ_DELETEIMAGES, OnThreadDeleteImages},
|
|
{ 0, NULL}
|
|
};
|
|
|
|
// Assume the default thumbnail size, in case we aren't able to calculate it
|
|
m_sizeThumbnails.cx = c_nDefaultThumbnailWidth;
|
|
m_sizeThumbnails.cy = c_nDefaultThumbnailHeight;
|
|
|
|
//
|
|
// Read the initial settings
|
|
//
|
|
CSimpleReg reg( HKEY_CURRENT_USER, REGSTR_PATH_USER_SETTINGS_WIAACMGR, false, KEY_READ );
|
|
m_bOpenShellAfterDownload = (reg.Query( REG_STR_OPENSHELL, m_bOpenShellAfterDownload ) != FALSE);
|
|
m_bSuppressFirstPage = (reg.Query( REG_STR_SUPRESSFIRSTPAGE, m_bSuppressFirstPage ) != FALSE);
|
|
|
|
//
|
|
// Initialize the background thread queue, which will handle all of our background requests
|
|
//
|
|
m_pThreadMessageQueue = new CThreadMessageQueue;
|
|
if (m_pThreadMessageQueue)
|
|
{
|
|
//
|
|
// Note that CBackgroundThread takes ownership of m_pThreadMessageQueue, and it doesn't have to be deleted in this thread
|
|
//
|
|
m_hBackgroundThread = CBackgroundThread::Create( m_pThreadMessageQueue, s_MsgMap, m_CancelEvent.Event(), NULL );
|
|
}
|
|
|
|
ZeroMemory( m_PublishWizardPages, sizeof(m_PublishWizardPages) );
|
|
}
|
|
|
|
CAcquisitionManagerControllerWindow::~CAcquisitionManagerControllerWindow(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::~CAcquisitionManagerControllerWindow"));
|
|
if (m_pEventParameters)
|
|
{
|
|
if (m_pEventParameters->pWizardSharedMemory)
|
|
{
|
|
delete m_pEventParameters->pWizardSharedMemory;
|
|
}
|
|
m_pEventParameters = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnDestroy( WPARAM, LPARAM )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::OnDestroy"));
|
|
|
|
//
|
|
// Tell the publishing wizard to release us
|
|
//
|
|
if (m_pPublishingWizard)
|
|
{
|
|
IUnknown_SetSite( m_pPublishingWizard, NULL );
|
|
}
|
|
|
|
//
|
|
// Release the publishing wizard and its data
|
|
//
|
|
m_pPublishingWizard = NULL;
|
|
|
|
//
|
|
// Stop downloading thumbnails
|
|
//
|
|
m_EventThumbnailCancel.Signal();
|
|
|
|
//
|
|
// Unpause the background thread
|
|
//
|
|
m_EventPauseBackgroundThread.Signal();
|
|
|
|
//
|
|
// Tell the background thread to destroy itself
|
|
//
|
|
m_pThreadMessageQueue->Enqueue( new CThreadMessage(TQ_DESTROY),CThreadMessageQueue::PriorityUrgent);
|
|
|
|
//
|
|
// Issue a cancel io command for this item
|
|
//
|
|
WiaUiUtil::IssueWiaCancelIO(m_pWiaItemRoot);
|
|
|
|
//
|
|
// Tell other instances we are done before the background thread is finished,
|
|
// so we can immediately start again
|
|
//
|
|
if (m_pEventParameters && m_pEventParameters->pWizardSharedMemory)
|
|
{
|
|
m_pEventParameters->pWizardSharedMemory->Close();
|
|
}
|
|
|
|
//
|
|
// Wait for the thread to exit
|
|
//
|
|
WiaUiUtil::MsgWaitForSingleObject( m_hBackgroundThread, INFINITE );
|
|
CloseHandle( m_hBackgroundThread );
|
|
|
|
//
|
|
// Clean up the icons
|
|
//
|
|
if (m_hWizardIconSmall)
|
|
{
|
|
DestroyIcon( m_hWizardIconSmall );
|
|
m_hWizardIconSmall = NULL;
|
|
}
|
|
if (m_hWizardIconBig)
|
|
{
|
|
DestroyIcon( m_hWizardIconBig );
|
|
m_hWizardIconBig = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
BOOL WINAPI CAcquisitionManagerControllerWindow::OnThreadDestroy( CThreadMessage *pMsg )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::OnThreadDestroy"));
|
|
// Return false to close the queue
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL WINAPI CAcquisitionManagerControllerWindow::OnThreadDownloadImage( CThreadMessage *pMsg )
|
|
{
|
|
CDownloadImagesThreadMessage *pDownloadImageThreadMessage = dynamic_cast<CDownloadImagesThreadMessage*>(pMsg);
|
|
if (pDownloadImageThreadMessage)
|
|
{
|
|
pDownloadImageThreadMessage->Download();
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pDownloadImageThreadMessage was NULL")));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL WINAPI CAcquisitionManagerControllerWindow::OnThreadDownloadThumbnail( CThreadMessage *pMsg )
|
|
{
|
|
CDownloadThumbnailsThreadMessage *pDownloadThumnailsThreadMessage = dynamic_cast<CDownloadThumbnailsThreadMessage*>(pMsg);
|
|
if (pDownloadThumnailsThreadMessage)
|
|
{
|
|
pDownloadThumnailsThreadMessage->Download();
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pDownloadThumnailThreadMessage was NULL")));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL WINAPI CAcquisitionManagerControllerWindow::OnThreadPreviewScan( CThreadMessage *pMsg )
|
|
{
|
|
CPreviewScanThreadMessage *pPreviewScanThreadMessage = dynamic_cast<CPreviewScanThreadMessage*>(pMsg);
|
|
if (pPreviewScanThreadMessage)
|
|
{
|
|
pPreviewScanThreadMessage->Scan();
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pPreviewScanThreadMessage was NULL")));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL WINAPI CAcquisitionManagerControllerWindow::OnThreadDeleteImages( CThreadMessage *pMsg )
|
|
{
|
|
CDeleteImagesThreadMessage *pDeleteImagesThreadMessage = dynamic_cast<CDeleteImagesThreadMessage*>(pMsg);
|
|
if (pDeleteImagesThreadMessage)
|
|
{
|
|
pDeleteImagesThreadMessage->DeleteImages();
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pPreviewScanThreadMessage was NULL")));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT CAcquisitionManagerControllerWindow::CreateDevice(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::CreateDevice"));
|
|
CComPtr<IWiaDevMgr> pWiaDevMgr;
|
|
HRESULT hr = CoCreateInstance( CLSID_WiaDevMgr, NULL, CLSCTX_LOCAL_SERVER, IID_IWiaDevMgr, (void**)&pWiaDevMgr );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bool bRetry = true;
|
|
for (DWORD dwRetryCount = 0;dwRetryCount < CREATE_DEVICE_RETRY_MAX_COUNT && bRetry;dwRetryCount++)
|
|
{
|
|
hr = pWiaDevMgr->CreateDevice( CSimpleBStr(m_pEventParameters->strDeviceID), &m_pWiaItemRoot );
|
|
WIA_PRINTHRESULT((hr,TEXT("pWiaDevMgr->CreateDevice returned")));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Break out of loop
|
|
//
|
|
bRetry = false;
|
|
|
|
//
|
|
// Register for events
|
|
//
|
|
CGenericWiaEventHandler::RegisterForWiaEvent( m_pEventParameters->strDeviceID, WIA_EVENT_DEVICE_DISCONNECTED, &m_pDisconnectEventObject, m_hWnd, m_nWiaEventMessage );
|
|
CGenericWiaEventHandler::RegisterForWiaEvent( m_pEventParameters->strDeviceID, WIA_EVENT_ITEM_DELETED, &m_pDeleteItemEventObject, m_hWnd, m_nWiaEventMessage );
|
|
CGenericWiaEventHandler::RegisterForWiaEvent( m_pEventParameters->strDeviceID, WIA_EVENT_DEVICE_CONNECTED, &m_pConnectEventObject, m_hWnd, m_nWiaEventMessage );
|
|
CGenericWiaEventHandler::RegisterForWiaEvent( m_pEventParameters->strDeviceID, WIA_EVENT_ITEM_CREATED, &m_pCreateItemEventObject, m_hWnd, m_nWiaEventMessage );
|
|
}
|
|
else if (WIA_ERROR_BUSY == hr)
|
|
{
|
|
//
|
|
// Wait a little while before retrying
|
|
//
|
|
Sleep(CREATE_DEVICE_RETRY_WAIT);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// All other errors are considered fatal
|
|
//
|
|
bRetry = false;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::GetCookiesOfSelectedImages( CWiaItem *pCurr, CSimpleDynamicArray<DWORD> &Cookies )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
GetCookiesOfSelectedImages(pCurr->Children(),Cookies);
|
|
if (pCurr->IsDownloadableItemType() && pCurr->SelectedForDownload())
|
|
{
|
|
Cookies.Append(pCurr->GlobalInterfaceTableCookie());
|
|
}
|
|
pCurr = pCurr->Next();
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::MarkAllItemsUnselected( CWiaItem *pCurrItem )
|
|
{
|
|
while (pCurrItem)
|
|
{
|
|
pCurrItem->SelectedForDownload(false);
|
|
MarkAllItemsUnselected( pCurrItem->Children() );
|
|
pCurrItem = pCurrItem->Next();
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::MarkItemSelected( CWiaItem *pItem, CWiaItem *pCurrItem )
|
|
{
|
|
while (pCurrItem)
|
|
{
|
|
if (pItem == pCurrItem && !pCurrItem->Deleted())
|
|
{
|
|
pCurrItem->SelectedForDownload(true);
|
|
}
|
|
MarkItemSelected( pItem, pCurrItem->Children() );
|
|
pCurrItem = pCurrItem->Next();
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::GetSelectedItems( CWiaItem *pCurr, CSimpleDynamicArray<CWiaItem*> &Items )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
GetSelectedItems(pCurr->Children(),Items);
|
|
if (pCurr->IsDownloadableItemType() && pCurr->SelectedForDownload())
|
|
{
|
|
Items.Append(pCurr);
|
|
}
|
|
pCurr = pCurr->Next();
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::GetRotationOfSelectedImages( CWiaItem *pCurr, CSimpleDynamicArray<int> &Rotation )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
GetRotationOfSelectedImages(pCurr->Children(),Rotation);
|
|
if (pCurr->IsDownloadableItemType() && pCurr->SelectedForDownload())
|
|
{
|
|
Rotation.Append(pCurr->Rotation());
|
|
}
|
|
pCurr = pCurr->Next();
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::GetCookiesOfAllImages( CWiaItem *pCurr, CSimpleDynamicArray<DWORD> &Cookies )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
GetCookiesOfAllImages(pCurr->Children(),Cookies);
|
|
if (pCurr->IsDownloadableItemType())
|
|
{
|
|
Cookies.Append(pCurr->GlobalInterfaceTableCookie());
|
|
}
|
|
pCurr = pCurr->Next();
|
|
}
|
|
}
|
|
|
|
|
|
int CAcquisitionManagerControllerWindow::GetSelectedImageCount( void )
|
|
{
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
CSimpleDynamicArray<int> Rotation;
|
|
GetCookiesOfSelectedImages( m_WiaItemList.Root(), Cookies );
|
|
GetRotationOfSelectedImages( m_WiaItemList.Root(), Rotation );
|
|
if (Rotation.Size() != Cookies.Size())
|
|
{
|
|
return 0;
|
|
}
|
|
return Cookies.Size();
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::DeleteDownloadedImages( HANDLE hCancelDeleteEvent )
|
|
{
|
|
//
|
|
// Make sure we are not paused
|
|
//
|
|
m_EventPauseBackgroundThread.Signal();
|
|
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
for (int i=0;i<m_DownloadedFileInformationList.Size();i++)
|
|
{
|
|
Cookies.Append(m_DownloadedFileInformationList[i].Cookie());
|
|
}
|
|
if (Cookies.Size())
|
|
{
|
|
CDeleteImagesThreadMessage *pDeleteImageThreadMessage = new CDeleteImagesThreadMessage(
|
|
m_hWnd,
|
|
Cookies,
|
|
hCancelDeleteEvent,
|
|
m_EventPauseBackgroundThread.Event(),
|
|
true
|
|
);
|
|
if (pDeleteImageThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pDeleteImageThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! Couldn't allocate the thread message")));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! No selected items! Cookies.Size() = %d"), Cookies.Size()));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::DeleteSelectedImages(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::DeleteSelectedImages"));
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
GetCookiesOfSelectedImages( m_WiaItemList.Root(), Cookies );
|
|
|
|
//
|
|
// Make sure we are not paused
|
|
//
|
|
m_EventPauseBackgroundThread.Signal();
|
|
|
|
if (Cookies.Size())
|
|
{
|
|
CDeleteImagesThreadMessage *pDeleteImageThreadMessage = new CDeleteImagesThreadMessage(
|
|
m_hWnd,
|
|
Cookies,
|
|
NULL,
|
|
m_EventPauseBackgroundThread.Event(),
|
|
false
|
|
);
|
|
if (pDeleteImageThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pDeleteImageThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! Couldn't allocate the thread message")));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! No selected items! Cookies.Size() = %d"), Cookies.Size()));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::DownloadSelectedImages( HANDLE hCancelDownloadEvent )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::DownloadSelectedImages"));
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
CSimpleDynamicArray<int> Rotation;
|
|
GetCookiesOfSelectedImages( m_WiaItemList.Root(), Cookies );
|
|
GetRotationOfSelectedImages( m_WiaItemList.Root(), Rotation );
|
|
|
|
//
|
|
// Make sure we are not paused
|
|
//
|
|
m_EventPauseBackgroundThread.Signal();
|
|
|
|
if (Cookies.Size() && Rotation.Size() == Cookies.Size())
|
|
{
|
|
CDownloadImagesThreadMessage *pDownloadImageThreadMessage = new CDownloadImagesThreadMessage(
|
|
m_hWnd,
|
|
Cookies,
|
|
Rotation,
|
|
m_szDestinationDirectory,
|
|
m_szRootFileName,
|
|
m_guidOutputFormat,
|
|
hCancelDownloadEvent,
|
|
m_bStampTimeOnSavedFiles,
|
|
m_EventPauseBackgroundThread.Event()
|
|
);
|
|
if (pDownloadImageThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pDownloadImageThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! Couldn't allocate the thread message")));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Uh-oh! No selected items! Cookies.Size() = %d, Rotation.Size() = %d"), Cookies.Size(), Rotation.Size()));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CAcquisitionManagerControllerWindow::DirectoryExists( LPCTSTR pszDirectoryName )
|
|
{
|
|
// Try to determine if this directory exists
|
|
DWORD dwFileAttributes = GetFileAttributes(pszDirectoryName);
|
|
if (dwFileAttributes == 0xFFFFFFFF || !(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
return false;
|
|
else return true;
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::RecursiveCreateDirectory( CSimpleString strDirectoryName )
|
|
{
|
|
// If this directory already exists, return true.
|
|
if (DirectoryExists(strDirectoryName))
|
|
return true;
|
|
// Otherwise try to create it.
|
|
CreateDirectory(strDirectoryName,NULL);
|
|
// If it now exists, return true
|
|
if (DirectoryExists(strDirectoryName))
|
|
return true;
|
|
else
|
|
{
|
|
// Remove the last subdir and try again
|
|
int nFind = strDirectoryName.ReverseFind(TEXT('\\'));
|
|
if (nFind >= 0)
|
|
{
|
|
RecursiveCreateDirectory( strDirectoryName.Left(nFind) );
|
|
// Now try to create it.
|
|
CreateDirectory(strDirectoryName,NULL);
|
|
}
|
|
}
|
|
//Does it exist now?
|
|
return DirectoryExists(strDirectoryName);
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::IsCameraThumbnailDownloaded( const CWiaItem &WiaItem, LPARAM lParam )
|
|
{
|
|
CAcquisitionManagerControllerWindow *pControllerWindow = reinterpret_cast<CAcquisitionManagerControllerWindow*>(lParam);
|
|
if (pControllerWindow &&
|
|
(pControllerWindow->m_DeviceTypeMode==CameraMode || pControllerWindow->m_DeviceTypeMode==VideoMode) &&
|
|
WiaItem.IsDownloadableItemType() &&
|
|
!WiaItem.BitmapData())
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int CAcquisitionManagerControllerWindow::GetCookies( CSimpleDynamicArray<DWORD> &Cookies, CWiaItem *pCurr, ComparisonCallbackFuntion pfnCallback, LPARAM lParam )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
GetCookies(Cookies, pCurr->Children(), pfnCallback, lParam );
|
|
if (pfnCallback && pfnCallback(*pCurr,lParam))
|
|
{
|
|
Cookies.Append(pCurr->GlobalInterfaceTableCookie());
|
|
}
|
|
pCurr = pCurr->Next();
|
|
}
|
|
return Cookies.Size();
|
|
}
|
|
|
|
// Download all of the camera's thumbnails that haven't been downloaded yet
|
|
void CAcquisitionManagerControllerWindow::DownloadAllThumbnails()
|
|
{
|
|
//
|
|
// Get all of the images in the device
|
|
//
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
GetCookies( Cookies, m_WiaItemList.Root(), IsCameraThumbnailDownloaded, reinterpret_cast<LPARAM>(this) );
|
|
if (Cookies.Size())
|
|
{
|
|
m_EventThumbnailCancel.Reset();
|
|
CDownloadThumbnailsThreadMessage *pDownloadThumbnailsThreadMessage = new CDownloadThumbnailsThreadMessage( m_hWnd, Cookies, m_EventThumbnailCancel.Event() );
|
|
if (pDownloadThumbnailsThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pDownloadThumbnailsThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::PerformPreviewScan( CWiaItem *pWiaItem, HANDLE hCancelPreviewEvent )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::PerformPreviewScan"));
|
|
if (pWiaItem)
|
|
{
|
|
CPreviewScanThreadMessage *pPreviewScanThreadMessage = new CPreviewScanThreadMessage( m_hWnd, pWiaItem->GlobalInterfaceTableCookie(), hCancelPreviewEvent );
|
|
if (pPreviewScanThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pPreviewScanThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::DisplayDisconnectMessageAndExit(void)
|
|
{
|
|
//
|
|
// Make sure we are not doing this more than once
|
|
//
|
|
if (!m_bDisconnected)
|
|
{
|
|
//
|
|
// Don't do this again
|
|
//
|
|
m_bDisconnected = true;
|
|
|
|
//
|
|
// Close the shared memory section so another instance can start up
|
|
//
|
|
if (m_pEventParameters && m_pEventParameters->pWizardSharedMemory)
|
|
{
|
|
m_pEventParameters->pWizardSharedMemory->Close();
|
|
}
|
|
|
|
if (m_OnDisconnect & OnDisconnectFailDownload)
|
|
{
|
|
//
|
|
// Set an appropriate error message
|
|
//
|
|
m_hrDownloadResult = WIA_ERROR_OFFLINE;
|
|
m_strErrorMessage.LoadString( IDS_DEVICE_DISCONNECTED, g_hInstance );
|
|
}
|
|
|
|
if ((m_OnDisconnect & OnDisconnectGotoLastpage) && m_hWndWizard)
|
|
{
|
|
//
|
|
// Find any active dialogs and close them
|
|
//
|
|
HWND hWndLastActive = GetLastActivePopup(m_hWndWizard);
|
|
if (hWndLastActive && hWndLastActive != m_hWndWizard)
|
|
{
|
|
SendMessage( hWndLastActive, WM_CLOSE, 0, 0 );
|
|
}
|
|
|
|
//
|
|
// Go to the finish page
|
|
//
|
|
PropSheet_SetCurSelByID( m_hWndWizard, IDD_COMMON_FINISH );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::SetMainWindowInSharedMemory( HWND hWnd )
|
|
{
|
|
//
|
|
// Try to grab the mutex
|
|
//
|
|
if (m_pEventParameters && m_pEventParameters->pWizardSharedMemory)
|
|
{
|
|
HWND *pHwnd = m_pEventParameters->pWizardSharedMemory->Lock();
|
|
if (pHwnd)
|
|
{
|
|
//
|
|
// Save the hWnd
|
|
//
|
|
*pHwnd = hWnd;
|
|
|
|
//
|
|
// Release the mutex
|
|
//
|
|
m_pEventParameters->pWizardSharedMemory->Release();
|
|
}
|
|
|
|
m_hWndWizard = hWnd;
|
|
}
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::GetAllImageItems( CSimpleDynamicArray<CWiaItem*> &Items, CWiaItem *pCurr )
|
|
{
|
|
while (pCurr)
|
|
{
|
|
if (pCurr->IsDownloadableItemType())
|
|
{
|
|
Items.Append( pCurr );
|
|
}
|
|
GetAllImageItems( Items, pCurr->Children() );
|
|
pCurr = pCurr->Next();
|
|
}
|
|
return(Items.Size() != 0);
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::GetAllImageItems( CSimpleDynamicArray<CWiaItem*> &Items )
|
|
{
|
|
return GetAllImageItems( Items, m_WiaItemList.Root() );
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::CanSomeSelectedImagesBeDeleted(void)
|
|
{
|
|
CSimpleDynamicArray<CWiaItem*> Items;
|
|
GetSelectedItems( m_WiaItemList.Root(), Items );
|
|
//
|
|
// Since we get these access flags in the background, if we don't actually have any yet,
|
|
// we will assume some images CAN be deleted
|
|
//
|
|
bool bNoneAreInitialized = true;
|
|
for (int i=0;i<Items.Size();i++)
|
|
{
|
|
if (Items[i])
|
|
{
|
|
if (Items[i]->AccessRights())
|
|
{
|
|
// At least one of the selected images has been initialized
|
|
bNoneAreInitialized = false;
|
|
|
|
// If at least one can be deleted, return true immediately
|
|
if (Items[i]->AccessRights() & WIA_ITEM_CAN_BE_DELETED)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If none of the images have been initialized, then we will report true
|
|
if (bNoneAreInitialized)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
CWiaItem *CAcquisitionManagerControllerWindow::FindItemByName( LPCWSTR pwszItemName )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CAcquisitionManagerControllerWindow::FindItemByName( %ws )"), pwszItemName ));
|
|
if (!pwszItemName)
|
|
return NULL;
|
|
if (!m_pWiaItemRoot)
|
|
return NULL;
|
|
return m_WiaItemList.Find(pwszItemName);
|
|
}
|
|
|
|
BOOL CAcquisitionManagerControllerWindow::ConfirmWizardCancel( HWND hWndParent )
|
|
{
|
|
//
|
|
// Always let it exit, for now.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
int CALLBACK CAcquisitionManagerControllerWindow::PropSheetCallback( HWND hWnd, UINT uMsg, LPARAM lParam )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::PropSheetCallback"));
|
|
if (PSCB_INITIALIZED == uMsg)
|
|
{
|
|
//
|
|
// Try to bring the window to the foreground.
|
|
//
|
|
SetForegroundWindow(hWnd);
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::DetermineScannerType(void)
|
|
{
|
|
LONG nProps = ScannerProperties::GetDeviceProps( m_pWiaItemRoot );
|
|
|
|
m_nScannerType = ScannerTypeUnknown;
|
|
|
|
//
|
|
// Determine which scanner type we have, based on which properties the scanner has, as follows:
|
|
//
|
|
// HasFlatBed HasDocumentFeeder SupportsPreview SupportsPageSize
|
|
// 1 1 1 1 ScannerTypeFlatbedAdf
|
|
// 1 0 1 0 ScannerTypeFlatbed
|
|
// 0 1 1 1 ScannerTypeFlatbedAdf
|
|
// 0 1 0 0 ScannerTypeScrollFed
|
|
//
|
|
// otherwise it is ScannerTypeUnknown
|
|
//
|
|
const int nMaxControllingProps = 4;
|
|
static struct
|
|
{
|
|
LONG ControllingProps[nMaxControllingProps];
|
|
int nScannerType;
|
|
}
|
|
s_DialogResourceData[] =
|
|
{
|
|
{ ScannerProperties::HasFlatBed, ScannerProperties::HasDocumentFeeder, ScannerProperties::SupportsPreview, ScannerProperties::SupportsPageSize, NULL },
|
|
{ ScannerProperties::HasFlatBed, ScannerProperties::HasDocumentFeeder, ScannerProperties::SupportsPreview, ScannerProperties::SupportsPageSize, ScannerTypeFlatbedAdf },
|
|
{ ScannerProperties::HasFlatBed, 0, ScannerProperties::SupportsPreview, 0, ScannerTypeFlatbed },
|
|
{ 0, ScannerProperties::HasDocumentFeeder, ScannerProperties::SupportsPreview, ScannerProperties::SupportsPageSize, ScannerTypeFlatbedAdf },
|
|
{ 0, ScannerProperties::HasDocumentFeeder, 0, 0, ScannerTypeScrollFed },
|
|
{ 0, ScannerProperties::HasDocumentFeeder, 0, ScannerProperties::SupportsPageSize, ScannerTypeFlatbedAdf },
|
|
{ ScannerProperties::HasFlatBed, ScannerProperties::HasDocumentFeeder, 0, ScannerProperties::SupportsPageSize, ScannerTypeFlatbedAdf },
|
|
};
|
|
|
|
//
|
|
// Find the set of flags that match this device. If they match, use this scanner type.
|
|
// Loop through each type description.
|
|
//
|
|
for (int nCurrentResourceFlags=1;nCurrentResourceFlags<ARRAYSIZE(s_DialogResourceData) && (ScannerTypeUnknown == m_nScannerType);nCurrentResourceFlags++)
|
|
{
|
|
//
|
|
// Loop through each controlling property
|
|
//
|
|
for (int nControllingProp=0;nControllingProp<nMaxControllingProps;nControllingProp++)
|
|
{
|
|
//
|
|
// If this property DOESN'T match, break out prematurely
|
|
//
|
|
if ((nProps & s_DialogResourceData[0].ControllingProps[nControllingProp]) != s_DialogResourceData[nCurrentResourceFlags].ControllingProps[nControllingProp])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If the current controlling property is equal to the maximum controlling property,
|
|
// we had matches all the way through, so use this type
|
|
//
|
|
if (nControllingProp == nMaxControllingProps)
|
|
{
|
|
m_nScannerType = s_DialogResourceData[nCurrentResourceFlags].nScannerType;
|
|
}
|
|
}
|
|
}
|
|
|
|
CSimpleString CAcquisitionManagerControllerWindow::GetCurrentDate(void)
|
|
{
|
|
SYSTEMTIME SystemTime;
|
|
TCHAR szText[MAX_PATH] = TEXT("");
|
|
|
|
GetLocalTime( &SystemTime );
|
|
GetDateFormat( LOCALE_USER_DEFAULT, 0, &SystemTime, CSimpleString(IDS_DATEFORMAT,g_hInstance), szText, ARRAYSIZE(szText) );
|
|
return szText;
|
|
}
|
|
|
|
|
|
bool CAcquisitionManagerControllerWindow::SuppressFirstPage(void)
|
|
{
|
|
return m_bSuppressFirstPage;
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::IsSerialCamera(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::IsSerialCamera"));
|
|
|
|
//
|
|
// Only check for serial devices if we are a camera
|
|
//
|
|
if (m_DeviceTypeMode==CameraMode)
|
|
{
|
|
#if defined(WIA_DIP_HW_CONFIG)
|
|
//
|
|
// Get the hardware configuration information
|
|
//
|
|
LONG nHardwareConfig = 0;
|
|
if (PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DIP_HW_CONFIG, nHardwareConfig ))
|
|
{
|
|
//
|
|
// If this is a serial device, return true
|
|
//
|
|
if (nHardwareConfig & STI_HW_CONFIG_SERIAL)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
#else
|
|
CSimpleStringWide strwPortName;
|
|
if (PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DIP_PORT_NAME, strwPortName ))
|
|
{
|
|
//
|
|
// Compare the leftmost 3 characters to the word COM (as in COM1, COM2, ... )
|
|
//
|
|
if (strwPortName.Left(3).CompareNoCase(CSimpleStringWide(L"COM"))==0)
|
|
{
|
|
WIA_TRACE((TEXT("A comparison of %ws and COM succeeded"), strwPortName.Left(3).String() ));
|
|
return true;
|
|
}
|
|
//
|
|
// Compare the portname to the word AUTO
|
|
//
|
|
else if (strwPortName.CompareNoCase(CSimpleStringWide(L"AUTO"))==0)
|
|
{
|
|
WIA_TRACE((TEXT("A comparison of %ws and AUTO succeeded"), strwPortName.String() ));
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
//
|
|
// Not a serial camera
|
|
//
|
|
return false;
|
|
}
|
|
|
|
HRESULT CAcquisitionManagerControllerWindow::CreateAndExecuteWizard(void)
|
|
{
|
|
//
|
|
// Structure used to setup our data-driven property sheet factory
|
|
//
|
|
enum CPageType
|
|
{
|
|
NormalPage = 0,
|
|
FirstPage = 1,
|
|
LastPage = 2
|
|
};
|
|
struct CPropertyPageInfo
|
|
{
|
|
LPCTSTR pszTemplate;
|
|
DLGPROC pfnDlgProc;
|
|
int nIdTitle;
|
|
int nIdSubTitle;
|
|
TCHAR szTitle[256];
|
|
TCHAR szSubTitle[1024];
|
|
CPageType PageType;
|
|
bool *pbDisplay;
|
|
int *pnPageIndex;
|
|
};
|
|
|
|
//
|
|
// Maximum number of statically created wizard pages
|
|
//
|
|
const int c_nMaxWizardPages = 7;
|
|
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Register common controls
|
|
//
|
|
INITCOMMONCONTROLSEX icce;
|
|
icce.dwSize = sizeof(icce);
|
|
icce.dwICC = ICC_WIN95_CLASSES | ICC_LISTVIEW_CLASSES | ICC_USEREX_CLASSES | ICC_PROGRESS_CLASS | ICC_LINK_CLASS;
|
|
InitCommonControlsEx( &icce );
|
|
|
|
//
|
|
// Register custom window classes
|
|
//
|
|
CWiaTextControl::RegisterClass( g_hInstance );
|
|
RegisterWiaPreviewClasses( g_hInstance );
|
|
|
|
//
|
|
// These are the pages we'll use for the scanner wizard, if it doesn't have an ADF
|
|
//
|
|
CPropertyPageInfo ScannerPropSheetPageInfo[] =
|
|
{
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_FIRST), CCommonFirstPage::DialogProc, 0, 0, TEXT(""), TEXT(""), FirstPage, NULL, NULL },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_SELECT), CScannerSelectionPage::DialogProc, IDS_SCANNER_SELECT_TITLE, IDS_SCANNER_SELECT_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nSelectionPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_TRANSFER), CCommonTransferPage::DialogProc, IDS_SCANNER_TRANSFER_TITLE, IDS_SCANNER_TRANSFER_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDestinationPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_PROGRESS), CCommonProgressPage::DialogProc, IDS_SCANNER_PROGRESS_TITLE, IDS_SCANNER_PROGRESS_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_UPLOAD_QUERY), CCommonUploadQueryPage::DialogProc, IDS_COMMON_UPLOAD_TITLE, IDS_COMMON_UPLOAD_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nUploadQueryPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_DELETE), CCommonDeleteProgressPage::DialogProc, IDS_COMMON_DELETE_TITLE, IDS_COMMON_DELETE_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDeleteProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_FINISH), CCommonFinishPage::DialogProc, 0, 0, TEXT(""), TEXT(""), LastPage, NULL, &m_nFinishPageIndex }
|
|
};
|
|
|
|
//
|
|
// These are the pages we'll use for the scanner wizard, if it is a scroll-fed scanner
|
|
//
|
|
CPropertyPageInfo ScannerScrollFedPropSheetPageInfo[] =
|
|
{
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_FIRST), CCommonFirstPage::DialogProc, 0, 0, TEXT(""), TEXT(""), FirstPage, NULL, NULL },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_SELECT), CScannerSelectionPage::DialogProc, IDS_SCROLLFED_SELECT_TITLE, IDS_SCROLLFED_SELECT_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nSelectionPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_TRANSFER), CCommonTransferPage::DialogProc, IDS_SCANNER_TRANSFER_TITLE, IDS_SCANNER_TRANSFER_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDestinationPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_PROGRESS), CCommonProgressPage::DialogProc, IDS_SCANNER_PROGRESS_TITLE, IDS_SCANNER_PROGRESS_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_UPLOAD_QUERY), CCommonUploadQueryPage::DialogProc, IDS_COMMON_UPLOAD_TITLE, IDS_COMMON_UPLOAD_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nUploadQueryPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_DELETE), CCommonDeleteProgressPage::DialogProc, IDS_COMMON_DELETE_TITLE, IDS_COMMON_DELETE_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDeleteProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_FINISH), CCommonFinishPage::DialogProc, 0, 0, TEXT(""), TEXT(""), LastPage, NULL, &m_nFinishPageIndex }
|
|
};
|
|
|
|
//
|
|
// These are the pages we'll use for the scanner wizard, if it does have an ADF
|
|
//
|
|
CPropertyPageInfo ScannerADFPropSheetPageInfo[] =
|
|
{
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_FIRST), CCommonFirstPage::DialogProc, 0, 0, TEXT(""), TEXT(""), FirstPage, NULL, NULL },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_ADF_SELECT), CScannerSelectionPage::DialogProc, IDS_SCANNER_SELECT_TITLE, IDS_SCANNER_SELECT_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nSelectionPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_SCANNER_TRANSFER), CCommonTransferPage::DialogProc, IDS_SCANNER_TRANSFER_TITLE, IDS_SCANNER_TRANSFER_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDestinationPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_PROGRESS), CCommonProgressPage::DialogProc, IDS_SCANNER_PROGRESS_TITLE, IDS_SCANNER_PROGRESS_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_UPLOAD_QUERY), CCommonUploadQueryPage::DialogProc, IDS_COMMON_UPLOAD_TITLE, IDS_COMMON_UPLOAD_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nUploadQueryPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_DELETE), CCommonDeleteProgressPage::DialogProc, IDS_COMMON_DELETE_TITLE, IDS_COMMON_DELETE_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDeleteProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_FINISH), CCommonFinishPage::DialogProc, 0, 0, TEXT(""), TEXT(""), LastPage, NULL, &m_nFinishPageIndex }
|
|
};
|
|
|
|
//
|
|
// These are the pages we'll use for the camera wizard
|
|
//
|
|
CPropertyPageInfo CameraPropSheetPageInfo[] =
|
|
{
|
|
{ MAKEINTRESOURCE(IDD_CAMERA_FIRST), CCommonFirstPage::DialogProc, 0, 0, TEXT(""), TEXT(""), FirstPage, NULL, NULL },
|
|
{ MAKEINTRESOURCE(IDD_CAMERA_SELECT), CCameraSelectionPage::DialogProc, IDS_CAMERA_SELECT_TITLE, IDS_CAMERA_SELECT_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nSelectionPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_CAMERA_TRANSFER), CCommonTransferPage::DialogProc, IDS_CAMERA_TRANSFER_TITLE, IDS_CAMERA_TRANSFER_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDestinationPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_PROGRESS), CCommonProgressPage::DialogProc, IDS_CAMERA_PROGRESS_TITLE, IDS_CAMERA_PROGRESS_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_UPLOAD_QUERY), CCommonUploadQueryPage::DialogProc, IDS_COMMON_UPLOAD_TITLE, IDS_COMMON_UPLOAD_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nUploadQueryPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_DELETE), CCommonDeleteProgressPage::DialogProc, IDS_COMMON_DELETE_TITLE, IDS_COMMON_DELETE_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDeleteProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_FINISH), CCommonFinishPage::DialogProc, 0, 0, TEXT(""), TEXT(""), LastPage, NULL, &m_nFinishPageIndex }
|
|
};
|
|
|
|
//
|
|
// These are the pages we'll use for the video wizard
|
|
//
|
|
CPropertyPageInfo VideoPropSheetPageInfo[] =
|
|
{
|
|
{ MAKEINTRESOURCE(IDD_VIDEO_FIRST), CCommonFirstPage::DialogProc, 0, 0, TEXT(""), TEXT(""), FirstPage, NULL, NULL },
|
|
{ MAKEINTRESOURCE(IDD_VIDEO_SELECT), CCameraSelectionPage::DialogProc, IDS_VIDEO_SELECT_TITLE, IDS_VIDEO_SELECT_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nSelectionPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_CAMERA_TRANSFER), CCommonTransferPage::DialogProc, IDS_CAMERA_TRANSFER_TITLE, IDS_CAMERA_TRANSFER_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDestinationPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_PROGRESS), CCommonProgressPage::DialogProc, IDS_CAMERA_PROGRESS_TITLE, IDS_CAMERA_PROGRESS_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_UPLOAD_QUERY), CCommonUploadQueryPage::DialogProc, IDS_COMMON_UPLOAD_TITLE, IDS_COMMON_UPLOAD_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nUploadQueryPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_DELETE), CCommonDeleteProgressPage::DialogProc, IDS_COMMON_DELETE_TITLE, IDS_COMMON_DELETE_SUBTITLE, TEXT(""), TEXT(""), NormalPage, NULL, &m_nDeleteProgressPageIndex },
|
|
{ MAKEINTRESOURCE(IDD_COMMON_FINISH), CCommonFinishPage::DialogProc, 0, 0, TEXT(""), TEXT(""), LastPage, NULL, &m_nFinishPageIndex }
|
|
};
|
|
|
|
//
|
|
// Initialize all of these variables, which differ depending on which type of device we are loading
|
|
//
|
|
LPTSTR pszbmWatermark = NULL;
|
|
LPTSTR pszbmHeader = NULL;
|
|
CPropertyPageInfo *pPropSheetPageInfo = NULL;
|
|
int nPropPageCount = 0;
|
|
int nWizardIconId = 0;
|
|
CSimpleString strDownloadManagerTitle = TEXT("");
|
|
|
|
//
|
|
// Decide which pages to use.
|
|
//
|
|
switch (m_DeviceTypeMode)
|
|
{
|
|
case CameraMode:
|
|
pszbmWatermark = MAKEINTRESOURCE(IDB_CAMERA_WATERMARK);
|
|
pszbmHeader = MAKEINTRESOURCE(IDB_CAMERA_HEADER);
|
|
pPropSheetPageInfo = CameraPropSheetPageInfo;
|
|
nPropPageCount = ARRAYSIZE(CameraPropSheetPageInfo);
|
|
strDownloadManagerTitle.LoadString( IDS_DOWNLOAD_MANAGER_TITLE, g_hInstance );
|
|
nWizardIconId = IDI_CAMERA_WIZARD;
|
|
break;
|
|
|
|
case VideoMode:
|
|
pszbmWatermark = MAKEINTRESOURCE(IDB_VIDEO_WATERMARK);
|
|
pszbmHeader = MAKEINTRESOURCE(IDB_VIDEO_HEADER);
|
|
pPropSheetPageInfo = VideoPropSheetPageInfo;
|
|
nPropPageCount = ARRAYSIZE(VideoPropSheetPageInfo);
|
|
strDownloadManagerTitle.LoadString( IDS_DOWNLOAD_MANAGER_TITLE, g_hInstance );
|
|
nWizardIconId = IDI_VIDEO_WIZARD;
|
|
break;
|
|
|
|
case ScannerMode:
|
|
DetermineScannerType();
|
|
pszbmWatermark = MAKEINTRESOURCE(IDB_SCANNER_WATERMARK);
|
|
pszbmHeader = MAKEINTRESOURCE(IDB_SCANNER_HEADER);
|
|
strDownloadManagerTitle.LoadString( IDS_DOWNLOAD_MANAGER_TITLE, g_hInstance );
|
|
nWizardIconId = IDI_SCANNER_WIZARD;
|
|
if (m_nScannerType == ScannerTypeFlatbedAdf)
|
|
{
|
|
pPropSheetPageInfo = ScannerADFPropSheetPageInfo;
|
|
nPropPageCount = ARRAYSIZE(ScannerADFPropSheetPageInfo);
|
|
}
|
|
else if (m_nScannerType == ScannerTypeFlatbed)
|
|
{
|
|
pPropSheetPageInfo = ScannerPropSheetPageInfo;
|
|
nPropPageCount = ARRAYSIZE(ScannerPropSheetPageInfo);
|
|
}
|
|
else if (m_nScannerType == ScannerTypeScrollFed)
|
|
{
|
|
pPropSheetPageInfo = ScannerScrollFedPropSheetPageInfo;
|
|
nPropPageCount = ARRAYSIZE(ScannerScrollFedPropSheetPageInfo);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Unknown scanner type
|
|
//
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HICON hIconSmall=NULL, hIconBig=NULL;
|
|
if (!SUCCEEDED(WiaUiExtensionHelper::GetDeviceIcons( CSimpleBStr(m_strwDeviceUiClassId), m_nDeviceType, &hIconSmall, &hIconBig )))
|
|
{
|
|
//
|
|
// Load the icons. They will be set using WM_SETICON in the first pages.
|
|
//
|
|
hIconSmall = reinterpret_cast<HICON>(LoadImage( g_hInstance, MAKEINTRESOURCE(nWizardIconId), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR ));
|
|
hIconBig = reinterpret_cast<HICON>(LoadImage( g_hInstance, MAKEINTRESOURCE(nWizardIconId), IMAGE_ICON, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR ));
|
|
}
|
|
|
|
//
|
|
// Make copies of these icons to work around NTBUG 351806
|
|
//
|
|
if (hIconSmall)
|
|
{
|
|
m_hWizardIconSmall = CopyIcon(hIconSmall);
|
|
DestroyIcon(hIconSmall);
|
|
}
|
|
if (hIconBig)
|
|
{
|
|
m_hWizardIconBig = CopyIcon(hIconBig);
|
|
DestroyIcon(hIconBig);
|
|
}
|
|
|
|
|
|
//
|
|
// Make sure we have a valid set of data
|
|
//
|
|
if (pszbmWatermark && pszbmHeader && pPropSheetPageInfo && nPropPageCount)
|
|
{
|
|
const int c_MaxPageCount = 20;
|
|
HPROPSHEETPAGE PropSheetPages[c_MaxPageCount] = {0};
|
|
|
|
//
|
|
// We might not be adding all of the pages.
|
|
//
|
|
int nTotalPageCount = 0;
|
|
|
|
for (int nCurrPage=0;nCurrPage<nPropPageCount && nCurrPage<c_MaxPageCount;nCurrPage++)
|
|
{
|
|
//
|
|
// Only add the page if the controlling pbDisplay variable is NULL or points to a non-FALSE value
|
|
//
|
|
if (!pPropSheetPageInfo[nCurrPage].pbDisplay || *(pPropSheetPageInfo[nCurrPage].pbDisplay))
|
|
{
|
|
PROPSHEETPAGE CurrentPropSheetPage = {0};
|
|
|
|
//
|
|
// Set up all of the required fields from out static info.
|
|
//
|
|
CurrentPropSheetPage.dwSize = sizeof(PROPSHEETPAGE);
|
|
CurrentPropSheetPage.hInstance = g_hInstance;
|
|
CurrentPropSheetPage.lParam = reinterpret_cast<LPARAM>(this);
|
|
CurrentPropSheetPage.pfnDlgProc = pPropSheetPageInfo[nCurrPage].pfnDlgProc;
|
|
CurrentPropSheetPage.pszTemplate = pPropSheetPageInfo[nCurrPage].pszTemplate;
|
|
CurrentPropSheetPage.pszTitle = strDownloadManagerTitle.String();
|
|
CurrentPropSheetPage.dwFlags = PSP_DEFAULT;
|
|
|
|
//
|
|
// Add in the fusion flags to get COMCTLV6
|
|
//
|
|
WiaUiUtil::PreparePropertyPageForFusion( &CurrentPropSheetPage );
|
|
|
|
//
|
|
// If we want to save the index of this page, save it
|
|
//
|
|
if (pPropSheetPageInfo[nTotalPageCount].pnPageIndex)
|
|
{
|
|
*(pPropSheetPageInfo[nTotalPageCount].pnPageIndex) = nTotalPageCount;
|
|
}
|
|
|
|
if (FirstPage == pPropSheetPageInfo[nCurrPage].PageType)
|
|
{
|
|
//
|
|
// No title or subtitle needed for "first pages"
|
|
//
|
|
CurrentPropSheetPage.dwFlags |= PSP_PREMATURE | PSP_HIDEHEADER | PSP_USETITLE;
|
|
}
|
|
else if (LastPage == pPropSheetPageInfo[nCurrPage].PageType)
|
|
{
|
|
//
|
|
// No title or subtitle needed for "last pages"
|
|
//
|
|
CurrentPropSheetPage.dwFlags |= PSP_HIDEHEADER | PSP_USETITLE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Add header and subtitle
|
|
//
|
|
CurrentPropSheetPage.dwFlags |= PSP_PREMATURE | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE | PSP_USETITLE;
|
|
|
|
//
|
|
// Load the header and subtitle
|
|
//
|
|
LoadString( g_hInstance, pPropSheetPageInfo[nCurrPage].nIdTitle, pPropSheetPageInfo[nCurrPage].szTitle, ARRAYSIZE(pPropSheetPageInfo[nCurrPage].szTitle) );
|
|
LoadString( g_hInstance, pPropSheetPageInfo[nCurrPage].nIdSubTitle, pPropSheetPageInfo[nCurrPage].szSubTitle, ARRAYSIZE(pPropSheetPageInfo[nCurrPage].szSubTitle) );
|
|
|
|
//
|
|
// Assign the title and subtitle strings
|
|
//
|
|
CurrentPropSheetPage.pszHeaderTitle = pPropSheetPageInfo[nCurrPage].szTitle;
|
|
CurrentPropSheetPage.pszHeaderSubTitle = pPropSheetPageInfo[nCurrPage].szSubTitle;
|
|
}
|
|
|
|
//
|
|
// Create and add one more page
|
|
//
|
|
HPROPSHEETPAGE hPropSheetPage = CreatePropertySheetPage(&CurrentPropSheetPage);
|
|
if (!hPropSheetPage)
|
|
{
|
|
WIA_PRINTHRESULT((HRESULT_FROM_WIN32(GetLastError()),TEXT("CreatePropertySheetPage failed on page %d"), nCurrPage ));
|
|
return E_FAIL;
|
|
}
|
|
PropSheetPages[nTotalPageCount++] = hPropSheetPage;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save the count of our pages
|
|
//
|
|
m_nWiaWizardPageCount = nTotalPageCount;
|
|
|
|
//
|
|
// Create the property sheet header
|
|
//
|
|
PROPSHEETHEADER PropSheetHeader = {0};
|
|
PropSheetHeader.hwndParent = NULL;
|
|
PropSheetHeader.dwSize = sizeof(PROPSHEETHEADER);
|
|
PropSheetHeader.dwFlags = PSH_NOAPPLYNOW | PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER | PSH_USECALLBACK;
|
|
PropSheetHeader.pszbmWatermark = pszbmWatermark;
|
|
PropSheetHeader.pszbmHeader = pszbmHeader;
|
|
PropSheetHeader.hInstance = g_hInstance;
|
|
PropSheetHeader.nPages = m_nWiaWizardPageCount;
|
|
PropSheetHeader.phpage = PropSheetPages;
|
|
PropSheetHeader.pfnCallback = PropSheetCallback;
|
|
PropSheetHeader.nStartPage = SuppressFirstPage() ? 1 : 0;
|
|
|
|
//
|
|
// Display the property sheet
|
|
//
|
|
INT_PTR nResult = PropertySheet( &PropSheetHeader );
|
|
|
|
//
|
|
// Check for an error
|
|
//
|
|
if (nResult == -1)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Generic failure will have to do
|
|
//
|
|
hr = E_FAIL;
|
|
|
|
//
|
|
// Dismiss the wait dialog before we display the message box
|
|
//
|
|
if (m_pWiaProgressDialog)
|
|
{
|
|
m_pWiaProgressDialog->Destroy();
|
|
m_pWiaProgressDialog = NULL;
|
|
}
|
|
|
|
//
|
|
// Display an error message telling the user this is not a supported device
|
|
//
|
|
CMessageBoxEx::MessageBox( m_hWnd, CSimpleString(IDS_UNSUPPORTED_DEVICE,g_hInstance), CSimpleString(IDS_ERROR_TITLE,g_hInstance), CMessageBoxEx::MBEX_ICONWARNING );
|
|
|
|
WIA_ERROR((TEXT("Unknown device type")));
|
|
}
|
|
|
|
//
|
|
// Make sure the status dialog has been dismissed by now
|
|
//
|
|
if (m_pWiaProgressDialog)
|
|
{
|
|
m_pWiaProgressDialog->Destroy();
|
|
m_pWiaProgressDialog = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
bool CAcquisitionManagerControllerWindow::EnumItemsCallback( CWiaItemList::CEnumEvent EnumEvent, UINT nData, LPARAM lParam, bool bForceUpdate )
|
|
{
|
|
//
|
|
// We would return false to cancel enumeration
|
|
//
|
|
bool bResult = true;
|
|
|
|
//
|
|
// Get the instance of the controller window
|
|
//
|
|
CAcquisitionManagerControllerWindow *pThis = reinterpret_cast<CAcquisitionManagerControllerWindow*>(lParam);
|
|
if (pThis)
|
|
{
|
|
//
|
|
// Which event are we being called for?
|
|
//
|
|
switch (EnumEvent)
|
|
{
|
|
case CWiaItemList::ReadingItemInfo:
|
|
//
|
|
// This is the event that is sent while the tree is being built
|
|
//
|
|
if (pThis->m_pWiaProgressDialog && pThis->m_bUpdateEnumerationCount && nData)
|
|
{
|
|
//
|
|
// We don't want to update the status text any more often than this (minimizes flicker)
|
|
//
|
|
const DWORD dwMinDelta = 200;
|
|
|
|
//
|
|
// Get the current tick count and see if it has been more than dwMinDelta milliseconds since our last update
|
|
//
|
|
DWORD dwCurrentTickCount = GetTickCount();
|
|
if (bForceUpdate || dwCurrentTickCount - pThis->m_dwLastEnumerationTickCount >= dwMinDelta)
|
|
{
|
|
//
|
|
// Assume we haven't been cancelled
|
|
//
|
|
BOOL bCancelled = FALSE;
|
|
|
|
//
|
|
// Set the progress message
|
|
//
|
|
pThis->m_pWiaProgressDialog->SetMessage( CSimpleStringWide().Format( IDS_ENUMERATIONCOUNT, g_hInstance, nData ) );
|
|
|
|
//
|
|
// Find out if we've been cancelled
|
|
//
|
|
pThis->m_pWiaProgressDialog->Cancelled(&bCancelled);
|
|
|
|
//
|
|
// If we have been cancelled, we'll return false to stop the enumeration
|
|
//
|
|
if (bCancelled)
|
|
{
|
|
bResult = false;
|
|
}
|
|
|
|
//
|
|
// Save the current tick count for next time
|
|
//
|
|
pThis->m_dwLastEnumerationTickCount = dwCurrentTickCount;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnPostInitialize( WPARAM, LPARAM )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::OnInitialize"));
|
|
|
|
//
|
|
// Try to get the correct animation for this device type. If we can't get the type,
|
|
// just use the camera animation. If there is a real error, it will get handled later
|
|
//
|
|
int nAnimationType = WIA_PROGRESSDLG_ANIM_CAMERA_COMMUNICATE;
|
|
LONG nAnimationDeviceType = 0;
|
|
|
|
//
|
|
// We don't want to update our enumeration count in the progress dialog for scanners, but we do for cameras
|
|
//
|
|
m_bUpdateEnumerationCount = true;
|
|
if (SUCCEEDED(WiaUiUtil::GetDeviceTypeFromId( CSimpleBStr(m_pEventParameters->strDeviceID), &nAnimationDeviceType )))
|
|
{
|
|
if (StiDeviceTypeScanner == GET_STIDEVICE_TYPE(nAnimationDeviceType))
|
|
{
|
|
nAnimationType = WIA_PROGRESSDLG_ANIM_SCANNER_COMMUNICATE;
|
|
m_bUpdateEnumerationCount = false;
|
|
}
|
|
else if (StiDeviceTypeStreamingVideo == GET_STIDEVICE_TYPE(nAnimationDeviceType))
|
|
{
|
|
nAnimationType = WIA_PROGRESSDLG_ANIM_VIDEO_COMMUNICATE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Put up a wait dialog
|
|
//
|
|
HRESULT hr = CoCreateInstance( CLSID_WiaDefaultUi, NULL, CLSCTX_INPROC_SERVER, IID_IWiaProgressDialog, (void**)&m_pWiaProgressDialog );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_pWiaProgressDialog->Create( m_hWnd, nAnimationType|WIA_PROGRESSDLG_NO_PROGRESS );
|
|
m_pWiaProgressDialog->SetTitle( CSimpleStringConvert::WideString(CSimpleString(IDS_DOWNLOADMANAGER_NAME,g_hInstance)));
|
|
m_pWiaProgressDialog->SetMessage( CSimpleStringConvert::WideString(CSimpleString(IDS_PROGDLG_MESSAGE,g_hInstance)));
|
|
|
|
//
|
|
// Show the progress dialog
|
|
//
|
|
m_pWiaProgressDialog->Show();
|
|
|
|
//
|
|
// Create the global interface table
|
|
//
|
|
hr = CoCreateInstance( CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, IID_IGlobalInterfaceTable, (VOID**)&m_pGlobalInterfaceTable );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Create the device
|
|
//
|
|
hr = WIA_FORCE_ERROR(FE_WIAACMGR,100,CreateDevice());
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Save a debug snapshot, if the entry is in the registry
|
|
//
|
|
WIA_SAVEITEMTREELOG(HKEY_CURRENT_USER,REGSTR_PATH_USER_SETTINGS_WIAACMGR,TEXT("CreateDeviceTreeSnapshot"),true,m_pWiaItemRoot);
|
|
|
|
//
|
|
// First, figure out what kind of device it is and get the UI class ID
|
|
//
|
|
if (PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DIP_DEV_TYPE, m_nDeviceType ) &&
|
|
PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DIP_UI_CLSID, m_strwDeviceUiClassId ))
|
|
{
|
|
switch (GET_STIDEVICE_TYPE(m_nDeviceType))
|
|
{
|
|
case StiDeviceTypeScanner:
|
|
m_DeviceTypeMode = ScannerMode;
|
|
break;
|
|
|
|
case StiDeviceTypeDigitalCamera:
|
|
m_DeviceTypeMode = CameraMode;
|
|
break;
|
|
|
|
case StiDeviceTypeStreamingVideo:
|
|
m_DeviceTypeMode = VideoMode;
|
|
break;
|
|
|
|
default:
|
|
m_DeviceTypeMode = UnknownMode;
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
WIA_ERROR((TEXT("Unable to read the device type")));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Get the device name
|
|
//
|
|
PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DIP_DEV_NAME, m_strwDeviceName );
|
|
|
|
//
|
|
// Find out if Take Picture is supported
|
|
//
|
|
m_bTakePictureIsSupported = WiaUiUtil::IsDeviceCommandSupported( m_pWiaItemRoot, WIA_CMD_TAKE_PICTURE );
|
|
|
|
//
|
|
// Enumerate all the items in the device tree
|
|
//
|
|
hr = m_WiaItemList.EnumerateAllWiaItems(m_pWiaItemRoot,EnumItemsCallback,reinterpret_cast<LPARAM>(this));
|
|
if (S_OK == hr)
|
|
{
|
|
if (ScannerMode == m_DeviceTypeMode)
|
|
{
|
|
//
|
|
// Mark only one scanner item as selected, and save it as the current scanner item
|
|
//
|
|
MarkAllItemsUnselected( m_WiaItemList.Root() );
|
|
CSimpleDynamicArray<CWiaItem*> Items;
|
|
GetAllImageItems( Items, m_WiaItemList.Root() );
|
|
if (Items.Size() && Items[0])
|
|
{
|
|
m_pCurrentScannerItem = Items[0];
|
|
MarkItemSelected(Items[0],m_WiaItemList.Root());
|
|
|
|
//
|
|
// Make sure we have all of the properties we need to construct the device
|
|
//
|
|
hr = WiaUiUtil::VerifyScannerProperties(Items[0]->WiaItem());
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
WIA_ERROR((TEXT("There don't seem to be any transfer items on this scanner")));
|
|
}
|
|
}
|
|
else if (VideoMode == m_DeviceTypeMode || CameraMode == m_DeviceTypeMode)
|
|
{
|
|
//
|
|
// Get the thumbnail width
|
|
//
|
|
LONG nWidth, nHeight;
|
|
if (PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DPC_THUMB_WIDTH, nWidth ) &&
|
|
PropStorageHelpers::GetProperty( m_pWiaItemRoot, WIA_DPC_THUMB_HEIGHT, nHeight ))
|
|
{
|
|
int nMax = max(nWidth,nHeight); // Allow for rotation
|
|
m_sizeThumbnails.cx = max(c_nMinThumbnailWidth,min(nMax,c_nMaxThumbnailWidth));
|
|
m_sizeThumbnails.cy = max(c_nMinThumbnailHeight,min(nMax,c_nMaxThumbnailHeight));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Dismiss the wait dialog
|
|
//
|
|
if (m_pWiaProgressDialog)
|
|
{
|
|
m_pWiaProgressDialog->Destroy();
|
|
m_pWiaProgressDialog = NULL;
|
|
}
|
|
|
|
//
|
|
// Choose an appropriate error message if we have a recognizable error.
|
|
//
|
|
CSimpleString strMessage;
|
|
int nIconId = 0;
|
|
switch (hr)
|
|
{
|
|
case WIA_ERROR_BUSY:
|
|
strMessage.LoadString( IDS_DEVICE_BUSY, g_hInstance );
|
|
nIconId = MB_ICONINFORMATION;
|
|
break;
|
|
|
|
case WIA_S_NO_DEVICE_AVAILABLE:
|
|
strMessage.LoadString( IDS_DEVICE_NOT_FOUND, g_hInstance );
|
|
nIconId = MB_ICONINFORMATION;
|
|
break;
|
|
|
|
|
|
default:
|
|
strMessage.LoadString( IDS_UNABLETOCREATE, g_hInstance );
|
|
nIconId = MB_ICONINFORMATION;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Tell the user we had a problem creating the device
|
|
//
|
|
MessageBox( m_hWnd, strMessage, CSimpleString( IDS_DOWNLOAD_MANAGER_TITLE, g_hInstance ), nIconId );
|
|
}
|
|
else if (S_OK == hr)
|
|
{
|
|
hr = CreateAndExecuteWizard();
|
|
}
|
|
//
|
|
// If we were cancelled, shut down the progress UI
|
|
//
|
|
else if (m_pWiaProgressDialog)
|
|
{
|
|
m_pWiaProgressDialog->Destroy();
|
|
m_pWiaProgressDialog = NULL;
|
|
}
|
|
|
|
//
|
|
// Make sure we kill this window, and thus, this thread.
|
|
//
|
|
PostMessage( m_hWnd, WM_CLOSE, 0, 0 );
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnCreate( WPARAM, LPARAM lParam )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::OnCreate"));
|
|
|
|
//
|
|
// Ensure the background thread was started
|
|
//
|
|
if (!m_hBackgroundThread || !m_pThreadMessageQueue)
|
|
{
|
|
WIA_ERROR((TEXT("There was an error starting the background thread")));
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Make sure we got a valid lParam
|
|
//
|
|
LPCREATESTRUCT pCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
|
|
if (!pCreateStruct)
|
|
{
|
|
WIA_ERROR((TEXT("pCreateStruct was NULL")));
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Get the event parameters
|
|
//
|
|
m_pEventParameters = reinterpret_cast<CEventParameters*>(pCreateStruct->lpCreateParams);
|
|
if (!m_pEventParameters)
|
|
{
|
|
WIA_ERROR((TEXT("m_pEventParameters was NULL")));
|
|
return -1;
|
|
}
|
|
|
|
SetForegroundWindow(m_hWnd);
|
|
|
|
//
|
|
// Center ourselves on the parent window
|
|
//
|
|
WiaUiUtil::CenterWindow( m_hWnd, m_pEventParameters->hwndParent );
|
|
|
|
PostMessage( m_hWnd, PWM_POSTINITIALIZE, 0, 0 );
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::OnNotifyDownloadImage( UINT nMsg, CThreadNotificationMessage *pThreadNotificationMessage )
|
|
{
|
|
CDownloadImagesThreadNotifyMessage *pDownloadImageThreadNotifyMessage = dynamic_cast<CDownloadImagesThreadNotifyMessage*>(pThreadNotificationMessage);
|
|
if (pDownloadImageThreadNotifyMessage)
|
|
{
|
|
switch (pDownloadImageThreadNotifyMessage->Status())
|
|
{
|
|
case CDownloadImagesThreadNotifyMessage::End:
|
|
{
|
|
switch (pDownloadImageThreadNotifyMessage->Operation())
|
|
{
|
|
case CDownloadImagesThreadNotifyMessage::DownloadImage:
|
|
{
|
|
if (S_OK != pDownloadImageThreadNotifyMessage->hr())
|
|
{
|
|
m_nFailedImagesCount++;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CDownloadImagesThreadNotifyMessage::DownloadAll:
|
|
{
|
|
if (S_OK == pDownloadImageThreadNotifyMessage->hr())
|
|
{
|
|
m_DownloadedFileInformationList = pDownloadImageThreadNotifyMessage->DownloadedFileInformation();
|
|
}
|
|
else
|
|
{
|
|
m_DownloadedFileInformationList.Destroy();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CDownloadImagesThreadNotifyMessage::Begin:
|
|
{
|
|
switch (pDownloadImageThreadNotifyMessage->Operation())
|
|
{
|
|
case CDownloadImagesThreadNotifyMessage::DownloadAll:
|
|
{
|
|
m_nFailedImagesCount = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CAcquisitionManagerControllerWindow::OnNotifyDownloadThumbnail( UINT nMsg, CThreadNotificationMessage *pThreadNotificationMessage )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CAcquisitionManagerControllerWindow::OnNotifyDownloadThumbnail( %d, %p )"), nMsg, pThreadNotificationMessage ));
|
|
CDownloadThumbnailsThreadNotifyMessage *pDownloadThumbnailsThreadNotifyMessage= dynamic_cast<CDownloadThumbnailsThreadNotifyMessage*>(pThreadNotificationMessage);
|
|
if (pDownloadThumbnailsThreadNotifyMessage)
|
|
{
|
|
switch (pDownloadThumbnailsThreadNotifyMessage->Status())
|
|
{
|
|
case CDownloadThumbnailsThreadNotifyMessage::Begin:
|
|
{
|
|
}
|
|
break;
|
|
case CDownloadThumbnailsThreadNotifyMessage::Update:
|
|
{
|
|
}
|
|
break;
|
|
case CDownloadThumbnailsThreadNotifyMessage::End:
|
|
{
|
|
switch (pDownloadThumbnailsThreadNotifyMessage->Operation())
|
|
{
|
|
case CDownloadThumbnailsThreadNotifyMessage::DownloadThumbnail:
|
|
{
|
|
WIA_TRACE((TEXT("Handling CDownloadThumbnailsThreadNotifyMessage::DownloadThumbnail")));
|
|
//
|
|
// Find the item in the list
|
|
//
|
|
CWiaItem *pWiaItem = m_WiaItemList.Find( pDownloadThumbnailsThreadNotifyMessage->Cookie() );
|
|
if (pWiaItem)
|
|
{
|
|
//
|
|
// Set the flag that indicates we've tried this image already
|
|
//
|
|
pWiaItem->AttemptedThumbnailDownload(true);
|
|
|
|
//
|
|
// Make sure we have valid thumbnail data
|
|
//
|
|
if (pDownloadThumbnailsThreadNotifyMessage->BitmapData())
|
|
{
|
|
//
|
|
// Don't replace existing thumbnail data
|
|
//
|
|
if (!pWiaItem->BitmapData())
|
|
{
|
|
//
|
|
// Set the item's thumbnail data. Take ownership of the thumbnail data
|
|
//
|
|
WIA_TRACE((TEXT("Found the thumbnail for the item with the GIT cookie %08X"), pDownloadThumbnailsThreadNotifyMessage->Cookie() ));
|
|
pWiaItem->BitmapData(pDownloadThumbnailsThreadNotifyMessage->DetachBitmapData());
|
|
pWiaItem->Width(pDownloadThumbnailsThreadNotifyMessage->Width());
|
|
pWiaItem->Height(pDownloadThumbnailsThreadNotifyMessage->Height());
|
|
pWiaItem->BitmapDataLength(pDownloadThumbnailsThreadNotifyMessage->BitmapDataLength());
|
|
pWiaItem->ImageWidth(pDownloadThumbnailsThreadNotifyMessage->PictureWidth());
|
|
pWiaItem->ImageHeight(pDownloadThumbnailsThreadNotifyMessage->PictureHeight());
|
|
pWiaItem->AnnotationType(pDownloadThumbnailsThreadNotifyMessage->AnnotationType());
|
|
pWiaItem->DefExt(pDownloadThumbnailsThreadNotifyMessage->DefExt());
|
|
}
|
|
else
|
|
{
|
|
WIA_TRACE((TEXT("Already got the image data for item %08X!"), pDownloadThumbnailsThreadNotifyMessage->Cookie()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("pDownloadThumbnailsThreadNotifyMessage->BitmapData was NULL!")));
|
|
}
|
|
|
|
|
|
//
|
|
// Assign the default format
|
|
//
|
|
pWiaItem->DefaultFormat(pDownloadThumbnailsThreadNotifyMessage->DefaultFormat());
|
|
|
|
//
|
|
// Assign the access flags
|
|
//
|
|
pWiaItem->AccessRights(pDownloadThumbnailsThreadNotifyMessage->AccessRights());
|
|
|
|
//
|
|
// Make sure we discard rotation angles if rotation is not possible
|
|
//
|
|
pWiaItem->DiscardRotationIfNecessary();
|
|
}
|
|
else
|
|
{
|
|
WIA_ERROR((TEXT("Can't find %08X in the item list"), pDownloadThumbnailsThreadNotifyMessage->Cookie() ));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnThreadNotification( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
WIA_PUSH_FUNCTION((TEXT("CAcquisitionManagerControllerWindow::OnThreadNotification( %d, %08X )"), wParam, lParam ));
|
|
CThreadNotificationMessage *pThreadNotificationMessage = reinterpret_cast<CThreadNotificationMessage*>(lParam);
|
|
if (pThreadNotificationMessage)
|
|
{
|
|
switch (pThreadNotificationMessage->Message())
|
|
{
|
|
case TQ_DOWNLOADTHUMBNAIL:
|
|
OnNotifyDownloadThumbnail( static_cast<UINT>(wParam), pThreadNotificationMessage );
|
|
break;
|
|
|
|
case TQ_DOWNLOADIMAGE:
|
|
OnNotifyDownloadImage( static_cast<UINT>(wParam), pThreadNotificationMessage );
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Notify all the registered windows
|
|
//
|
|
m_WindowList.SendMessage( m_nThreadNotificationMessage, wParam, lParam );
|
|
|
|
//
|
|
// Free the message structure
|
|
//
|
|
delete pThreadNotificationMessage;
|
|
}
|
|
|
|
return HANDLED_THREAD_MESSAGE;
|
|
}
|
|
|
|
|
|
void CAcquisitionManagerControllerWindow::AddNewItemToList( CGenericWiaEventHandler::CEventMessage *pEventMessage )
|
|
{
|
|
WIA_PUSHFUNCTION((TEXT("CAcquisitionManagerControllerWindow::AddNewItemToList")));
|
|
|
|
//
|
|
// Check to see if the item is already in our list
|
|
//
|
|
CWiaItem *pWiaItem = m_WiaItemList.Find(pEventMessage->FullItemName());
|
|
if (pWiaItem)
|
|
{
|
|
//
|
|
// If it is already in our list, just return.
|
|
//
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get an IWiaItem interface pointer for this item
|
|
//
|
|
CComPtr<IWiaItem> pItem;
|
|
HRESULT hr = m_pWiaItemRoot->FindItemByName( 0, CSimpleBStr(pEventMessage->FullItemName()).BString(), &pItem );
|
|
if (SUCCEEDED(hr) && pItem)
|
|
{
|
|
//
|
|
// Add it to the root of the item tree
|
|
//
|
|
m_WiaItemList.Add( NULL, new CWiaItem(pItem) );
|
|
}
|
|
}
|
|
|
|
|
|
void CAcquisitionManagerControllerWindow::RequestThumbnailForNewItem( CGenericWiaEventHandler::CEventMessage *pEventMessage )
|
|
{
|
|
WIA_PUSHFUNCTION((TEXT("CAcquisitionManagerControllerWindow::RequestThumbnailForNewItem")));
|
|
|
|
//
|
|
// Find the item in our list
|
|
//
|
|
CWiaItem *pWiaItem = m_WiaItemList.Find(pEventMessage->FullItemName());
|
|
if (pWiaItem)
|
|
{
|
|
//
|
|
// Add this item's cookie to an empty list
|
|
//
|
|
CSimpleDynamicArray<DWORD> Cookies;
|
|
Cookies.Append( pWiaItem->GlobalInterfaceTableCookie() );
|
|
if (Cookies.Size())
|
|
{
|
|
//
|
|
// Reset the cancel event
|
|
//
|
|
m_EventThumbnailCancel.Reset();
|
|
|
|
//
|
|
// Prepare and send the request
|
|
//
|
|
CDownloadThumbnailsThreadMessage *pDownloadThumbnailsThreadMessage = new CDownloadThumbnailsThreadMessage( m_hWnd, Cookies, m_EventThumbnailCancel.Event() );
|
|
if (pDownloadThumbnailsThreadMessage)
|
|
{
|
|
m_pThreadMessageQueue->Enqueue( pDownloadThumbnailsThreadMessage, CThreadMessageQueue::PriorityNormal );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnEventNotification( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::OnEventNotification"));
|
|
CGenericWiaEventHandler::CEventMessage *pEventMessage = reinterpret_cast<CGenericWiaEventHandler::CEventMessage *>(lParam);
|
|
if (pEventMessage)
|
|
{
|
|
//
|
|
// If we got an item created message, add the item to the list
|
|
//
|
|
if (pEventMessage->EventId() == WIA_EVENT_ITEM_CREATED)
|
|
{
|
|
AddNewItemToList( pEventMessage );
|
|
}
|
|
|
|
//
|
|
// On Disconnect, perform disconnection operations
|
|
//
|
|
else if (pEventMessage->EventId() == WIA_EVENT_DEVICE_DISCONNECTED)
|
|
{
|
|
DisplayDisconnectMessageAndExit();
|
|
}
|
|
|
|
//
|
|
// Propagate the message to all currently registered windows
|
|
//
|
|
m_WindowList.SendMessage( m_nWiaEventMessage, wParam, lParam );
|
|
|
|
//
|
|
// Make sure we ask for the new thumbnail *AFTER* we tell the views the item exists
|
|
//
|
|
if (pEventMessage->EventId() == WIA_EVENT_ITEM_CREATED)
|
|
{
|
|
RequestThumbnailForNewItem( pEventMessage );
|
|
}
|
|
|
|
//
|
|
// If this is a deleted item event, mark this item deleted
|
|
//
|
|
if (pEventMessage->EventId() == WIA_EVENT_ITEM_DELETED)
|
|
{
|
|
CWiaItem *pWiaItem = m_WiaItemList.Find(pEventMessage->FullItemName());
|
|
if (pWiaItem)
|
|
{
|
|
pWiaItem->MarkDeleted();
|
|
}
|
|
}
|
|
|
|
//
|
|
// On a connect event for this device, close the wizard
|
|
//
|
|
if (pEventMessage->EventId() == WIA_EVENT_DEVICE_CONNECTED)
|
|
{
|
|
if (m_bDisconnected && m_hWndWizard)
|
|
{
|
|
PropSheet_PressButton(m_hWndWizard,PSBTN_CANCEL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free the event message
|
|
//
|
|
delete pEventMessage;
|
|
}
|
|
return HANDLED_EVENT_MESSAGE;
|
|
}
|
|
|
|
LRESULT CAcquisitionManagerControllerWindow::OnPowerBroadcast( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if (PBT_APMQUERYSUSPEND == wParam)
|
|
{
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CALLBACK CAcquisitionManagerControllerWindow::WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
SC_BEGIN_REFCOUNTED_MESSAGE_HANDLERS(CAcquisitionManagerControllerWindow)
|
|
{
|
|
SC_HANDLE_MESSAGE( WM_CREATE, OnCreate );
|
|
SC_HANDLE_MESSAGE( WM_DESTROY, OnDestroy );
|
|
SC_HANDLE_MESSAGE( PWM_POSTINITIALIZE, OnPostInitialize );
|
|
SC_HANDLE_MESSAGE( WM_POWERBROADCAST, OnPowerBroadcast );
|
|
}
|
|
SC_HANDLE_REGISTERED_MESSAGE(m_nThreadNotificationMessage,OnThreadNotification);
|
|
SC_HANDLE_REGISTERED_MESSAGE(m_nWiaEventMessage,OnEventNotification);
|
|
SC_END_MESSAGE_HANDLERS();
|
|
}
|
|
|
|
|
|
bool CAcquisitionManagerControllerWindow::Register( HINSTANCE hInstance )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::Register"));
|
|
WNDCLASSEX WndClassEx;
|
|
memset( &WndClassEx, 0, sizeof(WndClassEx) );
|
|
WndClassEx.cbSize = sizeof(WNDCLASSEX);
|
|
WndClassEx.lpfnWndProc = WndProc;
|
|
WndClassEx.hInstance = hInstance;
|
|
WndClassEx.hCursor = LoadCursor(NULL,IDC_ARROW);
|
|
WndClassEx.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
|
|
WndClassEx.lpszClassName = ACQUISITION_MANAGER_CONTROLLER_WINDOW_CLASSNAME;
|
|
BOOL bResult = (::RegisterClassEx(&WndClassEx) != 0);
|
|
DWORD dw = GetLastError();
|
|
return(bResult != 0);
|
|
}
|
|
|
|
|
|
HWND CAcquisitionManagerControllerWindow::Create( HINSTANCE hInstance, CEventParameters *pEventParameters )
|
|
{
|
|
return CreateWindowEx( 0, ACQUISITION_MANAGER_CONTROLLER_WINDOW_CLASSNAME,
|
|
TEXT("WIA Acquisition Manager Controller Window"),
|
|
WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
|
NULL, NULL, hInstance, pEventParameters );
|
|
}
|
|
|
|
|
|
//
|
|
// Reference counting for our object
|
|
//
|
|
STDMETHODIMP_(ULONG) CAcquisitionManagerControllerWindow::AddRef(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::AddRef"));
|
|
ULONG nRes = InterlockedIncrement(&m_cRef);
|
|
WIA_TRACE((TEXT("m_cRef: %d"),m_cRef));
|
|
return nRes;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CAcquisitionManagerControllerWindow::Release(void)
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::Release"));
|
|
if (InterlockedDecrement(&m_cRef)==0)
|
|
{
|
|
WIA_TRACE((TEXT("m_cRef: 0")));
|
|
|
|
//
|
|
// Cause this thread to exit
|
|
//
|
|
PostQuitMessage(0);
|
|
|
|
//
|
|
// Delete this instance of the wizard
|
|
//
|
|
delete this;
|
|
return 0;
|
|
}
|
|
WIA_TRACE((TEXT("m_cRef: %d"),m_cRef));
|
|
return(m_cRef);
|
|
}
|
|
|
|
HRESULT CAcquisitionManagerControllerWindow::QueryInterface( REFIID riid, void **ppvObject )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::QueryInterface"));
|
|
HRESULT hr = S_OK;
|
|
*ppvObject = NULL;
|
|
if (IsEqualIID( riid, IID_IUnknown ))
|
|
{
|
|
*ppvObject = static_cast<IWizardSite*>(this);
|
|
reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
|
|
}
|
|
else if (IsEqualIID( riid, IID_IWizardSite ))
|
|
{
|
|
*ppvObject = static_cast<IWizardSite*>(this);
|
|
reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
|
|
}
|
|
else if (IsEqualIID( riid, IID_IServiceProvider ))
|
|
{
|
|
*ppvObject = static_cast<IServiceProvider*>(this);
|
|
reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
|
|
}
|
|
else
|
|
{
|
|
WIA_PRINTGUID((riid,TEXT("Unknown interface")));
|
|
*ppvObject = NULL;
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// IWizardSite
|
|
//
|
|
HRESULT CAcquisitionManagerControllerWindow::GetPreviousPage(HPROPSHEETPAGE *phPage)
|
|
{
|
|
if (!phPage)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
*phPage = PropSheet_IndexToPage( m_hWndWizard, m_nUploadQueryPageIndex );
|
|
if (*phPage)
|
|
{
|
|
return S_OK;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT CAcquisitionManagerControllerWindow::GetNextPage(HPROPSHEETPAGE *phPage)
|
|
{
|
|
if (!phPage)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
*phPage = PropSheet_IndexToPage( m_hWndWizard, m_nFinishPageIndex );
|
|
if (*phPage)
|
|
{
|
|
return S_OK;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
HRESULT CAcquisitionManagerControllerWindow::GetCancelledPage(HPROPSHEETPAGE *phPage)
|
|
{
|
|
return GetNextPage(phPage);
|
|
}
|
|
|
|
//
|
|
// IServiceProvider
|
|
//
|
|
HRESULT CAcquisitionManagerControllerWindow::QueryService( REFGUID guidService, REFIID riid, void **ppv )
|
|
{
|
|
WIA_PUSHFUNCTION(TEXT("CAcquisitionManagerControllerWindow::QueryService"));
|
|
WIA_PRINTGUID((guidService,TEXT("guidService")));
|
|
WIA_PRINTGUID((riid,TEXT("riid")));
|
|
|
|
if (!ppv)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// Initialize result
|
|
//
|
|
*ppv = NULL;
|
|
|
|
if (guidService == SID_PublishingWizard)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
static CSimpleString GetDisplayName( IShellItem *pShellItem )
|
|
{
|
|
CSimpleString strResult;
|
|
if (pShellItem)
|
|
{
|
|
LPOLESTR pszStr = NULL;
|
|
if (SUCCEEDED(pShellItem->GetDisplayName( SIGDN_FILESYSPATH, &pszStr )) && pszStr)
|
|
{
|
|
strResult = CSimpleStringConvert::NaturalString(CSimpleStringWide(pszStr));
|
|
|
|
CComPtr<IMalloc> pMalloc;
|
|
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
|
|
{
|
|
pMalloc->Free( pszStr );
|
|
}
|
|
}
|
|
}
|
|
return strResult;
|
|
}
|
|
|
|
//
|
|
// These two functions are needed to use the generic event handler class
|
|
//
|
|
void DllAddRef(void)
|
|
{
|
|
#if !defined(DBG_GENERATE_PRETEND_EVENT)
|
|
_Module.Lock();
|
|
#endif
|
|
}
|
|
|
|
void DllRelease(void)
|
|
{
|
|
#if !defined(DBG_GENERATE_PRETEND_EVENT)
|
|
_Module.Unlock();
|
|
#endif
|
|
}
|
|
|