~liuyang/ENRIT.git

// ViewLiveCam.cpp : ±¸Çö ÆÄÀÏÀÔ´Ï´Ù.
//
 
#include "stdafx.h"
#include "ENRIT.h"
#include "ViewLiveCam.h"
#include "afxdialogex.h"
#include "Global_Define.h"
 
// CViewLiveCam ´ëÈ »óÀÚÀÔ´Ï´Ù.
 
IMPLEMENT_DYNAMIC(CViewLiveCam, CDialogEx)
 
CViewLiveCam::CViewLiveCam(CWnd* pParent /*=NULL*/)
    : CDialogEx(CViewLiveCam::IDD, pParent)
{
    m_IV2M = NULL;
    m_pGlassData = NULL;
    m_pHardware = NULL;
    for(int i=0;i<MAX_CAMERA_COUNT;i++)
    {
        m_dZoom[i] = 1;
    }
}
 
CViewLiveCam::~CViewLiveCam()
{
}
 
void CViewLiveCam::DoDataExchange(CDataExchange* pDX)
{
    DDX_Control(pDX, IDC_SCROLLBAR1            , m_ctrlScrollH[0]);
    DDX_Control(pDX, IDC_SCROLLBAR2            , m_ctrlScrollH[1]);
    DDX_Control(pDX, IDC_SCROLLBAR3            , m_ctrlScrollH[2]);
    DDX_Control(pDX, IDC_SCROLLBAR4            , m_ctrlScrollH[3]);
 
    CDialogEx::DoDataExchange(pDX);
}
        
BEGIN_MESSAGE_MAP(CViewLiveCam, CDialogEx)
    ON_MESSAGE(WM_LIVE_IMG_UPDATE    , OnLiveImgUpDate)
    ON_WM_HSCROLL()
    ON_WM_TIMER()
    ON_WM_MOUSEWHEEL()    
END_MESSAGE_MAP()
 
BEGIN_EVENTSINK_MAP(CViewLiveCam, CDialogEx)
    ON_EVENT(CViewLiveCam, IDC_BTN_CAM_LIVE, DISPID_CLICK, CViewLiveCam::OnBnClickedBtnCamLive, VTS_NONE)
    ON_EVENT(CViewLiveCam, IDC_BTN_STOP, DISPID_CLICK, CViewLiveCam::OnBnClickedBtnStop, VTS_NONE)
    ON_EVENT(CViewLiveCam, IDC_RDO_SIGNAL1, DISPID_CLICK, CViewLiveCam::OnBnClickedRdoSignal1, VTS_NONE)
    ON_EVENT(CViewLiveCam, IDC_RDO_SIGNAL2, DISPID_CLICK, CViewLiveCam::OnBnClickedRdoSignal2, VTS_NONE)
    ON_EVENT(CViewLiveCam, IDC_BTN_CAM_SNAP, DISPID_CLICK, CViewLiveCam::OnBnClickedBtnCamSnap, VTS_NONE)    
END_EVENTSINK_MAP()
 
// CViewLiveCam ¸Þ½ÃÁö Ã³¸®±âÀÔ´Ï´Ù.
int  CViewLiveCam::GetIndex(int nSide)
{
    int  nIndex = 0;
 
    if(m_pHardware != NULL)
    {
        nIndex = m_pHardware->GetCameraIndexToDimension((DimensionDir)nSide);
    }
 
    return nIndex;
}
 
void CViewLiveCam::SetRecipe(CHardwareSettings *pHW)
{
    m_pHardware = pHW;
 
    int nSide,i;
    LPBYTE        plpBuf = NULL;
    for(i = 0 ; i < 4 ; i++)
    {
        nSide = LiveGetSideIdx(i);
 
        m_frameImg[i].SetSide(nSide);
 
        plpBuf = NULL;
        if(m_IV2M != NULL)
            plpBuf = m_IV2M->IV2M_GetGrabBufferByDimension((DimensionDir)nSide,0);
        m_frameImg[i].SetImage(plpBuf);
        m_frameImg[i].SetGlassData(m_pGlassData);    
    }
}
 
BOOL CViewLiveCam::OnInitDialog()
{    
    UpdateData(FALSE);
 
    CRect rc[4];
    int i =0;
 
 
    GetDlgItem(IDC_STATIC_CAM1)->GetWindowRect(rc[0]);
    GetDlgItem(IDC_STATIC_CAM2)->GetWindowRect(rc[1]);
    GetDlgItem(IDC_STATIC_CAM3)->GetWindowRect(rc[2]);
    GetDlgItem(IDC_STATIC_CAM4)->GetWindowRect(rc[3]);
        
    for(i = 0 ; i < 4 ; i++)
    {
        ScreenToClient(rc[i]);        
        m_frameImg[i].InitBitMap();
        
        m_frameImg[i].Create(NULL,NULL,WS_VISIBLE | WS_CHILD,rc[i],this,0);            
 
        m_dZoom[i] = 1;
        m_frameImg[i].SetZommMode(m_dZoom[i]);
        m_frameImg[i].ViewUpdate();
    }
    InitScrollInfo(-1);
 
    return TRUE;
}
 
int CViewLiveCam::LiveGetSideIdx(int nViewIndex)
{
    if(m_pHardware == NULL)
        return 0;
        
    CCameraSettings *pCamera = NULL;
 
    pCamera = m_pHardware->GetCameraSettings(nViewIndex,0);
    if(pCamera == NULL)
        return 0;
 
    return (int)pCamera->m_eDimension;
}
 
BOOL CViewLiveCam::PreTranslateMessage(MSG* pMsg)
{
    if( pMsg->message == WM_KEYDOWN )
    {
        if(pMsg->wParam == VK_RETURN
            || pMsg->wParam == VK_ESCAPE )
        {
            ::TranslateMessage(pMsg);
            ::DispatchMessage(pMsg);
            return TRUE;                    // DO NOT process further
        }
    }
 
    return CDialog::PreTranslateMessage(pMsg);
}
 
void CViewLiveCam::OnBnClickedBtnCamLive()
{    
    OnBnClickedBtnStop();
    
    int nDisplayFrame = 0;
    if(m_nRdoSignal == 0)
    {
        nDisplayFrame = 20;
    }    
 
    if(m_IV2M != NULL)
    {
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(0),FALSE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(1),FALSE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(2),FALSE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(3),FALSE);
    }
 
    SetTimer(1,100,NULL);    
}
 
void CViewLiveCam::OnTimer(UINT_PTR nIDEvent)
{
    for(int i = 0 ; i < 4 ; i++)
    {
        m_frameImg[i].ViewUpdate();
    }
 
    CDialogEx::OnTimer(nIDEvent);
}
 
void CViewLiveCam::OnBnClickedBtnStop()
{
    if(m_IV2M != NULL)
    {
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(0),TRUE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(1),TRUE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(2),TRUE);
        m_IV2M->IV2M_SetLiveGrabCommand((DimensionDir)LiveGetSideIdx(3),TRUE);
    }
    
    KillTimer(1);
}
 
void CViewLiveCam::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
    // TODO: ¿©±â¿¡ ¸Þ½ÃÁö Ã³¸®±â ÄÚµå¸¦ Ãß°¡ ¹×/¶Ç´Â ±âº»°ªÀ» È£ÃâÇÕ´Ï´Ù.
 
    int nIndex;
 
    if(pScrollBar->m_hWnd        == m_ctrlScrollH[0].m_hWnd)
    {
        nIndex = 0;
    }
    else if(pScrollBar->m_hWnd    == m_ctrlScrollH[1].m_hWnd)
    {
        nIndex = 1;
    }
    else if(pScrollBar->m_hWnd    == m_ctrlScrollH[2].m_hWnd)
    {
        nIndex = 2;
    }
    else if(pScrollBar->m_hWnd    == m_ctrlScrollH[3].m_hWnd)
    {
        nIndex = 3;
    }
 
 
    if(nIndex != -1)
    {
        SCROLLINFO si;
        si.fMask=SIF_ALL;
        m_ctrlScrollH[nIndex].GetScrollInfo(&si,SIF_ALL);
 
        switch(nSBCode)
        {
        case SB_LINEUP:
            si.nPos--;
            break;
        case SB_LINEDOWN:
            si.nPos++;
            break;
        case SB_PAGEUP:
            si.nPos-=si.nPage;
            break;
        case SB_PAGEDOWN:
            si.nPos+=si.nPage;
            break;
        case SB_THUMBTRACK:
            si.nPos=nPos;            
            break;
        }
 
        if(si.nPos>(int)(si.nMax-si.nMin-si.nPage+1)) si.nPos=si.nMax-si.nMin-si.nPage+1;
        if(si.nPos<si.nMin) si.nPos=si.nMin;
        si.fMask=SIF_POS;
        m_ctrlScrollH[nIndex].SetScrollInfo(&si);    
 
        m_frameImg[nIndex].m_ptOrg.x = si.nPos;
        
        PostMessage(WM_LIVE_IMG_UPDATE,NULL,nIndex);
 
    }
    CDialogEx::OnHScroll(nSBCode, nPos, pScrollBar);
}
 
void CViewLiveCam::InitScrollInfo(int nCam /*= -1*/)
{
    int i =0;
    SCROLLINFO scrollInfoH;
 
    scrollInfoH.cbSize        = sizeof(SCROLLINFO);
    scrollInfoH.fMask        = SIF_ALL;
    scrollInfoH.nMin        = 1;
    scrollInfoH.nPos        = 1;
    scrollInfoH.nTrackPos    = 64;
 
 
    scrollInfoH.nMax    = IMAGE_WIDTH;    
 
    if(nCam == -1)
    {
        for(i = 0 ; i < 4 ; i++)
        {
            double dZoom = m_frameImg[i].GetZoomData();
            scrollInfoH.nPage    = (int)(m_frameImg[i].m_WndRect.Width() / dZoom);
 
            m_ctrlScrollH[i].SetScrollPos(0);
            m_ctrlScrollH[i].SetScrollInfo(&scrollInfoH);
        }
    }
    else
    {
        double dZoom = m_frameImg[nCam].GetZoomData();
        scrollInfoH.nPage    = (int)(m_frameImg[nCam].m_WndRect.Width() / dZoom);
 
        m_ctrlScrollH[nCam].SetScrollPos(0);
        m_ctrlScrollH[nCam].SetScrollInfo(&scrollInfoH);
    }
}
 
void CViewLiveCam::OnBnClickedRdoSignal1()
{
    m_nRdoSignal = 0;
 
    OnBnClickedBtnStop();
}
 
 
void CViewLiveCam::OnBnClickedRdoSignal2()
{
    m_nRdoSignal = 1;
    OnBnClickedBtnStop();
}
 
 
 
void CViewLiveCam::OnBnClickedBtnCamSnap()
{
    OnBnClickedBtnStop();
}
 
LRESULT CViewLiveCam::OnLiveImgUpDate(WPARAM wParam, LPARAM lParam)
{
    int nIndex  = int(lParam);    
 
    m_frameImg[nIndex].ViewUpdate();
 
    return 0;
}
 
BOOL CViewLiveCam::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
    // TODO: Add your message handler code here and/or call default
 
    CPoint        point = pt;
    int            nIndex = -1;
    CRect        rect;
 
    ScreenToClient(&point);
    for(int i = 0; i < MAX_CAMERA_COUNT;i++)
    {
        m_frameImg[i].GetWindowRect(rect);
        ScreenToClient(&rect);
 
        if(rect.PtInRect(point) == TRUE)
        {
            nIndex = i;
            break;
        }
    }
 
    if(nIndex == -1)
        return 1;
 
    if(zDelta > 0)
    {
        m_dZoom[nIndex] += 0.1;    
 
        if(m_dZoom[nIndex] > 4)
            m_dZoom[nIndex] = 4;
    }
    else
    {
        m_dZoom[nIndex] -= 0.1;    
 
        if(m_dZoom[nIndex] < 0.1)
            m_dZoom[nIndex] = 0.1;
    }
 
    UpdateZoom(nIndex);
 
    return CDialogEx::OnMouseWheel(nFlags, zDelta, pt);
}
 
void CViewLiveCam::UpdateZoom(int nIndex)
{
    if(nIndex == -1)
    {
        for(int i = 0; i < MAX_CAMERA_COUNT;i++)
        {
            m_frameImg[i].SetZommMode(m_dZoom[i]);        
            InitScrollInfo(-1);
            m_frameImg[i].Invalidate(FALSE);
        }    
    }
    else
    {
        m_frameImg[nIndex].SetZommMode(m_dZoom[nIndex]);        
        InitScrollInfo(nIndex);
        m_frameImg[nIndex].Invalidate(FALSE);
    }
}