// DlgSideDimensionSetting.cpp : 备泅 颇老涝聪促.
//

#include "stdafx.h"
#include "EdgeInspector_App.h"
#include "DlgSideDimensionSetting.h"
#include "afxdialogex.h"


// CDlgSideDimensionSetting 措拳 惑磊涝聪促.

IMPLEMENT_DYNAMIC(CDlgSideDimensionSetting, CDialogEx)

CDlgSideDimensionSetting::CDlgSideDimensionSetting(CWnd* pParent /*=NULL*/)
	: CDialogEx(CDlgSideDimensionSetting::IDD, pParent)
{
	m_pDlgRecipe = NULL;
	m_pGlassData = NULL;
	m_pSelectSideIdx = NULL;
}

CDlgSideDimensionSetting::~CDlgSideDimensionSetting()
{
}

void CDlgSideDimensionSetting::DoDataExchange(CDataExchange* pDX)
{
	DDX_Control(pDX, IDC_SIDE_DIMENSION_SETTING_LIST, m_SideDimensionSetting);
	DDX_Control(pDX, IDC_TOP_CORNER_DIMENSION_SETTING_LIST, m_TopCornerDimensionSetting);
	DDX_Control(pDX, IDC_BOT_CORNER_DIMENSION_SETTING_LIST, m_BotCornerDimensionSetting);
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CDlgSideDimensionSetting, CDialogEx)
END_MESSAGE_MAP()

BOOL CDlgSideDimensionSetting::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 CDlgSideDimensionSetting::SetDlgRecipe(CGlassRecipe* pDlgRecipe)
{
	m_pDlgRecipe = pDlgRecipe;
	UpdateRecipe(FALSE);
}

void CDlgSideDimensionSetting::UpdateRecipe(BOOL bGetData)
{
	if(bGetData == FALSE) {
		Fill_SideDimensionSetting(bGetData);
		Fill_TopCornerDimensionSetting(bGetData);
		Fill_BotCornerDimensionSetting(bGetData);
	}
	else {
		Fill_SideDimensionSetting(bGetData);
		Fill_TopCornerDimensionSetting(bGetData);
		Fill_BotCornerDimensionSetting(bGetData);
	}
}

void CDlgSideDimensionSetting::RefreshSideUI(BOOL bReinitGrid /*=TRUE*/)
{
	if (!m_pSelectSideIdx) { 
		return;
	}

	const int nSideIdx = *m_pSelectSideIdx;
	const DimensionDir eDim = (DimensionDir)nSideIdx;
	m_bIsRipSide = (DIMENSION_A_RIP == eDim) || (DIMENSION_B_RIP == eDim) || (DIMENSION_C_RIP == eDim) || (DIMENSION_D_RIP == eDim);

	CString strTemp;
	strTemp.Format(_T("[%s] Dim. Setting"), g_SideName[nSideIdx]);
	SetDlgItemText(IDC_STATIC_TITLE, strTemp);

	strTemp.Format(_T("Top Corner [%s] Dim. Setting"), g_SideName[nSideIdx]);
	SetDlgItemText(IDC_STATIC_TITLE_TOP_CORNER, strTemp);

	strTemp.Format(_T("Bot Corner [%s] Dim. Setting"), g_SideName[nSideIdx]);
	SetDlgItemText(IDC_STATIC_TITLE_BOT_CORNER, strTemp);

	if (CWnd* p = GetDlgItem(IDC_BUTTON_CAL)) {
		p->EnableWindow(!m_bIsRipSide);
	}

	if (CWnd* p = GetDlgItem(IDC_BUTTON_GET_SIDE_RESULT)) {
		p->EnableWindow(!m_bIsRipSide);
	}

	if (bReinitGrid) {
		Init_SideDimensionSetting();
	}
}

void CDlgSideDimensionSetting::Init_SideDimensionSetting()
{
	if (m_SideDimensionSetting.GetSafeHwnd() == NULL) {
		return;
	}

	if (m_pSelectSideIdx == nullptr) {
		return;
	}

	auto ScaleX = [&](int px)->int {
		HDC hdc = ::GetDC(m_hWnd);
		const int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
		::ReleaseDC(m_hWnd, hdc);
		return MulDiv(px, dpi, 96);
	};

	struct ColDef { int w; LPCTSTR name; };
	static const ColDef kColsRip[] = {
		{ 90, _T("No.") },
		{ 100, _T("Start Line To Y(um)") },
		{ 100, _T("Use Dim.") },
	};
	static const ColDef kColsNormal[] = {
		{ 90, _T("No.") },
		{ 70, _T("Top Mark To Y(um)") },
		{ 70, _T("Use Dim.") },
		{ 70, _T("Thres") },
		{ 70, _T("Std(mm)") },
		{ 70, _T("Min(mm)") },
		{ 70, _T("Max(mm)") },
		{ 70, _T("Off(mm)") },
		{ 70, _T("Use Chamfer") },
		{ 70, _T("Std(mm)") },
		{ 70, _T("Min(mm)") },
		{ 70, _T("Max(mm)") },
	};
	const ColDef* cols = m_bIsRipSide ? kColsRip : kColsNormal;
	const int nCols = m_bIsRipSide ? (int)_countof(kColsRip) : (int)_countof(kColsNormal);
	const int nRows = 1;
	const int nFixRows = 1;
	const int nFixCols = 0;

	m_SideDimensionSetting.DeleteAllItems();
	m_SideDimensionSetting.SetVirtualMode(FALSE);
	m_SideDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetBackClr(g_nGridFixCellColor);
	m_SideDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetBackClr(g_nGridFixCellColor);
	m_SideDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetBackClr(g_nGridCellColor);
	m_SideDimensionSetting.SetFixedTextColor(g_nGridFixFontColor);

	m_SideDimensionSetting.SetRowCount(nRows);
	m_SideDimensionSetting.SetColumnCount(nCols);
	m_SideDimensionSetting.SetFixedRowCount(nFixRows);
	m_SideDimensionSetting.SetFixedColumnCount(nFixCols);

	if (CFont* pFont = m_SideDimensionSetting.GetFont()) {
		LOGFONT lf{}; pFont->GetLogFont(&lf);
		lf.lfItalic = 0;
		lf.lfWeight = FW_BOLD;
		_tcscpy_s(lf.lfFaceName, _T("Arial"));
		lf.lfHeight = 14;

		m_SideDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetFont(&lf);
		m_SideDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetFont(&lf);
		m_SideDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetFont(&lf);
		m_SideDimensionSetting.GetDefaultCell(TRUE, TRUE)->SetFont(&lf);
	}

	for (int c = 0; c < nCols; ++c) {
		m_SideDimensionSetting.SetColumnWidth(c, ScaleX(cols[c].w));
		m_SideDimensionSetting.SetItemText(0, c, cols[c].name);
	}

	m_SideDimensionSetting.SetFixedRowSelection(FALSE);
	m_SideDimensionSetting.SetFixedColumnSelection(FALSE);
	m_SideDimensionSetting.EnableSelection(TRUE);
	m_SideDimensionSetting.SetEditable(TRUE);
	m_SideDimensionSetting.SetRowResize(FALSE);
	m_SideDimensionSetting.SetColumnResize(FALSE);
	m_SideDimensionSetting.ExpandColumnsToFit(TRUE);
}

void CDlgSideDimensionSetting::Fill_SideDimensionSetting(BOOL bGetData)
{
	if (m_SideDimensionSetting.GetSafeHwnd() == NULL) {
		return;
	}

	if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
		return;
	}

	int nSideIdx = *(m_pSelectSideIdx);
	if (nSideIdx < 0 || nSideIdx >= eRcp_SideRD_End) {
		return;
	}

	int c = 0;
	const int COL_NO = c++;
	const int COL_TOPMARK_Y = c++;
	const int COL_USE_DIM = c++;

	int COL_THRES = -1, COL_STD = -1, COL_MIN = -1, COL_MAX = -1, COL_OFF = -1;
	int COL_CHAMFER_USE = -1, COL_CH_STD = -1, COL_CH_MIN = -1, COL_CH_MAX = -1;

	if (!m_bIsRipSide) {
		COL_THRES = c++;
		COL_STD = c++;
		COL_MIN = c++;
		COL_MAX = c++;
		COL_OFF = c++;
		COL_CHAMFER_USE = c++;
		COL_CH_STD = c++;
		COL_CH_MIN = c++;
		COL_CH_MAX = c++;
	}

	// 单元格读写封装
	auto SetCell = [&](int r, int col, LPCTSTR s) { m_SideDimensionSetting.SetItemText(r, col, s); };
	auto SetCellInt = [&](int r, int col, int v) { CString t; t.Format(_T("%d"), v); SetCell(r, col, t); };
	auto SetCellDouble = [&](int r, int col, double v, int prec = 3) { CString t; t.Format(_T("%.*f"), prec, v); SetCell(r, col, t); };
	auto SetCellBool = [&](int r, int col, BOOL b) { CString t; t.Format(_T("%d"), b ? 1 : 0); SetCell(r, col, t); };
	auto GetCellStr = [&](int r, int col)->CString { CString s = m_SideDimensionSetting.GetItemText(r, col); s.Trim(); return s; };
	auto GetCellInt = [&](int r, int col, int def = 0)->int { CString s = GetCellStr(r, col); return s.IsEmpty() ? def : _wtoi(s); };
	auto GetCellDouble = [&](int r, int col, double def = 0.0)->double { CString s = GetCellStr(r, col); return s.IsEmpty() ? def : _wtof(s); };
	auto GetCellBool = [&](int r, int col)->BOOL { return GetCellInt(r, col, 0) ? TRUE : FALSE; };

	m_SideDimensionSetting.SetRedraw(FALSE);
	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];
	if (!bGetData) {
		const int nDimensionCount = max(0, min(pParam->m_nSideDimensionCount, MAX_SIDE_DIMENSION_MEASURE_COUNT));
		m_SideDimensionSetting.SetRowCount(nDimensionCount + 1);

		for (int i = 0; i < nDimensionCount; ++i) {
			const int r = i + 1;

			// 1) No.
			CString no; no.Format(_T("S_D/C_%d"), i + 1);
			SetCell(r, COL_NO, no);

			// 2) Top Mark To Distance Y (um)
			SetCellInt(r, COL_TOPMARK_Y, pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);

			// 3) Use Dimension (0/1)
			SetCellBool(r, COL_USE_DIM, pParam->m_bSideDimension_Use[i]);

			if (!m_bIsRipSide) {
				// 4) Thres
				SetCellInt(r, COL_THRES, pParam->m_nSideDimensionSpec_Thres[i]);

				// 5-7) Std/Min/Max
				SetCellDouble(r, COL_STD, pParam->m_dSideDimensionSpec_mm_Std[i]);
				SetCellDouble(r, COL_MIN, pParam->m_dSideDimensionSpec_mm_Min[i]);
				SetCellDouble(r, COL_MAX, pParam->m_dSideDimensionSpec_mm_Max[i]);

				// 8) Offset
				SetCellDouble(r, COL_OFF, pParam->m_dSideDimensionSpec_mm_Off[i]);

				// 9) Chamfer Use
				SetCellBool(r, COL_CHAMFER_USE, pParam->m_bSideChamfer_Use[i]);

				// 10-12) Chamfer Std/Min/Max
				SetCellDouble(r, COL_CH_STD, pParam->m_dSideChamfer_Spec_mm_Std[i]);
				SetCellDouble(r, COL_CH_MIN, pParam->m_dSideChamfer_Spec_mm_Min[i]);
				SetCellDouble(r, COL_CH_MAX, pParam->m_dSideChamfer_Spec_mm_Max[i]);
			}
		}
	}
	else {
		int nDimensionCount = max(0, m_SideDimensionSetting.GetRowCount() - 1);
		nDimensionCount = min(nDimensionCount, MAX_SIDE_DIMENSION_MEASURE_COUNT);
		pParam->m_nSideDimensionCount = nDimensionCount;

		for (int i = 0; i < nDimensionCount; ++i) {
			const int r = i + 1;
			int col = COL_TOPMARK_Y;

			// 2) Top Mark To Distance Y (um)
			pParam->m_nSideDimensionPos_TopMarkToDistance_um[i] = GetCellInt(r, col++, pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);

			// 3) Use Dimension
			pParam->m_bSideDimension_Use[i] = GetCellBool(r, col++);

			if (!m_bIsRipSide) {
				// 4) Thres
				pParam->m_nSideDimensionSpec_Thres[i] = GetCellInt(r, col++, pParam->m_nSideDimensionSpec_Thres[i]);

				// 5-7) Std/Min/Max
				pParam->m_dSideDimensionSpec_mm_Std[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Std[i]);
				pParam->m_dSideDimensionSpec_mm_Min[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Min[i]);
				pParam->m_dSideDimensionSpec_mm_Max[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Max[i]);

				// 8) Offset
				pParam->m_dSideDimensionSpec_mm_Off[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Off[i]);

				// 9) Chamfer Use
				pParam->m_bSideChamfer_Use[i] = GetCellBool(r, col++);

				// 10-12) Chamfer Std/Min/Max
				pParam->m_dSideChamfer_Spec_mm_Std[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Std[i]);
				pParam->m_dSideChamfer_Spec_mm_Min[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Min[i]);
				pParam->m_dSideChamfer_Spec_mm_Max[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Max[i]);
			}
		}

		for (int k = nDimensionCount; k < MAX_SIDE_DIMENSION_MEASURE_COUNT; ++k) {
			pParam->m_nSideDimensionPos_TopMarkToDistance_um[k] = 0;
			pParam->m_bSideDimension_Use[k] = FALSE;

			pParam->m_nSideDimensionSpec_Thres[k] = 0;
			pParam->m_dSideDimensionSpec_mm_Std[k] = 0.0;
			pParam->m_dSideDimensionSpec_mm_Min[k] = 0.0;
			pParam->m_dSideDimensionSpec_mm_Max[k] = 0.0;
			pParam->m_dSideDimensionSpec_mm_Off[k] = 0.0;

			pParam->m_bSideChamfer_Use[k] = FALSE;
			pParam->m_dSideChamfer_Spec_mm_Std[k] = 0.0;
			pParam->m_dSideChamfer_Spec_mm_Min[k] = 0.0;
			pParam->m_dSideChamfer_Spec_mm_Max[k] = 0.0;
		}
	}

	m_SideDimensionSetting.SetRedraw(TRUE);
	m_SideDimensionSetting.Invalidate(FALSE);
}

void CDlgSideDimensionSetting::Fill_SideDimensionSetting_CurrentResult()
{
	if(m_SideDimensionSetting.GetSafeHwnd() == NULL)
		return;

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	CString strTemp;
	int nRow = 0;
	int nCol = 0;

	int nDimensionCount = pParam->m_nSideDimensionCount;

	m_SideDimensionSetting.SetRowCount(nDimensionCount + 1);

	for(int i=0; i<nDimensionCount; i++)
	{
		nRow = i + 1;
		nCol = 0;

		// 1. No.
		strTemp.Format(_T("S_D/C_%d"), i + 1);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 2. Top Mark To Distance Y (um)
		strTemp.Format(_T("%d"), pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 3. Use Dimension
		strTemp.Format(_T("%d"), (int) pParam->m_bSideDimension_Use[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 4. Thres
		strTemp.Format(_T("%d"), (int)pParam->m_nSideDimensionSpec_Thres[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 5. Std
		double dCutLine_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dSideMeasrue_CutLine_Result_mm[i];
		strTemp.Format(_T("%.3f"), dCutLine_Result);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 6. Min
		strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Min[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 7. Max
		strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Max[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 8. Offset
		strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Off[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 9. Chamfer
		strTemp.Format(_T("%d"), (int) pParam->m_bSideChamfer_Use[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 10. Std
		double dChamfer_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dSideMeasrue_Chamfer_Result_mm[i];
		strTemp.Format(_T("%.3f"), dChamfer_Result);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 11. Min
		strTemp.Format(_T("%.3f"), pParam->m_dSideChamfer_Spec_mm_Min[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 12. Max
		strTemp.Format(_T("%.3f"), pParam->m_dSideChamfer_Spec_mm_Max[i]);
		m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
	}

	m_SideDimensionSetting.Invalidate();
}

void CDlgSideDimensionSetting::Init_TopCornerDimensionSetting()
{
	if (m_TopCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	int nRows = MAX_CORNER_DIMENSION_MEASURE_COUNT + 1;
	int nCols = 8 + 1;

	int nFixRows = 1;
	int nFixCols = 0;
	int nRowIdx = 0;
	int nColIdx = 0;

	m_TopCornerDimensionSetting.DeleteAllItems();
	m_TopCornerDimensionSetting.SetVirtualMode(FALSE);
	m_TopCornerDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetBackClr(g_nGridFixCellColor);
	m_TopCornerDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetBackClr(g_nGridFixCellColor);
	m_TopCornerDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetBackClr(g_nGridCellColor);
	m_TopCornerDimensionSetting.SetFixedTextColor(g_nGridFixFontColor);

	m_TopCornerDimensionSetting.SetRowCount(nRows);
	m_TopCornerDimensionSetting.SetColumnCount(nCols);
	m_TopCornerDimensionSetting.SetFixedRowCount(nFixRows);
	m_TopCornerDimensionSetting.SetFixedColumnCount(nFixCols);

	CFont *pFont = m_TopCornerDimensionSetting.GetFont();
	if (pFont)
	{
		LOGFONT lf;
		pFont->GetLogFont(&lf);
		lf.lfItalic = 0;
		lf.lfHeight = 14;
		lf.lfWeight = FW_BOLD;
		_tcscpy_s(lf.lfFaceName, _T("Arial"));

		m_TopCornerDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetFont(&lf);
		m_TopCornerDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetFont(&lf);
		m_TopCornerDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetFont(&lf);
		m_TopCornerDimensionSetting.GetDefaultCell(TRUE, TRUE)->SetFont(&lf);
	}

	// Col
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 100);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("No."));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 90);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Dim."));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std(mm)"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min(mm)"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max(mm)"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 90);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Chamfer"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std(mm)"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min(mm)"));
	m_TopCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_TopCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max(mm)"));

	m_TopCornerDimensionSetting.SetFixedRowSelection(FALSE);
	m_TopCornerDimensionSetting.SetFixedColumnSelection(FALSE);
	m_TopCornerDimensionSetting.EnableSelection(TRUE);
	m_TopCornerDimensionSetting.SetEditable(TRUE);
	m_TopCornerDimensionSetting.SetRowResize(FALSE);
	m_TopCornerDimensionSetting.SetColumnResize(FALSE);
	m_TopCornerDimensionSetting.ExpandColumnsToFit(TRUE);
}

void CDlgSideDimensionSetting::Fill_TopCornerDimensionSetting(BOOL bGetData)
{
	if(m_TopCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	CString strTemp;
	int nRow = 0;
	int nCol = 0;

	if(bGetData == FALSE)
	{
		for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
		{
			nRow = i + 1;
			nCol = 0;

			// 1. No.
			strTemp.Format(_T("T_D/C_%d"), i + 1);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 2. Dimension
			strTemp.Format(_T("%d"), (int) pParam->m_bTopCornerDimension_Use[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 3. Std
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerDimensionSpec_mm_Std[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 4. Min
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerDimensionSpec_mm_Min[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 5. Max
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerDimensionSpec_mm_Max[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 6. Chamfer
			strTemp.Format(_T("%d"), (int) pParam->m_bTopCornerChamfer_Use[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 7. Std
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerChamfer_Spec_mm_Std[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 8. Min
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerChamfer_Spec_mm_Min[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 9. Max
			strTemp.Format(_T("%.3f"), pParam->m_dTopCornerChamfer_Spec_mm_Max[i]);
			m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		}

		m_TopCornerDimensionSetting.Invalidate();
	}
	else
	{
		for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
		{
			nRow = i + 1;
			nCol = 1;

			// 1. No.

			// 2. Dimension
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_bTopCornerDimension_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;

			// 3. Std
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerDimensionSpec_mm_Std[i] = _wtof(strTemp);

			// 4. Min
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerDimensionSpec_mm_Min[i] = _wtof(strTemp);

			// 5. Max
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerDimensionSpec_mm_Max[i] = _wtof(strTemp);

			// 6. Chamfer
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_bTopCornerChamfer_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;

			// 7. Std
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerChamfer_Spec_mm_Std[i] = _wtof(strTemp);

			// 8. Min
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerChamfer_Spec_mm_Min[i] = _wtof(strTemp);

			// 9. Max
			strTemp = m_TopCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dTopCornerChamfer_Spec_mm_Max[i] = _wtof(strTemp);
		}
	}
}

void CDlgSideDimensionSetting::Fill_TopCornerDimensionSetting_CurrentResult()
{
	if(m_TopCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	CString strTemp;
	int nRow = 0;
	int nCol = 0;

	for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
	{
		nRow = i + 1;
		nCol = 0;

		// 1. No.
		strTemp.Format(_T("T_D/C_%d"), i + 1);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 2. Dimension
		strTemp.Format(_T("%d"), (int) pParam->m_bTopCornerDimension_Use[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 3. Std
		double dCutLine_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dTopCornerMeasrue_CutLine_Result_mm[i];
		strTemp.Format(_T("%.3f"), dCutLine_Result);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 4. Min
		strTemp.Format(_T("%.3f"), pParam->m_dTopCornerDimensionSpec_mm_Min[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 5. Max
		strTemp.Format(_T("%.3f"), pParam->m_dTopCornerDimensionSpec_mm_Max[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 6. Chamfer
		strTemp.Format(_T("%d"), (int) pParam->m_bTopCornerChamfer_Use[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 7. Std
		double dChamfer_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dTopCornerMeasrue_Chamfer_Result_mm[i];
		strTemp.Format(_T("%.3f"), dChamfer_Result);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 8. Min
		strTemp.Format(_T("%.3f"), pParam->m_dTopCornerChamfer_Spec_mm_Min[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 9. Max
		strTemp.Format(_T("%.3f"), pParam->m_dTopCornerChamfer_Spec_mm_Max[i]);
		m_TopCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

	}

	m_TopCornerDimensionSetting.Invalidate();
}

void CDlgSideDimensionSetting::Init_BotCornerDimensionSetting()
{
	if (m_BotCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	int nRows = MAX_CORNER_DIMENSION_MEASURE_COUNT + 1;
	int nCols = 8 + 1;

	int nFixRows = 1;
	int nFixCols = 0;
	int nRowIdx = 0;
	int nColIdx = 0;

	m_BotCornerDimensionSetting.DeleteAllItems();
	m_BotCornerDimensionSetting.SetVirtualMode(FALSE);
	m_BotCornerDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetBackClr(g_nGridFixCellColor);
	m_BotCornerDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetBackClr(g_nGridFixCellColor);
	m_BotCornerDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetBackClr(g_nGridCellColor);
	m_BotCornerDimensionSetting.SetFixedTextColor(g_nGridFixFontColor);

	m_BotCornerDimensionSetting.SetRowCount(nRows);
	m_BotCornerDimensionSetting.SetColumnCount(nCols);
	m_BotCornerDimensionSetting.SetFixedRowCount(nFixRows);
	m_BotCornerDimensionSetting.SetFixedColumnCount(nFixCols);

	CFont *pFont = m_BotCornerDimensionSetting.GetFont();
	if (pFont)
	{
		LOGFONT lf;
		pFont->GetLogFont(&lf);
		lf.lfItalic = 0;
		lf.lfHeight = 14;
		lf.lfWeight = FW_BOLD;
		_tcscpy_s(lf.lfFaceName, _T("Arial"));

		m_BotCornerDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetFont(&lf);
		m_BotCornerDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetFont(&lf);
		m_BotCornerDimensionSetting.GetDefaultCell(FALSE, FALSE)->SetFont(&lf);
		m_BotCornerDimensionSetting.GetDefaultCell(TRUE, TRUE)->SetFont(&lf);
	}

	// Col
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 100);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("No."));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 90);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Dim"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std (mm)"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min (mm)"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max (mm)"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 90);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Chamfer"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std (mm)"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min (mm)"));
	m_BotCornerDimensionSetting.SetColumnWidth(nColIdx, 80);
	m_BotCornerDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max (mm)"));

	m_BotCornerDimensionSetting.SetFixedRowSelection(FALSE);
	m_BotCornerDimensionSetting.SetFixedColumnSelection(FALSE);
	m_BotCornerDimensionSetting.EnableSelection(TRUE);
	m_BotCornerDimensionSetting.SetEditable(TRUE);
	m_BotCornerDimensionSetting.SetRowResize(FALSE);
	m_BotCornerDimensionSetting.SetColumnResize(FALSE);
	m_BotCornerDimensionSetting.ExpandColumnsToFit(TRUE);
}

void CDlgSideDimensionSetting::Fill_BotCornerDimensionSetting(BOOL bGetData)
{
	if(m_BotCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	CString strTemp;
	int nRow = 0;
	int nCol = 0;

	if(bGetData == FALSE)
	{
		for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
		{
			nRow = i + 1;
			nCol = 0;

			// 1. No.
			strTemp.Format(_T("B_D/C_%d"), i + 1);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 2. Dimension
			strTemp.Format(_T("%d"), (int) pParam->m_bBottomCornerDimension_Use[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 3. Std
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerDimensionSpec_mm_Std[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 4. Min
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerDimensionSpec_mm_Min[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 5. Max
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerDimensionSpec_mm_Max[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 6. Chamfer
			strTemp.Format(_T("%d"), (int) pParam->m_bBottomCornerChamfer_Use[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 7. Std
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerChamfer_Spec_mm_Std[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 8. Min
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerChamfer_Spec_mm_Min[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

			// 9. Max
			strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerChamfer_Spec_mm_Max[i]);
			m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);
		}

		m_BotCornerDimensionSetting.Invalidate();
	}
	else
	{
		for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
		{
			nRow = i + 1;
			nCol = 1;

			// 1. No.

			// 2. Dimension
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_bBottomCornerDimension_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;

			// 3. Std
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerDimensionSpec_mm_Std[i] = _wtof(strTemp);

			// 4. Min
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerDimensionSpec_mm_Min[i] = _wtof(strTemp);

			// 5. Max
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerDimensionSpec_mm_Max[i] = _wtof(strTemp);

			// 6. Chamfer
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_bBottomCornerChamfer_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;

			// 7. Std
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerChamfer_Spec_mm_Std[i] = _wtof(strTemp);

			// 8. Min
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerChamfer_Spec_mm_Min[i] = _wtof(strTemp);

			// 9. Max
			strTemp = m_BotCornerDimensionSetting.GetItemText(nRow, nCol++);
			pParam->m_dBottomCornerChamfer_Spec_mm_Max[i] = _wtof(strTemp);
		}
	}
}

void CDlgSideDimensionSetting::Fill_BotCornerDimensionSetting_CurrentResult()
{
	if(m_BotCornerDimensionSetting.GetSafeHwnd() == NULL)
		return;

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	CString strTemp;
	int nRow = 0;
	int nCol = 0;

	for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
	{
		nRow = i + 1;
		nCol = 0;

		// 1. No.
		strTemp.Format(_T("B_D/C_%d"), i + 1);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 2. Dimension
		strTemp.Format(_T("%d"), (int) pParam->m_bBottomCornerDimension_Use[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 3. Std
		double dCutLine_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dBotCornerMeasrue_CutLine_Result_mm[i];
		strTemp.Format(_T("%.3f"), dCutLine_Result);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 4. Min
		strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerDimensionSpec_mm_Min[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 5. Max
		strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerDimensionSpec_mm_Max[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 6. Chamfer
		strTemp.Format(_T("%d"), (int) pParam->m_bBottomCornerChamfer_Use[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 7. Std
		double dChamfer_Result = m_pGlassData->GetSideData((DimensionDir) nSideIdx)->m_dBotCornerMeasrue_Chamfer_Result_mm[i];
		strTemp.Format(_T("%.3f"), dChamfer_Result);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 8. Min
		strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerChamfer_Spec_mm_Min[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);

		// 9. Max
		strTemp.Format(_T("%.3f"), pParam->m_dBottomCornerChamfer_Spec_mm_Max[i]);
		m_BotCornerDimensionSetting.SetItemText(nRow, nCol++, strTemp);
	}

	m_BotCornerDimensionSetting.Invalidate();
}

BOOL CDlgSideDimensionSetting::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	Init_SideDimensionSetting();

	Init_TopCornerDimensionSetting();

	Init_BotCornerDimensionSetting();

	return TRUE;
}

BEGIN_EVENTSINK_MAP(CDlgSideDimensionSetting, CDialogEx)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_ADD, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonAdd, VTS_NONE)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_DEL, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonDel, VTS_NONE)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_CAL, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonCal, VTS_NONE)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_GET_SIDE_RESULT, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonGetSideResult, VTS_NONE)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_GET_TOP_CORNER_RESULT, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonGetTopCornerResult, VTS_NONE)
	ON_EVENT(CDlgSideDimensionSetting, IDC_BUTTON_GET_BOT_CORNER_RESULT, DISPID_CLICK, CDlgSideDimensionSetting::ClickButtonGetBotCornerResult, VTS_NONE)
END_EVENTSINK_MAP()


void CDlgSideDimensionSetting::ClickButtonAdd()
{
	if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
		return;
	}

	int nSideIdx = *(m_pSelectSideIdx);

	if (nSideIdx < 0 || eRcp_SideRD_End <= nSideIdx) {
		return;
	}

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	int nAddIdx = pParam->m_nSideDimensionCount;

	if(nAddIdx < 0 || MAX_SIDE_DIMENSION_MEASURE_COUNT <= nAddIdx) {
		CString strMsg;
		strMsg.Format(_T("Max Dimension Measure Count : %d ea"), MAX_SIDE_DIMENSION_MEASURE_COUNT);
		AfxMessageBox(strMsg);
		return;
	}

	UpdateRecipe(TRUE);

	pParam->m_nSideDimensionPos_TopMarkToDistance_um[nAddIdx] = 0;
	pParam->m_dSideDimensionSpec_mm_Min[nAddIdx] = 0;
	pParam->m_dSideDimensionSpec_mm_Max[nAddIdx] = 0;
	pParam->m_dSideDimensionSpec_mm_Off[nAddIdx] = 0;
	pParam->m_nSideDimensionCount = nAddIdx + 1;

	UpdateRecipe(FALSE);
}


void CDlgSideDimensionSetting::ClickButtonDel()
{
	if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
		return;
	}

	int nSideIdx = *(m_pSelectSideIdx);

	if (nSideIdx < 0 || eRcp_SideRD_End <= nSideIdx) {
		return;
	}

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	int nSideDimensionCount = pParam->m_nSideDimensionCount;

	CCellID FocusedID = m_SideDimensionSetting.GetFocusCell();
	int nDelIdx = FocusedID.row - 1;

	if(nDelIdx < 0 || nSideDimensionCount <= nDelIdx) {
		AfxMessageBox(_T("Select Error"));
		return;
	}

	UpdateRecipe(TRUE);

	int nPosIdx = 0;
	for(int i=0; i<MAX_DIMENSION_COUNT; i++) {
		if (i == nDelIdx) {
			continue;
		}

		pParam->m_nSideDimensionPos_TopMarkToDistance_um[nPosIdx] = pParam->m_nSideDimensionPos_TopMarkToDistance_um[i];
		pParam->m_dSideDimensionSpec_mm_Min[nPosIdx] = pParam->m_dSideDimensionSpec_mm_Min[i];
		pParam->m_dSideDimensionSpec_mm_Max[nPosIdx] = pParam->m_dSideDimensionSpec_mm_Max[i];
		pParam->m_dSideDimensionSpec_mm_Off[nPosIdx] = pParam->m_dSideDimensionSpec_mm_Off[i];
		nPosIdx++;
	}
	pParam->m_nSideDimensionCount = nSideDimensionCount - 1;

	UpdateRecipe(FALSE);
}

void CDlgSideDimensionSetting::ClickButtonCal()
{
	UpdateRecipe(TRUE);

	if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
		return;

	int nSideIdx = *(m_pSelectSideIdx);

	if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
		return;

	CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

	int nSideDimensionCount = pParam->m_nSideDimensionCount;

	if(nSideDimensionCount < 2)
	{
		AfxMessageBox(_T("Error, Count < 2"));
		return;
	}

	int nStart = pParam->m_nSideDimensionPos_TopMarkToDistance_um[0];
	int nEnd = pParam->m_nSideDimensionPos_TopMarkToDistance_um[nSideDimensionCount -1];

	if((nEnd - nStart) == 0)
	{
		AfxMessageBox(_T("End - Start is 0"));
		return;
	}

	double dStep = (double)((nEnd - nStart)) / (double)((nSideDimensionCount-1));

	for(int i=0; i<nSideDimensionCount; i++)
	{
		pParam->m_nSideDimensionPos_TopMarkToDistance_um[i] = (nStart + (int)((dStep * i)));
	}

	UpdateRecipe(FALSE);
}

void CDlgSideDimensionSetting::ClickButtonGetSideResult()
{
	if(m_pGlassData == NULL)
		return;

	if(IDYES != AfxMessageBox(_T("Set Current Result ?"), MB_YESNO))
		return;

	Fill_SideDimensionSetting_CurrentResult();
}


void CDlgSideDimensionSetting::ClickButtonGetTopCornerResult()
{
	if(m_pGlassData == NULL)
		return;

	if(IDYES != AfxMessageBox(_T("Set Current Result ?"), MB_YESNO))
		return;

	Fill_TopCornerDimensionSetting_CurrentResult();
}


void CDlgSideDimensionSetting::ClickButtonGetBotCornerResult()
{
	if(m_pGlassData == NULL)
		return;

	if(IDYES != AfxMessageBox(_T("Set Current Result ?"), MB_YESNO))
		return;

	Fill_BotCornerDimensionSetting_CurrentResult();
}