relctrldlg.cpp

佳能数码相机 SDK 7.3 开发包 VC++代码 含英文说明文档

// RelCtrlDlg.cpp : implementation file
//

#include "stdafx.h"
#include <vfw.h>
#include <afxmt.h>

#include "RelCtrl.h"
#include "Progress.h"
#include "RelCtrlDlg.h"
#include "ComSettingDlg.h"

#include "cdAPI.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define		VIEWFINDER_WIDTH		320
#define		VIEWFINDER_HEIGHT		240
#define		VIEWFINDER_MUTEXNAME	"ViewFineder Mutex"

#define		FILEFORMAT_JPG			0
#define		FILEFORMAT_BMP			1

#define		CAMERAEVENTMESSAGESTRING_RELEASE_ON		"Camera Event ReleaseOn"
#define		CAMERAEVENTMESSAGESTRING_RELEASE_COMP	"Camera Event ReleaseComplete"
#define		CAMERAEVENTMESSAGESTRING_ABORT_PC_EVF	"Camera Event Abort PC EVF"
#define		CAMERAEVENTMESSAGESTRING_CHANGE_BY_UI	"Camera Event Change By UI"

#ifndef		GETERRORID
#define		GETERRORID( x )		(cdERROR_ERRORID_MASK&x)
#endif

UINT			g_ReleaseOnMessage=0;		/* A message when the shutter release of a camera is pushed */
UINT			g_ReleaseCompleteMessage=0;	/* A message when photography is completed */
UINT			g_AbortPCEVF=0;
CWinThread		*g_CpVFThread;				/* The class of a picture display thread */
CMutex			g_CVFMutex;					/* The synchronous class of image data */

UINT			g_ChangeByUI=0;				/* A message when the capture parameter of the camera is changed 
											   by operation of the camera UI. */

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRelCtrlDlg dialog

CRelCtrlDlg::CRelCtrlDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CRelCtrlDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CRelCtrlDlg)
	m_CInfoString = _T("");
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CRelCtrlDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRelCtrlDlg)
	DDX_Control(pDX, IDC_STATIC_SHOOTING_MODE, m_Static_ShootingMode);
	DDX_Control(pDX, IDC_STATIC_RELEASE_PARAM, m_Static_ReleaseParam);
	DDX_Control(pDX, IDC_STATIC_PHOTO_EFFECT, m_Static_PhotoEffect);
	DDX_Control(pDX, IDC_STATIC_ISO_SPEED, m_Static_ISOSpeed);
	DDX_Control(pDX, IDC_STATIC_FLASH, m_Static_Flash);
	DDX_Control(pDX, IDC_STATIC_EXPO_COMP, m_Static_ExpoComp);
	DDX_Control(pDX, IDC_PHOTO_EFFECT, m_CPhotoEffect);
	DDX_Control(pDX, IDC_SHOOTING_MODE, m_CShootingMode);
	DDX_Control(pDX, IDC_ISO_SPEED, m_CISOSpeed);
	DDX_Control(pDX, IDC_FLASH, m_CFlash);
	DDX_Control(pDX, IDC_EXPO_COMP, m_CExpoComp);
	DDX_Control(pDX, IDC_SAVEPATH, m_CSavePath);
	DDX_Control(pDX, IDC_BROWSE, m_CBrowse);
	DDX_Control(pDX, IDC_AEAF, m_CAEAF);
	DDX_Control(pDX, IDC_VIEWIMG, m_CViewImage);
	DDX_Control(pDX, IDC_VIEWFINDER, m_CViewFinder);
	DDX_Control(pDX, IDC_RELEASE, m_CRelease);
	DDX_Control(pDX, IDC_RELCHECK4, m_CRelChk4);
	DDX_Control(pDX, IDC_RELCHECK3, m_CRelChk3);
	DDX_Control(pDX, IDC_RELCHECK2, m_CRelChk2);
	DDX_Control(pDX, IDC_RELCHECK1, m_CRelChk1);
	DDX_Control(pDX, IDC_END, m_CEnd);
	DDX_Control(pDX, IDC_DISCONNECT, m_CDisconnect);
	DDX_Control(pDX, IDC_CONNECT, m_CConnect);
	DDX_Text(pDX, IDC_INFORMATION, m_CInfoString);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CRelCtrlDlg, CDialog)
	//{{AFX_MSG_MAP(CRelCtrlDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_CONNECT, OnConnect)
	ON_BN_CLICKED(IDC_DISCONNECT, OnDisconnect)
	ON_BN_CLICKED(IDC_END, OnEnd)
	ON_BN_CLICKED(IDC_RELEASE, OnRelease)
	ON_BN_CLICKED(IDC_RELCHECK1, OnRelcheck1)
	ON_BN_CLICKED(IDC_RELCHECK2, OnRelcheck2)
	ON_BN_CLICKED(IDC_RELCHECK3, OnRelcheck3)
	ON_BN_CLICKED(IDC_RELCHECK4, OnRelcheck4)
	ON_BN_CLICKED(IDC_VIEWFINDER, OnViewfinder)
	ON_BN_CLICKED(IDC_AEAF, OnAeaf)
	ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
	ON_WM_DESTROY()
	ON_CBN_SELCHANGE(IDC_SHOOTING_MODE, OnSelchangeShootingMode)
	ON_CBN_SELCHANGE(IDC_EXPO_COMP, OnSelchangeExpoComp)
	ON_CBN_SELCHANGE(IDC_FLASH, OnSelchangeFlash)
	ON_CBN_SELCHANGE(IDC_ISO_SPEED, OnSelchangeISOSpeed)
	ON_CBN_SELCHANGE(IDC_PHOTO_EFFECT, OnSelchangePhotoEffect)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// Call back function

cdUInt32 cdSTDCALL	CRelCtrlDlg::CamCallBackFunc(	cdEventID		EventID,
													const cdVoid*	pData,
													cdUInt32		DataSize,
													cdContext		Context )
{
	WPARAM			wParam;
	CRelCtrlDlg		*CpThis;
		
	CpThis = (CRelCtrlDlg*)Context;
	
	/* A security level is checked. */
	switch( cdEVENT_SEVERITY(EventID) )
	{
		case cdEVENT_SEVERITY_SHUTDOWN:
			wParam = ((WPARAM)BN_CLICKED<<16)|(0xFFFF&IDC_DISCONNECT);
			CpThis->PostMessage( WM_COMMAND, wParam, NULL );
			break;
		case cdEVENT_SEVERITY_NONE:
		case cdEVENT_SEVERITY_WARNING:
			break;
	}
	
	return	cdOK;
}

/**/
cdUInt32 cdSTDCALL	CRelCtrlDlg::RelCallBackFunc(	cdReleaseEventID	EventID,
													const void *		pData,
													cdUInt32 			DataSize,
													cdContext			Context )
{
	cdError			err=cdOK;
	CRelCtrlDlg		*CpThis;
	cdUInt32		*dwpCount;
	CProgress		CProg;
	
	CpThis = (CRelCtrlDlg*)Context;
	
	switch( EventID )
	{
		case cdRELEASE_EVENT_RESET_HW_ERROR:
			break;
		case cdRELEASE_EVENT_CHANGED_BY_UI:
			CpThis->PostMessage( g_ChangeByUI );
			break;
		case cdRELEASE_EVENT_RELEASE_START:
			break;
		case cdRESEASE_EVENT_RELEASE_COMPLETE:
			dwpCount = (cdUInt32*)pData;
			CpThis->PostMessage( g_ReleaseCompleteMessage, (WPARAM)*dwpCount );
			break;
		case cdRELEASE_EVENT_CAM_RELEASE_ON:
			CpThis->PostMessage( g_ReleaseOnMessage );
			break;
		case cdRELEASE_EVENT_ABORT_PC_EVF:
			CpThis->PostMessage( g_AbortPCEVF );
			break;
	}
	
	return	err;
}

/* The function which receives the picture from a camera */
cdUInt32 cdSTDCALL	CRelCtrlDlg::ViewFinderCallBackFun(	cdVoid		*pBuf,
											 			cdUInt32	Size,
														cdUInt32	Format,
														cdContext	Context )
{
	cdError				err=cdOK;
	LPBYTE				bpPixel;
	PBITMAPFILEHEADER	pBmpFileheader;
	PBITMAPINFOHEADER	pBmpInfoheader;
	CRelCtrlDlg			*CpThis;
	
	CpThis = (CRelCtrlDlg*)Context;
	if( Format == FILEFORMAT_BMP )
	{
		pBmpFileheader = (PBITMAPFILEHEADER)pBuf;
		pBmpInfoheader = (PBITMAPINFOHEADER)((LPBYTE)pBuf + sizeof(BITMAPFILEHEADER));
		bpPixel = (LPBYTE)pBuf + pBmpFileheader->bfOffBits;
		
		/* A picture is saved at a buffer. */
		g_CVFMutex.Lock();
		memcpy( CpThis->m_BackSurface.vpBits, bpPixel, pBmpInfoheader->biSizeImage );
		g_CVFMutex.Unlock();
		/* A picture is displayed. */
		g_CpVFThread->ResumeThread();

	}
	
	return	err;
}

/////////////////////////////////////////////////////////////////////////////
// Thread function

/* The thread for displaying a picture */
UINT WINAPI	CRelCtrlDlg::ViewFinderProc( LPVOID	vpParam )
{
	CRelCtrlDlg		*CpThis;
	BOOL			*fpEnd;
	HDC				hdcDest,hdcSrc;
		
	CpThis = (CRelCtrlDlg*)vpParam;
	fpEnd = (BOOL*)(&CpThis->m_fVFEnd);
	while( *fpEnd )
	{
		/* It waits until it can use data. */
		g_CVFMutex.Lock();
		
		/* A picture is displayed. */
		hdcDest = ::GetDC( CpThis->m_CpViewFinder->GetSafeHwnd() );
		hdcSrc = ::CreateCompatibleDC( hdcDest );
		::SelectObject( hdcSrc, CpThis->m_BackSurface.hBmp );
		::BitBlt(	hdcDest,
					0,0,VIEWFINDER_WIDTH,VIEWFINDER_HEIGHT,
					hdcSrc,
					0,0,
					SRCCOPY );
		::DeleteDC( hdcSrc );
		::ReleaseDC( CpThis->m_CpViewFinder->GetSafeHwnd(), hdcDest );
		
		/* The ownership of data is released. */
		g_CVFMutex.Unlock();
		/* A thread is suspended. */
		g_CpVFThread->SuspendThread();
	}
	
	return	0;
}

/////////////////////////////////////////////////////////////////////////////
// CRelCtrlDlg Internal function

/* DIB is created. */
BOOL	CRelCtrlDlg::CreateDIBBuffer()
{
	cdError		err=cdOK;
	BITMAPINFO	BmpInfo;
		
	memset( &BmpInfo, 0, sizeof(BITMAPINFO) );
	BmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	BmpInfo.bmiHeader.biWidth = VIEWFINDER_WIDTH;
	BmpInfo.bmiHeader.biHeight = VIEWFINDER_HEIGHT;
	BmpInfo.bmiHeader.biPlanes = 1;
	BmpInfo.bmiHeader.biBitCount = 24;
	BmpInfo.bmiHeader.biCompression = BI_RGB;
	
	m_BackSurface.hBmp = ::CreateDIBSection(	NULL,
												&BmpInfo,
												DIB_RGB_COLORS,
												&m_BackSurface.vpBits,
												NULL,
												0 );
	if( !m_BackSurface.hBmp )
	{
		return	FALSE;
	}
	
	return	TRUE;
}

void	CRelCtrlDlg::GetCameraInformation()
{
	cdError			err;
	CString			CAddStr;
	
	UpdateData( TRUE );
	m_CInfoString = "";
	
	/* Quality of image, image size, and the average size of a picture file are acquired. */
	cdCompQuality	Quality;
	cdImageSize		Size;
	err = CDGetImageFormatAttribute( m_hSource, &Quality, &Size );
	if( GETERRORID(err) == cdOK )
	{
		switch( Quality&0x00ff )
		{
			case cdCOMP_QUALITY_ECONOMY:
				CAddStr.Format( "ImageQuality = Economy\r\n" );
				break;
			case cdCOMP_QUALITY_NORMAL:
				CAddStr.Format( "ImageQuality = Normal\r\n" );
				break;
			case cdCOMP_QUALITY_FINE:
				CAddStr.Format( "ImageQuality = Fine\r\n" );
				break;
			case cdCOMP_QUALITY_RAW:
				CAddStr.Format( "ImageQuality = Raw\r\n" );
				break;
			case cdCOMP_QUALITY_SUPERFINE:
				CAddStr.Format( "ImageQuality = SuperFine\r\n" );
				break;
			case cdCOMP_QUALITY_UNKNOWN:
			default:
				CAddStr.Format( "ImageQuality = Unknown\r\n" );
				break;
		}
		m_CInfoString += CAddStr;
		
		switch( Size&0x00ff )
		{
			case cdIMAGE_SIZE_LARGE:
				CAddStr.Format( "ImageSize = Large\r\n" );
				break;
			case cdIMAGE_SIZE_MEDIUM:
				CAddStr.Format( "ImageSize = Medium\r\n" );
				break;
			case cdIMAGE_SIZE_SMALL:
				CAddStr.Format( "ImageSize = Small\r\n" );
				break;
			case cdIMAGE_SIZE_MEDIUM1:
				CAddStr.Format( "ImageSize = Medium1\r\n" );
				break;
			case cdIMAGE_SIZE_MEDIUM2:
				CAddStr.Format( "ImageSize = Medium2\r\n" );
				break;
			case cdIMAGE_SIZE_UNKNOWN:
			default:
				CAddStr.Format( "ImageSize = Unknown\r\n" );
				break;
		}
		m_CInfoString += CAddStr;
	}
	else if( GETERRORID(err) != cdNOT_SUPPORTED )
	{
		CAddStr.Format( "<err>CDGetImageFormatAttribute = 0x%08X\r\n", err );
		m_CInfoString += CAddStr;
	}
	
	/* Shooting mode is acquired. */
	cdShootingMode		ShootingMode;
	err = CDGetShootingMode( m_hSource, &ShootingMode );
	if( GETERRORID(err) == cdOK )
	{
		switch( ShootingMode )
		{
			case cdSHOOTING_MODE_AUTO:
				CAddStr.Format( "ShootingMode = Auto\r\n" );
				break;
			case cdSHOOTING_MODE_PROGRAM:
				CAddStr.Format( "ShootingMode = Program\r\n" );
				break;
			case cdSHOOTING_MODE_TV:
				CAddStr.Format( "ShootingMode = Tv\r\n" );
				break;
			case cdSHOOTING_MODE_AV:
				CAddStr.Format( "ShootingMode = Av\r\n" );
				break;
			case cdSHOOTING_MODE_MANUAL:
				CAddStr.Format( "ShootingMode = Manual\r\n" );
				break;
			case cdSHOOTING_MODE_A_DEP:
				CAddStr.Format( "ShootingMode = A Dep\r\n" );
				break;
			case cdSHOOTING_MODE_M_DEP:
				CAddStr.Format( "ShootingMode = M Dep\r\n" );
				break;
			case cdSHOOTING_MODE_BULB:
				CAddStr.Format( "ShootingMode = Bulb\r\n" );
				break;
			case cdSHOOTING_MODE_MANUAL_2:
				CAddStr.Format( "ShootingMode = Manual2\r\n" );
				break;
			case cdSHOOTING_MODE_FAR_SCENE:
				CAddStr.Format( "ShootingMode = Far Scene\r\n" );
				break;
			case cdSHOOTING_MODE_FAST_SHUTTER:
				CAddStr.Format( "ShootingMode = Fast Shutter\r\n" );
				break;
			case cdSHOOTING_MODE_SLOW_SHUTTER:
				CAddStr.Format( "ShootingMode = Slow Shutter\r\n" );
				break;
			case cdSHOOTING_MODE_NIGHT_SCENE:
				CAddStr.Format( "ShootingMode = Night Scene\r\n" );
				break;
			case cdSHOOTING_MODE_GRAY_SCALE:
				CAddStr.Format( "ShootingMode = Gray Scale\r\n" );
				break;
			case cdSHOOTING_MODE_SEPIA:
				CAddStr.Format( "ShootingMode = Mode Sepia\r\n" );
				break;
			case cdSHOOTING_MODE_PORTRAIT:
				CAddStr.Format( "ShootingMode = Portrait\r\n" );
				break;
			case cdSHOOTING_MODE_SPOT:
				CAddStr.Format( "ShootingMode = Spot\r\n" );
				break;
			case cdSHOOTING_MODE_MACRO:
				CAddStr.Format( "ShootingMode = Macro\r\n" );
				break;
			case cdSHOOTING_MODE_BW:
				CAddStr.Format( "ShootingMode = BW\r\n" );
				break;
			case cdSHOOTING_MODE_PANFOCUS:
				CAddStr.Format( "ShootingMode = Panfocus\r\n" );
				break;
			case cdSHOOTING_MODE_VIVID:
				CAddStr.Format( "ShootingMode = Vivid\r\n" );
				break;
			case cdSHOOTING_MODE_NEUTRAL:
				CAddStr.Format( "ShootingMode = Neutral\r\n" );
				break;
			case cdSHOOTING_MODE_INVALID:
			default:
				CAddStr.Format( "ShootingMode = Invalid\r\n" );
				break;
		}
		m_CInfoString += CAddStr;
	}
	else if( GETERRORID(err) != cdNOT_SUPPORTED )
	{
		CAddStr.Format( "<err>CDGetShootingMode = 0x%08X\r\n", err );
		m_CInfoString += CAddStr;
	}
	
	/* The number of sheets which can be remaining photoed is acquired. */
	cdUInt32	Num;
	err = CDGetNumAvailableShot( m_hSource, &Num );
	if( GETERRORID(err) == cdOK )
	{
		CAddStr.Format( "NumAvailableShot = %d\r\n", Num );
		m_CInfoString += CAddStr;
	}