// D:\zm\GeomativeV2.5logging\cpp\logging\CDialogLoggingWnd.cpp : 实现文件
//

#include "stdafx.h"
#include "GeoMative.h"
#include "logging\CDialogLoggingWnd.h"
#include "logging\CLoggingDataOper.h"
//#include "afxdialogex.h"


// CDialogLoggingWnd 对话框

IMPLEMENT_DYNAMIC(CDialogLoggingWnd, CDialog)
extern void SplitterString(CStringArray &szArray, const CString& szSource, const CString& szSplitter);
CDialogLoggingWnd::CDialogLoggingWnd(CWnd* pParent /*=NULL*/)
	: CDialog(CDialogLoggingWnd::IDD, pParent)
{
	m_fWellDepth = 0;
	m_fMinSPR = 0;		//SP最小电阻率
	m_fMaxSPR = 0;		//SP最大电阻率
	m_fMinLR = 0;		//L最小电阻率
	m_fMaxLR = 0;		//L最大电阻率
	m_fMinSR = 0;		//short最小电阻率
	m_fMaxSR = 0;		//short最大电阻率
	m_fMinGR = 0;//最小梯度电阻率
	m_fMaxGR = 0;//最大梯度电阻率
}

CDialogLoggingWnd::~CDialogLoggingWnd()
{
}

CDialogLoggingWnd* CDialogLoggingWnd::GetInstance()
{
	static CDialogLoggingWnd dlgLoggingWnd;
	return &dlgLoggingWnd;
}

void CDialogLoggingWnd::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}


BEGIN_MESSAGE_MAP(CDialogLoggingWnd, CDialog)
	ON_WM_PAINT()
	ON_WM_CTLCOLOR()
	ON_WM_MOUSEHOVER()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()


// CDialogLoggingWnd 消息处理程序
BOOL CDialogLoggingWnd::OnInitDialog()
{
	CDialog::OnInitDialog();

	if (LANG_ZHCN == g_iUILanguage)
	{
		SetDlgItemTextA(IDC_STATIC_COMPANY_NAME, _T("赛盈地脉测井系统"));
		SetDlgItemTextA(IDC_STATIC_BORING_NUMBER, _T("钻  孔  编  号:"));
		SetDlgItemTextA(IDC_STATIC_GROUND_TUBE_TYPE, _T("探   管   型   号:"));
		SetDlgItemTextA(IDC_STATIC_MEASURING_TIME, _T("测  量  时  间:"));
		SetDlgItemTextA(IDC_STATIC_WELL_DEPTH, _T("井         深(米):"));
		SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION, _T("测   井   方   向:"));
		SetDlgItemTextA(IDC_STATIC_MEASURING_LOCATION, _T("测  量  地  点:"));
		SetDlgItemTextA(IDC_STATIC_CALIPER, _T("井      径(毫米):"));
		SetDlgItemTextA(IDC_STATIC_INITIAL_DEPTH, _T("起  始  深  度(米):"));
		SetDlgItemTextA(IDC_STATIC_OPERATOR, _T("操     作     员:"));
		SetDlgItemTextA(IDC_STATIC_SLEEVE_LENGTH, _T("套 管 长 度(米):"));
		SetDlgItemTextA(IDC_STATIC_TERMINATION_DEPTH, _T("终  止  深  度(米):"));
		SetDlgItemTextA(IDC_STATIC_HEAD, _T("负     责     人:"));
		SetDlgItemTextA(IDC_STATIC_WATER_LEVEL, _T("水         位(米):"));
		SetDlgItemTextA(IDC_STATIC_SAMPLING_INTERVAL, _T("采  样  间  隔(米):"));
		SetDlgItemTextA(IDC_STATIC_MEASURE_UNIT, _T("测  量  单  位:"));
		SetDlgItemTextA(IDC_STATIC_ALTITUDE_HIGH, _T("海 拔 高 度(米):"));
		SetDlgItemTextA(IDC_STATIC_LOGGING_SPEED, _T("测井速度(米/分):"));
		SetDlgItemTextA(IDC_STATIC_WORKING_DIRECTORY, _T("工  作  目  录:"));
		SetDlgItemTextA(IDC_STATIC_SCENE_TEMPERATURE, _T("现 场 温 度(℃):"));
		SetDlgItemTextA(IDC_STATIC_RECORD_ZERO_LONG, _T("记  录  零  长(米):"));
		SetDlgItemTextA(IDC_STATIC_FILE_NAME, _T("文     件     名:"));

		SetDlgItemTextA(IDC_STATIC_SP_R, _T("自电(V)"));
		SetDlgItemTextA(IDC_STATIC_LONG_R, _T("长电位电阻率(Ω)"));
		SetDlgItemTextA(IDC_STATIC_SHORT_R, _T("短电位电阻率(Ω)"));
		SetDlgItemTextA(IDC_STATIC_GRADIENT_R, _T("梯度电阻率(Ω)"));
	}

	SetColumnNameVisible(FALSE);

 	RECT rcWnd;
 	GetParent()->GetClientRect(&rcWnd);
	MoveWindow(&rcWnd, TRUE);
	RECT rcCompanyName;
	GetDlgItem(IDC_STATIC_COMPANY_NAME)->GetClientRect(&rcCompanyName);
	GetDlgItem(IDC_STATIC_COMPANY_NAME)->MoveWindow((rcWnd.right - rcWnd.left) / 2 - (rcCompanyName.right - rcCompanyName.left) / 2, COMPANY_NAME_TO_TOP_DISTANCE, rcCompanyName.right - rcCompanyName.left, rcCompanyName.bottom - rcCompanyName.top);

	// TODO:  在此添加额外的初始化
	//绘制Static控件位置
	RECT rcLastColumn = DrawFirstColumnStatic(rcWnd);
	rcLastColumn = DrawSecondColumnStatic(rcWnd, rcLastColumn);
	rcLastColumn.right = (rcWnd.right - rcWnd.left) / 3;
	rcLastColumn = DrawThreeColumnStatic(rcWnd, rcLastColumn);
	rcLastColumn = DrawFourColumnStatic(rcWnd, rcLastColumn);
	rcLastColumn.right = (rcWnd.right - rcWnd.left) / 3 * 2;
	rcLastColumn = DrawFiveColumnStatic(rcWnd, rcLastColumn);
	m_rcDrawData = DrawSixColumnStatic(rcWnd, rcLastColumn);
	m_rcWnd = rcWnd;

	CRect rcClientWnd;
	GetClientRect(&rcClientWnd);
	m_rcDrawData.left = rcClientWnd.left + 20;
	m_rcDrawData.right = rcClientWnd.right - 20;
	m_rcDrawData.top = m_rcDrawData.bottom + DRAW_DATA_TO_STATIC_DISTANCE;
	m_rcDrawData.bottom = m_rcDrawData.top + CUSTOM_COLUMN_HEIGHT;

	m_rcLithology.left = m_rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH + BOTTOM_DEPTH_COLUMN_WIDTH + STRATA_THICKNESS_COLUMN_WIDTH;
	m_rcLithology.right = m_rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH + BOTTOM_DEPTH_COLUMN_WIDTH + STRATA_THICKNESS_COLUMN_WIDTH + LITHOLOGY_COLUMN_WIDTH;
	m_rcLithology.top = m_rcDrawData.bottom;
	m_rcLithology.bottom = m_rcLithology.top;//默认情况不需要绘制
	DrawTitleStatic(m_rcDrawData);

	//加载数据库数据
	STLoggingLithologyInfo stLithologyInfo;
	if (LANG_ZHCN == g_iUILanguage)
		stLithologyInfo = CLoggingDataOper::GetInstance()->QueryLithologyInfoByName(_T("粘土"));
	else
		stLithologyInfo = CLoggingDataOper::GetInstance()->QueryLithologyInfoByName(_T("clay"));
	
	if (strlen(stLithologyInfo.szLithologyName) != 0
		&& strlen(stLithologyInfo.szLithologyPic) != 0)
	{
		STLithologyProfile stProfile;
		stProfile.fStartDepth = 1.0;
		stProfile.fEndDepth = 2.3;
		stProfile.fLithologyType = 1;
		strcpy(stProfile.szLithologyName, stLithologyInfo.szLithologyName);
		strcpy(stProfile.szLithologyPic, stLithologyInfo.szLithologyPic);
		m_vecLithologyProfile.push_back(stProfile);
	}	
	return TRUE;  // return TRUE unless you set the focus to a control
	// 异常:  OCX 属性页应返回 FALSE
}

RECT CDialogLoggingWnd::DrawFirstColumnStatic(RECT rcWnd)
{
	int iWidth = 0, iHeight = 0;
	RECT rc;
	GetDlgItem(IDC_STATIC_BORING_NUMBER)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeight = rc.bottom - rc.top;

	rc.left = rcWnd.left + 50;
	rc.right = rc.left + iWidth;

	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = iHeight + rc.top;
	GetDlgItem(IDC_STATIC_BORING_NUMBER)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_WELL_DEPTH)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_CALIPER)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_SLEEVE_LENGTH)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_WATER_LEVEL)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_ALTITUDE_HIGH)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeight;
	GetDlgItem(IDC_STATIC_SCENE_TEMPERATURE)->MoveWindow(&rc);

	return rc;
}

RECT CDialogLoggingWnd::DrawSecondColumnStatic(RECT rcWnd, RECT rcLastColumn)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0;
	GetDlgItem(IDC_STATIC_BORING_NUMBER_VALUE)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.left = rcLastColumn.right + 5;
	//中文版本间距过大
	if (LANG_ZHCN == g_iUILanguage)
	{
		rc.left = rcLastColumn.right - 20;
	}
	rc.right = rc.left + iWidth;
	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_BORING_NUMBER_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_WELL_DEPTH_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_CALIPER_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_SLEEVE_LENGTH_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_WATER_LEVEL_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_ALTITUDE_HIGH_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_SCENE_TEMPERATURE_VALUE)->MoveWindow(&rc);
	return rc;
}
RECT CDialogLoggingWnd::DrawThreeColumnStatic(RECT rcWnd, RECT rcLastColumn)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0;
	GetDlgItem(IDC_STATIC_GROUND_TUBE_TYPE)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.left = rcLastColumn.right + 5;
	rc.right = rc.left + iWidth;
	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_GROUND_TUBE_TYPE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_LOGGING_DIRECTION)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_INITIAL_DEPTH)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_TERMINATION_DEPTH)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_SAMPLING_INTERVAL)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_LOGGING_SPEED)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_RECORD_ZERO_LONG)->MoveWindow(&rc);
	return rc;
}
RECT CDialogLoggingWnd::DrawFourColumnStatic(RECT rcWnd, RECT rcLastColumn)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0;
	GetDlgItem(IDC_STATIC_GROUND_TUBE_TYPE_VALUE)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.left = rcLastColumn.right + 5;
	//中文版本间距过大
	if (LANG_ZHCN == g_iUILanguage)
	{
		rc.left = rcLastColumn.right - 30;
	}
	rc.right = rc.left + iWidth;
	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_GROUND_TUBE_TYPE_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_LOGGING_DIRECTION_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_INITIAL_DEPTH_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_TERMINATION_DEPTH_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_SAMPLING_INTERVAL_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_LOGGING_SPEED_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_RECORD_ZERO_LONG_VALUE)->MoveWindow(&rc);
	return rc;
}
RECT CDialogLoggingWnd::DrawFiveColumnStatic(RECT rcWnd, RECT rcLastColumn)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0;
	GetDlgItem(IDC_STATIC_MEASURING_TIME)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.left = rcLastColumn.right + 5;
	rc.right = rc.left + iWidth;
	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURING_TIME)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURING_LOCATION)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_OPERATOR)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_HEAD)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURE_UNIT)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_WORKING_DIRECTORY)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_FILE_NAME)->MoveWindow(&rc);
	return rc;
}
RECT CDialogLoggingWnd::DrawSixColumnStatic(RECT rcWnd, RECT rcLastColumn)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0;
	GetDlgItem(IDC_STATIC_MEASURING_TIME_VALUE)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.left = rcLastColumn.right + 5;
	if (LANG_ZHCN == g_iUILanguage)
	{
		rc.left = rcLastColumn.right - 30;
	}
	rc.right = rc.left + iWidth;
	rc.top = rcWnd.top + STATIC_TO_WND_TOP_DISTANCE;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURING_TIME_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURING_LOCATION_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_OPERATOR_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_HEAD_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_MEASURE_UNIT_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_WORKING_DIRECTORY_VALUE)->MoveWindow(&rc);
	rc.top = rc.bottom + STATIC_HEIGHT_INTERVAL;
	rc.bottom = rc.top + iHeigh;
	GetDlgItem(IDC_STATIC_FILE_NAME_VALUE)->MoveWindow(&rc);
	return rc;
}

void CDialogLoggingWnd::DrawTitleStatic(RECT rcWnd)
{
	RECT rc;
	int iWidth = 0, iHeigh = 0, iDrawStartPosition;
	GetDlgItem(IDC_STATIC_LITHOLOGY_NAME)->GetClientRect(&rc);
	iWidth = rc.right - rc.left;
	iHeigh = rc.bottom - rc.top;

	rc.top = rcWnd.top + 40;
	rc.bottom = rc.top + iHeigh;
	iDrawStartPosition = rcWnd.left;
	rc.left = iDrawStartPosition + LITHOLOGY_NAME_COLUMN_WIDTH / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_LITHOLOGY_NAME)->MoveWindow(&rc);

	iDrawStartPosition += LITHOLOGY_NAME_COLUMN_WIDTH;
	rc.left = iDrawStartPosition + BOTTOM_DEPTH_COLUMN_WIDTH / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_BOTTOM_DEPTH)->MoveWindow(&rc);

	iDrawStartPosition += BOTTOM_DEPTH_COLUMN_WIDTH;
	rc.left = iDrawStartPosition + STRATA_THICKNESS_COLUMN_WIDTH / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_STRATA_THICKNESS)->MoveWindow(&rc);

	iDrawStartPosition += STRATA_THICKNESS_COLUMN_WIDTH;
	rc.left = iDrawStartPosition + LITHOLOGY_COLUMN_WIDTH / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_LITHOLOGY)->MoveWindow(&rc);

	iDrawStartPosition += LITHOLOGY_COLUMN_WIDTH;
	rc.left = iDrawStartPosition + DEPTH_COLUMN_WIDTH / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_WELL_DEPTH_M)->MoveWindow(&rc);

	iDrawStartPosition += DEPTH_COLUMN_WIDTH;
	float fRemindWidth = (rcWnd.right - iDrawStartPosition) / 4;

	//绘制SP R Low值位置
	RECT rcR, rcLowStatic, rcHighStatic;
	int iLowHighWidth, iLowHighHeigh;
	GetDlgItem(IDC_STATIC_SP_R_LOW_VALUE)->GetClientRect(&rcLowStatic);
	iLowHighWidth = rcLowStatic.right - rcLowStatic.left;
	iLowHighHeigh = rcLowStatic.bottom - rcLowStatic.top;
	rcHighStatic.bottom = rcLowStatic.bottom = rcWnd.bottom - DISTANCE_TO_BOTTOM_FRAME;
	rcHighStatic.top = rcLowStatic.top = rcLowStatic.bottom - iLowHighHeigh;
	rcLowStatic.left = iDrawStartPosition + 5;
	rcLowStatic.right = rcLowStatic.left + iLowHighWidth;
	GetDlgItem(IDC_STATIC_SP_R_LOW_VALUE)->MoveWindow(&rcLowStatic);

	//绘制SP R标题位置
	GetDlgItem(IDC_STATIC_SP_R)->GetClientRect(&rcR);
	iWidth = rcR.right - rcR.left;
	iHeigh = rcR.bottom - rcR.top;
	rc.top = rcWnd.top + CUSTOM_COLUMN_HEIGHT / 2 - iHeigh / 2;
	rc.bottom = rc.top + iHeigh;
	rc.left = iDrawStartPosition + fRemindWidth / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_SP_R)->MoveWindow(&rc);

	//绘制SP R High值位置
	iDrawStartPosition += fRemindWidth;
	rcHighStatic.right = iDrawStartPosition - DISTANCE_TO_RIGHT_FRAME;
	rcHighStatic.left = rcHighStatic.right - iLowHighWidth;
	GetDlgItem(IDC_STATIC_SP_R_HIGH_VALUE)->MoveWindow(&rcHighStatic);

	//绘制Long R Low值位置
	rcLowStatic.left = iDrawStartPosition + 5;
	rcLowStatic.right = rcLowStatic.left + iLowHighWidth;
	GetDlgItem(IDC_STATIC_LONG_R_LOW_VALUE)->MoveWindow(&rcLowStatic);

	//绘制LongR标题
	rc.left = iDrawStartPosition + fRemindWidth / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_LONG_R)->MoveWindow(&rc);

	iDrawStartPosition += fRemindWidth;
	//绘制LongR High值位置
	rcHighStatic.right = iDrawStartPosition - DISTANCE_TO_RIGHT_FRAME;
	rcHighStatic.left = rcHighStatic.right - iLowHighWidth;
	GetDlgItem(IDC_STATIC_LONG_R_HIGH_VALUE)->MoveWindow(&rcHighStatic);

	//绘制Short R Low值位置
	rcLowStatic.left = iDrawStartPosition + 5;
	rcLowStatic.right = rcLowStatic.left + iLowHighWidth;
	GetDlgItem(IDC_STATIC_SHORT_R_LOW_VALUE)->MoveWindow(&rcLowStatic);

	//绘制Short R标题位置
	rc.left = iDrawStartPosition + fRemindWidth / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_SHORT_R)->MoveWindow(&rc);

	//绘制Gradient R标题
	iDrawStartPosition += fRemindWidth;
	//绘制Short R High值位置
	rcHighStatic.right = iDrawStartPosition - DISTANCE_TO_RIGHT_FRAME;
	rcHighStatic.left = rcHighStatic.right - iLowHighWidth;
	GetDlgItem(IDC_STATIC_SHORT_R_HIGH_VALUE)->MoveWindow(&rcHighStatic);

	//绘制Gradient R Low值位置
	rcLowStatic.left = iDrawStartPosition + 5;
	rcLowStatic.right = rcLowStatic.left + iLowHighWidth;
	GetDlgItem(IDC_STATIC_GRADIENT_R_LOW_VALUE)->MoveWindow(&rcLowStatic);

	rc.left = iDrawStartPosition + fRemindWidth / 2 - iWidth / 2;
	rc.right = rc.left + iWidth;
	GetDlgItem(IDC_STATIC_GRADIENT_R)->MoveWindow(&rc);

	//绘制Gradient R Hight值位置
	rcHighStatic.right = rcWnd.right - DISTANCE_TO_RIGHT_FRAME;
	rcHighStatic.left = rcHighStatic.right - iLowHighWidth;
	GetDlgItem(IDC_STATIC_GRADIENT_R_HIGH_VALUE)->MoveWindow(&rcHighStatic);
}
void CDialogLoggingWnd::SetColumnNameVisible(BOOL bVisible)
{
	GetDlgItem(IDC_STATIC_SP_R)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_LONG_R)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_SHORT_R)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_GRADIENT_R)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_SP_R_LOW_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_SP_R_HIGH_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_LONG_R_LOW_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_LONG_R_HIGH_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_SHORT_R_LOW_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_SHORT_R_HIGH_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_GRADIENT_R_LOW_VALUE)->ShowWindow(bVisible);
	GetDlgItem(IDC_STATIC_GRADIENT_R_HIGH_VALUE)->ShowWindow(bVisible);
}
void CDialogLoggingWnd::UpdateLowHighValue()
{
	SetColumnNameVisible(TRUE);

	CString strText;
	strText.Format(_T("%.1f"), (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE)<0 ? 0 : (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE));
	SetDlgItemTextA(IDC_STATIC_SP_R_LOW_VALUE, strText);

	strText.Format(_T("%.1f"), m_fMaxSPR + LOW_HIGH_DEVIATION_VALUE);
	SetDlgItemTextA(IDC_STATIC_SP_R_HIGH_VALUE, strText);

	strText.Format(_T("%.1f"), (m_fMinLR - LOW_HIGH_DEVIATION_VALUE)<0 ? 0 : (m_fMinLR - LOW_HIGH_DEVIATION_VALUE));
	SetDlgItemTextA(IDC_STATIC_LONG_R_LOW_VALUE, strText);

	strText.Format(_T("%.1f"), m_fMaxLR + LOW_HIGH_DEVIATION_VALUE);
	SetDlgItemTextA(IDC_STATIC_LONG_R_HIGH_VALUE, strText);

	strText.Format(_T("%.1f"), (m_fMinSR - LOW_HIGH_DEVIATION_VALUE)<0 ? 0 : (m_fMinSR - LOW_HIGH_DEVIATION_VALUE));
	SetDlgItemTextA(IDC_STATIC_SHORT_R_LOW_VALUE, strText);

	strText.Format(_T("%.1f"), m_fMaxSR + LOW_HIGH_DEVIATION_VALUE);
	SetDlgItemTextA(IDC_STATIC_SHORT_R_HIGH_VALUE, strText);

	strText.Format(_T("%.1f"), (m_fMinGR - LOW_HIGH_DEVIATION_VALUE)<0 ? 0 : (m_fMinGR - LOW_HIGH_DEVIATION_VALUE));
	SetDlgItemTextA(IDC_STATIC_GRADIENT_R_LOW_VALUE, strText);

	strText.Format(_T("%.1f"), m_fMaxGR + LOW_HIGH_DEVIATION_VALUE);
	SetDlgItemTextA(IDC_STATIC_GRADIENT_R_HIGH_VALUE, strText);
}

UINT CDialogLoggingWnd::GetStartDrawDataHeight()
{
	return m_uiStartDrawHeigh;
}

void CDialogLoggingWnd::OnPaint()
{
	CPaintDC dc(this); // device context for painting
	// TODO:  在此处添加消息处理程序代码
	// 不为绘图消息调用 CDialogEx::OnPaint()
	CRect rcWnd;
	GetClientRect(&rcWnd);
	dc.FillSolidRect(rcWnd, RGB(255, 255, 255));

	CPen pen;
	pen.CreatePen(PS_SOLID, 3, RGB(0, 0, 255));
	dc.SelectObject(pen);

	CFont font;
	font.CreateFontA(25, 15, 0, 0, 700, FALSE, TRUE, FALSE, GB2312_CHARSET, 0, 0, 0, 0, _T(""));
	GetDlgItem(IDC_STATIC_COMPANY_NAME)->SetFont(&font);

	RECT rcDrawData = m_rcDrawData;
	//没有加载数据，或者无效数据
	if (m_fWellDepth <= 0.000001)
	{
		dc.Rectangle(&rcDrawData);
	}
	else
	{
		rcDrawData.bottom = m_rcDrawData.bottom + DEPTH_SCALE_DISTANCE*(m_fWellDepth*ONE_DECIMETER_TO_HEIGHT + 10);
		::SetWindowPos(m_hWnd, HWND_TOPMOST, m_rcWnd.left, m_rcWnd.top, m_rcWnd.right, rcDrawData.bottom, SWP_NOSIZE | SWP_NOMOVE);
		m_rcLithology.bottom = rcDrawData.bottom;
		dc.Rectangle(&rcDrawData);
	}

	CPen blackPen;
	blackPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	dc.SelectObject(blackPen);
	//横线
	dc.MoveTo(rcDrawData.left, rcDrawData.top + CUSTOM_COLUMN_HEIGHT);
	dc.LineTo(rcDrawData.right, rcDrawData.top + CUSTOM_COLUMN_HEIGHT);
	m_uiStartDrawHeigh = rcDrawData.top + CUSTOM_COLUMN_HEIGHT;

	int iDrawStartPosition = rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH;
	dc.MoveTo(iDrawStartPosition, rcDrawData.top);
	dc.LineTo(iDrawStartPosition, rcDrawData.bottom);

	iDrawStartPosition += BOTTOM_DEPTH_COLUMN_WIDTH;
	dc.MoveTo(iDrawStartPosition, rcDrawData.top);
	dc.LineTo(iDrawStartPosition, rcDrawData.bottom);

	iDrawStartPosition += STRATA_THICKNESS_COLUMN_WIDTH;
	dc.MoveTo(iDrawStartPosition, rcDrawData.top);
	dc.LineTo(iDrawStartPosition, rcDrawData.bottom);

	iDrawStartPosition += LITHOLOGY_COLUMN_WIDTH;
	dc.MoveTo(iDrawStartPosition, rcDrawData.top);
	dc.LineTo(iDrawStartPosition, rcDrawData.bottom);

	//绘制深度刻度线
	float fRightDepth = rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH + BOTTOM_DEPTH_COLUMN_WIDTH + STRATA_THICKNESS_COLUMN_WIDTH + LITHOLOGY_COLUMN_WIDTH + DEPTH_COLUMN_WIDTH;
	float fLeftDepth = fRightDepth - DEPTH_COLUMN_WIDTH;
	dc.MoveTo(fRightDepth, rcDrawData.top);
	dc.LineTo(fRightDepth, rcDrawData.bottom);
	if (m_vecDataInfo.size() > 0)
	{
		//绘制岩性柱状相关信息
		if (m_vecLithologyProfile.size() > 0)
		{
			CString strText;
			int iSub = 0,  iBmpIndex= 0;//商
			float fMod = 0.0;//余数

			int iProfileCount = m_vecLithologyProfile.size();
			float fDrawHeight = 0,fTop,fBottom,fLeft;
			CDC memDC;
			CBitmap bmp;
			HBITMAP hBmp;
			BITMAP bitMap;
			CBitmap* pBmp = NULL;
			for (int i = 0; i < iProfileCount; i++)
			{
				//岩性柱状顶部线条
				fTop = fDrawHeight = rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecLithologyProfile[i].fStartDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT;
				fLeft = rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH + BOTTOM_DEPTH_COLUMN_WIDTH + STRATA_THICKNESS_COLUMN_WIDTH;
				dc.MoveTo(fLeft, fDrawHeight);
				dc.LineTo(fLeftDepth, fDrawHeight);

				fBottom = fDrawHeight = rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecLithologyProfile[i].fEndDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT;
				//底部虚线
				dc.MoveTo(rcDrawData.left, fDrawHeight);
				dc.LineTo(fLeftDepth, fDrawHeight);

				//绘制图片				
				memDC.CreateCompatibleDC(&dc);				
				hBmp = (HBITMAP)LoadImage(AfxGetInstanceHandle(), m_vecLithologyProfile[i].szLithologyPic, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
				memDC.SelectObject(hBmp);
				if (bmp.Attach(hBmp))
				{					
					bmp.GetBitmap(&bitMap);					
					pBmp = memDC.SelectObject(&bmp);
					//分批次绘制
					if (fBottom - fTop - 1 > (bitMap.bmHeight/4))
					{
						iSub = (fBottom - fTop - 1) / (bitMap.bmHeight / 4);
						fMod = ((int)(fBottom - fTop) - 1) % (bitMap.bmHeight / 4);
						fTop += 1;
						for (iBmpIndex = 0; iBmpIndex < iSub; iBmpIndex++)
						{
							dc.StretchBlt(fLeft + 1, fTop, LITHOLOGY_COLUMN_WIDTH - 1, bitMap.bmHeight/4, &memDC, 0, 0, bitMap.bmWidth, bitMap.bmHeight, SRCCOPY);
							fTop += bitMap.bmHeight/4;
						}

						if (fMod > 0)
						{
							dc.StretchBlt(fLeft + 1, fTop, LITHOLOGY_COLUMN_WIDTH - 1, fBottom - fTop - 1, &memDC, 0, 0, bitMap.bmWidth, (fBottom - fTop - 1)*4, SRCCOPY);
						}
					}
					else
					{
						//一次可以绘制完
						dc.StretchBlt(fLeft + 1, fTop+1, LITHOLOGY_COLUMN_WIDTH - 1, fBottom - fTop - 1, &memDC, 0, 0, bitMap.bmWidth, (fBottom - fTop - 1) * 4, SRCCOPY);
					}
					
					dc.SelectObject(pBmp);
				}
				

				//岩性名称
				dc.TextOutA(rcDrawData.left + 10, fDrawHeight - 20, m_vecLithologyProfile[i].szLithologyName);

				//深度
				strText.Format(_T("%.1f"), m_vecLithologyProfile[i].fEndDepth);
				dc.TextOutA(rcDrawData.left + LITHOLOGY_NAME_COLUMN_WIDTH + 10, fDrawHeight - 20, strText);
			}
		}

		//深度刻度线短横线
		int iWellDepth = (int)m_fWellDepth;
		CString strDepthScale;
		for (int i = 0; i <= iWellDepth*ONE_DECIMETER_TO_HEIGHT; i++)
		{
			if (i % 5 == 0)
			{
				dc.MoveTo(fLeftDepth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
				dc.LineTo(fLeftDepth + DEPTH_LONG_SCALE_VALUE, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);

				dc.MoveTo(fRightDepth - DEPTH_LONG_SCALE_VALUE, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
				dc.LineTo(fRightDepth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
			}
			else
			{
				dc.MoveTo(fLeftDepth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
				dc.LineTo(fLeftDepth + DEPTH_SHORT_SCALE_VALUE, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);

				dc.MoveTo(fRightDepth - DEPTH_SHORT_SCALE_VALUE, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
				dc.LineTo(fRightDepth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE);
			}

			if ((i != 0) && (i % 10 == 0))
			{
				strDepthScale.Format(_T("%d"), i/ONE_DECIMETER_TO_HEIGHT);
				dc.TextOutA(fLeftDepth + DEPTH_LONG_SCALE_VALUE + 10, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE - 10, strDepthScale);
			}
		}

		//深度刻度线长横线，一米绘制10刻度
		for (int i = 1; i <= iWellDepth; i++)
		{
			dc.MoveTo(fRightDepth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);
			dc.LineTo(rcDrawData.right, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + i * DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);
		}

		//数据部分虚线
		CPen penDot;
		penDot.CreatePen(PS_DOT, 1, RGB(0, 0, 0));
		dc.SelectObject(penDot);
		//竖线
		iDrawStartPosition += DEPTH_COLUMN_WIDTH;
		float fRemindWidth = (rcDrawData.right - rcDrawData.left) - iDrawStartPosition;
		float fColumnWidth = fRemindWidth / TOTAL_DATA_COLUMN;//总共16列
		for (int i = 1; i <= TOTAL_DATA_COLUMN; i++)
		{
			if (i % 4 == 0 && (i != TOTAL_DATA_COLUMN))
			{
				//绘制不同电阻率之间的分割线
				dc.SelectObject(blackPen);
				dc.MoveTo(fRightDepth + i*fColumnWidth, rcDrawData.top);
				dc.LineTo(fRightDepth + i*fColumnWidth, rcDrawData.bottom);
			}
			else
			{
				//绘制不同电阻率之间的虚线
				dc.SelectObject(penDot);
				dc.MoveTo(fRightDepth + i*fColumnWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT);
				dc.LineTo(fRightDepth + i*fColumnWidth, rcDrawData.bottom);
			}
		}

		//绘制SP数据线
		dc.SelectObject(blackPen);
		float fStartSPPoint = fRightDepth;
		float fStartLPoint = fStartSPPoint + fColumnWidth * 4;
		float fStartSPoint = fStartLPoint + fColumnWidth * 4;
		float fStartGPoint = fStartSPoint + fColumnWidth * 4;
		float fSPCellWidth = (fColumnWidth * 4) / (m_fMaxSPR + LOW_HIGH_DEVIATION_VALUE - (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE));
		float fLRCellWidth = (fColumnWidth * 4) / (m_fMaxLR + LOW_HIGH_DEVIATION_VALUE - (m_fMinLR - LOW_HIGH_DEVIATION_VALUE));
		float fSRCellWidth = (fColumnWidth * 4) / (m_fMaxSR + LOW_HIGH_DEVIATION_VALUE - (m_fMinSR - LOW_HIGH_DEVIATION_VALUE));
		float fGRCellWidth = (fColumnWidth * 4) / (m_fMaxGR + LOW_HIGH_DEVIATION_VALUE - (m_fMinGR - LOW_HIGH_DEVIATION_VALUE));
		for (int i = 0; i < m_vecDataInfo.size(); i++)
		{
			if (i == 0)
			{
				//SP
				dc.MoveTo(fStartSPPoint + (m_vecDataInfo[i].fSPV - (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE))*fSPCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth * DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartSPPoint + (m_vecDataInfo[i].fSPV - (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE))*fSPCellWidth + 1, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth * DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT + 1);

				//LR
				dc.MoveTo(fStartLPoint + (m_vecDataInfo[i].fLR - (m_fMinLR - LOW_HIGH_DEVIATION_VALUE))*fLRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartLPoint + (m_vecDataInfo[i].fLR - (m_fMinLR - LOW_HIGH_DEVIATION_VALUE))*fLRCellWidth + 1, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT + 1);

				//SR
				dc.MoveTo(fStartSPoint + (m_vecDataInfo[i].fSR - (m_fMinSR - LOW_HIGH_DEVIATION_VALUE))*fSRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartSPoint + (m_vecDataInfo[i].fSR - (m_fMinSR - LOW_HIGH_DEVIATION_VALUE))*fSRCellWidth + 1, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT + 1);

				//GR
				dc.MoveTo(fStartGPoint + (m_vecDataInfo[i].fGR - (m_fMinGR - LOW_HIGH_DEVIATION_VALUE))*fGRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartGPoint + (m_vecDataInfo[i].fGR - (m_fMinGR - LOW_HIGH_DEVIATION_VALUE))*fGRCellWidth + 1, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT + 1);

			}
			else
			{
				//SP
				dc.MoveTo(fStartSPPoint + (m_vecDataInfo[i - 1].fSPV - (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE))*fSPCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i - 1].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartSPPoint + (m_vecDataInfo[i].fSPV - (m_fMinSPR - LOW_HIGH_DEVIATION_VALUE))*fSPCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);

				//LR
				dc.MoveTo(fStartLPoint + (m_vecDataInfo[i - 1].fLR - (m_fMinLR - LOW_HIGH_DEVIATION_VALUE))*fLRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i - 1].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartLPoint + (m_vecDataInfo[i].fLR - (m_fMinLR - LOW_HIGH_DEVIATION_VALUE))*fLRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);

				//SR
				dc.MoveTo(fStartSPoint + (m_vecDataInfo[i - 1].fSR - (m_fMinSR - LOW_HIGH_DEVIATION_VALUE))*fSRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i - 1].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartSPoint + (m_vecDataInfo[i].fSR - (m_fMinSR - LOW_HIGH_DEVIATION_VALUE))*fSRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);

				//GR
				dc.MoveTo(fStartGPoint + (m_vecDataInfo[i - 1].fGR - (m_fMinGR - LOW_HIGH_DEVIATION_VALUE))*fGRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i - 1].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);//每一个刻度对应一米间距，一米间距对应5个像素
				dc.LineTo(fStartGPoint + (m_vecDataInfo[i].fGR - (m_fMinGR - LOW_HIGH_DEVIATION_VALUE))*fGRCellWidth, rcDrawData.top + CUSTOM_COLUMN_HEIGHT + m_vecDataInfo[i].fDepth* DEPTH_SCALE_DISTANCE*ONE_DECIMETER_TO_HEIGHT);
			}
		}
	}
}

HBRUSH CDialogLoggingWnd::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
	if (CTLCOLOR_STATIC == nCtlColor)
	{
		static HBRUSH hbrStatic = ::CreateSolidBrush(RGB(255, 255, 255));
		//COLOR是你想设置的背景颜色 此处必须为静态变量，否则不能实现
		pDC->SetBkColor(RGB(255, 255, 255));
		pDC->SetTextColor(RGB(0, 0, 255));
		return hbrStatic; //返回该刷
	}
	// TODO:  在此更改 DC 的任何特性

	// TODO:  如果默认的不是所需画笔，则返回另一个画笔
	return hbr;
}

float CDialogLoggingWnd::OpenFile(CString strFolderPath, CString strFileName)
{
	//更新画布大小
	RECT rcWnd;
	GetParent()->GetClientRect(&rcWnd);
	MoveWindow(&rcWnd);
	/*if (m_bIsOpenFile)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("已经存在打开的文件"));
		else
			MessageBoxEx(NULL, _T("An open file already exists"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return FALSE;
	}*/
	CString strFile;
	float fWellDepth = 0;
	//CFileDialog cfd(TRUE, _T(".xml"), _T("*.xml"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("xml Files(*.xml)|*.txt||"), NULL);
	//if (IDOK == cfd.DoModal())
	{
		//m_bIsOpenFile = TRUE;
		//CString strFileName = cfd.GetPathName();
		if (strFolderPath.IsEmpty() || strFileName.IsEmpty())
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("无效文件名"));
			else
				MessageBoxEx(NULL, _T("Invalid file name"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return FALSE;
		}

		strFile.Format(_T("%s\\%s.xml"), strFolderPath, strFileName);
		fWellDepth = LoadParamXMLFile(strFile);

		//m_strFileName.Format(_T("%s\\%s.dat"), cfd.GetFolderPath(), cfd.GetFileTitle());
		strFile.Format(_T("%s\\%s.dat"), strFolderPath, strFileName);
		LoadDataDATFile(strFile);
		RedrawWindow();
	}
	return TRUE;
}

BOOL CDialogLoggingWnd::CloseFile()
{
	//清空参数
	SetDlgItemTextA(IDC_STATIC_BORING_NUMBER_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_WELL_DEPTH_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_CALIPER_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_SLEEVE_LENGTH_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_WATER_LEVEL_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_ALTITUDE_HIGH_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_SCENE_TEMPERATURE_VALUE, _T(""));

	SetDlgItemTextA(IDC_STATIC_GROUND_TUBE_TYPE_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_INITIAL_DEPTH_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_TERMINATION_DEPTH_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_SAMPLING_INTERVAL_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_LOGGING_SPEED_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_RECORD_ZERO_LONG_VALUE, _T(""));

	SetDlgItemTextA(IDC_STATIC_MEASURING_TIME_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_MEASURING_LOCATION_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_OPERATOR_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_HEAD_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_MEASURE_UNIT_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_WORKING_DIRECTORY_VALUE, _T(""));
	SetDlgItemTextA(IDC_STATIC_FILE_NAME_VALUE, _T(""));

	//清空绘制数据部分
	SetColumnNameVisible(FALSE);

	m_fWellDepth = 0;
	m_vecDataInfo.clear();
	m_vecLithologyProfile.clear();
	RedrawWindow();
	return TRUE;
}

//打开文件时，加载参数文件
float CDialogLoggingWnd::LoadParamXMLFile(CString strFilePath)
{
	//加载参数文件
	CMarkup xmlFile;
	bool bRes = xmlFile.Load(strFilePath);
	if (!bRes)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("解析xml文件失败"));
		else
			MessageBoxEx(NULL, _T("Failed to parse the XML file"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return FALSE;
	}
	xmlFile.FindElem(_T("measure"));
	//测试地点
	xmlFile.FindChildElem(_T("measure_location"));
	SetDlgItemTextA(IDC_STATIC_MEASURING_LOCATION_VALUE, xmlFile.GetChildData());

	//采样间隔
	xmlFile.FindChildElem(_T("sample_interval"));
	SetDlgItemTextA(IDC_STATIC_SAMPLING_INTERVAL_VALUE, xmlFile.GetChildData());

	//温度
	xmlFile.FindChildElem(_T("temperature"));
	SetDlgItemTextA(IDC_STATIC_SCENE_TEMPERATURE_VALUE, xmlFile.GetChildData());

	//井深
	//xmlFile.FindChildElem(_T("height"));
	//SetDlgItemTextA(IDC_STATIC_WELL_DEPTH_VALUE, xmlFile.GetChildData());
	//修改绘制矩形框的高度	

	//测试时间
	xmlFile.FindChildElem(_T("test_date"));
	CString strTestTime = xmlFile.GetChildData();
	xmlFile.FindChildElem(_T("test_time"));
	strTestTime += _T(" ");
	strTestTime += xmlFile.GetChildData();
	SetDlgItemTextA(IDC_STATIC_MEASURING_TIME_VALUE, strTestTime);

	float fWellInitDepth,fWellEndDepth;
	xmlFile.FindChildElem(_T("initial_depth"));
	fWellInitDepth = atof(xmlFile.GetChildData());

	//测试方向 0:由上往下测试 1:由下往上测试
	xmlFile.FindChildElem(_T("WellTestDir"));
	CString strWellTestDir = xmlFile.GetChildData();
	if (0 == atoi(xmlFile.GetChildData()))
	{
		if (LANG_ZHCN == g_iUILanguage)
			SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION_VALUE, _T("向下"));
		else
			SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION_VALUE, _T("down"));
	}
	else
	{
		if (LANG_ZHCN == g_iUILanguage)
			SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION_VALUE, _T("向上"));
		else
			SetDlgItemTextA(IDC_STATIC_LOGGING_DIRECTION_VALUE, _T("up"));
	}

	//结束深度
	xmlFile.FindChildElem(_T("WellEndDepth"));
	fWellEndDepth = atof(xmlFile.GetChildData());
	SetDlgItemTextA(IDC_STATIC_TERMINATION_DEPTH_VALUE, xmlFile.GetChildData());

	m_fWellDepth = fWellEndDepth - fWellInitDepth;
	//井深
	CString strTemp;
	strTemp.Format(_T("%.2f"), m_fWellDepth);
	SetDlgItemTextA(IDC_STATIC_WELL_DEPTH_VALUE, strTemp);

	//测试间隔
	xmlFile.FindChildElem(_T("WellInterval"));
	SetDlgItemTextA(IDC_STATIC_SAMPLING_INTERVAL_VALUE, xmlFile.GetChildData());
	xmlFile.OutOfElem();

	int iFlag = strFilePath.ReverseFind('\\');
	if (iFlag != -1)
	{
		//工作目录
		strTemp = strFilePath.Mid(0, iFlag);
		SetDlgItemTextA(IDC_STATIC_WORKING_DIRECTORY_VALUE, strTemp);

		//文件名
		strTemp.Empty();
		strTemp = strFilePath.Mid(iFlag + 1);
		SetDlgItemTextA(IDC_STATIC_FILE_NAME_VALUE, strTemp);
	}
	return m_fWellDepth;
}

//打开文件时，加载数据文件
BOOL CDialogLoggingWnd::LoadDataDATFile(CString strFilePath)
{
	/*读取数据信息*/
	CMarkup xmlDataFile;
	xmlDataFile.Load(strFilePath);
	xmlDataFile.FindElem(_T("TD"));

	xmlDataFile.FindChildElem("param");

	xmlDataFile.FindChildElem("Data");
	xmlDataFile.IntoElem();
	int iTsn = 1;
	CStringArray strTdConArray;
	CString strNodeName, strTdCon, strShowErr;
	strNodeName.Format(_T("D%.5d"), iTsn);
	ST_DATA_INFO stDataInfo;
	BOOL bFirstEnter = TRUE;
	while (xmlDataFile.FindChildElem(strNodeName))
	{
		memset(&stDataInfo, 0, sizeof(ST_DATA_INFO));
		strTdCon.Empty();
		strTdCon = xmlDataFile.GetChildData();
		if (strTdCon.IsEmpty())
		{
			if (LANG_ZHCN == g_iUILanguage)
			{
				strShowErr.Format(_T("获取 %s 子数据为空!!!"), strTdCon.GetBuffer(0));
				AfxMessageBox(strShowErr.GetBuffer(0));
			}
			else
			{
				strShowErr.Format(_T("Get %s childdata is empty!!!"), strTdCon.GetBuffer(0));
				MessageBoxEx(NULL, strShowErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			}
		}

		SplitterString(strTdConArray, strTdCon, _T(";"));

		if (strTdConArray.GetSize() < 11)
		{
			strShowErr.Empty();
			if (LANG_ZHCN == g_iUILanguage)
			{
				strShowErr.Format(_T("%s的元素大小错误，应该至少为11，但实际上是%d"), strNodeName.GetBuffer(0), strTdConArray.GetSize());
				AfxMessageBox(strShowErr.GetBuffer(0));
			}
			else
			{
				strShowErr.Format(_T("%s 's element size error, should be at least 11 but actually is %d"), strNodeName.GetBuffer(0), strTdConArray.GetSize());
				MessageBoxEx(NULL, strShowErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			}
			xmlDataFile.OutOfElem();
			return FALSE;
		}

		stDataInfo.fDepth = abs(atoi(strTdConArray.GetAt(0)));
		stDataInfo.fSPV = atoi(strTdConArray.GetAt(1));
		stDataInfo.fLV = atoi(strTdConArray.GetAt(2));
		stDataInfo.fLI = atoi(strTdConArray.GetAt(3));
		stDataInfo.fLR = atoi(strTdConArray.GetAt(4));
		stDataInfo.fSV = atoi(strTdConArray.GetAt(5));
		stDataInfo.fSI = (float)atof(strTdConArray.GetAt(6));
		stDataInfo.fSR = (float)atof(strTdConArray.GetAt(7));
		stDataInfo.fGV = (float)atof(strTdConArray.GetAt(8));
		stDataInfo.fGI = (float)atof(strTdConArray.GetAt(9));
		stDataInfo.fGR = (float)atof(strTdConArray.GetAt(10));
		if (bFirstEnter)
		{
			bFirstEnter = FALSE;
			m_fMinSPR = m_fMaxSPR = stDataInfo.fSPV;
			m_fMinLR = m_fMaxLR = stDataInfo.fLR;
			m_fMinSR = m_fMaxSR = stDataInfo.fSR;
			m_fMinGR = m_fMaxGR = stDataInfo.fGR;
		}
		else
		{
			//SP
			if (stDataInfo.fSPV < m_fMinSPR)
			{
				m_fMinSPR = stDataInfo.fSPV;
			}
			else if (stDataInfo.fSPV > m_fMaxSPR)
			{
				m_fMaxSPR = stDataInfo.fSPV;
			}

			//L
			if (stDataInfo.fLR < m_fMinLR)
			{
				m_fMinLR = stDataInfo.fLR;
			}
			else if (stDataInfo.fLR > m_fMaxLR)
			{
				m_fMaxLR = stDataInfo.fLR;
			}

			//R
			if (stDataInfo.fSR < m_fMinSR)
			{
				m_fMinSR = stDataInfo.fSR;
			}
			else if (stDataInfo.fSR > m_fMaxSR)
			{
				m_fMaxSR = stDataInfo.fSR;
			}

			//GR
			if (stDataInfo.fGR < m_fMinGR)
			{
				m_fMinGR = stDataInfo.fGR;
			}
			else if (stDataInfo.fGR > m_fMaxGR)
			{
				m_fMaxGR = stDataInfo.fGR;
			}
		}

		iTsn++;
		strNodeName.Empty();
		if (iTsn <= 99999)
		{
			strNodeName.Format(_T("D%.5d"), iTsn);
		}
		else
		{
			strNodeName.Format(_T("D%d"), iTsn);
		}
		m_vecDataInfo.push_back(stDataInfo);
	}
	xmlDataFile.OutOfElem();

	//更新控件值
	UpdateLowHighValue();
	return TRUE;
}

void CDialogLoggingWnd::OnMouseHover(UINT nFlags, CPoint point)
{
	// TODO:  在此添加消息处理程序代码和/或调用默认值
	CString strTime;
	strTime.Format(_T("CDialogLoggingWnd::OnMouseHover %u\n"), GetCurrentTime());
	OutputDebugString(strTime);
	CDialog::OnMouseHover(nFlags, point);
}


void CDialogLoggingWnd::OnMouseMove(UINT nFlags, CPoint point)
{
	// TODO:  在此添加消息处理程序代码和/或调用默认值
	CDialog::OnMouseMove(nFlags, point);

	/*if (m_rcLithology.PtInRect(point))
	{
		CClientDC dc(this);
		CPen pen;
		pen.CreatePen(PS_SOLID, 3, RGB(255, 95, 0));
		dc.SelectObject(pen);
		dc.MoveTo(m_rcDrawData.right - 3, point.y);
		dc.LineTo(m_rcDrawData.left + 3, point.y);
		ReleaseDC(&dc);
		Invalidate(TRUE);
	}*/
	//
	/*if (m_rcLithology.PtInRect(point))
	{
	// 		CClientDC dc(this);
	// 		CPen pen;
	// 		pen.CreatePen(PS_SOLID, 3, RGB(255, 0, 0));
	// 		dc.SelectObject(pen);
	//
	// 		dc.MoveTo(m_rcDrawData.right-3, point.y);
	// 		dc.LineTo(m_rcDrawData.left+3, point.y);
	// 		ReleaseDC(&dc);

	CPen pen;
	pen.CreatePen(PS_SOLID, 3, RGB(255, 127, 39));
	m_pClientDC->SelectObject(pen);

	m_pClientDC->MoveTo(m_rcDrawData.right - 3, point.y);
	m_pClientDC->LineTo(m_rcDrawData.left + 3, point.y);
	m_pClientDC->SetROP2(R2_NOT);
	m_pClientDC->MoveTo(m_rcDrawData.right - 3, point.y);
	m_pClientDC->LineTo(m_rcDrawData.left + 3, point.y);
	}*/
	/*if (m_rcLithology.PtInRect(point))
	{
	CDC *pcdc = this->GetDC();
	CPen newPen(PS_SOLID, 1, RGB(255, 0, 0));
	CPen *pOldePen;
	pcdc->SelectStockObject(NULL_BRUSH);
	pOldePen = pcdc->SelectObject(&newPen);
	int nNew = SetROP2(pcdc->m_hDC, R2_NOT); //屏幕色取反
	pcdc->MoveTo(m_rcDrawData.right - 3, point.y);
	pcdc->LineTo(m_rcDrawData.left + 3, point.y);
	SetROP2(pcdc->m_hDC, nNew);
	//TargetPos = point;
	pcdc->MoveTo(m_rcDrawData.right - 3, point.y);
	pcdc->LineTo(m_rcDrawData.left + 3, point.y);
	newPen.DeleteObject();
	ReleaseDC(pcdc);
	}*/
}

void CDialogLoggingWnd::OnLButtonDown(UINT nFlags, CPoint point)
{
	// TODO:  在此添加消息处理程序代码和/或调用默认值
	if (m_rcLithology.PtInRect(point))
	{
		float fCurStartDepth, fCurEndDepth,fMinDifference = -1;
		float fCurDepth = (point.y - m_uiStartDrawHeigh)*1.0 / DEPTH_SCALE_DISTANCE;

		STLithologyProfile stProfile;
		int iItemCount = m_vecLithologyProfile.size();
		for (int i = 0; i < iItemCount; i++)
		{
			//选出距离最近的线
			if (fMinDifference == -1 
				|| abs(m_vecLithologyProfile[i].fStartDepth - fCurDepth) < fMinDifference
				|| abs(m_vecLithologyProfile[i].fEndDepth - fCurDepth) < fMinDifference)
			{				
				if (abs(m_vecLithologyProfile[i].fStartDepth - fCurDepth) > abs(m_vecLithologyProfile[i].fEndDepth - fCurDepth))
				{
					fCurStartDepth = m_vecLithologyProfile[i].fEndDepth;
					fMinDifference = abs(m_vecLithologyProfile[i].fEndDepth - fCurDepth);
				}
				else
				{
					fCurStartDepth = m_vecLithologyProfile[i].fStartDepth;
					fMinDifference = abs(m_vecLithologyProfile[i].fStartDepth - fCurDepth);
				}

				fCurEndDepth = fCurDepth;
				if (fCurStartDepth > fCurDepth)
				{
					fCurEndDepth = fCurStartDepth;
					fCurStartDepth = fCurDepth;
				}
			}			
		}

		//绘制横线
		CClientDC dc(this);
		CPen pen;
		pen.CreatePen(PS_SOLID, 3, RGB(255, 95, 0));
		dc.SelectObject(pen);
		dc.MoveTo(m_rcDrawData.right - 3, point.y);
		dc.LineTo(m_rcDrawData.left + 3, point.y);
		ReleaseDC(&dc);			

		CDialogLoggingLithologicWnd  dlg;
		dlg.SetProfileList(m_vecLithologyProfile);
		dlg.SetStartEndDepth(fCurStartDepth, fCurEndDepth/ONE_DECIMETER_TO_HEIGHT);
		dlg.CenterWindow();
		if (IDOK == dlg.DoModal())
		{ 
			m_vecLithologyProfile = dlg.GetProfileList();
			RedrawWindow();
		}
	}
	CDialog::OnLButtonDown(nFlags, point);
}