receivemessage.cpp

此代码是奥林巴斯相机驱动的例程

// ReceiveMessage.cpp : implementation file
//

#include "stdafx.h"
#include "ControlCamera.h"
#include "ReceiveMessage.h"
#include "MochaCommon.h"
#include "Common.h"

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

/////////////////////////////////////////////////////////////////////////////
// ReceiveMessage dialog
HWND main_hwnd;

ReceiveMessage::ReceiveMessage(CWnd* pParent /*=NULL*/)
	: CDialog(ReceiveMessage::IDD, pParent)
{
	//{{AFX_DATA_INIT(ReceiveMessage)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
//	main_hwnd=this->m_hWnd;
	::CoInitialize(NULL);
	_Module.Init(NULL, ::GetModuleHandle(NULL));

	m_pMocha = NULL;
	m_dwCookie = 0;
	m_nCurCam = -1;
//	CreateMocha();
	// Initialization of a Mocha object
//	InitMocha();
}
ReceiveMessage::~ReceiveMessage()
{
	if(m_dwCookie)
		AtlUnadvise(m_pMocha,DIID__IMochaEvents,m_dwCookie);
	_Module.Term();

}

void ReceiveMessage::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(ReceiveMessage)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(ReceiveMessage, CDialog)
	//{{AFX_MSG_MAP(ReceiveMessage)
		// NOTE: the ClassWizard will add message map macros here
	//}}AFX_MSG_MAP
	ON_MESSAGE(DEF_WM_TRANSFER, OnTransferMessage)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// ReceiveMessage message handlers

bool ReceiveMessage::SaveFileData(LPCTSTR lpszFileName, PBYTE pBuf, DWORD dwSize)
{
	try
	{
		CFile file(lpszFileName,CFile::modeCreate|CFile::modeWrite|CFile::typeBinary);
		file.Write(pBuf,dwSize);
		file.Close();
	}
	catch( CFileException* e )
	{
		CString strFileError;
		LPSTR lpszErrorMsg = strFileError.GetBufferSetLength( 256 );
		e->GetErrorMessage( lpszErrorMsg, 256 );
		e->Delete();
		return false;
	}
	return true;
}

void ReceiveMessage::GetBurstNumberDesc()
{

}

int ReceiveMessage::InitMocha()
{
	try
	{
		_bstr_t bstrName;

		m_pMocha->InitControl();
		long lnCamCount = m_pMocha->GetCameraCount();
/*
		for(int i=0;i<lnCamCount;i++)
		{
			bstrName = m_pMocha->GetCameraName(i);
			m_cmbCamera.AddString((char*)bstrName);
		}
*/
		if(lnCamCount)
		{
			m_nCurCam = 0;
//			m_cmbCamera.SetCurSel(m_nCurCam);
			m_pMocha->OpenSession(m_nCurCam);
			m_pMocha->Discovery(m_nCurCam);
			m_pMocha->SetCameraControlMode(m_nCurCam,PRM_CAM_CONTROL);

//			m_cmbCaptureMode.SetCurSel(0);
//			((CComboBox*) GetDlgItem(IDC_COMBO_BURST_NUM))->EnableWindow(FALSE);
			SetCameraMode(m_wMode);
		}
		return lnCamCount;
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnErrNo = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("InitMocha Error");

		TRACE("  %x\n",lnErrNo);
		return -1;
	}
	
}

void ReceiveMessage::CreateMocha()
{
#if 1
	{// The method using a license file
		long lnRet = m_pMocha.CreateInstance(CLSID_Mocha);
		if(S_OK != lnRet)
			return;
	}
#else
	{// The method using a license key at CreateInstance
		USES_CONVERSION;

		BSTR bstr_lic;
		LPCLASSFACTORY2 cls_comfact2;

		if (CoGetClassObject(CLSID_Mocha, CLSCTX_INPROC_SERVER, NULL,
		      IID_IClassFactory2, (LPVOID *)&cls_comfact2) != S_OK)
		{// Error
			TRACE("CoGetClassObject ERROR\n");
			return;
		}

		// Set license key
		bstr_lic = SysAllocString( T2OLE(DEF_LICENCE_KEY)); 

		if (cls_comfact2->CreateInstanceLic(NULL, NULL, IID_IMocha,bstr_lic,(void **)&m_pMocha) != S_OK)
		{// Error
			TRACE("CreateInstanceLic ERROR\n");
			cls_comfact2->Release();
			return;
		}

		SysFreeString(bstr_lic);

		cls_comfact2->Release();
	}	
#endif	

	if(!m_dwCookie)
	{
		CComObject<CMochaEvent> *pMochaEvent=NULL;
		CComObject<CMochaEvent>::CreateInstance(&pMochaEvent);
		if(!pMochaEvent)
			return;

		CComPtr<IUnknown> pComEvent = (IUnknown*) pMochaEvent;
		AtlAdvise(m_pMocha,pComEvent,DIID__IMochaEvents,&m_dwCookie);
	}
}

BOOL ReceiveMessage::DestroyWindow() 
{
	// TODO: Add your specialized code here and/or call the base class
	try
	{
		if(-1 != m_nCurCam)
			m_pMocha->CloseSession(m_nCurCam);
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("CloseSession Error");

		TRACE("  %x\n",lnError);
	}	
	return CDialog::DestroyWindow();
}

void ReceiveMessage::SetCamera(int iCurNum)
{
	if(-1 == m_nCurCam)
		return;
	
//	CWaitCursor cur;
//	int nCamNo = m_cmbCamera.GetCurSel();
	try
	{
		m_pMocha->CloseSession(m_nCurCam);
		m_nCurCam = iCurNum;
		m_pMocha->OpenSession(m_nCurCam);
		m_pMocha->Discovery(m_nCurCam);
		m_pMocha->SetCameraControlMode(m_nCurCam,PRM_CAM_CONTROL);
		SetCameraMode(m_wMode);
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnErrNo = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("OnSelchangeComboCamera Error");

		TRACE("  %x\n",lnErrNo);
	}
}

void ReceiveMessage::SetCameraMode(int iMode)
{
	COleSafeArray	arryParam,arryResp,arryBuf;
	LPVOID lpBuf;
//	WORD wMode;

	if(-1 == m_nCurCam)
		return;
	m_wMode=iMode;
	arryParam.CreateOneDim(VT_UI1, sizeof(CMD_PARAM_VALUE));
	arryResp.CreateOneDim(VT_UI1, sizeof(CMD_RESP_VALUE));
	arryBuf.CreateOneDim(VT_UI1, sizeof(WORD));
/*	if(1 == iMode)
	{
	//	((CComboBox*) GetDlgItem(IDC_COMBO_BURST_NUM))->EnableWindow(TRUE);
		iMode = PRM_CAPTURE_BURST;
	//	GetBurstNumberDesc();
	}
	else
	{
	//	((CComboBox*) GetDlgItem(IDC_COMBO_BURST_NUM))->EnableWindow(FALSE);
		iMode = PRM_CAPTURE_NORMAL;
	}
*/
//	m_wMode=cm;
	arryBuf.AccessData(&lpBuf);
	CopyMemory(lpBuf,&m_wMode,sizeof(WORD));
	arryBuf.UnaccessData();
	try
	{
		m_pMocha->SendCmd(m_nCurCam,OP_SET_STILL_CAPTURE_MODE,arryParam,arryResp,arryBuf,sizeof(WORD));
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("OnSelchangeComboMode Error");

		TRACE("  %x\n",lnError);
	}	
	arryParam.Clear();
	arryResp.Clear();
	arryBuf.Clear();
}

void ReceiveMessage::SetBurstNum(WORD iNum)
{
	COleSafeArray arryParam,arryResp,arryBuf;
	LPVOID lpBuf;

	if(-1==m_nCurCam)
		return;
	m_wNum=iNum;
	arryParam.CreateOneDim(VT_UI1,sizeof(CMD_PARAM_VALUE));
	arryResp.CreateOneDim(VT_UI1,sizeof(CMD_RESP_VALUE));
	arryBuf.CreateOneDim(VT_UI1,sizeof(WORD));
	arryBuf.AccessData(&lpBuf);
	CopyMemory(lpBuf,&m_wNum,sizeof(WORD));
	arryBuf.UnaccessData();
	
	try
	{
		m_pMocha->SendCmd(m_nCurCam,OP_SET_BURST_NUMBER,arryParam,arryResp,arryBuf,sizeof(WORD));
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("OnSelchangeComboBurstNum Error");

		TRACE("  %x\n",lnError);
	}	
	arryParam.Clear();
	arryResp.Clear();
	arryBuf.Clear();
}
void ReceiveMessage::OnTransferMessage(WPARAM wParam, LPARAM lParam)
{
	CTransferInfo* pTransInfo = (CTransferInfo*)wParam;
	try
	{
		COleSafeArray	arryBuf;
		LPVOID lpBuf;
		{
			arryBuf.CreateOneDim(VT_UI1, pTransInfo->m_lnImageSize);

			m_pMocha->GetImage(pTransInfo->m_lnCamNo,pTransInfo->m_lnObjectHandle,arryBuf,pTransInfo->m_lnImageSize,0);
			arryBuf.AccessData(&lpBuf);
			CString strFile;

			if(PIC_FORMAT_RAW == pTransInfo->m_lnFormatCode)
				strFile.Format("Pic%d.ORF",pTransInfo->m_lnCamNo+1);
			else if(PIC_FORMAT_EXIF == pTransInfo->m_lnFormatCode)
				strFile.Format(m_filename,pTransInfo->m_lnCamNo+1);
			else
				strFile.Format("Pic%d.TIF",pTransInfo->m_lnCamNo+1);

			SaveFileData(m_filename,(LPBYTE)lpBuf,pTransInfo->m_lnImageSize);
			arryBuf.UnaccessData();
			arryBuf.Clear();

		}
	}
	catch(_com_error& e)
	{
		::PostMessage(m_hWnd,DEF_WM_CANCELEND,pTransInfo->m_lnCamNo,0);
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("OnTransferMessage Error");

		TRACE("  %x\n",lnError);
	}	
	delete pTransInfo;

}



void ReceiveMessage::Capture(char *filename,int Press_mode)
{
	if(-1 == m_nCurCam)
		return;

	try
	{
//		memcpy(&m_filename,filename,sizeof(filename));
		m_filename.Format("%d%s",m_nCurCam,filename);
		m_pMocha->Capture(m_nCurCam,m_nValue);
		if(m_nValue ==1)
		{
			//set capture step to 2nd
			m_nValue = 2;
		}else if(m_nValue ==2)
		{
			//set capture step to 1st
			m_nValue = 3;
		}
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("OnButtonCapture Error");

		TRACE("  %x\n",lnError);
	}	
}

int ReceiveMessage::initcamera()
{
	int camerastate;
	main_hwnd=this->m_hWnd;
/*	::CoInitialize(NULL);
	_Module.Init(NULL, ::GetModuleHandle(NULL));

	m_pMocha = NULL;
	m_dwCookie = 0;
	m_nCurCam = -1;*/
	CreateMocha();
	// Initialization of a Mocha object
	camerastate=InitMocha();
	m_nValue=3;
	return camerastate;
}

void ReceiveMessage::SetAFLMode(BOOL bEnable)
{
	COleSafeArray	arryParam,arryResp,arryBufMode,arryBufStatus;
	LPVOID lpBuf;
	WORD wAELAFLMode = 0x0002;
	WORD wAELBtnStatus = bEnable?0x0001:0;

	if(-1 == m_nCurCam)
		return;

	CWaitCursor cur;
		arryParam.CreateOneDim(VT_UI1, sizeof(CMD_PARAM_VALUE));
		arryResp.CreateOneDim(VT_UI1, sizeof(CMD_RESP_VALUE));
		arryBufMode.CreateOneDim(VT_UI1, sizeof(WORD));
		arryBufStatus.CreateOneDim(VT_UI1, sizeof(WORD));

		arryBufMode.AccessData(&lpBuf);
		CopyMemory(lpBuf,&wAELAFLMode,sizeof(WORD));
		arryBufMode.UnaccessData();

		arryBufStatus.AccessData(&lpBuf);
		CopyMemory(lpBuf,&wAELBtnStatus,sizeof(WORD));
		arryBufStatus.UnaccessData();

		try
		{
			m_pMocha->SendCmd(m_nCurCam,OP_SET_AELAFL_MODE,arryParam,arryResp,arryBufMode,sizeof(WORD));
			m_pMocha->SendCmd(m_nCurCam,OP_SET_AELBTN_STATUS,arryParam,arryResp,arryBufStatus,sizeof(WORD));

		}
		catch(_com_error& e)
		{
			_bstr_t bstrMes = e.Description();
			long lnError = e.Error();
			if(bstrMes.length())
				TRACE(bstrMes);
			else
				TRACE("OnSelchangeComboFocusM Error");

			TRACE("  %x\n",lnError);
		}	

		arryParam.Clear();
		arryResp.Clear();
		arryBufMode.Clear();
		arryBufStatus.Clear();
}

void ReceiveMessage::SetDirectMFMode(BOOL bEnable)
{
	WORD wValue = bEnable?1:0;
	LPVOID lpBuf;
	COleSafeArray	arryParam,arryResp,arryData;

	arryParam.CreateOneDim(VT_UI1, sizeof(CMD_PARAM_VALUE));
	arryResp.CreateOneDim(VT_UI1, sizeof(CMD_RESP_VALUE));
	arryData.CreateOneDim(VT_UI1, sizeof(WORD));
	arryData.AccessData(&lpBuf);
	CopyMemory(lpBuf,&wValue,sizeof(WORD));		
	arryData.UnaccessData();

	try
	{
		m_pMocha->SendCmd(m_nCurCam,OP_SET_MANUAL_FOCUS_MODE,arryParam,arryResp,arryData,sizeof(WORD));
		m_nValue = 1;
	}
	catch(_com_error& e)
	{
		_bstr_t bstrMes = e.Description();
		long lnError = e.Error();
		if(bstrMes.length())
			TRACE(bstrMes);
		else
			TRACE("MF Error");

		TRACE("  %x\n",lnError);
	}	
	arryParam.Clear();
	arryResp.Clear();
	arryData.Clear();	
}