// ViewDefect.cpp : ±¸Çö ÆÄÀÏÀÔ´Ï´Ù.
//

#include "stdafx.h"
#include "EdgeInspector_App.h"
#include "ViewMain_Defect.h"
#include "afxdialogex.h"
#include "Global_Define.h"

// CViewDefect ´ëÈ­ »óÀÚÀÔ´Ï´Ù.

#define GRID_FIX_COLOR			RGB(144,200,246)
#define GRID_COLOR				RGB(242,242,242)
#define GRID_TEXT_COLOR			RGB(255,255,255)
#define GRID_LINE_COLOR			GRID_FIX_COLOR

const int	DEFECT_COLUMN_COUNT = 13;
const TCHAR	*DEFECTLIST_COLUMN_ITEM[DEFECT_COLUMN_COUNT]	= 
{
	_T("No"),
	_T("Side"),
	_T("Type"),
	_T("X Size(um)"),
	_T("Y Size(um)"),
	_T("X Size(pxl)"),
	_T("Y Size(pxl)"),
	_T("Area(pxl)"),
	_T("Avg Gray(Gry)"),
	_T("Area Ratio(%)"),
	_T("OK/NG"),
	_T("Judge X(um)"),
	_T("Judge Y(um)")
};
const int	DEFECT_COLUMN_WIDHT[DEFECT_COLUMN_COUNT] = {40,60,60,80,80,80,80,80,80,80,80,80,80};

IMPLEMENT_DYNAMIC(CViewMain_Defect, CDialogEx)

CViewMain_Defect::CViewMain_Defect(CWnd* pParent /*=NULL*/)
	: CDialogEx(CViewMain_Defect::IDD, pParent)
{
	m_pHardware = NULL;
	m_pGlassData = NULL;
	m_pMapDefect = NULL;
	m_bAsending = TRUE;	
	m_pIV2M = NULL;
	m_pSelDefect = NULL;
}

CViewMain_Defect::~CViewMain_Defect()
{
}

void CViewMain_Defect::DoDataExchange(CDataExchange* pDX)
{
	DDX_Control(pDX,IDC_GRD_DEFECT_LIST,m_GrdDefect);
	DDX_Control(pDX, IDC_SCROLLBAR_DEFECT_H, m_ctrlScrollH);
	CDialogEx::DoDataExchange(pDX);
}


BEGIN_MESSAGE_MAP(CViewMain_Defect, CDialogEx)
	ON_WM_HSCROLL()
	ON_NOTIFY(NM_CLICK, IDC_GRD_DEFECT_LIST, OnGridClick)
	ON_NOTIFY(NM_DBLCLK, IDC_GRD_DEFECT_LIST, OnGridDBClick)
	ON_MESSAGE(UM_CLK_ITEM_UPDATE	, OnCImgListViewItemCLK)
END_MESSAGE_MAP()

BOOL CViewMain_Defect::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 CDialogEx::PreTranslateMessage(pMsg);
}

BOOL CViewMain_Defect::OnInitDialog(void)
{
	CDialogEx::OnInitDialog();	
	
	Init_DefectGrid();

	GetDlgItem(IDC_STATIC_DEFECT_IMAGE)->GetWindowRect(&m_rcDefectImg);
	ScreenToClient(m_rcDefectImg);

	m_DefectImg.SetMeasureAble(TRUE);
	m_DefectImg.Create(m_rcDefectImg, this);
	
	InitScrollInfo();

	CRect rc;

	m_pContextImgList.m_pNewViewClass = RUNTIME_CLASS(CImgListView);
	m_pImgList = (CImgListView*)((CFrameWnd*)this)->CreateView(&m_pContextImgList);
	ASSERT(m_pImgList);

	GetDlgItem(IDC_STATIC_IMG_LIST)->GetWindowRect(rc);
	ScreenToClient(rc);

	m_pImgList->ShowWindow(SW_NORMAL);
	m_pImgList->MoveWindow(rc);

	return TRUE;
}

// CViewDefect ¸Þ½ÃÁö 󸮱âÀÔ´Ï´Ù.
void CViewMain_Defect::SetRecipe(CHardwareSettings *pHW)
{
	m_pHardware = pHW;
}

void CViewMain_Defect::SetGlassData(CGlass_Data *pGlass)
{	
	m_pGlassData = pGlass;	
}

void CViewMain_Defect::OnGridClick(NMHDR *pNotifyStruct, LRESULT* /*pResult*/)
{
	NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;

	if(pItem->iRow == 0)
	{
		SortListDefect(pItem->iColumn);
		FillDefectList();	
	}	
}

void CViewMain_Defect::SelectDefect( int nSelDefect )
{
	if(m_GrdDefect.GetRowCount() <= 1)
		return;

	int nListDefectIdx;
	int	iRow,iCol=0;
	CString		str;

	if(m_nSelectedRow > 0)
	{			
		m_GrdDefect.SetItemState(m_nSelectedRow, m_nSelectedCol, m_GrdDefect.GetItemState(m_nSelectedRow, m_nSelectedCol) & ~GVIS_SELECTED & ~GVIS_FOCUSED);		
		m_nSelectedRow = -1;
		m_nSelectedCol = -1;
	}

	for (iRow = 1; iRow < m_GrdDefect.GetRowCount() ; iRow++)
	{
		str = m_GrdDefect.GetItemText(iRow, 0);
		nListDefectIdx = _ttoi(str);
		if (nListDefectIdx == nSelDefect)
		{
			m_GrdDefect.SetItemState(iRow,iCol, LVIS_SELECTED|LVIS_FOCUSED);
			m_GrdDefect.EnsureVisible(iRow, 0);
			m_nSelectedRow = iRow;
			m_nSelectedCol = 0;
			break;

		}
	}
	m_GrdDefect.Invalidate();
}

LRESULT CViewMain_Defect::OnCImgListViewItemCLK(WPARAM wParam, LPARAM lParam)
{
	CString strFileName = m_pImgList->GetSelectImgPath();
	if((int)m_pSortDefect.size() <= 0)
		return 0;

	LISTDefectit	it;
	CDefect			*pDefect;
	CString			strFullPath;
	int				nIndex = 0;

	for(it = m_pSortDefect.begin(); it != m_pSortDefect.end(); ++it,nIndex++)
	{
		pDefect = *it;
		if(pDefect == NULL)
			continue;

		if (pDefect->m_nIdx < 0 || (int)m_pSortDefect.size() <= 0)
			break;

		strFullPath = pDefect->m_strSaveImagePath;
		if(strFullPath.IsEmpty() == TRUE)
			continue;
				
		strFileName.MakeUpper();
		strFullPath.MakeUpper();
		if(strFileName == strFullPath)
		{
			SelectDefect(pDefect->m_nIdx);
			SetSelectDefectImg(nIndex+1);
			break;
		}
	}

	return 1;
}

void CViewMain_Defect::SetSelectDefectImg(int iRow)
{
	if(m_pIV2M != NULL)
	{
		int iDefect = _ttoi(m_GrdDefect.GetItemText(iRow,0));

		m_pSelDefect = FindDefectBuffer(iDefect);		

		if(m_pSelDefect == NULL)
			return;

		if(m_pSelDefect->m_strSaveImagePath.IsEmpty() == TRUE || m_pSelDefect->m_bJudge_NG == FALSE)
		{
			// Buffer¿¡¼­ À̹ÌÁö °¡Á®¿À°Ô Çϴ°͵µ..

		}
		else
		{
			int		nStageNo = g_pBase->m_nStageNo;

			if(nStageNo < 0 || nStageNo > 1)
				nStageNo = 0;

			CCameraSettings *pCamera = NULL;
			double		dResH=5,dResV=5;
			if(m_pHardware != NULL)
			{
				pCamera = m_pHardware->GetCameraSettings(m_pSelDefect->m_DefectInfo.m_nCamID,m_pSelDefect->m_DefectInfo.m_nScanIdx);
				dResH = pCamera->m_dConvResolution[nStageNo];
				dResV = pCamera->m_dScanResolution[nStageNo];
			}

			m_DefectImg.SetDefectImage(m_pSelDefect->m_DefectInfo.m_DefectLoc, m_pSelDefect->m_strSaveImagePath, dResH, dResV);
		}
	}

	InitScrollInfo();
}

void CViewMain_Defect::OnGridDBClick(NMHDR *pNotifyStruct, LRESULT* pResult)
{
	NM_GRIDVIEW* pItem = (NM_GRIDVIEW*) pNotifyStruct;
	if (pItem->iRow < 0)
		return;

	m_nSelectedRow = pItem->iRow;
	m_nSelectedCol = pItem->iColumn;

	SetSelectDefectImg(m_nSelectedRow);	
}

CDefect* CViewMain_Defect::FindDefectBuffer(int iGlassIdx)
{
	if(m_pMapDefect == NULL)
		return NULL;

	MapDefectIt		it;
	CDefect	*pDefect;		

	for(it=m_pMapDefect->begin();it!=m_pMapDefect->end();it++)
	{
		pDefect = static_cast<CDefect*>(it->second);
		if(pDefect == NULL)
			continue;

		if(pDefect->m_nIdx == iGlassIdx)
		{
			return pDefect;
		}
	}

	return NULL;
}

void CViewMain_Defect::InitScrollInfo()
{
	SCROLLINFO scrollInfoH;

	scrollInfoH.cbSize		= sizeof(SCROLLINFO);
	scrollInfoH.fMask		= SIF_ALL;
	scrollInfoH.nMin		= 1;
	scrollInfoH.nPos		= abs(m_DefectImg.m_ptOrg.x);
	scrollInfoH.nTrackPos	= 64;
	scrollInfoH.nMax		= m_DefectImg.GetImgWidth()	- m_rcDefectImg.Width();
	scrollInfoH.nPage		= scrollInfoH.nMax - (m_DefectImg.GetImgWidth() - m_rcDefectImg.Width()); 

	m_ctrlScrollH.SetScrollPos(abs(m_DefectImg.m_ptOrg.x));
	m_ctrlScrollH.SetScrollInfo(&scrollInfoH);
}

void CViewMain_Defect::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	// TODO: ¿©±â¿¡ ¸Þ½ÃÁö 󸮱â Äڵ带 Ãß°¡ ¹×/¶Ç´Â ±âº»°ªÀ» È£ÃâÇÕ´Ï´Ù.
	SCROLLINFO si;
	si.fMask = SIF_ALL;
	m_ctrlScrollH.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.SetScrollInfo(&si);
	//m_frameImg.m_ptOrg.x = si.nPos;
	m_DefectImg.m_ptOrg.x = si.nPos;
	m_DefectImg.Invalidate(FALSE);

	CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CViewMain_Defect::ResetView()
{
	m_pOrgDefect.clear();
	m_pSortDefect.clear();

	FillDefectList();

	m_pImgList->DeleteItemAll();
	m_pImgList->Invalidate(FALSE);
}

void CViewMain_Defect::SortListDefect( int nCol )
{
	LISTDefectit		it;
	CDefect		*pDefect;

	m_bAsending = !m_bAsending;
	vector< pair<double,CDefect*> > vec;	
	double dValue;		

	for(it = m_pSortDefect.begin(); it != m_pSortDefect.end(); ++it)
	{
		pDefect = *it;

		/*
		_T("No"),
		_T("Side"),
		_T("Type"),
		_T("X Size(um)"),
		_T("Y Size(um)"),
		_T("X Size(pxl)"),
		_T("Y Size(pxl)"),
		_T("Area(pxl)"),
		_T("OK/NG"),
		_T("Judge X(um)"),
		_T("Judge Y(um)")
		*/
		switch(nCol)
		{
		case 0:		dValue = (double) pDefect->m_nIdx;										break;
		case 1:		dValue = (double) pDefect->m_DefectInfo.m_nSideIdx;						break;
		case 2:		dValue = (double) pDefect->m_DefectInfo.m_DefectLoc;					break;
		case 3:		dValue = (double) pDefect->m_dSizeX_um;									break;		
		case 4:		dValue = (double) pDefect->m_dSizeY_um;									break;		
		case 5:		dValue = (double) pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width();		break;			
		case 6:		dValue = (double) pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height();		break;
		case 7:		dValue = (double) pDefect->m_DefectInfo.m_nBlobCount;					break;
		case 8:		dValue = (double) pDefect->m_DefectInfo.m_dGray_Avg;					break;
		case 9:		dValue = (double) pDefect->m_DefectInfo.m_dRectArea_Ratio;				break;
		case 10:	dValue = (double) pDefect->m_bJudge_NG;									break;
		case 11:	dValue = (double) pDefect->m_nJudge_X_um;								break;				
		case 12:	dValue = (double) pDefect->m_nJudge_Y_um;								break;						
		default:
			continue;
		}

		vec.push_back(make_pair(dValue,pDefect));
	}

	if(m_bAsending == TRUE)
	{
		std::sort(vec.begin(),vec.end(),greater< pair<double,CDefect*> >());
	}
	else
	{
		std::sort(vec.begin(),vec.end(),less< pair<double,CDefect*> >());
	}

	m_pSortDefect.clear();
	vector< pair<double,CDefect*> >::iterator itVec;
	for(itVec = vec.begin(); itVec != vec.end(); ++itVec)
	{
		m_pSortDefect.push_back(itVec->second);			
	}

	vec.clear();		
}

void CViewMain_Defect::SetDefectList(MapDefect* pMapDefect)
{
	if(pMapDefect == NULL)
	{
		m_pMapDefect = NULL;
	}
	else
	{
		m_pMapDefect = pMapDefect;

		int nDefectSize = (int)m_pMapDefect->size();
		MapDefectIt		it;	
		CDefect	*pInsDefect;

		for (MapDefectIt it = m_pMapDefect->begin(); it != m_pMapDefect->end(); it++)
		{
			pInsDefect = static_cast<CDefect*>(it->second);

			if (!pInsDefect)
				continue;

			m_pOrgDefect.push_back(pInsDefect);
			m_pSortDefect.push_back(pInsDefect);
		}			
	}
	
	SortListDefect(0);
	FillDefectList();	
}

void CViewMain_Defect::SetDefectPath(CString strPath)
{
	m_strDefectPath = strPath;

	m_pImgList->DeleteItemAll();
	m_pImgList->Invalidate(FALSE);

	if((int)m_pSortDefect.size() > 0)
	{
		CString		str = strPath + _T("\\");
		m_pImgList->LoadImageFolder(str,g_pBase->m_strHPanelID);
	}

}

void CViewMain_Defect::FillDefectList()
{
	if(m_GrdDefect.GetSafeHwnd() == NULL)
		return;

	m_GrdDefect.SetRowCount((int)m_pSortDefect.size()+1);

	LISTDefectit it;
	CDefect* pDefect;
	int iRow,iCol;
	CString str;

	iRow = 1;
	for(it = m_pSortDefect.begin(); it != m_pSortDefect.end(); ++it)
	{
		pDefect = *it;
		if(pDefect == NULL)
			continue;

		/*
		_T("No"),
		_T("Side"),
		_T("Type"),
		_T("X Size(um)"),
		_T("Y Size(um)"),
		_T("X Size(pxl)"),
		_T("Y Size(pxl)"),
		_T("Area(pxl)"),
		_T("Avg Gray(Gry)"),
		_T("Area Ratio(%)"),
		_T("OK/NG"),
		_T("Judge X(um)"),
		_T("Judge Y(um)")
		*/

		iCol = 0;
		str.Format(_T("%d"),pDefect->m_nIdx);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%s"), PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx]);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%s"), g_strDefectType[pDefect->m_DefectInfo.m_DefectLoc]);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%.2f"), pDefect->m_dSizeX_um);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%.2f"), pDefect->m_dSizeY_um);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%d"), pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width());
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%d"), pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height());
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%d"), pDefect->m_DefectInfo.m_nBlobCount);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%.1f"), pDefect->m_DefectInfo.m_dGray_Avg);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%.1f"), pDefect->m_DefectInfo.m_dRectArea_Ratio);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		if(pDefect->m_bJudge_NG == TRUE)
		{
			str = _T("NG");
			m_GrdDefect.GetCell(iRow,iCol)->SetBackClr(RGB(255,100,100));
		}
		else
		{
			str = _T("OK");
			m_GrdDefect.GetCell(iRow,iCol)->SetBackClr(RGB(100,255,100));
		}
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%d"), pDefect->m_nJudge_X_um);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		str.Format(_T("%d"), pDefect->m_nJudge_Y_um);
		m_GrdDefect.SetItemText(iRow,iCol++,str);

		iRow++;
	}

	m_GrdDefect.SetRowCount(iRow);

	m_GrdDefect.Invalidate();
}

void CViewMain_Defect::Init_DefectGrid()
{
	if(m_GrdDefect.GetSafeHwnd() == NULL)
		return;

// 	m_GrdDefect.GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
// 	m_GrdDefect.GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
// 	m_GrdDefect.GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
// 	m_GrdDefect.SetFixedBkColor(GRID_FIX_COLOR);
	m_GrdDefect.SetGridLines(GVL_BOTH);	

	m_GrdDefect.SetColumnCount(DEFECT_COLUMN_COUNT);
	m_GrdDefect.SetRowCount(1000);
	m_GrdDefect.SetFixedRowCount(1);
	m_GrdDefect.SetFixedColumnCount(0);
	
	CFont *pFont = m_GrdDefect.GetFont();
	if (!pFont) 
		return;

	LOGFONT lf;	
	pFont->GetLogFont(&lf);
	lf.lfItalic = 0;
	lf.lfHeight = 14;
	lf.lfWeight = FW_BOLD;
	_tcscpy(lf.lfFaceName, _T("Arial"));

	m_GrdDefect.GetDefaultCell(TRUE, FALSE)->SetFont(&lf);
	m_GrdDefect.GetDefaultCell(FALSE, TRUE)->SetFont(&lf);
	m_GrdDefect.GetDefaultCell(TRUE, TRUE)->SetFont(&lf);	
	m_GrdDefect.SetEditable(FALSE);
	m_GrdDefect.EnableSelection(TRUE);

	m_GrdDefect.SetFixedRowSelection(TRUE);	
	m_GrdDefect.SetSingleRowSelection(TRUE);
	m_GrdDefect.SetSingleColSelection(TRUE);	

	Init_DefectGridHeader();

	m_GrdDefect.Invalidate();
}

void CViewMain_Defect::Init_DefectGridHeader()
{
	CString str;	
	GV_ITEM Item;	
	int		nCol = 0;
	int		iLoop;

	Item.mask = GVIF_TEXT;	
	Item.row = 0;
	for(iLoop=0;iLoop<DEFECT_COLUMN_COUNT;iLoop++)
	{
		Item.col = nCol++;	
		Item.strText.Format(_T("%s"),DEFECTLIST_COLUMN_ITEM[iLoop]);
		m_GrdDefect.SetItem(&Item);	
		m_GrdDefect.SetColumnWidth(Item.col,DEFECT_COLUMN_WIDHT[iLoop]);
	}		

	m_GrdDefect.Invalidate();
}