红色软件上传

main
wklyj 6 months ago
commit 5dd543ab38

12
.gitignore vendored

@ -0,0 +1,12 @@
################################################################################
# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。
################################################################################
/LaiPuLaser/LaiPuLaser.VC.VC.opendb
/LaipuDrawing/LaipuDrawing.VC.VC.opendb
*.suo
/LaipuDrawing/LaipuDrawing.VC.db
/LaiPuLaser/ipch/LAIPULASER-bc8889c5/LAIPU-c4d6e947.ipch
/LaiPuLaser/LaiPuLaser.VC.db
/LaipuDrawing/Debug
/LaipuDrawing/hlp/LaiPuLaser.chm

@ -0,0 +1,211 @@
// 3DBar.cpp: implementation of the C3DBar class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "3DBar.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
C3DBar::C3DBar()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
m_crChannel = RGB(255, 100, 0);
UpdateColours();
CreatePens();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
C3DBar::~C3DBar()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
void C3DBar::UpdateColours()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
// Calculates the lighter and darker colors, as well as the shadow colors.
m_crColorLight = LightenColor(m_crChannel, 51);
m_crColorLighter = LightenColor(m_crColorLight, 51);
m_crColorLightest = LightenColor(m_crColorLighter, 51);
m_crColorDark = DarkenColor(m_crChannel, 51);
m_crColorDarker = DarkenColor(m_crColorDark, 51);
m_crDkShadow = ::GetSysColor(COLOR_3DDKSHADOW);
m_crLiteShadow = ::GetSysColor(COLOR_3DSHADOW);
// Get a color halfway between COLOR_3DDKSHADOW and COLOR_3DSHADOW
BYTE byRed3DDkShadow = GetRValue(m_crDkShadow);
BYTE byRed3DLiteShadow = GetRValue(m_crLiteShadow);
BYTE byGreen3DDkShadow = GetGValue(m_crDkShadow);
BYTE byGreen3DLiteShadow = GetGValue(m_crLiteShadow);
BYTE byBlue3DDkShadow = GetBValue(m_crDkShadow);
BYTE byBlue3DLiteShadow = GetBValue(m_crLiteShadow);
m_crShadow = RGB(byRed3DLiteShadow + ((byRed3DDkShadow - byRed3DLiteShadow) >> 1),
byGreen3DLiteShadow + ((byGreen3DDkShadow - byGreen3DLiteShadow) >> 1),
byBlue3DLiteShadow + ((byBlue3DDkShadow - byBlue3DLiteShadow) >> 1));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
void C3DBar::DrawHorizontal(CDC *pDC, CRect &BarRect)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
if (!BarRect.Width()) return;
CBrush brLightest(m_crColorLightest);
pDC->FillRect(BarRect, &brLightest);
int nLeft = BarRect.left;
int nTop = BarRect.top;
int nBottom = BarRect.bottom;
int nRight = BarRect.right;
CPen *pOldPen = pDC->SelectObject(&m_penColorLight);
{
pDC->MoveTo(nLeft + 2, nBottom - 4);
pDC->LineTo(nRight - 2, nBottom - 4);
pDC->MoveTo(nLeft + 2, nTop + 2);
pDC->LineTo(nRight - 2, nTop + 2);
pDC->SetPixel(nLeft + 1, nBottom - 3, m_crColorLight);
pDC->SetPixel(nLeft + 1, nTop + 1, m_crColorLight);
}
pDC->SelectObject(&m_penColorLighter);
{
pDC->MoveTo(nLeft + 2, nBottom - 5);
pDC->LineTo(nRight - 3, nBottom - 5);
pDC->LineTo(nRight - 3, nTop + 3);
pDC->LineTo(nLeft + 1, nTop + 3);
pDC->SetPixel(nLeft + 1, nBottom - 4, m_crColorLighter);
pDC->SetPixel(nLeft + 1, nTop + 2, m_crColorLighter);
}
pDC->SelectObject(&m_penColor);
{
pDC->MoveTo(nLeft, nBottom - 1);
pDC->LineTo(nLeft, nTop);
pDC->LineTo(nLeft + 2, nTop);
pDC->SetPixel(nLeft + 1, nBottom - 2, m_crChannel);
pDC->MoveTo(nLeft + 2, nBottom - 3);
pDC->LineTo(nRight - 2, nBottom - 3);
pDC->MoveTo(nLeft + 2, nTop + 1);
pDC->LineTo(nRight - 1, nTop + 1);
}
pDC->SelectObject(&m_penColorDark);
{
pDC->MoveTo(nLeft + 2, nBottom - 2);
pDC->LineTo(nRight - 2, nBottom - 2);
pDC->LineTo(nRight - 2, nTop + 1);
pDC->MoveTo(nLeft + 2, nTop);
pDC->LineTo(nRight, nTop);
pDC->SetPixel(nLeft + 1, nBottom - 1, m_crColorDark);
}
pDC->SelectObject(&m_penColorDarker);
{
pDC->MoveTo(nLeft + 2, nBottom - 1);
pDC->LineTo(nRight - 1, nBottom - 1);
pDC->LineTo(nRight - 1, nTop);
}
pDC->SelectObject(&m_penShadow);
{
pDC->MoveTo(nRight, nTop);
pDC->LineTo(nRight, nBottom);
}
pDC->SelectObject(&m_penLiteShadow);
{
pDC->MoveTo(nRight + 1, nTop);
pDC->LineTo(nRight + 1, nBottom);
}
pDC->SelectObject(pOldPen);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
void C3DBar::DeletePens()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
if (m_penColorLight.m_hObject) m_penColorLight.DeleteObject();
if (m_penColorLighter.m_hObject) m_penColorLighter.DeleteObject();
if (m_penColor.m_hObject) m_penColor.DeleteObject();
if (m_penColorDark.m_hObject) m_penColorDark.DeleteObject();
if (m_penColorDarker.m_hObject) m_penColorDarker.DeleteObject();
if (m_penDkShadow.m_hObject) m_penDkShadow.DeleteObject();
if (m_penShadow.m_hObject) m_penShadow.DeleteObject();
if (m_penLiteShadow.m_hObject) m_penLiteShadow.DeleteObject();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
void C3DBar::CreatePens()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
DeletePens();
m_penColorLight.CreatePen(PS_SOLID, 1, m_crColorLight);
m_penColorLighter.CreatePen(PS_SOLID, 1, m_crColorLighter);
m_penColor.CreatePen(PS_SOLID, 1, m_crChannel);
m_penColorDark.CreatePen(PS_SOLID, 1, m_crColorDark);
m_penColorDarker.CreatePen(PS_SOLID, 1, m_crColorDarker);
m_penDkShadow.CreatePen(PS_SOLID, 1, m_crDkShadow);
m_penShadow.CreatePen(PS_SOLID, 1, m_crShadow);
m_penLiteShadow.CreatePen(PS_SOLID, 1, m_crLiteShadow);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
COLORREF C3DBar::LightenColor(const COLORREF crColor, BYTE byIncreaseVal)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
BYTE byRed = GetRValue(crColor);
BYTE byGreen = GetGValue(crColor);
BYTE byBlue = GetBValue(crColor);
if ((byRed + byIncreaseVal) <= 255)
byRed = BYTE(byRed + byIncreaseVal);
if ((byGreen + byIncreaseVal) <= 255)
byGreen = BYTE(byGreen + byIncreaseVal);
if ((byBlue + byIncreaseVal) <= 255)
byBlue = BYTE(byBlue + byIncreaseVal);
return RGB(byRed, byGreen, byBlue);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
COLORREF C3DBar::DarkenColor(const COLORREF crColor, BYTE byReduceVal)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
BYTE byRed = GetRValue(crColor);
BYTE byGreen = GetGValue(crColor);
BYTE byBlue = GetBValue(crColor);
if (byRed >= byReduceVal)
byRed = BYTE(byRed - byReduceVal);
if (byGreen >= byReduceVal)
byGreen = BYTE(byGreen - byReduceVal);
if (byBlue >= byReduceVal)
byBlue = BYTE(byBlue - byReduceVal);
return RGB(byRed, byGreen, byBlue);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header
void C3DBar::SetBarColour(COLORREF cr)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
m_crChannel = cr;
UpdateColours();
CreatePens();
}

@ -0,0 +1,49 @@
// 3DBar.h: interface for the C3DBar class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_)
#define AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "stdafx.h"
class C3DBar
{
public:
void SetBarColour(COLORREF cr);
void UpdateColours();
void CreatePens();
void DrawHorizontal(CDC* pDC, CRect& BarRect);
C3DBar();
virtual ~C3DBar();
protected:
void DeletePens();
COLORREF DarkenColor(const COLORREF crColor, BYTE byReduceVal);
COLORREF LightenColor(const COLORREF crColor, BYTE byIncreaseVal);
COLORREF m_crChannel;
COLORREF m_crColorLight;
COLORREF m_crColorLighter;
COLORREF m_crColorLightest;
COLORREF m_crColorDark;
COLORREF m_crColorDarker;
COLORREF m_crDkShadow;
COLORREF m_crShadow;
COLORREF m_crLiteShadow;
CPen m_penColor;
CPen m_penColorLight;
CPen m_penColorLighter;
CPen m_penColorDark;
CPen m_penColorDarker;
CPen m_penDkShadow;
CPen m_penShadow;
CPen m_penLiteShadow;
};
#endif // !defined(AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_)

@ -0,0 +1,325 @@
#include "StdAfx.h"
#include "AllThreadMgr.h"
#include "CStringFuc.h"
#include "FileMgr.h"
#include "WorkTime.h"
#include "LogMgr.h"
CAllThreadMgr gAllThreadMgr;
bool gbStopAllThread= false;//停止所有线程
CAllThreadMgr::CAllThreadMgr(void)
{
InitThreadInfoVec();
}
CAllThreadMgr::~CAllThreadMgr(void)
{
}
//初始化线程容器
void CAllThreadMgr::InitThreadInfoVec()
{
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_AutoWorkFlowCtrlThread;
ThreadInfo.m_ThreadName = "工作流程控制线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_LaserSleepThread;
ThreadInfo.m_ThreadName = "激光休眠线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_GetDataPtThread,
ThreadInfo.m_ThreadName = "运行时测量线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_ExecuteStepThread;
ThreadInfo.m_ThreadName = "步骤执行线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_FastReadInfoThread;
ThreadInfo.m_ThreadName = "状态读取线程(fast)";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_SlowReadInfoThread;
ThreadInfo.m_ThreadName = "状态读取线程(slow)";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_PlcReadInfoThread;
ThreadInfo.m_ThreadName = "PLC 通信线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_SwitchLaserLddThread;
ThreadInfo.m_ThreadName = "激光器ldd 线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
#ifdef __LASER_DEVICE_BEAMTECH__
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_BeamtechSetParToLaserThread;
ThreadInfo.m_ThreadName = "激光器参数线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
#endif
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_TimingProgressThread;
ThreadInfo.m_ThreadName = "进度条线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_RecordTimeThread;
ThreadInfo.m_ThreadName = "记录计时线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_WaitTransferLoadEndThread;
ThreadInfo.m_ThreadName = "等待load 结束线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_CheckTransferLoadThread;
ThreadInfo.m_ThreadName = "检查是否需要load 的线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_DlgDeviceStateInfoTimer;
ThreadInfo.m_ThreadName = "状态信息timer1";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_DlgDeviceStateInfoTimer2;
ThreadInfo.m_ThreadName = "状态信息timer2";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_ReadLaserPower;
ThreadInfo.m_ThreadName = "功率计线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_LaserDisMeterReadThread;
ThreadInfo.m_ThreadName = "测距仪通信timer";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_ReadLaserInfoThread;
ThreadInfo.m_ThreadName = "绿激光信息读取线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_ReadRedLaserInfoThread;
ThreadInfo.m_ThreadName = "红光信息读取线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_AutoTransferFlowThread;
ThreadInfo.m_ThreadName = "自动传片测试线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_ReadTransferArmInfoThread;
ThreadInfo.m_ThreadName = "TransferArm 通信线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_UpdateSecsDataThread;
ThreadInfo.m_ThreadName = "SecsVariable 线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_CtrlHostJobThread;
ThreadInfo.m_ThreadName = "CtrlHostJob 线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
{
CThreadInfo ThreadInfo;
ThreadInfo.m_ThreadType = _EThreadType_CyclicRunThread;
ThreadInfo.m_ThreadName = "CyclicRun 线程";
m_ThreadInfoVec.push_back(ThreadInfo);
}
}
void CAllThreadMgr::InsertThreadInfoList(CListCtrl &List,bool bInsert)
{
if(bInsert)
List.DeleteAllItems();
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
int idx = 0;
if(bInsert)
{
List.InsertItem(i," ");//插入一行
}
List.SetItemText(i,idx++,Int2CString(i+1));//序号
List.SetItemText(i,idx++,ThreadInfo.m_ThreadName);//参数名称
CString s;
if(ThreadInfo.m_bRunning)
s = "On";
else
s = "Off";
List.SetItemText(i,idx++,s);//状态
}
}
//设置线程的运行状态
void CAllThreadMgr::SetThreadInfoState(EThreadType ThreadType,bool bRunning)
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_ThreadType == ThreadType)
{
ThreadInfo.m_bRunning = bRunning;
break;
}
}
//更新线程时间
//UpdateThreadTime(ThreadType);
}
//更新线程时间
void CAllThreadMgr::UpdateThreadTime(EThreadType ThreadType)
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_ThreadType == ThreadType)
{
CString RunTime;
CWorkTime WorkTime;
ThreadInfo.m_LastRunTime = WorkTime.GetDateTime("/",":");
break;
}
}
}
COLORREF CAllThreadMgr::GetStateColor(int idx)
{
COLORREF c = RGB_GRAY2;
int size = m_ThreadInfoVec.size();
if(idx>=0 && idx < size)
{
if(m_ThreadInfoVec[idx].m_bRunning)
{
c = RGB_GREEN;
}
}
return c;
}
//是否有正在运行的线程
bool CAllThreadMgr::HasThreadRunning()
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_bRunning)
{
return true;
}
}
return false;
}
//显示运行线程的名字
void CAllThreadMgr::ShowRunningThreadName()
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_bRunning)
{
CString s("RunningThread : ");
s += ThreadInfo.m_ThreadName;
gLogMgr->WriteDebugLog(s);
}
}
}
//绑定线程地址
void CAllThreadMgr::BindingThreadAdr(EThreadType ThreadType,CWinThread*p)
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_ThreadType == ThreadType)
{
ThreadInfo.m_pThread = p;
break;
}
}
}
//将线程运行的时间写到文件中
void CAllThreadMgr::WriteAllTreadTimeToFile()
{
CString FileName = "\\CommPar\\TreadTimeFile.txt";
CFileMgr FileMgr;
char filepath[1024];
FileMgr.GetFullFilePath(filepath,FileName);
ofstream FileStream;
FileStream.open(filepath);
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
FileStream<<ThreadInfo.m_ThreadName<<" "<<ThreadInfo.m_LastRunTime<<"\n";
}
FileStream<<endl;
FileStream.close();
}
//查询线程ThreadType 是否在运行
bool CAllThreadMgr::IsThreadRunning(EThreadType ThreadType)
{
int size = m_ThreadInfoVec.size();
for(int i=0;i<size;i++)
{
CThreadInfo &ThreadInfo = m_ThreadInfoVec[i];
if(ThreadInfo.m_ThreadType == ThreadType)
{
return ThreadInfo.m_bRunning;
}
}
return false;
}
void CAllThreadMgr::StopAllThread()
{
gbStopAllThread = true;
}
bool CAllThreadMgr::IsbStopAllThread()
{
return gbStopAllThread;
}

@ -0,0 +1,80 @@
#pragma once
#include "GlobalDefine.h"
//线程的类型
enum EThreadType
{
_EThreadType_NULL=0,
_EThreadType_AutoWorkFlowCtrlThread,//工作流程控制线程
_EThreadType_LaserSleepThread,//激光休眠线程
_EThreadType_GetDataPtThread,//运行时测量线程
_EThreadType_ExecuteStepThread,//步骤执行线程
_EThreadType_FastReadInfoThread,//状态读取线程(fast)
_EThreadType_SlowReadInfoThread,//状态读取线程(slow)
_EThreadType_PlcReadInfoThread,//PLC 通信线程
_EThreadType_LaserDisMeterReadThread,//测距仪通信线程
_EThreadType_SwitchLaserLddThread,//Beamtech激光器ldd 线程
_EThreadType_BeamtechSetParToLaserThread,//Beamtech激光器参数线程
_EThreadType_TimingProgressThread,//进度条线程
_EThreadType_WaferAdjustCtrlThread,//晶圆准直线程
_EThreadType_RecordTimeThread,//记录计时线程
_EThreadType_DlgDeviceStateInfoTimer,//状态信息timer
_EThreadType_DlgDeviceStateInfoTimer2,//状态信息timer2
_EThreadType_ReadLaserPower,//功率计timer
_EThreadType_WaitTransferLoadEndThread,//等待load 结束线程
_EThreadType_CheckTransferLoadThread,//检查是否需要load 的线程
_EThreadType_ReadLaserInfoThread,
_EThreadType_ReadRedLaserInfoThread,
_EThreadType_ReadTekOscilloscopeInfoThread,//读取示波器信息
_EThreadType_AutoTransferFlowThread,//自动传片测试流程控制线程
_EThreadType_ReadTransferArmInfoThread,
_EThreadType_UpdateSecsDataThread,
_EThreadType_CtrlHostJobThread,
_EThreadType_CyclicRunThread,
};
class CThreadInfo
{
public:
CThreadInfo(void)
{
m_bRunning = false;
m_pThread = NULL;//线程的指针
};
public:
EThreadType m_ThreadType;//线程类型
CWinThread* m_pThread;//线程的指针
CString m_ThreadName;//线程的名字
bool m_bRunning;//是否正在运行
CString m_LastRunTime;//最近一次运行的时间(用来看线程是否挂掉)
};
class CAllThreadMgr
{
public:
CAllThreadMgr(void);
~CAllThreadMgr(void);
void InsertThreadInfoList(CListCtrl &List,bool bInsert);
void BindingThreadAdr(EThreadType ThreadType,CWinThread*p);
void SetThreadInfoState(EThreadType ThreadType,bool bRunning);
void StopAllThread();
bool IsbStopAllThread();
COLORREF GetStateColor(int idx);
bool HasThreadRunning();
void WriteAllTreadTimeToFile();
bool IsThreadRunning(EThreadType ThreadType);
void ShowRunningThreadName();
private:
void InitThreadInfoVec();
void UpdateThreadTime(EThreadType ThreadType);
private:
vector<CThreadInfo> m_ThreadInfoVec;//线程容器
};
extern CAllThreadMgr gAllThreadMgr;
extern bool gbStopAllThread;//停止所有线程

@ -0,0 +1,76 @@
#include "StdAfx.h"
#include "ApplicationPriority.h"
#include "PropertieMgr.h"
#include "Propertie.h"
#include "LogMgr.h"
#include "AuthorityMgr.h"
CAppPriorityMgr *gAppPriorityMgr = new CAppPriorityMgr;
CAppPriorityMgr::CAppPriorityMgr(void)
{
m_bGetHighestPriority = false;//是否在打开软件时获取最高优先级
}
CAppPriorityMgr::~CAppPriorityMgr(void)
{
}
CMFCPropertyGridProperty *CAppPriorityMgr::CreatGridProperty()
{
CString PropertyName;//属性名称
CString Description;//描述
CString Path = _T("AppPriority");//存储路径
CString Name;
CString GroupName;
CString ModuleName;
//-------------------------------------------------------------------------------//
PropertyName = _T("程序优先级");
GroupName = PropertyName;
CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName);
//-------------------------------------------------------------------------------//
if(gAuthorityMgr->CheckAuthority(_Authority_Factory))
{
//添加属性变量映射
Name = _T("m_bGetHighestPriority");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bGetHighestPriority);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("最高优先级");
Description = _T("是否将程序优先级提升致系统最高级别,设置后需要重启软件");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bGetHighestPriority, Description);
pGroup->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
//-------------------------------------------------------------------------------//
return pGroup;
}
void CAppPriorityMgr::OnAppInitialize()
{
if(m_bGetHighestPriority)
{
//获取最高权限
GetHighestPriority();
}
}
//获取最高权限
void CAppPriorityMgr::GetHighestPriority()
{
//提升当前程序的优先级
if(SetPriorityClass( GetCurrentProcess(), REALTIME_PRIORITY_CLASS ))
{
gLogMgr->WriteDebugLog("Func---->CAppPriorityMgr : GetHighestPriority : OK");
}
else
{
gLogMgr->WriteDebugLog("Err---->CAppPriorityMgr : GetHighestPriority : Err");
}
}

@ -0,0 +1,20 @@
#pragma once
#include "module.h"
#include "EnumPropertieType.h"
//程序的优先级管理
class CAppPriorityMgr :public CModule
{
public:
CAppPriorityMgr(void);
~CAppPriorityMgr(void);
virtual void OnAppInitialize();
virtual MODULE GetModuleType(){return _APP_PRIORITY_PROP;};
virtual CMFCPropertyGridProperty *CreatGridProperty();
private:
void GetHighestPriority();
private:
bool m_bGetHighestPriority;//是否在打开软件时获取最高优先级
};
extern CAppPriorityMgr *gAppPriorityMgr;

@ -0,0 +1,154 @@
#include "StdAfx.h"
#include "ArrayMgr.h"
#include "GlobalFunction.h"
#include "CommandArray.h"
#include "CommandMgr.h"
CArrayMgr::CArrayMgr(void)
{
}
CArrayMgr::~CArrayMgr(void)
{
}
void CArrayMgr::Creat(SArrayPar &ArrayPar)
{
//初始化
m_ObjContainer.Clear();
if(ArrayPar.m_bRectArray)
{
RectCreat(ArrayPar);
}
else if(ArrayPar.m_bCircleArray)
{
CircleCreat(ArrayPar);
}
else
{
FillCreat(ArrayPar);
}
//创建指令
CreatCmd();
}
//矩形阵列方式
void CArrayMgr::RectCreat(SArrayPar &ArrayPar)
{
//按照指定个数每次克隆一个obj 到m_ObjContainer 中
for(int i=0;i<ArrayPar.m_ArrayCntV;i++)
{
for(int j=0;j<ArrayPar.m_ArrayCntH;j++)
{
//导入当前选择的obj (此时为选择状态)
gLayer.CloneObj(m_ObjContainer,true);
//移动到阵列的位置--------------------------------------
SObjOperatePar par;
par.OpType = _OP_MOVE;
par.MoveX = ArrayPar.m_ArrayOffsetV*i;
par.MoveY = ArrayPar.m_ArrayOffsetH*j;
m_ObjContainer.OperateObj(par,true);
//操作完成后变为非选择状态
m_ObjContainer.NotSelAllObj();
}
}
}
//圆形阵列方式
void CArrayMgr::CircleCreat(SArrayPar &ArrayPar)
{
//先X 方向阵列,在偏移旋转成圆形-----------------------------------------------------
//计算圆的周长
double Perimeter = 2*PI*ArrayPar.m_Radius;
//计算阵列间隔
ArrayPar.m_ArrayCntH = 1;//1行
ArrayPar.m_ArrayCntV = ArrayPar.m_ArrayCnt;//1行
ArrayPar.m_ArrayOffsetV = Perimeter*(ArrayPar.m_GapAngle/360);
ArrayPar.m_ArrayOffsetH = 0;
RectCreat(ArrayPar);
//计算出圆心点
DbRect AllCharRect = m_ObjContainer.GetObjRect(false);//所有obj 的范围
//底部中心点
Dbxy BottomCenterPt = AllCharRect.GetBottomCenterPt();
Dbxy CenterPt;//圆心点
CenterPt.x = BottomCenterPt.x;
CenterPt.y = BottomCenterPt.y - ArrayPar.m_Radius;
//依次旋转偏移到合适的位置
int size = m_ObjContainer.GetSize();
for(int i=0;i<size;i++)
{
DbRect ObjRect = m_ObjContainer.GetObjRect(i);
Dbxy pt = ObjRect.GetBottomCenterPt();
//旋转角度(360)
double angle = 360*(BottomCenterPt.x-pt.x)/Perimeter;
//旋转后的点
Dbxy pt2 = RotatoPt(BottomCenterPt,_360ToAngle(angle),CenterPt);
//计算偏移量
double OffsetX = pt2.x-pt.x;
double OffsetY = pt2.y-pt.y;
//旋转字符
SObjOperatePar par;
par.OpType = _OP_ROTATO;
par.BasePt = ObjRect.GetCenterPt();
par.Angle = angle;
m_ObjContainer.Operate(par,i);
//偏移字符
par.OpType = _OP_MOVE;
par.MoveX = OffsetX;
par.MoveY = OffsetY;
m_ObjContainer.Operate(par,i);
}
}
void CArrayMgr::FillCreat(SArrayPar &ArrayPar)
{
for(int k=0;k<=ArrayPar.m_FillCnt;k++)
{
bool flg = false;
//导入当前选择的obj (此时为选择状态)
gLayer.CloneObj(m_ObjContainer,true);
DbRect Rect = m_ObjContainer.GetObjRect(false);//所有obj 的范围
double w = Rect.Width();
{
SObjOperatePar par;
par.OpType = _OP_STRETCH;
par.BasePt = Rect.GetCenterPt();
par.OldSize = Rect.Width();
par.Diff = ArrayPar.m_FillOffset*k;
par.NewSize = par.OldSize + par.Diff;
if(par.NewSize < ArrayPar.m_FillOffset)
flg = true;
par.xy = _X;
m_ObjContainer.OperateObj(par,true);
}
{
SObjOperatePar par;
par.OpType = _OP_STRETCH;
par.BasePt = Rect.GetCenterPt();
par.OldSize = Rect.Height();
par.Diff = ArrayPar.m_FillOffset*k;
par.NewSize = par.OldSize + par.Diff;
if(par.NewSize < ArrayPar.m_FillOffset)
flg = true;
par.xy = _Y;
m_ObjContainer.OperateObj(par,true);
}
//操作完成后变为非选择状态
m_ObjContainer.NotSelAllObj();
if(flg)
break;
}
}
//创建指令
void CArrayMgr::CreatCmd()
{
if(!m_ObjContainer.Empty())
{
//创建撤销指令-------start
CCommandArray *pCmd = new CCommandArray;
gCommandMgr.AddUndoCommand(pCmd,m_ObjContainer.GetObjVec());
CLayer &layer = gLayer;
pCmd->SaveBaseObj(layer.GetObjContainer());
//创建撤销指令-------end
pCmd->Excute();
}
}

@ -0,0 +1,54 @@
#pragma once
#include "ObjContainer.h"
//阵列用参数
struct SArrayPar{
public:
SArrayPar()
{
m_bRectArray = true;//是否为矩形阵列
m_bCircleArray = false;
m_bFillArray = false;
m_ArrayCntH = 10;//阵列行数
m_ArrayCntV = 1;//阵列行数
m_ArrayOffsetH = 20;//横向间距
m_ArrayOffsetV = 1;//纵向间距
m_ArrayCnt = 36;//圆形阵列的数量
m_Radius = 10;//阵列半径
m_StartAngle = 90;//阵列开始角度
m_GapAngle = 10;//阵列间隔角度(360 度角)
m_FillOffset = -0.1;
m_FillCnt = 1000;
}
public:
bool m_bRectArray;//是否为矩形阵列
bool m_bCircleArray;
bool m_bFillArray;
int m_ArrayCntH;//阵列行数
int m_ArrayCntV;//阵列列数
double m_ArrayOffsetH;//横向间距
double m_ArrayOffsetV;//纵向间距
int m_ArrayCnt;//圆形阵列的数量
double m_Radius;//阵列半径
double m_StartAngle;//阵列开始角度(360 度角)
double m_GapAngle;//阵列间隔角度(360 度角)
double m_FillOffset;
int m_FillCnt;
};
class CArrayMgr
{
public:
CArrayMgr(void);
~CArrayMgr(void);
void Creat(SArrayPar &par);
private:
void RectCreat(SArrayPar &ArrayPar);
void CircleCreat(SArrayPar &ArrayPar);
void FillCreat(SArrayPar &ArrayPar);
void CreatCmd();
private:
CObjContainer m_ObjContainer;
};

@ -0,0 +1,581 @@
#include "StdAfx.h"
#include "AuthorityMgr.h"
#include "MsgBox.h"
#include "FileMgr.h"
#include "LogMgr.h"
#include "PropertieMgr.h"
#include "Propertie.h"
#include "CStringFuc.h"
#include "WorkTime.h"
#include "ProgramLaserTuiHuo.h"
#define LAIPU_NAME "laipu"
#define LAIPU_PASSWORD "laipu123"
#define FILE_PATH _T("\\Parameter\\Authority\\Authority.par")
#define AUTHORITY_PARA_FILE _T("\\CommPar\\Authority.bin")
#define NEW_LOGIN_FILE_PATH _T("\\LoginRecord\\")
bool CompareUser(CAccount Account1,CAccount Account2)
{
return Account1.m_Authority>Account2.m_Authority;
}
CAuthorityMgr *gAuthorityMgr = new CAuthorityMgr;
CAuthorityMgr::CAuthorityMgr(void)
{
m_AutoFactory = false;//打开软件自动升级到管理员权限
m_CurAuthority = _Authority_NoLogin;//当前权限
m_CurUserName = ACCOUNT_NoLogin;
m_bLoginDlgOpen = false;//是否正在打开登录对话框
}
CAuthorityMgr::~CAuthorityMgr(void)
{
}
CMFCPropertyGridProperty *CAuthorityMgr::CreatGridProperty()
{
CString PropertyName;//属性名称
CString Description;//描述
CString Path = _T("AuthorityMgr");//存储路径
CString Name;
CString GroupName;
CString ModuleName;
//-------------------------------------------------------------------------------//
PropertyName = _T("程序权限");
GroupName = PropertyName;
CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName);
//-------------------------------------------------------------------------------//
if(gAuthorityMgr->CheckAuthority(_Authority_Factory))
{
//添加属性变量映射
Name = _T("m_AutoFactory");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_AutoFactory);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("厂家权限");
Description = _T("打开软件时自动获得厂家权限,调试用");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_AutoFactory, Description);
pGroup->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
//-------------------------------------------------------------------------------//
return pGroup;
}
void CAuthorityMgr::OnAppInitialize()
{
SaveOrLoad(false);//读取文件
if(m_AutoFactory)
m_CurAuthority = _Authority_Factory;
//读取权限参数文件
ReadAuthorityParaFile();
}
//检查当前权限
bool CAuthorityMgr::CheckAuthority(eAuthorityType authority,bool bShowMsgbox)
{
if((int)m_CurAuthority >= (int)authority)
{
return true;
}
else
{
if(bShowMsgbox)
{
CMsgBox MsgBox;
CString str = "需要["+GetAccountName(authority) + "]权限!";
MsgBox.Show(str);
}
return false;
}
}
//是否登录
bool CAuthorityMgr::IsLogin()
{
return m_CurAuthority != _Authority_NoLogin;
}
//锁定用户,权限变成未登录
void CAuthorityMgr::Lock()
{
//记录
{
CUserCtrlPar UserCtrlPar;
UserCtrlPar.m_UserName = m_CurUserName;
UserCtrlPar.m_UserCtrlType = _UserCtrlType_logout;
UserCtrlPar.m_AuthorityType = m_CurAuthority;
SaveUserCtrlHistory(UserCtrlPar);
}
SetAuthority(_Authority_NoLogin);
m_CurUserName = ACCOUNT_NoLogin;
}
//登录
bool CAuthorityMgr::Login(CString name,CString PassWord)
{
//读取账号信息
SaveOrLoad(false);
//读取权限参数文件
ReadAuthorityParaFile();
bool ret = false;
eAuthorityType authority = GetCurAuthority();
if(name == LAIPU_NAME && PassWord == LAIPU_PASSWORD)
{
ret = true;
authority = _Authority_Factory;
}
else
{
vector<CAccount>::iterator iter = m_UserVec.begin();
vector<CAccount>::iterator iter_end = m_UserVec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).m_Name == name)
{
if((*iter).m_PassWord == PassWord)
{
ret = true;
authority = (*iter).m_Authority;
break;
}
else
{
CMsgBox MsgBox;
MsgBox.Show("密码和账号不匹配");
break;
}
}
}
if(iter==iter_end)
{
CMsgBox MsgBox;
MsgBox.Show("账号或密码错误!");
}
}
if(ret)
{
SetAuthority(authority);
m_CurUserName = name;
CString log = "CAuthorityMgr::Login::";
log += GetAccountName(authority);
log += "->"+name;
gLogMgr->WriteDebugLog(log);
//记录
{
CUserCtrlPar UserCtrlPar;
UserCtrlPar.m_UserName = name;
UserCtrlPar.m_UserCtrlType = _UserCtrlType_login;
UserCtrlPar.m_AuthorityType = authority;
SaveUserCtrlHistory(UserCtrlPar);
}
}
return ret;
}
CString CAuthorityMgr::GetAccountName(eAuthorityType authority)
{
CString s;
switch(authority)
{
case _Authority_NoLogin:
s = ACCOUNT_NoLogin;
break;
case _Authority_Operator:
s = ACCOUNT_Operator;
break;
case _Authority_OperatorAdmin:
s = ACCOUNT_OperatorAdmin;
break;
case _Authority_Engineer:
s = ACCOUNT_Engineer;
break;
case _Authority_Technics:
s = ACCOUNT_Technics;
break;
case _Authority_Factory:
s = ACCOUNT_Factory;
break;
default:
break;
}
return s;
}
//当前账户类型
CString CAuthorityMgr::GetCurAccountName()
{
return GetAccountName(GetCurAuthority());
}
//保存或者读取账户信息
void CAuthorityMgr::SaveOrLoad(bool bSave)
{
CFileMgr FileMgr;
char filepath[1024];
FileMgr.GetFullFilePath(filepath,FILE_PATH);//获取完整路径
if(bSave)
{
CFile file(filepath,CFile::modeReadWrite|CFile::modeCreate);
CArchive ar(&file,CArchive::store);
SaveOrLoadExt(ar);
}
else
{
CFile file;
if(file.Open(filepath,CFile::modeRead))
{
CArchive ar(&file,CArchive::load);
SaveOrLoadExt(ar);
}
else
{
gLogMgr->WriteDebugLog("Authority File Read Error");
}
}
}
void CAuthorityMgr::SaveOrLoadExt(CArchive &ar)
{
int size = 0;
if(ar.IsStoring())
{
size = m_UserVec.size();//Account 的数量
ar<<size;
}
else
{
m_UserVec.clear();
ar>>size;
for(int i=0;i<size;i++)
{
CAccount Account;
m_UserVec.push_back(Account);
}
}
for(int i=0;i<size;i++)
{
m_UserVec[i].Serialize(ar);
}
if(!ar.IsStoring())
{
//重新排序
SortUserVec();
}
}
void CAuthorityMgr::AddAccount(CAccount Account)
{
//检查是否有重复的用户名
vector<CAccount>::iterator iter = m_UserVec.begin();
vector<CAccount>::iterator iter_end = m_UserVec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).m_Name == Account.m_Name)
{
CMsgBox MsgBox;
CString str(_T("用户:"));
str += Account.m_Name + "已存在!";
MsgBox.Show(str);
return;
}
}
m_UserVec.push_back(Account);
//重新排序
SortUserVec();
SaveOrLoad(true);
//记录
{
CUserCtrlPar UserCtrlPar;
UserCtrlPar.m_UserName = Account.m_Name;
UserCtrlPar.m_UserCtrlType = _UserCtrlType_AddUser;
UserCtrlPar.m_AuthorityType = Account.m_Authority;
SaveUserCtrlHistory(UserCtrlPar);
}
CMsgBox MsgBox;
MsgBox.Show("创建成功!");
}
//删除指定的用户
void CAuthorityMgr::DelUser(int idx)
{
//Engineer 才能删除用户
if(gAuthorityMgr->CheckAuthority(_Authority_Engineer,true)==false)
{
return;
}
vector<CAccount>::iterator iter = m_UserVec.begin();
vector<CAccount>::iterator iter_end = m_UserVec.end();
for(int i=0;iter!=iter_end;iter++,i++)
{
if(i==idx)
{
CAccount Account = (*iter);
CMsgBox MsgBox;
if((*iter).m_Authority>m_CurAuthority)
{
MsgBox.Show(_T("不能删除更高级的用户!"));
return;
}
CString str(_T("删除"));
str += (*iter).m_Name + "?";
if(MsgBox.ConfirmOkCancel(str))
{
m_UserVec.erase(iter);
SortUserVec();
SaveOrLoad(true);
//记录
{
CUserCtrlPar UserCtrlPar;
UserCtrlPar.m_UserName = Account.m_Name;
UserCtrlPar.m_UserCtrlType = _UserCtrlType_DelUser;
UserCtrlPar.m_AuthorityType = Account.m_Authority;
SaveUserCtrlHistory(UserCtrlPar);
}
}
return;
}
}
}
void CAuthorityMgr::InsertToList(CListCtrl &List)
{
int size = m_UserVec.size();
for(int i=0;i<size;i++)
{
int idx = 0;
List.InsertItem(i," ");//插入一行
List.SetItemText(i,idx++,GetAccountName(m_UserVec[i].m_Authority));//权限类型
List.SetItemText(i,idx++,(m_UserVec[i].m_Name));//用户名
}
}
//重新排序
void CAuthorityMgr::SortUserVec()
{
sort(m_UserVec.begin(),m_UserVec.end(),CompareUser);
}
#if 1
//读取权限参数文件
void CAuthorityMgr::ReadAuthorityParaFile()
{
gLogMgr->WriteDebugLog("Func--->ReadAuthorityParaFile");
CFileMgr FileMgr;
CString FilePath;
FileMgr.GetFullFilePath(FilePath,AUTHORITY_PARA_FILE);//结果文件路径
vector<vector<CString>> StrVec;
FileMgr.ReadFileToStrVec(FilePath,StrVec);
m_AuthorityParVec.clear();
int size = StrVec.size();
for(int k=0;k<size;k++)
{
if(StrVec[k].size() == 6)
{
CAuthorityPar AuthorityPar;
AuthorityPar.m_AuthorityName = StrVec[k][0];
AuthorityPar.m_ShowName = StrVec[k][1];
AuthorityPar.m_bOperator = (StrVec[k][2]=="1")?true:false;
AuthorityPar.m_bOperatorAdmin = (StrVec[k][3]=="1")?true:false;
AuthorityPar.m_bEngineer = (StrVec[k][4]=="1")?true:false;
AuthorityPar.m_bTechnics = (StrVec[k][5]=="1")?true:false;
m_AuthorityParVec.push_back(AuthorityPar);
}
}
}
void CAuthorityMgr::SaveAuthorityParaFile()
{
gLogMgr->WriteDebugLog("Func--->SaveAuthorityParaFile");
CFileMgr FileMgr;
CString FilePath;
FileMgr.GetFullFilePath(FilePath,AUTHORITY_PARA_FILE);//结果文件路径
m_AuthorityParVec = m_TmpAuthorityParVec;
ofstream FileStream;
FileStream.open(FilePath);
int size = m_AuthorityParVec.size();
for(int k=0;k<size;k++)
{
CAuthorityPar &AuthorityPar = m_AuthorityParVec[k];
FileStream<<AuthorityPar.m_AuthorityName<<",";
FileStream<<AuthorityPar.m_ShowName<<",";
FileStream<<Bool2CString(AuthorityPar.m_bOperator)<<",";
FileStream<<Bool2CString(AuthorityPar.m_bOperatorAdmin)<<",";
FileStream<<Bool2CString(AuthorityPar.m_bEngineer)<<",";
FileStream<<Bool2CString(AuthorityPar.m_bTechnics)<<"\n";
}
}
bool CAuthorityMgr::CheckAuthorityByName(CString AuthorityName,bool bShowMsgbox)
{
bool Ret = false;
CString ShowName;
int size = m_AuthorityParVec.size();
for(int k=0;k<size;k++)
{
CAuthorityPar &AuthorityPar = m_AuthorityParVec[k];
if(AuthorityName == AuthorityPar.m_AuthorityName)
{
if(m_CurAuthority==_Authority_Operator && AuthorityPar.m_bOperator)
Ret = true;
if(m_CurAuthority==_Authority_OperatorAdmin && AuthorityPar.m_bOperatorAdmin)
Ret = true;
if(m_CurAuthority==_Authority_Engineer && AuthorityPar.m_bEngineer)
Ret = true;
if(m_CurAuthority==_Authority_Technics && AuthorityPar.m_bTechnics)
Ret = true;
if(m_CurAuthority==_Authority_Factory)
Ret = true;
ShowName = AuthorityPar.m_ShowName;
break;
}
}
if(!Ret && bShowMsgbox)
{
CMsgBox MsgBox;
CString str = ShowName + " : 权限不足!";
MsgBox.Show(str);
}
return Ret;
}
void CAuthorityMgr::InitAuthorityTypeComb(CComboBox &Combo)
{
int idx = 0;
Combo.InsertString(idx++,GetAccountName(_Authority_Operator));
Combo.InsertString(idx++,GetAccountName(_Authority_OperatorAdmin));
Combo.InsertString(idx++,GetAccountName(_Authority_Engineer));
Combo.InsertString(idx++,GetAccountName(_Authority_Technics));
Combo.SetCurSel(0);
}
void CAuthorityMgr::InitAuthorityParList(CListCtrl &List)
{
//设置风格
List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_CHECKBOXES);
//设置列
int idx = 0;
List.InsertColumn(idx,"",LVCFMT_LEFT,25);//checkbox
idx++;
List.InsertColumn(idx,"",LVCFMT_LEFT,200,-1);
idx++;
int size = m_AuthorityParVec.size();
for(int i=0;i<size;i++)
{
CAuthorityPar &AuthorityPar = m_AuthorityParVec[i];
int idx = 0;
List.InsertItem(i," ");//插入一行
List.SetItemText(i,idx++,"");//check box
List.SetItemText(i,idx++,AuthorityPar.m_ShowName);//层号
}
//当前操作临时容器
m_TmpAuthorityParVec = m_AuthorityParVec;
UpdateAuthorityParList(List,0);
}
void CAuthorityMgr::UpdateAuthorityParList(CListCtrl &List,int AuthorityType)
{
for(int i=0;i<List.GetItemCount();i++)
{
CAuthorityPar &AuthorityPar = m_TmpAuthorityParVec[i];
if(AuthorityType==0)
List.SetCheck(i,AuthorityPar.m_bOperator);
if(AuthorityType==1)
List.SetCheck(i,AuthorityPar.m_bOperatorAdmin);
if(AuthorityType==2)
List.SetCheck(i,AuthorityPar.m_bEngineer);
if(AuthorityType==3)
List.SetCheck(i,AuthorityPar.m_bTechnics);
}
}
void CAuthorityMgr::UpdateAuthorityPar(CListCtrl &List,int AuthorityType)
{
for(int i=0;i<List.GetItemCount();i++)
{
CAuthorityPar &AuthorityPar = m_TmpAuthorityParVec[i];
if(AuthorityType==0)
AuthorityPar.m_bOperator = List.GetCheck(i);
if(AuthorityType==1)
AuthorityPar.m_bOperatorAdmin = List.GetCheck(i);
if(AuthorityType==2)
AuthorityPar.m_bEngineer = List.GetCheck(i);
if(AuthorityType==3)
AuthorityPar.m_bTechnics = List.GetCheck(i);
}
}
#endif
#if 1
//记录当前账户操作记录
void CAuthorityMgr::SaveUserCtrlHistory(CUserCtrlPar UserCtrlPar)
{
if(UserCtrlPar.m_AuthorityType==_Authority_NoLogin)
return;
if(UserCtrlPar.m_UserName==ACCOUNT_NoLogin)
return;
CWorkTime WorkTime;
CString CurDateTime = WorkTime.GetDateTime("/",":");
CCsvData CsvData;
CsvData.AddData("时间",false);
CsvData.AddData(CurDateTime,true);
CsvData.AddData("操作类型",false);
switch(UserCtrlPar.m_UserCtrlType)
{
case _UserCtrlType_AddUser:
{
CsvData.AddData("Add",true);
}
break;
case _UserCtrlType_DelUser:
{
CsvData.AddData("Delete",true);
}
break;
case _UserCtrlType_login:
{
CsvData.AddData("Login",true);
}
break;
case _UserCtrlType_logout:
{
CsvData.AddData("Logout",true);
}
break;
default:
break;
}
CsvData.AddData("用户名",false);
CsvData.AddData(UserCtrlPar.m_UserName,true);
CsvData.AddData("权限",false);
CsvData.AddData(GetAccountName(UserCtrlPar.m_AuthorityType),true);
CsvData.AddData("",false);
CsvData.AddData("",true);//空行
CFileMgr FileMgr;
CString DataPath;
CurDateTime = WorkTime.GetCurDate("_");
CString DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(NEW_LOGIN_FILE_PATH);
DataPath += DirPath;
DataPath += WorkTime.GetCurYear();
DataPath += "\\"+WorkTime.GetCurMonth();
//DataPath += "\\"+WorkTime.GetCurDay();
DataPath += "\\";
CString DataName;
DataName += "LaipuDrawing_";
DataName += CurDateTime;
//创建数据目录
FileMgr.CreatDir(DataPath);
FileMgr.WriteDataToExcel(DataPath,DataName,CsvData,true);
}
#endif

@ -0,0 +1,141 @@
#pragma once
#include "GlobalDefine.h"
#include "module.h"
#define ACCOUNT_NoLogin "No Login"
#define ACCOUNT_Operator "Operator"
#define ACCOUNT_OperatorAdmin "OperatorAdmin"
#define ACCOUNT_Engineer "Engineer"
#define ACCOUNT_Technics "Technics"
#define ACCOUNT_Factory "Factory"
enum eAuthorityType
{
_Authority_NoLogin = 0,//未登录
_Authority_Operator,//操作员
_Authority_OperatorAdmin,//产线管理员
_Authority_Engineer,//设备工程师
_Authority_Technics,//工艺工程师
_Authority_Factory,//厂家
};
//账号
class CAccount
{
public:
CAccount()
{
m_Authority = _Authority_NoLogin;
}
void Serialize(CArchive& ar)
{
if(ar.IsStoring())
{
ar<<(int)m_Authority;
ar<<m_Name;
ar<<m_PassWord;
}
else
{
int tmp;
ar>>tmp;
m_Authority = (eAuthorityType)tmp;
ar>>m_Name;
ar>>m_PassWord;
}
}
public:
eAuthorityType m_Authority;//权限
CString m_Name;//用户名
CString m_PassWord;//密码
};
class CAuthorityPar
{
public:
CAuthorityPar(void)
{
m_bOperator = false;//操作员
m_bOperatorAdmin = false;//产线管理员
m_bEngineer = false;//设备工程师
m_bTechnics = false;//工艺工程师
};
public:
CString m_AuthorityName;//参数名称
CString m_ShowName;//显示用名称
bool m_bOperator;//操作员
bool m_bOperatorAdmin;//产线管理员
bool m_bEngineer;//设备工程师
bool m_bTechnics;//工艺工程师
};
enum eUserCtrlType
{
_UserCtrlType_AddUser = 0,//添加账号
_UserCtrlType_DelUser,//删除账号
_UserCtrlType_login,//登录
_UserCtrlType_logout,//退出登录
};
class CUserCtrlPar
{
public:
CUserCtrlPar(void)
{
};
public:
eUserCtrlType m_UserCtrlType;//操作类型
CString m_UserName;//用户名
eAuthorityType m_AuthorityType;//权限类型
};
//权限管理
class CAuthorityMgr:public CModule
{
public:
CAuthorityMgr(void);
~CAuthorityMgr(void);
virtual void OnAppInitialize();
virtual MODULE GetModuleType(){return _AUTHORITY_PROP;};
virtual CMFCPropertyGridProperty *CreatGridProperty();
void SetAuthority(eAuthorityType authority){m_CurAuthority = authority;};//设置当前权限
bool CheckAuthority(eAuthorityType authority,bool bShowMsgbox = false);//检查当前权限
bool CheckAuthorityByName(CString AuthorityName,bool bShowMsgbox);
eAuthorityType GetCurAuthority(){return m_CurAuthority;};
void AddAccount(CAccount Account);
bool Login(CString name,CString PassWord);
CString GetAccountName(eAuthorityType authority);
void SaveOrLoad(bool bSave);
void InsertToList(CListCtrl &List);
void DelUser(int idx);
CString GetCurAccountName();
CString GetCurUserName(){return m_CurUserName;};
bool IsAutoFactory(){return m_AutoFactory;};
void Lock();
bool IsLogin();
void InitAuthorityParList(CListCtrl &List);
void InitAuthorityTypeComb(CComboBox &Combo);
void UpdateAuthorityPar(CListCtrl &List,int AuthorityType);
void UpdateAuthorityParList(CListCtrl &List,int AuthorityType);
void SaveAuthorityParaFile();
void SetbLoginDlgOpen(bool b){m_bLoginDlgOpen = b;};
bool IsbLoginDlgOpen(){return m_bLoginDlgOpen;};
private:
void SaveOrLoadExt(CArchive &ar);
void SortUserVec();
void ReadAuthorityParaFile();
void SaveUserCtrlHistory(CUserCtrlPar UserCtrlPar);
private:
eAuthorityType m_CurAuthority;//当前权限
CString m_CurUserName;//当前用户名
vector<CAccount> m_UserVec;//所有的用户
bool m_AutoFactory;//打开软件自动升级到管理员权限
bool m_bLoginDlgOpen;//是否正在打开登录对话框
vector<CAuthorityPar> m_AuthorityParVec;
vector<CAuthorityPar> m_TmpAuthorityParVec;//当前操作的参数
};
extern CAuthorityMgr *gAuthorityMgr;

@ -0,0 +1,51 @@
#pragma once
//位运算函数
//PortVal 的PortIdx 位设置为1
inline long SetBitOn(long Val,int Idx)
{
Val= Val |(1<<Idx);
return Val;
}
inline void SetIntBitOn(int &Val,int Idx)
{
Val= Val |(1<<Idx);
}
inline void SetIntBitOff(int &Val,int Idx)
{
Val = (Val)&(~(1<<Idx));
}
inline void SetIntBitState(int &Val,int Idx,bool bOn)
{
if(bOn)
SetIntBitOn(Val,Idx);
else
SetIntBitOff(Val,Idx);
}
//PortVal 的PortIdx 位设置为0
inline BYTE SetBitOff(BYTE Val,int Idx)
{
Val = (Val)&(~(1<<Idx));
return Val;
}
//判断某位是否为1,PortIdx 从右到左
inline BOOL IsBitOn(BYTE Val,int Idx)
{
if((Val>>Idx)&1)
return TRUE;
else
return FALSE;
}
inline BOOL IsBitOn(int Val,int Idx)
{
if((Val>>Idx)&1)
return TRUE;
else
return FALSE;
}
inline long SetBitByBool(BYTE Val,int Idx,bool b)
{
if(b)
return SetBitOn(Val,Idx);
return SetBitOff(Val,Idx);
}

@ -0,0 +1,141 @@
#pragma once
#include "GlobalDefine.h"
#include "BitOperation.h"
#define TRUE_STR _T("TRUE")
#define FALSE_STR _T("FALSE")
//和MFC CString 相关的一些函数
//去掉小数点后面不要的0
inline void DeleteZero(CString &s)
{
int nIndex;
nIndex=s.Find('.');
if (nIndex>=0)
{
s.TrimRight('0');
if (s.GetLength()==nIndex+1)
{
s=s.Left(nIndex);
if (s.IsEmpty())
s='0';
}
}
}
//double 转换为CString (DigitsCnt 是小数点后保留位数,最多== 6)
inline CString Db2CString(double n,int DigitsCnt = -1)
{
CString s;
if(DigitsCnt==0)
s.Format("%ld",(int)n);
if(DigitsCnt==1)
s.Format("%.1f",n);
if(DigitsCnt==2)
s.Format("%.2f",n);
if(DigitsCnt==3)
s.Format("%.3f",n);
if(DigitsCnt==4)
s.Format("%.4f",n);
if(DigitsCnt==5)
s.Format("%.5f",n);
if(DigitsCnt==6)
s.Format("%.6f",n);
if(DigitsCnt<0)
{
s.Format("%lf",n);
//删除末尾的0
DeleteZero(s);
}
return s;
}
//int 转换为CString
inline CString Int2CString(int n)
{
CString s;
s.Format("%ld",n);
return s;
}
inline CString ByteToString(BYTE bit)
{
CString str;
for(int i=7;i>=0;i--)
{
if(IsBitOn(bit,i))
str += "1";
else
str += "0";
}
return str;
}
//获取bool 类型的str
inline CString GetBoolValStr(bool b)
{
if(b)
return TRUE_STR;
else
return FALSE_STR;
}
//在str 中查找SubStr ,找到返回true
inline bool FindSubStr(CString &str,CString &SubStr)
{
return (str.Find(SubStr) != -1);
}
//删除子串,并返回剩余右边的部分
inline CString DelSubStr(CString str,CString &SubStr)
{
int pos = str.Find(SubStr);
if(pos != -1)
{
str = str.Right(str.GetLength()-(pos+SubStr.GetLength()));
}
return str;
}
inline int CStringToInt(CString &str)
{
return _tstoi(LPCTSTR(str));
}
inline double CStringToDouble(CString &str)
{
return _tstof(LPCTSTR(str));
}
inline bool CStringToBool(CString &str)
{
if(str == TRUE_STR)
return true;
return false;
}
inline CString Bool2Str(bool b)
{
if(b)
return "TRUE";
else
return "FALSE";
}
inline CString Bool2CString(bool b)
{
if(b)
return "1";
else
return "0";
}
inline bool Str2Bool(CString &str)
{
if(str == _T("TRUE"))
return true;
else
return false;
}
inline CString Int2Str_LeftZero(int n)
{
CString s;
if(n<10)
s.Format("0%ld",n);//左边补0
else
s.Format("%ld",n);
return s;
}
//判断String 是否为数字
inline bool IsStringDigit(CString s)
{
return (s.SpanIncluding("0123456789") == s);
}

@ -0,0 +1,301 @@
#include "StdAfx.h"
#include "CatchMgr.h"
#include "GlobalDrawMgr.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "DrawSimpleShape.h"
#include "ObjComponentMgr.h"
#include "MouseToolmgr.h"
CCatchMgr gCatchMgr;//捕捉管理
CCatchMgr::CCatchMgr()
{
ResetCatchNode();
}
CCatchMgr::~CCatchMgr(void)
{
}
#if 1//捕捉基础函数
void CCatchMgr::DrawCatchPoint(CCatchPoint CatchPt,CDC* pDC)
{
if(m_CatchPointVec.empty())
{
ResetCatchPoint(pDC);
}
else
{
//擦除之前的
if(!CatchPt.Equal(m_CatchNode))
{
ResetCatchPoint(pDC);
}
if(!CatchPt.Equal(m_CatchNode))
{
DrawCatchPointExt(CatchPt,pDC);
//保存当前的捕获
m_CatchNode = CatchPt;
}
}
}
void CCatchMgr::DrawCatchPointExt(CCatchPoint pt,CDC* pDC)
{
DbRect NodeRect(pt,gDraw->GetCatchNodeSize());
switch(pt.GetType())
{
case _CATCH_NODE:
DrawRect(pDC,gDraw->GetCatchNodePen(),NodeRect);
break;
case _CATCH_INTERSECT:
case _CATCH_ORTHO:
case _CATCH_CUT_TRACK:
XorDrawCrossX(pDC,gDraw->GetCatchNodePen(),NodeRect);
break;
default:
break;
}
}
void CCatchMgr::ResetCatchNode()
{
m_CatchNode.x = -10000.123456;
m_CatchNode.y = -10000.123456;
}
void CCatchMgr::ResetCatchPoint(CDC* pDC)
{
if(HasCatchPoint())
{
//擦除之前的
DrawCatchPointExt(m_CatchNode,pDC);
}
//重置坐标
ResetCatchNode();
}
bool CCatchMgr::HasCatchPoint()
{
if(m_CatchNode.x == -10000.123456)
{
return false;
}
return true;
}
bool CCatchMgr::GetCatchPoint(CPoint &pt)
{
if(HasCatchPoint())
{
pt = gDraw->Dbxy2CPoint(m_CatchNode);
return true;
}
return false;
}
//获取离鼠标最近的捕获点
CCatchPoint CCatchMgr::GetNearestCatchPt(Dbxy pt)
{
CCatchPoint CatchPt;
double MinDis;
vector<CCatchPoint>::iterator iter = m_CatchPointVec.begin();
vector<CCatchPoint>::iterator iter_end = m_CatchPointVec.end();
for(;iter!=iter_end;iter++)
{
double dis = CalDistance(pt,(*iter));
if(iter == m_CatchPointVec.begin())
{
MinDis = dis;
CatchPt = (*iter);
}
else if(dis<MinDis)
{
MinDis = dis;
CatchPt = (*iter);
}
}
return CatchPt;
}
#endif
#if 1//每种捕捉对应的函数
//捕获pt 附近的点
void CCatchMgr::Catch(Dbxy DownPt,Dbxy pt,CDC* pDC,bool bCatchTemp)
{
//先清空捕获点容器
m_CatchPointVec.clear();
m_DataPtLineVec.clear();
//获得鼠标为中心的捕获矩形rect
DbRect rect = gDraw->GetCurCatchRect(pt);
//收集rect 范围内所有的线段
GetLineInRect(rect,bCatchTemp);
//捕获rect 范围内的node 节点
CatchNode(rect);
//捕获rect 范围内线段的交点
CatchIntersectPointOfLines(rect);
//捕获鼠标rect 和线段的交点
CatchIntersectPointWithMouse(rect);
//捕获正交点
CatchOrthoPoint(DownPt,pt,rect);
//捕捉元件对象切割道的交点用于指定mark 点
CatchCutTrack(rect);
//选择离鼠标最近的点为捕获点
CCatchPoint CatchPt;
if(!m_CatchPointVec.empty())
{
CatchPt = GetNearestCatchPt(pt);
}
//绘制捕获点
DrawCatchPoint(CatchPt,pDC);
}
//收集rect 范围内所有的线段
void CCatchMgr::GetLineInRect(DbRect &rect,bool bCatchTemp)
{
gLayer.GetLineInRect(rect,m_DataPtLineVec,bCatchTemp);
}
//收集rect 范围内的节点
void CCatchMgr::CatchNode(DbRect rect)
{
if(gDraw->IsCatchObjNode()== false)
return;
//优先级控制
if(!m_CatchPointVec.empty())
return;
//检查线段的端点是否在矩形内即可
vector<DbLine>::iterator iter = m_DataPtLineVec.begin();
vector<DbLine>::iterator iter_end = m_DataPtLineVec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).m_pt1.IsNode())
{
Dbxy pt = (*iter).m_pt1.GetPt();
if(IsPointInRect(pt,rect))
{
CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_NODE);
m_CatchPointVec.push_back(CatchPoint);
}
}
if((*iter).m_pt2.IsNode())
{
Dbxy pt = (*iter).m_pt2.GetPt();
if(IsPointInRect(pt,rect))
{
CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_NODE);
m_CatchPointVec.push_back(CatchPoint);
}
}
}
}
//收集rect 范围内的线段交点
void CCatchMgr::CatchIntersectPointOfLines(DbRect rect)
{
if(gDraw->IsCatchCrossPoint()== false)
return;
//优先级控制
if(!m_CatchPointVec.empty())
return;
int size = m_DataPtLineVec.size();
for(int i=0;i<size;i++)
{
DbLine &line1 = m_DataPtLineVec[i];
for(int j=i+1;j<size;j++)
{
DbLine &line2 = m_DataPtLineVec[j];
//连续线段的交点不算
if(line1.IsSerialLine(line2))
{
continue;
}
//先判断是否相交
if(IsTwoLineIntersect(line1.m_pt1.GetPt(),line1.m_pt2.GetPt(),line2.m_pt1.GetPt(),line2.m_pt2.GetPt()))
{
//如果相交求出交点
Dbxy pt = CalIntersection(line1.m_pt1.GetPt(),line1.m_pt2.GetPt(),line2.m_pt1.GetPt(),line2.m_pt2.GetPt());
//交点在rect 内则加入捕捉点
if(IsPointInRect(pt,rect))
{
CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_INTERSECT);
m_CatchPointVec.push_back(CatchPoint);
}
}
}
}
}
//捕获线段和鼠标的交点
void CCatchMgr::CatchIntersectPointWithMouse(DbRect rect)
{
if(gDraw->IsCatchObjLine()== false)
return;
//优先级控制
if(!m_CatchPointVec.empty())
return;
vector<DbLine>::iterator iter = m_DataPtLineVec.begin();
vector<DbLine>::iterator iter_end = m_DataPtLineVec.end();
for(;iter!=iter_end;iter++)
{
Dbxy LinePt1 = (*iter).m_pt1.GetPt();
Dbxy LinePt2 = (*iter).m_pt2.GetPt();
if(IsPointInRect(LinePt1,rect)||IsPointInRect(LinePt2,rect))//不要捕捉端点的部分
{
break;
}
Dbxy pt = IntersectionOfRectAndLine(LinePt1,LinePt2,rect);
CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_INTERSECT);
m_CatchPointVec.push_back(CatchPoint);
}
}
//捕获正交点
void CCatchMgr::CatchOrthoPoint(Dbxy DownPt,Dbxy MousePt,DbRect rect)
{
if(gDraw->IsCatchOrthoPoint()== false)
return;
//优先级控制
if(!m_CatchPointVec.empty())
return;
DbSize size = rect.GetSize();
if(abs(MousePt.x-DownPt.x)<=size.w/2)
{
CCatchPoint CatchPoint(DownPt.x,MousePt.y,_CATCH_ORTHO);
m_CatchPointVec.push_back(CatchPoint);
}
else if(abs(MousePt.y-DownPt.y)<=size.h/2)
{
CCatchPoint CatchPoint(MousePt.x,DownPt.y,_CATCH_ORTHO);
m_CatchPointVec.push_back(CatchPoint);
}
}
//捕捉元件对象切割道的交点用于指定mark 点
void CCatchMgr::CatchCutTrack(DbRect rect)
{
if(gDraw->IsCatchCutTrack()== false)
return;
//优先级控制
if(!m_CatchPointVec.empty())
return;
//只有在测量的时候才捕捉
MOUSE_TOOL tool = gMouseToolMgr.GetToolType();
if(tool == _TOOL_MEASURE)
{
vector<CObjComponent>&vec = gObjComponentMgr->GetComponentVec();
Dbxy pt = rect.GetCenterPt();
double MinDis = 0;//最近的距离
int MinIdx = -1;
int size = vec.size();
for(int i=0;i<size;i++)
{
double CurDis = CalDistance(pt,vec[i].GetBasePt());
if(CurDis <= vec[i].GetSize().w)
{
if(MinDis == 0 || CurDis<MinDis)
{
MinIdx = i;
MinDis = CurDis;
}
}
}
if(MinIdx != -1)
{
Dbxy pt = vec[MinIdx].GetBasePt();
CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_CUT_TRACK);
m_CatchPointVec.push_back(CatchPoint);
}
}
}
#endif

@ -0,0 +1,34 @@
#pragma once
#include "GlobalDefine.h"
#include "ObjBase.h"
#include "SmartPtr.h"
//鼠标捕捉管理
class CCatchMgr
{
public:
CCatchMgr(void);
~CCatchMgr(void);
void Clear();
void Catch(Dbxy DownPt,Dbxy pt,CDC* pDC,bool bCatchTemp);
void ResetCatchPoint(CDC* pDC);
bool GetCatchPoint(CPoint &pt);
private:
void CatchNode(DbRect rect);
void CatchIntersectPointOfLines(DbRect rect);
void CatchIntersectPointWithMouse(DbRect rect);
void ResetCatchNode();
bool HasCatchPoint();
void DrawCatchPoint(CCatchPoint pt,CDC* pDC);
void DrawCatchPointExt(CCatchPoint pt,CDC* pDC);
CCatchPoint GetNearestCatchPt(Dbxy pt);
void GetLineInRect(DbRect &rect,bool bCatchTemp);
void CatchOrthoPoint(Dbxy DownPt,Dbxy MousePt,DbRect rect);
void CatchCutTrack(DbRect rect);
private:
vector<DbLine> m_DataPtLineVec;//保存rect 范围内所有的线段
vector<CCatchPoint> m_CatchPointVec;//在鼠标范围内的捕获点的容器
CCatchPoint m_CatchNode;//之前抓取的点
};
extern CCatchMgr gCatchMgr;

@ -0,0 +1,66 @@
// ChildFrm.cpp : CChildFrame 类的实现
//
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "ChildFrm.h"
#include "GlobalDrawMgr.h"
#include "LogMgr.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CChildFrame
IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWndEx)
BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWndEx)
ON_WM_SYSCOMMAND()
END_MESSAGE_MAP()
// CChildFrame 构造/析构
CChildFrame::CChildFrame()
{
// TODO: 在此添加成员初始化代码
}
CChildFrame::~CChildFrame()
{
}
BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: 在此处通过修改 CREATESTRUCT cs 来修改窗口类或样式
if( !CMDIChildWndEx::PreCreateWindow(cs) )
return FALSE;
cs.style |= WS_MAXIMIZE;
return TRUE;
}
// CChildFrame 诊断
#ifdef _DEBUG
void CChildFrame::AssertValid() const
{
CMDIChildWndEx::AssertValid();
}
void CChildFrame::Dump(CDumpContext& dc) const
{
CMDIChildWndEx::Dump(dc);
}
#endif //_DEBUG
// CChildFrame 消息处理程序
void CChildFrame::OnSysCommand(UINT nID, LPARAM lParam)
{
if(nID == SC_CLOSE)
return;
CMDIChildWndEx::OnSysCommand(nID, lParam);
}

@ -0,0 +1,34 @@
// ChildFrm.h : CChildFrame 类的接口
//
#pragma once
class CChildFrame : public CMDIChildWndEx
{
DECLARE_DYNCREATE(CChildFrame)
public:
CChildFrame();
// 特性
public:
// 操作
public:
// 重写
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
// 实现
public:
virtual ~CChildFrame();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
// 生成的消息映射函数
protected:
afx_msg void OnSysCommand( UINT nID, LPARAM lParam );
DECLARE_MESSAGE_MAP()
};

@ -0,0 +1,689 @@
/*
Comm Base Library(WIN98/NT/2000) ver 1.1
Compile by BC++ 5; C++ Builder 4, 5, 6, X; VC++ 5, 6; VC.net; GCC;
copyright(c) 2004.5 - 2005.8 llbird wushaojian@21cn.com
*/
#ifndef _CN_COMM_H_
#define _CN_COMM_H_
#pragma warning(disable: 4530)
#pragma warning(disable: 4786)
#pragma warning(disable: 4800)
//屏蔽编译警告
#pragma warning(disable : 4244)
#pragma warning(disable : 4305)
#pragma warning(disable : 4996)
#pragma warning(disable : 4101)
#pragma warning(disable : 4477)
#include <assert.h>
#include <stdio.h>
#include <Windows.h>
//第三方的串口类: 提供了通用的窗口操作
/*
cnComm com;
1.使
com.Open();
2.
com.Write(m_send);//m_send为发送的字符串
3.()
ON_COM_RECEIVE
afx_msg LRESULT OnCommRecv(WPARAM wParam, LPARAM lParam);
ON_MESSAGE(ON_COM_RECEIVE,OnCommRecv)
com.SetWnd((*this));
LRESULT CSerialPortClassDlg::OnCommRecv(WPARAM wParam, LPARAM lParam)
{
 //读取串口上的字符
 char str[100];
 com.ReadString(str, 100);
}
*/
//送到窗口的消息 WPARAM 端口号
#define ON_COM_RECEIVE WM_USER + 618
#define ON_COM_CTS WM_USER + 619 //LPARAM 1 valid
#define ON_COM_DSR WM_USER + 621 //LPARAM 1 valid
#define ON_COM_RING WM_USER + 623
#define ON_COM_RLSD WM_USER + 624
#define ON_COM_BREAK WM_USER + 625
#define ON_COM_TXEMPTY WM_USER + 626
#define ON_COM_ERROR WM_USER + 627 //LPARAM save Error ID
#define DEFAULT_COM_MASK_EVENT EV_RXCHAR | EV_ERR | EV_CTS | EV_DSR | EV_BREAK | EV_TXEMPTY | EV_RING | EV_RLSD
class cnComm
{
public:
//------------------------------Construction-----------------------------------
//第1个参数为是否在打开串口时启动监视线程 第2个参数为IO方式 阻塞方式0/ 异步重叠方式(默认)
cnComm(bool fAutoBeginThread = true, DWORD dwIOMode = FILE_FLAG_OVERLAPPED): _dwIOMode(dwIOMode), _fAutoBeginThread(fAutoBeginThread)
{
Init();
}
virtual ~cnComm()
{
Close();
UnInit();
}
//----------------------------------Attributes----------------------------------
//判断串口是否打开
inline bool IsOpen()
{
return _hCommHandle != INVALID_HANDLE_VALUE;
}
//判断串口是否打开
operator bool()
{
return _hCommHandle != INVALID_HANDLE_VALUE;
}
//获得串口句炳
inline HANDLE GetHandle()
{
return _hCommHandle;
}
//获得串口句炳
operator HANDLE()
{
return _hCommHandle;
}
//获得串口参数 DCB
DCB *GetState()
{
return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) == TRUE ?
&_DCB: NULL;
}
//设置串口参数 DCB
bool SetState(DCB *pdcb = NULL)
{
return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB:pdcb) == TRUE: false;
}
//设置串口参数:波特率,停止位,等 支持设置字符串 "9600, 8, n, 1"
bool SetState(char *szSetStr)
{
if (IsOpen())
{
if (::GetCommState(_hCommHandle, &_DCB) != TRUE)
return false;
if (::BuildCommDCB(szSetStr, &_DCB) != TRUE)
return false;
return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
}
return false;
}
//设置串口参数:波特率,停止位,等
bool SetState(DWORD dwBaudRate, DWORD dwByteSize = 8, DWORD dwParity = NOPARITY, DWORD dwStopBits = ONESTOPBIT)
{
if (IsOpen())
{
if (::GetCommState(_hCommHandle, &_DCB) != TRUE)
return false;
_DCB.BaudRate = dwBaudRate;
_DCB.ByteSize = (unsigned char)dwByteSize;
_DCB.Parity = (unsigned char)dwParity;
_DCB.StopBits = (unsigned char)dwStopBits;
return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
}
return false;
}
//获得超时结构
LPCOMMTIMEOUTS GetTimeouts(void)
{
return IsOpen() && ::GetCommTimeouts(_hCommHandle, &_CO) == TRUE ? &_CO: NULL;
}
//设置超时
bool SetTimeouts(LPCOMMTIMEOUTS lpCO)
{
return IsOpen() ? ::SetCommTimeouts(_hCommHandle, lpCO) == TRUE:false;
}
//设置串口的I/O缓冲区大小
bool SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize)
{
return IsOpen() ? ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize)== TRUE: false;
}
//关联消息的窗口句柄
inline void SetWnd(HWND hWnd)
{
assert(::IsWindow(hWnd));
_hNotifyWnd = hWnd;
}
//设定发送通知, 接受字符最小值
inline void SetNotifyNum(DWORD dwNum)
{
_dwNotifyNum = dwNum;
}
//线程是否运行
inline bool IsThreadRunning()
{
return _hThreadHandle != NULL;
}
//获得线程句柄
inline HANDLE GetThread()
{
return _hThreadHandle;
}
//设置要监视的事件, 打开前设置有效
void SetMaskEvent(DWORD dwEvent = DEFAULT_COM_MASK_EVENT)
{
_dwMaskEvent = dwEvent;
}
//获得读缓冲区的字符数
int GetInputSize()
{
COMSTAT Stat;
DWORD dwError;
return ::ClearCommError(_hCommHandle, &dwError, &Stat) == TRUE ? Stat.cbInQue : (DWORD) - 1L;
}
//----------------------------------Operations----------------------------------
//打开串口 缺省 9600, 8, n, 1
bool Open(DWORD dwPort)
{
return Open(dwPort, 9600);
}
//打开串口 缺省 baud_rate, 8, n, 1
bool Open(DWORD dwPort, DWORD dwBaudRate)
{
if (dwPort < 1 || dwPort > 1024)
return false;
BindCommPort(dwPort);
if (!OpenCommPort())
return false;
if (!SetupPort())
return false;
return SetState(dwBaudRate);
}
//打开串口, 使用类似"9600, 8, n, 1"的设置字符串设置串口
bool Open(DWORD dwPort, char *szSetStr)
{
if (dwPort < 1 || dwPort > 1024)
return false;
BindCommPort(dwPort);
if (!OpenCommPort())
return false;
if (!SetupPort())
return false;
return SetState(szSetStr);
}
//读取串口 dwBufferLength个字符到 Buffer 返回实际读到的字符数 可读任意数据
DWORD Read(LPVOID Buffer, DWORD dwBufferLength, DWORD dwWaitTime = 10)
{
if (!IsOpen())
return 0;
COMSTAT Stat;
DWORD dwError;
if (::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0)
{
::PurgeComm(_hCommHandle,PURGE_RXABORT | PURGE_RXCLEAR);
return 0;
}
if (!Stat.cbInQue)
// 缓冲区无数据
return 0;
unsigned long uReadLength = 0;
dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue :dwBufferLength;
if (!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength,&_ReadOverlapped))
{
if (::GetLastError() == ERROR_IO_PENDING)
{
WaitForSingleObject(_ReadOverlapped.hEvent, dwWaitTime);
// 结束异步I/O
if (!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped,&uReadLength, false))
{
if (::GetLastError() != ERROR_IO_INCOMPLETE)
uReadLength = 0;
}
}
else
uReadLength = 0;
}
return uReadLength;
}
//读取串口 dwBufferLength - 1 个字符到 szBuffer 返回ANSI C 模式字符串指针 适合一般字符通讯
char *ReadString(char *szBuffer, DWORD dwBufferLength, DWORD dwWaitTime =20)
{
unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1,dwWaitTime);
szBuffer[uReadLength] = '\0';
return szBuffer;
}
//写串口 可写任意数据 "abcd" or "\x0\x1\x2"
DWORD Write(LPVOID Buffer, DWORD dwBufferLength)
{
if (!IsOpen())
return 0;
DWORD dwError;
if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
unsigned long uWriteLength = 0;
if (!::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength,&_WriteOverlapped))
if (::GetLastError() != ERROR_IO_PENDING)
uWriteLength = 0;
return uWriteLength;
}
//写串口 写ANSI C 模式字符串指针
DWORD Write(const char *szBuffer)
{
assert(szBuffer);
return Write((void*)szBuffer, strlen(szBuffer));
}
//读串口 同步应用
DWORD ReadSync(LPVOID Buffer, DWORD dwBufferLength)
{
if (!IsOpen())
return 0;
DWORD dwError;
if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
{
::PurgeComm(_hCommHandle,PURGE_RXABORT | PURGE_RXCLEAR);
return 0;
}
DWORD uReadLength = 0;
::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, NULL);
return uReadLength;
}
//写串口 同步应用
DWORD WriteSync(LPVOID Buffer, DWORD dwBufferLength)
{
if (!IsOpen())
return 0;
DWORD dwError;
if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
unsigned long uWriteLength = 0;
::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, NULL);
return uWriteLength;
}
//写串口 szBuffer 可以输出格式字符串 包含缓冲区长度
DWORD Write(char *szBuffer, DWORD dwBufferLength, char *szFormat, ...)
{
if (!IsOpen())
return 0;
va_list va;
va_start(va, szFormat);
_vsnprintf(szBuffer, dwBufferLength, szFormat, va);
va_end(va);
return Write(szBuffer);
}
//写串口 szBuffer 可以输出格式字符串 不检查缓冲区长度 小心溢出
DWORD Write(char *szBuffer, char *szFormat, ...)
{
if (!IsOpen())
return 0;
va_list va;
va_start(va, szFormat);
vsprintf(szBuffer, szFormat, va);
va_end(va);
return Write(szBuffer);
}
//关闭串口 同时也关闭关联线程
virtual void Close()
{
if (IsOpen())
{
PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
EndThread();
::CloseHandle(_hCommHandle);
_hCommHandle = INVALID_HANDLE_VALUE;
}
}
//DTR 电平控制
bool SetDTR(bool OnOrOff)
{
return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETDTR :CLRDTR): false;
}
//RTS 电平控制
bool SetRTS(bool OnOrOff)
{
return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETRTS :CLRRTS): false;
}
//
bool SetBreak(bool OnOrOff)
{
return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETBREAK: CLRBREAK): false;
}
//辅助线程控制 建监视线程
bool BeginThread()
{
if (!IsThreadRunning())
{
_fRunFlag = true;
_hThreadHandle = NULL;
DWORD id;
_hThreadHandle = ::CreateThread(NULL, 0, CommThreadProc, this, 0,&id);
return (_hThreadHandle != NULL);
}
return false;
}
//暂停监视线程
inline bool SuspendThread()
{
return IsThreadRunning() ? ::SuspendThread(_hThreadHandle) !=0xFFFFFFFF: false;
}
//恢复监视线程
inline bool ResumeThread()
{
return IsThreadRunning() ? ::ResumeThread(_hThreadHandle) !=0xFFFFFFFF: false;
}
//终止线程
bool EndThread(DWORD dwWaitTime = 100)
{
if (IsThreadRunning())
{
_fRunFlag = false;
::SetCommMask(_hCommHandle, 0);
::SetEvent(_WaitOverlapped.hEvent);
if (::WaitForSingleObject(_hThreadHandle, dwWaitTime) !=WAIT_OBJECT_0)
if (!::TerminateThread(_hThreadHandle, 0))
return false;
::CloseHandle(_hThreadHandle);
::ResetEvent(_WaitOverlapped.hEvent);
_hThreadHandle = NULL;
return true;
}
return false;
}
protected:
volatile DWORD _dwPort; //串口号
volatile HANDLE _hCommHandle; //串口句柄
char _szCommStr[20]; //保存COM1类似的字符串
DCB _DCB; //波特率,停止位,等
COMMTIMEOUTS _CO; //超时结构
DWORD _dwIOMode; // 0 同步 默认 FILE_FLAG_OVERLAPPED重叠I/O异步
OVERLAPPED _ReadOverlapped, _WriteOverlapped; // 重叠I/O
volatile HANDLE _hThreadHandle; //辅助线程
volatile HWND _hNotifyWnd; // 通知窗口
volatile DWORD _dwNotifyNum; //接受多少字节(>=_dwNotifyNum)发送通知消息
volatile DWORD _dwMaskEvent; //监视的事件
volatile bool _fRunFlag; //线程运行循环标志
bool _fAutoBeginThread; //Open() 自动 BeginThread();
OVERLAPPED _WaitOverlapped; //WaitCommEvent use
//初始化
void Init()
{
memset(_szCommStr, 0, 20);
memset(&_DCB, 0, sizeof(_DCB));
_DCB.DCBlength = sizeof(_DCB);
_hCommHandle = INVALID_HANDLE_VALUE;
memset(&_ReadOverlapped, 0, sizeof(_ReadOverlapped));
memset(&_WriteOverlapped, 0, sizeof(_WriteOverlapped));
_ReadOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
assert(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE);
_WriteOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
assert(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE);
_hNotifyWnd = NULL;
_dwNotifyNum = 0;
_dwMaskEvent = DEFAULT_COM_MASK_EVENT;
_hThreadHandle = NULL;
memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped));
_WaitOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
assert(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE);
}
//析构
void UnInit()
{
if (_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE)
CloseHandle(_ReadOverlapped.hEvent);
if (_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE)
CloseHandle(_WriteOverlapped.hEvent);
if (_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE)
CloseHandle(_WaitOverlapped.hEvent);
}
//绑定串口
void BindCommPort(DWORD dwPort)
{
assert(dwPort >= 1 && dwPort <= 1024);
char p[5];
_dwPort = dwPort;
strcpy(_szCommStr, "\\\\.\\COM");
ltoa(_dwPort, p, 10);
strcat(_szCommStr, p);
}
//打开串口
virtual bool OpenCommPort()
{
if (IsOpen())
Close();
_hCommHandle = ::CreateFile(_szCommStr, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | _dwIOMode,NULL);
if (_fAutoBeginThread)
{
if (IsOpen() && BeginThread())
return true;
else
{
Close(); //创建线程失败
return false;
}
}
return IsOpen();
}
//设置串口
virtual bool SetupPort()
{
if (!IsOpen())
return false;
if (!::SetupComm(_hCommHandle, 4096, 4096))
return false;
if (!::GetCommTimeouts(_hCommHandle, &_CO))
return false;
_CO.ReadIntervalTimeout = 0;
_CO.ReadTotalTimeoutMultiplier = 1;
_CO.ReadTotalTimeoutConstant = 1000;
_CO.WriteTotalTimeoutMultiplier = 1;
_CO.WriteTotalTimeoutConstant = 1000;
if (!::SetCommTimeouts(_hCommHandle, &_CO))
return false;
if (!::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_RXABORT |PURGE_TXCLEAR | PURGE_RXCLEAR))
return false;
return true;
}
//---------------------------------------threads callback-----------------------------------
//线程收到消息自动调用, 如窗口句柄有效, 送出消息, 包含串口编号, 均为虚函数可以在基层类中扩展
virtual void OnReceive() //EV_RXCHAR
{
if (::IsWindow(_hNotifyWnd))
::PostMessage(_hNotifyWnd, ON_COM_RECEIVE, WPARAM(_dwPort), LPARAM (0));
}
virtual void OnDSR()
{
if (::IsWindow(_hNotifyWnd))
{
DWORD Status;
if (GetCommModemStatus(_hCommHandle, &Status))
::PostMessage(_hNotifyWnd, ON_COM_DSR, WPARAM(_dwPort),LPARAM((Status &MS_DSR_ON) ? 1 : 0));
}
}
virtual void OnCTS()
{
if (::IsWindow(_hNotifyWnd))
{
DWORD Status;
if (GetCommModemStatus(_hCommHandle, &Status))
::PostMessage(_hNotifyWnd, ON_COM_CTS, WPARAM(_dwPort), LPARAM( (Status &MS_CTS_ON) ? 1 : 0));
}
}
virtual void OnBreak()
{
if (::IsWindow(_hNotifyWnd))
{
::PostMessage(_hNotifyWnd, ON_COM_BREAK, WPARAM(_dwPort), LPARAM(0));
}
}
virtual void OnTXEmpty()
{
if (::IsWindow(_hNotifyWnd))
::PostMessage(_hNotifyWnd, ON_COM_TXEMPTY, WPARAM(_dwPort), LPARAM (0));
}
virtual void OnError()
{
DWORD dwError;
::ClearCommError(_hCommHandle, &dwError, NULL);
if (::IsWindow(_hNotifyWnd))
::PostMessage(_hNotifyWnd, ON_COM_ERROR, WPARAM(_dwPort), LPARAM (dwError));
}
virtual void OnRing()
{
if (::IsWindow(_hNotifyWnd))
::PostMessage(_hNotifyWnd, ON_COM_RING, WPARAM(_dwPort), LPARAM(0));
}
virtual void OnRLSD()
{
if (::IsWindow(_hNotifyWnd))
::PostMessage(_hNotifyWnd, ON_COM_RLSD, WPARAM(_dwPort), LPARAM(0));
}
virtual DWORD ThreadFunc()
{
if (!::SetCommMask(_hCommHandle, _dwMaskEvent))
{
char szBuffer[256];
_snprintf(szBuffer, 255,
"%s(%d) : COM%d Call WINAPI SetCommMask(%x, %x) Fail, thread work invalid! GetLastError() = %d;", __FILE__, __LINE__, _dwPort, _hCommHandle, _dwMaskEvent, GetLastError());
MessageBox(NULL, szBuffer, "Class cnComm", MB_OK);
return 1;
}
COMSTAT Stat;
DWORD dwError;
for (DWORD dwLength, dwMask = 0; _fRunFlag && IsOpen(); dwMask = 0)
{
if (!::WaitCommEvent(_hCommHandle, &dwMask, &_WaitOverlapped))
{
if (::GetLastError() == ERROR_IO_PENDING)
// asynchronous
::GetOverlappedResult(_hCommHandle, &_WaitOverlapped,&dwLength, TRUE);
else
continue;
}
if (dwMask == 0)
continue;
switch (dwMask)
{
case EV_RXCHAR:
::ClearCommError(_hCommHandle, &dwError, &Stat);
if (Stat.cbInQue >= _dwNotifyNum)
OnReceive();
break;
case EV_TXEMPTY:
OnTXEmpty();
break;
case EV_CTS:
OnCTS();
break;
case EV_DSR:
OnDSR();
break;
case EV_RING:
OnRing();
break;
case EV_RLSD:
OnRLSD();
break;
case EV_BREAK:
OnBreak();
break;
case EV_ERR:
OnError();
break;
} //case
} //for
return 0;
}
private:
//the function protected
cnComm(const cnComm &);
cnComm &operator = (const cnComm &);
//base function for thread
static DWORD WINAPI CommThreadProc(LPVOID lpPara)
{
return ((cnComm*)lpPara)->ThreadFunc();
}
};
#endif //_CN_COMM_H_

@ -0,0 +1,49 @@
#include "StdAfx.h"
#include "CommandAddNode.h"
CCommandAddNode::CCommandAddNode(void)
{
}
CCommandAddNode::~CCommandAddNode(void)
{
}
void CCommandAddNode::ExcuteExt()
{
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->InsertNode(m_idx,m_pt);
}
}
}
void CCommandAddNode::UndoExt()
{
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->DelNodePtByIdx(m_idx);
}
}
}
CString CCommandAddNode::GetStr()
{
CString str = "_add_node Ìí¼Ó½Úµã-----";
return str;
}
void CCommandAddNode::SetPar(int idx,Dbxy pt)
{
m_idx = idx;
m_pt = pt;
}

@ -0,0 +1,17 @@
#pragma once
#include "commandbase.h"
//添加节点
class CCommandAddNode :public CCommandBase
{
public:
CCommandAddNode(void);
~CCommandAddNode(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
void SetPar(int idx,Dbxy pt);
private:
int m_idx;//节点的索引值
Dbxy m_pt;//节点的坐标
};

@ -0,0 +1,47 @@
#include "StdAfx.h"
#include "CommandArray.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandArray::CCommandArray(void)
{
}
CCommandArray::~CCommandArray(void)
{
}
void CCommandArray::ExcuteExt()
{
CLayer &layer = gLayer;
//先删除阵列基准obj
layer.DelObj(m_BaseObjContainer);
//再导入阵列对象
layer.AddObject(m_ObjContainer);
}
void CCommandArray::UndoExt()
{
CLayer &layer = gLayer;
//删除阵列对象
layer.DelObj(m_ObjContainer);
//导入基准对象
layer.AddObject(m_BaseObjContainer);
}
CString CCommandArray::GetStr()
{
CString str = "_array 阵列-----";
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
if(vec.size()>1)
{
CString str1;
str1.Format("%ld",vec.size());
str +="[数量] : <"+str1+">";
}
return str;
};
//保存基准obj
void CCommandArray::SaveBaseObj(CObjContainer &ObjContainer)
{
ObjContainer.AllObjAddToContainer(m_BaseObjContainer,true);
}

@ -0,0 +1,16 @@
#pragma once
#include "commandbase.h"
class CCommandArray :
public CCommandBase
{
public:
CCommandArray(void);
~CCommandArray(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
void SaveBaseObj(CObjContainer &ObjContainer);
private:
CObjContainer m_BaseObjContainer;//基准对象的容器
};

@ -0,0 +1,36 @@
#include "StdAfx.h"
#include "CommandBase.h"
#include "EasyOperationMgr.h"
CCommandBase::CCommandBase(void)
{
}
CCommandBase::~CCommandBase(void)
{
}
//添加操作对象
void CCommandBase::AddOpObj(Sptr<CObjBase> p)
{
m_ObjContainer.AddObject(p);
}
void CCommandBase::AddOpObj(CObjBase *p)
{
//保存到智能指针
Sptr<CObjBase> sPtr(p);
AddOpObj(sPtr);
}
//是否有操作对象
bool CCommandBase::HasOpObj()
{
return !m_ObjContainer.Empty();
}
void CCommandBase::Excute()
{
ExcuteExt();
gEasyOperationMgr->Refresh();
}
void CCommandBase::Undo()
{
UndoExt();
gEasyOperationMgr->Refresh();
}

@ -0,0 +1,25 @@
#pragma once
#include "GlobalDefine.h"
#include "SmartPtr.h"
#include "ObjContainer.h"
#include "ObjBase.h"
class CCommandBase
{
public:
CCommandBase(void);
virtual ~CCommandBase(void);
virtual CString GetStr() = 0;
virtual void ExcuteExt(){};
virtual void UndoExt(){};
void Excute();
void Undo();
void AddOpObj(CObjBase *p);
void AddOpObj(Sptr<CObjBase>);
bool HasOpObj();
void SetOperatePar(SObjOperatePar par){m_Par = par;};
protected:
CObjContainer m_ObjContainer;//obj 对象容器管理对象
SObjOperatePar m_Par;//操作参数
};

@ -0,0 +1,67 @@
#include "StdAfx.h"
#include "CommandBreakNode.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandBreakNode::CCommandBreakNode(void)
{
}
CCommandBreakNode::~CCommandBreakNode(void)
{
}
//第一个是打断之前的obj
void CCommandBreakNode::ExcuteExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->SetSelected(true);
if((*iter).IsNull()==false)
{
if(iter == vec.begin())
{
layer.DelObj((*iter));
}
else
{
layer.AddObject((*iter));
}
}
}
}
}
void CCommandBreakNode::UndoExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->SetSelected(true);
if(iter == vec.begin())
{
layer.AddObject((*iter));
}
else
{
layer.DelObj((*iter));
}
}
}
}
CString CCommandBreakNode::GetStr()
{
CString str = "_break 打断节点-----";
return str;
}

@ -0,0 +1,12 @@
#pragma once
#include "commandbase.h"
class CCommandBreakNode :public CCommandBase
{
public:
CCommandBreakNode(void);
~CCommandBreakNode(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,37 @@
#include "StdAfx.h"
#include "CommandCopy.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandCopy::CCommandCopy(void)
{
}
CCommandCopy::~CCommandCopy(void)
{
}
void CCommandCopy::ExcuteExt()
{
CLayer &layer = gLayer;
layer.AddObject(m_ObjContainer);
}
void CCommandCopy::UndoExt()
{
CLayer &layer = gLayer;
layer.DelObj(m_ObjContainer);
}
CString CCommandCopy::GetStr()
{
CString str = "_copy ¸´ÖÆ-----";
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
if(vec.size()>1)
{
CString str1;
str1.Format("%ld",vec.size());
str +="[ÊýÁ¿] : <"+str1+">";
}
return str;
};

@ -0,0 +1,13 @@
#pragma once
#include "commandbase.h"
class CCommandCopy :
public CCommandBase
{
public:
CCommandCopy(void);
~CCommandCopy(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,47 @@
#include "StdAfx.h"
#include "CommandCreat.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandCreat::CCommandCreat(void)
{
}
CCommandCreat::~CCommandCreat(void)
{
}
CString CCommandCreat::GetStr()
{
CString str = "_creat ´´½¨-----";
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
str += ((*iter)->GetStr()+" ");
break;
}
}
if(vec.size()>1)
{
CString str1;
str1.Format("%ld",vec.size());
str +="[ÊýÁ¿] : <"+str1+">";
}
return str;
};
void CCommandCreat::ExcuteExt()
{
CLayer &layer = gLayer;
layer.AddObject(m_ObjContainer);
}
void CCommandCreat::UndoExt()
{
CLayer &layer = gLayer;
layer.DelObj(m_ObjContainer);
}

@ -0,0 +1,12 @@
#pragma once
#include "CommandBase.h"
class CCommandCreat :public CCommandBase
{
public:
CCommandCreat(void);
~CCommandCreat(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,68 @@
#include "StdAfx.h"
#include "CommandCut.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandCut::CCommandCut(void)
{
}
CCommandCut::~CCommandCut(void)
{
}
//m_ObjContainer 的第一个为剪切的obj
//剪切后的obj 可能为0~2 个
void CCommandCut::ExcuteExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->SetSelected(false);
if((*iter).IsNull()==false)
{
if(iter == vec.begin())
{
layer.DelObj((*iter));
}
else
{
layer.AddObject((*iter));
}
}
}
}
}
void CCommandCut::UndoExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
if(iter == vec.begin())
{
layer.AddObject((*iter));
}
else
{
layer.DelObj((*iter));
}
}
}
}
CString CCommandCut::GetStr()
{
CString str = "_cut 修剪-----";
return str;
}

@ -0,0 +1,12 @@
#pragma once
#include "commandbase.h"
class CCommandCut :public CCommandBase
{
public:
CCommandCut(void);
~CCommandCut(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,47 @@
#include "StdAfx.h"
#include "CommandDelNode.h"
CCommandDelNode::CCommandDelNode(void)
{
}
CCommandDelNode::~CCommandDelNode(void)
{
}
void CCommandDelNode::ExcuteExt()
{
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->DelNodePtByIdx(m_idx);
}
}
}
void CCommandDelNode::UndoExt()
{
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->InsertNode(m_idx,m_pt);
}
}
}
CString CCommandDelNode::GetStr()
{
CString str = "_del_node ɾ³ý½Úµã-----";
return str;
}
void CCommandDelNode::SetPar(int idx,Dbxy pt)
{
m_idx = idx;
m_pt = pt;
}

@ -0,0 +1,16 @@
#pragma once
#include "commandbase.h"
class CCommandDelNode :public CCommandBase
{
public:
CCommandDelNode(void);
~CCommandDelNode(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
void SetPar(int idx,Dbxy pt);
private:
int m_idx;
Dbxy m_pt;
};

@ -0,0 +1,38 @@
#include "StdAfx.h"
#include "CommandDelete.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandDelete::CCommandDelete(void)
{
}
CCommandDelete::~CCommandDelete(void)
{
}
void CCommandDelete::ExcuteExt()
{
CLayer &layer = gLayer;
layer.DelObj(m_ObjContainer);
}
void CCommandDelete::UndoExt()
{
CLayer &layer = gLayer;
layer.AddObject(m_ObjContainer);
}
CString CCommandDelete::GetStr()
{
CString str = "_erase ɾ³ý-----";
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
if(vec.empty()==false)
{
CString str1;
str1.Format("%ld",vec.size());
str +="[ÊýÁ¿] : <"+str1+">";
}
return str;
}

@ -0,0 +1,12 @@
#pragma once
#include "CommandBase.h"
class CCommandDelete :public CCommandBase
{
public:
CCommandDelete(void);
~CCommandDelete(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,68 @@
#include "StdAfx.h"
#include "CommandJion.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandJion::CCommandJion(void)
{
}
CCommandJion::~CCommandJion(void)
{
}
//最后一个是合并后的obj
void CCommandJion::ExcuteExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->SetSelected(true);
if((*iter).IsNull()==false)
{
if(iter == vec.end()-1)
{
layer.AddObject((*iter));
}
else
{
layer.DelObj((*iter));
}
}
}
}
}
void CCommandJion::UndoExt()
{
CLayer &layer = gLayer;
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->SetSelected(true);
if(iter == vec.end()-1)
{
layer.DelObj((*iter));
}
else
{
layer.AddObject((*iter));
}
}
}
}
CString CCommandJion::GetStr()
{
CString str = "_jion 合并-----";
return str;
}

@ -0,0 +1,13 @@
#pragma once
#include "commandbase.h"
//ºÏ²¢
class CCommandJion :public CCommandBase
{
public:
CCommandJion(void);
~CCommandJion(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,121 @@
#include "StdAfx.h"
#include "CommandMgr.h"
#include "LogMgr.h"
#include "GlobalFunction.h"
#define MAX_UNDO_CNT 100//最大撤销次数
CCommandMgr gCommandMgr;
CCommandMgr::CCommandMgr(void)
{
}
CCommandMgr::~CCommandMgr(void)
{
m_UndoQueue.clear();
m_RedoQueue.clear();
}
//p 是指令特定的操作对象
void CCommandMgr::AddUndoCommand(CCommandBase *p)
{
vector<Sptr<CObjBase>> Vec;
AddUndoCommand(p,Vec);
}
void CCommandMgr::AddUndoCommand(CCommandBase *p,vector<Sptr<CObjBase>> &pMarkObjectVec)
{
if(p->HasOpObj()==false)
{
//加入指定的
if(pMarkObjectVec.empty()==false)
{
vector<Sptr<CObjBase>>::iterator iter = pMarkObjectVec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = pMarkObjectVec.end();
for(;iter!=iter_end;iter++)
{
p->AddOpObj((*iter));
}
}
else//没有指定就加入当前选择的obj
{
gLayer.GetObjContainer().AddObjToCmd(p,true);
}
}
if(p->HasOpObj()==false)//没有操作对象时不要添加指令
{
delete p;
return;
}
gCommandMgr.AddUndoCommandExt(p);
}
//添加指令
void CCommandMgr::AddUndoCommandExt(CCommandBase *p)
{
//------------------------------------日志start
CLog log;
log.AddCmdLog();
log.str = p->GetStr();
gLogMgr->WriteLog(log);
//------------------------------------日志end
//保存到智能指针
Sptr<CCommandBase> sPtr(p);
m_UndoQueue.push_back(sPtr);
if(m_UndoQueue.size()>MAX_UNDO_CNT)
{
m_UndoQueue.pop_front();
}
//之前的redo 全部清除
m_RedoQueue.clear();
}
bool CCommandMgr::HasUndoCmd()
{
return !m_UndoQueue.empty();
}
bool CCommandMgr::HasRedoCmd()
{
return !m_RedoQueue.empty();
}
void CCommandMgr::Undo()
{
if(!m_UndoQueue.empty())
{
Sptr<CCommandBase> p = m_UndoQueue[m_UndoQueue.size()-1];
p->Undo();
m_RedoQueue.push_back(p);
m_UndoQueue.pop_back();
//------------------------------------日志start
CLog log;
log.AddCmdLog();
{
CString str = p->GetStr();
log.str = "_undo 撤销"+str;
}
gLogMgr->WriteLog(log);
//------------------------------------日志end
}
}
void CCommandMgr::Redo()
{
if(!m_RedoQueue.empty())
{
Sptr<CCommandBase> p = m_RedoQueue[m_RedoQueue.size()-1];
p->Excute();
m_UndoQueue.push_back(p);
m_RedoQueue.pop_back();
//------------------------------------日志start
CLog log;
log.AddCmdLog();
{
CString str = p->GetStr();
log.str = "_redo 重做"+str;
}
gLogMgr->WriteLog(log);
//------------------------------------日志end
}
}
//重置回撤指令状态
void CCommandMgr::Reset()
{
m_UndoQueue.clear();
m_RedoQueue.clear();
}

@ -0,0 +1,25 @@
#pragma once
#include "CommandBase.h"
#include "GlobalDefine.h"
//³·ÏúÖ¸Áî¹ÜÀí
class CCommandMgr
{
public:
CCommandMgr(void);
~CCommandMgr(void);
void AddUndoCommand(CCommandBase *p);
void AddUndoCommand(CCommandBase *p,vector<Sptr<CObjBase>> &pMarkObjectVec);
void AddUndoCommandExt(CCommandBase *p);
bool HasUndoCmd();
bool HasRedoCmd();
void Undo();
void Redo();
void Reset();
private:
deque<Sptr<CCommandBase>> m_UndoQueue;
deque<Sptr<CCommandBase>> m_RedoQueue;
};
extern CCommandMgr gCommandMgr;

@ -0,0 +1,19 @@
#include "StdAfx.h"
#include "CommandMirror.h"
CCommandMirror::CCommandMirror(void)
{
}
CCommandMirror::~CCommandMirror(void)
{
}
void CCommandMirror::ExcuteExt()
{
m_ObjContainer.OperateObj(m_Par,false);
}
void CCommandMirror::UndoExt()
{
m_ObjContainer.OperateObj(m_Par,false);
}

@ -0,0 +1,12 @@
#pragma once
#include "CommandBase.h"
class CCommandMirror :public CCommandBase
{
public:
CCommandMirror(void);
~CCommandMirror(void);
virtual CString GetStr(){return "¾µÏñ";};
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,48 @@
#include "StdAfx.h"
#include "CommandModifiCircle.h"
#include "ObjCircle.h"
CCommandModifiCircle::CCommandModifiCircle(void)
{
}
CCommandModifiCircle::~CCommandModifiCircle(void)
{
}
//b 为true 时设置旧参数
void CCommandModifiCircle::SetPar(double Radius,int EdgeCnt,bool b)
{
if(b)
{
m_OldRadius = Radius;//半径
m_OldEdgeCnt = EdgeCnt;//边数
}
else
{
m_Radius = Radius;//半径
m_EdgeCnt = EdgeCnt;//边数
}
}
void CCommandModifiCircle::ExcuteExt()
{
ReCreatObj(true);
}
void CCommandModifiCircle::UndoExt()
{
ReCreatObj(false);
}
void CCommandModifiCircle::ReCreatObj(bool bExcute)
{
CObjBase *pBase = m_ObjContainer.GetCurOpObj();
if(pBase)
{
CObjCircle *p = dynamic_cast<CObjCircle*>(pBase);
if(bExcute)
{
p->ReCreat(m_Radius,m_EdgeCnt);
}
else
{
p->ReCreat(m_OldRadius,m_OldEdgeCnt);
}
}
}

@ -0,0 +1,24 @@
#pragma once
#include "commandbase.h"
//修改圆
class CCommandModifiCircle :
public CCommandBase
{
public:
CCommandModifiCircle(void);
~CCommandModifiCircle(void);
virtual CString GetStr(){return "修改circle";};
virtual void ExcuteExt();
virtual void UndoExt();
void SetPar(double Radius,int EdgeCnt,bool b);
private:
void ReCreatObj(bool bExcute);
private:
double m_OldRadius;//半径
int m_OldEdgeCnt;//边数
double m_Radius;//半径
int m_EdgeCnt;//边数
};

@ -0,0 +1,31 @@
#include "StdAfx.h"
#include "CommandModifiFill.h"
CCommandModifiFill::CCommandModifiFill(void)
{
}
CCommandModifiFill::~CCommandModifiFill(void)
{
}
//b 为true 时设置旧参数
void CCommandModifiFill::SetPar(SFillPar par,bool b)
{
if(b)
{
m_OldPar = par;
}
else
{
m_NewPar = par;
}
}
void CCommandModifiFill::ExcuteExt()
{
m_ObjContainer.FillObj(m_NewPar,false);
}
void CCommandModifiFill::UndoExt()
{
m_ObjContainer.FillObj(m_OldPar,false);
}

@ -0,0 +1,20 @@
#pragma once
#include "commandbase.h"
#include "SFillPar.h"
//填充
class CCommandModifiFill :public CCommandBase
{
public:
CCommandModifiFill(void);
~CCommandModifiFill(void);
virtual CString GetStr(){return "修改fill";};
virtual void ExcuteExt();
virtual void UndoExt();
void SetPar(SFillPar par,bool b);
private:
//字体参数
SFillPar m_OldPar;
SFillPar m_NewPar;
};

@ -0,0 +1,49 @@
#include "StdAfx.h"
#include "CommandModifiFont.h"
#include "ObjTxt.h"
CCommandModifiFont::CCommandModifiFont(void)
{
}
CCommandModifiFont::~CCommandModifiFont(void)
{
}
//b Ϊtrue ʱÉèÖþɲÎÊý
void CCommandModifiFont::SetStringPar(SFontPar &par,bool b)
{
if(b)
{
m_OldFontPar = par;
}
else
{
m_NewFontPar = par;
}
}
void CCommandModifiFont::ExcuteExt()
{
ReCreatObj(true);
}
void CCommandModifiFont::UndoExt()
{
ReCreatObj(false);
}
void CCommandModifiFont::ReCreatObj(bool bExcute)
{
CObjBase *pBase = m_ObjContainer.GetCurOpObj();
if(pBase)
{
CObjTxt *p = dynamic_cast<CObjTxt*>(pBase);
if(bExcute)
{
p->SetFontPar(m_NewFontPar);
}
else
{
p->SetFontPar(m_OldFontPar);
}
p->Creat();
}
}

@ -0,0 +1,21 @@
#pragma once
#include "commandbase.h"
#include "SFontPar.h"
class CCommandModifiFont :public CCommandBase
{
public:
CCommandModifiFont(void);
~CCommandModifiFont(void);
virtual CString GetStr(){return "修改font";};
virtual void ExcuteExt();
virtual void UndoExt();
void SetStringPar(SFontPar &par,bool b);
private:
void ReCreatObj(bool bExcute);
private:
//字体参数
SFontPar m_OldFontPar;
SFontPar m_NewFontPar;
};

@ -0,0 +1,55 @@
#include "StdAfx.h"
#include "CommandModifiString.h"
#include "ObjTxt.h"
CCommandModifiString::CCommandModifiString()
{
}
CCommandModifiString::~CCommandModifiString(void)
{
}
//b 为true 时设置旧参数
void CCommandModifiString::SetStringPar(SStringPar &par,bool b)
{
if(b)
{
m_OldStringPar.Copy(par);
}
else
{
m_NewStringPar.Copy(par);
}
}
void CCommandModifiString::ExcuteExt()
{
ReCreatObj(true);
}
void CCommandModifiString::UndoExt()
{
ReCreatObj(false);
}
void CCommandModifiString::ReCreatObj(bool bExcute)
{
CObjBase *pBase = m_ObjContainer.GetCurOpObj();
if(pBase)
{
CObjString *p = dynamic_cast<CObjString*>(pBase);
if(bExcute)
{
//可变文本
p->SetValStr(m_NewStringPar.m_ValString);
//字体
p->SetFontTypeName(m_NewStringPar.m_FontTypeName);
p->SetFontName(m_NewStringPar.m_FontName);
}
else
{
//可变文本
p->SetValStr(m_OldStringPar.m_ValString);
//字体
p->SetFontTypeName(m_OldStringPar.m_FontTypeName);
p->SetFontName(m_OldStringPar.m_FontName);
}
p->Creat();
}
}

@ -0,0 +1,21 @@
#pragma once
#include "commandbase.h"
#include "SStringPar.h"
//修改合成对象
class CCommandModifiString :public CCommandBase
{
public:
CCommandModifiString();
~CCommandModifiString(void);
virtual CString GetStr(){return "修改string";};
virtual void ExcuteExt();
virtual void UndoExt();
void SetStringPar(SStringPar &par,bool b);
private:
void ReCreatObj(bool bExcute);
private:
SStringPar m_OldStringPar;
SStringPar m_NewStringPar;
};

@ -0,0 +1,32 @@
#include "StdAfx.h"
#include "CommandMove.h"
CCommandMove::CCommandMove(void)
{
}
CCommandMove::~CCommandMove(void)
{
}
CString CCommandMove::GetStr()
{
CString str1 = "CommandMove--------[Dis x ] : <";
CString str2;
str2.Format("%lf",m_Par.MoveX);
CString str3 = "> [Dis y ] : <";
CString str4;
str4.Format("%lf",m_Par.MoveY);
CString str5 = ">";
return str1+str2+str3+str4+str5;
}
void CCommandMove::ExcuteExt()
{
m_ObjContainer.OperateObj(m_Par,false);
}
void CCommandMove::UndoExt()
{
//·´ÏòÒƶ¯
SObjOperatePar par = m_Par;
par.MoveX = par.MoveX*(-1);
par.MoveY = par.MoveY*(-1);
m_ObjContainer.OperateObj(par,false);
}

@ -0,0 +1,13 @@
#pragma once
#include "CommandBase.h"
class CCommandMove :public CCommandBase
{
public:
CCommandMove(void);
~CCommandMove(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,44 @@
#include "StdAfx.h"
#include "CommandMoveNode.h"
CCommandMoveNode::CCommandMoveNode(void)
{
}
CCommandMoveNode::~CCommandMoveNode(void)
{
}
CString CCommandMoveNode::GetStr()
{
CString str = "_moveNode 移动节点";
return str;
}
void CCommandMoveNode::SetPar(int idx,Dbxy OldPt,Dbxy NewPt)
{
m_NodeIdx = idx;//操作node 节点的索引值
m_OldPt = OldPt;//旧的坐标
m_NewPt = NewPt;//新的坐标
}
void CCommandMoveNode::ExcuteExt()
{
SetNode(true);
}
void CCommandMoveNode::UndoExt()
{
SetNode(false);
}
void CCommandMoveNode::SetNode(bool bExcute)
{
CObjBase *pBase = m_ObjContainer.GetCurOpObj();
if(pBase)
{
if(bExcute)
{
pBase->SetNodePtByIdx(m_NodeIdx,m_NewPt);
}
else
{
pBase->SetNodePtByIdx(m_NodeIdx,m_OldPt);
}
}
}

@ -0,0 +1,19 @@
#pragma once
#include "commandbase.h"
class CCommandMoveNode :public CCommandBase
{
public:
CCommandMoveNode(void);
~CCommandMoveNode(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
void SetPar(int idx,Dbxy OldPt,Dbxy NewPt);
private:
void SetNode(bool bExcute);
private:
int m_NodeIdx;//操作node 节点的索引值
Dbxy m_OldPt;//旧的坐标
Dbxy m_NewPt;//新的坐标
};

@ -0,0 +1,45 @@
#include "StdAfx.h"
#include "CommandReverse.h"
#include "Layer.h"
#include "GlobalFunction.h"
CCommandReverse::CCommandReverse(void)
{
}
CCommandReverse::~CCommandReverse(void)
{
}
void CCommandReverse::ExcuteExt()
{
Operater();
}
void CCommandReverse::UndoExt()
{
Operater();
}
CString CCommandReverse::GetStr()
{
CString str = "_reverse ·´×ª½áµã˳Ðò-----";
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
if(vec.empty()==false)
{
CString str1;
str1.Format("%ld",vec.size());
str +="[¶ÔÏóÊýÁ¿] : <"+str1+">";
}
return str;
}
void CCommandReverse::Operater()
{
vector<Sptr<CObjBase>> &vec = m_ObjContainer.GetObjVec();
vector<Sptr<CObjBase>>::iterator iter = vec.begin();
vector<Sptr<CObjBase>>::iterator iter_end = vec.end();
for(;iter!=iter_end;iter++)
{
if((*iter).IsNull()==false)
{
(*iter)->Operate(m_Par);
}
}
}

@ -0,0 +1,15 @@
#pragma once
#include "commandbase.h"
//反转节点顺序
class CCommandReverse :public CCommandBase
{
public:
CCommandReverse(void);
~CCommandReverse(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
private:
void Operater();
};

@ -0,0 +1,34 @@
#include "StdAfx.h"
#include "CommandRotato.h"
CCommandRotato::CCommandRotato(void)
{
}
CCommandRotato::~CCommandRotato(void)
{
}
CString CCommandRotato::GetStr()
{
CString str1 = "_rotato Ðýת-------- [½Ç¶È] : <";
double angle = m_Par.Angle;
if(angle>180)
{
angle = (360-angle)*(-1);
}
CString str2;
str2.Format("%lf",angle);
CString str3 = ">";
return str1+str2+str3;
}
void CCommandRotato::ExcuteExt()
{
m_ObjContainer.OperateObj(m_Par,false);
}
void CCommandRotato::UndoExt()
{
SObjOperatePar par = m_Par;
par.Angle = par.Angle*(-1);
m_ObjContainer.OperateObj(par,false);
}

@ -0,0 +1,12 @@
#pragma once
#include "CommandBase.h"
class CCommandRotato :public CCommandBase
{
public:
CCommandRotato(void);
~CCommandRotato(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
};

@ -0,0 +1,70 @@
#include "StdAfx.h"
#include "CommandStretch.h"
CCommandStretch::CCommandStretch(void)
{
m_bSetXY = false;//是否同时设置XY 方向
}
CCommandStretch::~CCommandStretch(void)
{
}
CString CCommandStretch::GetStr()
{
CString str1 = "_stretch 拉伸-------- [方向] : <";
CString str2;
if(m_Par.xy == _X)
str2 = "X> [旧尺寸] : <";
else
str2 = "Y> [旧尺寸] : <";
CString str3;
str3.Format("%lf",m_Par.OldSize);
CString str4 = "> [新尺寸] : <";
CString str5;
str5.Format("%lf",m_Par.NewSize);
CString str6 = ">";
return str1+str2+str3+str4+str5+str6;
};
void CCommandStretch::SetOperateParY(SObjOperatePar par)
{
m_bSetXY = true;//是否同时设置XY 方向
m_ParY = par;
};
void CCommandStretch::ExcuteExt()
{
if(m_bSetXY)
{
m_ObjContainer.OperateObj(m_Par,true);
m_ObjContainer.OperateObj(m_ParY,true);
}
else
{
m_ObjContainer.OperateObj(m_Par,true);
}
}
void CCommandStretch::UndoExt()
{
SObjOperatePar par = m_Par;
par.OpType = _OP_STRETCH;
par.BasePt = m_Par.BasePt;
par.OldSize = m_Par.NewSize;
par.Diff = m_Par.Diff*(-1);
par.xy = m_Par.xy;
SObjOperatePar parY = m_ParY;
parY.OpType = _OP_STRETCH;
parY.BasePt = m_ParY.BasePt;
parY.OldSize = m_ParY.NewSize;
parY.Diff = m_ParY.Diff*(-1);
parY.xy = m_ParY.xy;
if(m_bSetXY)
{
m_ObjContainer.OperateObj(par,true);
m_ObjContainer.OperateObj(parY,true);
}
else
{
m_ObjContainer.OperateObj(par,true);
}
}

@ -0,0 +1,16 @@
#pragma once
#include "commandBase.h"
class CCommandStretch :public CCommandBase
{
public:
CCommandStretch(void);
~CCommandStretch(void);
virtual CString GetStr();
virtual void ExcuteExt();
virtual void UndoExt();
void SetOperateParY(SObjOperatePar par);
private:
bool m_bSetXY;//是否同时设置XY 方向
SObjOperatePar m_ParY;//操作参数
};

@ -0,0 +1,32 @@
#pragma once
//定义一些常用的字符串
#define COMMON_TEXT_1 "测距仪功能被屏蔽,不支持此操作!"
#define COMMON_TEXT_2 "没有配置光束分析仪,不支持此操作!"
#define COMMON_TEXT_3 "没有配置光束衰减器,不支持此操作!"
#define COMMON_TEXT_4 "当前为手动模式!"
#define COMMON_TEXT_5 "激光在光束分析仪位置附近不能关闭衰减器!"
#define COMMON_TEXT_6 "当前无法操作衰减器!"
#define COMMON_TEXT_7 "设备未初始化不能打开光闸!"
#define COMMON_TEXT_8 "电机不能移动到安全范围外!"
#define COMMON_TEXT_9 "设备未初始化!"
#define COMMON_TEXT_10 "没有读取到测量项目名列表!"
#define COMMON_TEXT_11 "Wait AsixXY Stop Over time!"
#define COMMON_TEXT_12 "测距仪数据读取错误"
#define COMMON_TEXT_13 "设备报警状态未清除!"
#define COMMON_TEXT_14 "退火前准备:"

@ -0,0 +1,765 @@
#include "StdAfx.h"
#include "CommonFlowMgr.h"
#include "MsgBox.h"
#include "WorkCmdInvoker.h"
#include "Propertie.h"
#include "PropertieMgr.h"
#include "AuthorityMgr.h"
#include "LogMgr.h"
#include "CStringFuc.h"
#include "Laser.h"
#include "MarkAreaMgr.h"
#include "ObjComponentMgr.h"
#include "MeasureMgr.h"
#include "ExceptionMsg.h"
#include "FileMgr.h"
#include "DrawSimpleShape.h"
#include "LaiPuLaserView.h"
#include "Layer.h"
#include "ObjContainer.h"
#include "WorkRecord.h"
#include "EncryptionMgr.h"
#include "WorkFileMgr.h"
#include "ProgramLaserTuiHuo.h"
#include "ProgressMgr.h"
#include "WorkCmdTimingProgress.h"
#include "TimingProgressMgr.h"
#include "WaferRecipeDataMgr.h"
#include "CommomText.h"
#include "RecipeMgr.h"
#include "WaferRecipeDataMgr.h"
#include "LaserPowCheckMgr.h"
#include "WorkAreaMgr.h"
#include "ModuleDeviceMgr.h"
#include "CriticalSection.h"
UINT AutomationWorkFlowStartThread(LPVOID pParam)
{
CCommonFlowMgr *p = (CCommonFlowMgr *)pParam;
p->StartAutomationWorkFlow();
return 0;
}
#define MAX_AREA_SIZE 10000 //单个area 的范围最大值
#define NOT_MOVE_Z_COORD 99999
#define ORG_POS_MAX_ADJUST_VAL 10//原点位置单次最大调整量
#define SPOT_METER_LASER_FRE 1000 //测量光斑时的固定激光频率
#define SPOT_METER_LASER_PULSE_DELAY 0 //测量光斑时的固定激光双脉冲延时
CCommonFlowMgr *gCommonFlowMgr = new CCommonFlowMgr;
CCommonFlowMgr::CCommonFlowMgr(void)
{
m_bIniPlatfrom = true;//是否初始化电机平台
m_bIniConfirmMsgBox = true;//是否弹出初始化确认对话框
m_bIniMotorZ = false;//是否初始化电机Z
m_bInitedToProductPt = false;//初始化完成后是否返回上料点
m_bSetLightState = true;//是否设置警示灯状态
m_bConnectObj = true;//是否连接多个obj 数据
m_bNeedInit = false;//是否需要初始化才能进行操作
m_bShowErrMsg = true;//运行时出错后对话框提示
m_bStopWorkMsg = true;//点了停止按钮后是否提示对话框
m_bShowStartMsg = true;//在开始加工时是否对话框提示
m_MotorZSafeCoord = 10;//Z 轴的安全坐标位置
m_DrawLineGapCnt = 1;//每间隔几条线绘制一次
m_OneLineScanSpeed = 150;//单条扫描线的速度
m_TransferTestDelay = 10000;//传片测试延时ms
m_OneLineAnnealTimeAdjsut = 150;//单条线段退火时间的调整量
m_MoveTestDelay = 300;//移动测试延时ms
m_bXyMoveTesting = false;
m_bLaserSpotMarkMode = false;//当前是否为打光斑模式
m_LightAlamTime = 10;//蜂鸣器时间
m_bKeepJobN2Air = false;//在job 运行时一直保持吹气
m_bCtrlN2Air = true;//是否控制氮气开关(调试时可以关闭)
m_bAutomationWorking = false;
m_bStopAutomationWork = false;
}
CCommonFlowMgr::~CCommonFlowMgr(void)
{
}
CString CCommonFlowMgr::GetParDirName()
{
CString DirName = _T("CommonFlowMgr");
return DirName;
}
CMFCPropertyGridProperty * CCommonFlowMgr::CreatGridProperty()
{
CString PropertyName;//属性名称
CString Description;//描述
CString Path = GetParDirName();
CString Name;
CString GroupName;
CString ModuleName;
//-------------------------------------------------------------------------------//
PropertyName = _T("常用流程");
ModuleName = PropertyName;
CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName);
{
{
GroupName = ("共通设定");
CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(GroupName);
if(gAuthorityMgr->CheckAuthority(_Authority_Factory))
{
{
//添加属性变量映射
Name = _T("m_bNeedInit");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bNeedInit);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("需要初始化");
Description = _T("是否需要初始化才能进行操作");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
pPropertie->SetModuleName(ModuleName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bNeedInit, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_DrawLineGapCnt");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_DrawLineGapCnt);
pPropertie->SetType(_PROP_TYPE_INT);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("绘制间隔");
Description = _T("每间隔几条线绘制一次,避免有些线段没有显示");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DrawLineGapCnt, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_OneLineAnnealTimeAdjsut");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_OneLineAnnealTimeAdjsut);
pPropertie->SetType(_PROP_TYPE_INT);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("加减速时间");
Description = _T("单条线段退火时间的调整量ms");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_OneLineAnnealTimeAdjsut, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bShowStartMsg");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bShowStartMsg);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("加工前提示");
Description = _T("在开始加工时是否对话框提示");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShowStartMsg, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bShowErrMsg");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bShowErrMsg);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("运行时错误");
Description = _T("运行过程中发生错误时弹出对话框提示");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShowErrMsg, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bStopWorkMsg");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bStopWorkMsg);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("停止提示");
Description = _T("运行过程中点停止是否弹出对话框提示");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bStopWorkMsg, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_LightAlamTime");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_LightAlamTime);
pPropertie->SetType(_PROP_TYPE_INT);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("蜂鸣器时间");
Description = _T("蜂鸣器时间");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LightAlamTime, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_MotorZSafeCoord");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_MotorZSafeCoord);
pPropertie->SetType(_PROP_TYPE_DOUBLE);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("Z轴安全坐标");
Description = _T("Z轴安全坐标(危险)");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorZSafeCoord, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_TransferTestDelay");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_TransferTestDelay);
pPropertie->SetType(_PROP_TYPE_INT);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("传片测试延时");
Description = _T("传片测试每片的延时时间ms");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_TransferTestDelay, Description);
pGroup1->AddSubItem(p1);
gDevicePropertieMgr.Insert(p1, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_MoveTestDelay");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_MoveTestDelay);
pPropertie->SetType(_PROP_TYPE_INT);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("移动测试延时");
Description = _T("移动测试延时ms");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MoveTestDelay, Description);
pGroup1->AddSubItem(p1);
gDevicePropertieMgr.Insert(p1, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bKeepJobN2Air");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bKeepJobN2Air);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("Job 持续氮气");
Description = _T("在job 运行时一直保持吹氮气");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bKeepJobN2Air, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bCtrlN2Air");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bCtrlN2Air);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("氮气控制");
Description = _T("是否控制氮气开关(调试时可以关闭)");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCtrlN2Air, Description);
pGroup1->AddSubItem(p);
gDevicePropertieMgr.Insert(p, pPropertie);
}
pGroup->AddSubItem(pGroup1);
}
}
{
GroupName = ("设备初始化");
CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("设备初始化"));
if(gAuthorityMgr->CheckAuthority(_Authority_Factory))
{
{
//添加属性变量映射
Name = _T("m_bIniConfirmMsgBox");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bIniConfirmMsgBox);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("初始化msgbox");
Description = _T("是否弹出对话框确认");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniConfirmMsgBox, Description);
pGroup1->AddSubItem(p1);
gDevicePropertieMgr.Insert(p1, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bIniPlatfrom");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bIniPlatfrom);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("初始化平台");
Description = _T("是否初始化XY 电机平台");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniPlatfrom, Description);
pGroup1->AddSubItem(p1);
gDevicePropertieMgr.Insert(p1, pPropertie);
}
{
//添加属性变量映射
Name = _T("m_bIniMotorZ");//变量名字
CPropertie *pPropertie = new CPropertie;
pPropertie->SetpVal((void*)&m_bIniMotorZ);
pPropertie->SetType(_PROP_TYPE_BOOL);
pPropertie->SetpModule(this);
pPropertie->SetPath(Path);
pPropertie->SetName(Name);
pPropertie->WriteRead(true);//读取保存的属性
//添加属性显示
PropertyName = _T("初始化电机Z");
Description = _T("是否初始化电机Z");
pPropertie->SetGroupName(GroupName);
pPropertie->SetShowName(PropertyName);
CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniMotorZ, Description);
pGroup1->AddSubItem(p1);
gDevicePropertieMgr.Insert(p1, pPropertie);
}
pGroup->AddSubItem(pGroup1);
}
}
}
return pGroup;
}
void CCommonFlowMgr::OnAppInitialize()
{
}
void CCommonFlowMgr::Draw(CDC* pDC)
{
//绘制光斑mark 点
DrawLaserSpotPt(pDC);
DrawTestLineVec(pDC);
}
void CCommonFlowMgr::DrawTestLineVec(CDC* pDC)
{
int size = m_CTestLineVec.size();
for(int k=0;k<size;k++)
{
CTestLine &TestLine = m_CTestLineVec[k];
if(k==0)
DrawLine(pDC,gDraw->GetCatchNodePen(),TestLine.m_pt1,TestLine.m_pt2);
else
DrawLine(pDC,gDraw->GetScanLine(),TestLine.m_pt1,TestLine.m_pt2);
}
}
//绘制光斑mark 点
void CCommonFlowMgr::DrawLaserSpotPt(CDC* pDC)
{
if(!m_bLaserSpotMarkMode)
return;
int CenterIdx = 0;
int size = m_LaserSpotPtVec.size();
for(int k=0;k<size;k++)
{
CLaserSpotPt SpotPt = m_LaserSpotPtVec[k];
double w = 0.5;
double h = 4;
DbSize Size;
if(gLaser->IsbScanByDirX())
Size = DbSize(w,h);
else
Size = DbSize(h,w);
DbRect rect(SpotPt.m_Coord,DbSize(h,w));
COLORREF color;
if(SpotPt.m_AdjustZVal==0)
{
color = RGB_RED;
CenterIdx = k;
}
else
{
color = RGB_YELLOW;
}
DrawSolidRect(pDC,color,rect);
//把每个点的Z 轴调整量显示出来
CString str;
str.Format(_T("%.2f"),SpotPt.m_AdjustZVal);
if(gLaser->IsbScanByDirX())
{
SpotPt.m_Coord.x -= 0.5;
SpotPt.m_Coord.y += 3;
}
else
{
SpotPt.m_Coord.x += 3;
}
gDraw->DrawTxt(pDC,str,SpotPt.m_Coord);
int Idx = k+1;
if(CenterIdx>0 && color == RGB_YELLOW)
{
//Idx = (size-k)+(k-CenterIdx);
}
str.Format(_T("%d"),Idx);
if(gLaser->IsbScanByDirX())
SpotPt.m_Coord.y -= 6;
else
SpotPt.m_Coord.x -= 6;
gDraw->DrawTxt(pDC,str,SpotPt.m_Coord);
}
}
#if 1
//检查设备初始化状态
bool CCommonFlowMgr::CheckDeviceInitState()
{
return true;
}
//初始化设备(平台,Z 轴)
bool CCommonFlowMgr::InitDeviceFlow(bool bConfirmMsgBox)
{
return true;
}
#endif
#if 1
//开始加工前的统一工作
bool CCommonFlowMgr::CommWorkStart()
{
//恢复扫描线的颜色
gWaferRecipeDataMgr->SetbScanEnd(false);
//检查是否初始化设备
if(!CheckDeviceInitState())
return false;
//加工记录开始
gWorkRecordMgr->StartRecord();
m_pView->RefreshView();
return true;
}
//结束加工后的统一工作
void CCommonFlowMgr::CommWorkEnd()
{
//结束记录
gWorkRecordMgr->EndRecord();
}
#endif
#if 1
//移动到指定的位置(MotorZCoord 是移动后Z 轴坐标)
bool CCommonFlowMgr::MoveToPos(Dbxy MovePt,Dbxy TargetPt,double MotorZCoord)
{
return true;
}
//当前是否在激光安全位置
bool CCommonFlowMgr::AtLaserSafePlace(Dbxy PlatformCoord)
{
return false;
}
#endif
#if 1
//收集多点移动数据(返回退火所需要的时间)
//ABCDEF点参照笔记里面的原理图
int CCommonFlowMgr::CollectMultiMovePoint()
{
return 1;
}
#endif
#if 1
//关闭激光器的流程
void CCommonFlowMgr::CloseLaserLddFlow()
{
}
#endif
#if 1
//手动步进移动平台
void CCommonFlowMgr::ManualMoveAsixXY(double MoveDis,DIRECTION MoveDir)
{
}
//手动移动Z轴
void CCommonFlowMgr::ManualMoveAsixZ(double dis)
{
}
//载盘上手动取放wafer 的流程(顶针/真空/破空)
void CCommonFlowMgr::ManualCtrlPlatWaferFlow(bool bWaferOn)
{
}
#endif
#if 1
//利用测距仪平面度测量流程
void CCommonFlowMgr::PlanenessMeasureFlow()
{
}
//XY 运动测试流程
void CCommonFlowMgr::XyMoveTestFlow()
{
}
//打开运动测试对象
void CCommonFlowMgr::OpenMoveTestObj()
{
}
//记录坐标
void CCommonFlowMgr::XYMoveSaveCoord()
{
}
//打印运动测试结果
void CCommonFlowMgr::CalXYMoveTestResult(int MeasurePtCnt)
{
}
//初始化结果列表
void CCommonFlowMgr::InitMoveRetList(CListCtrl &List)
{
}
//测量结果插入列表
void CCommonFlowMgr::InsertMoveRetList(CListCtrl &List)
{
}
void CCommonFlowMgr::InsertMoveRetListExt(CListCtrl &List,int Line,int Idx,CMovePtData &MovePtData,X_OR_Y Xy)
{
}
#endif
#if 1
//创建点检准备cmd
void CCommonFlowMgr::CreatPowCheckPrepareCmd(CWorkCmdInvoker &WorkCmdInvoker)
{
}
//激光功率点检流程(不操作激光LDD,双绿光的时候只把另外一路设置为0)
bool CCommonFlowMgr::LaserPowCheckFlow()
{
return true;
}
#endif
#if 1
//创建自动校准的指令流程(bToLaserFocus表示完成后是否回到焦距位置)
void CCommonFlowMgr::CreatAutoFindFocusInvokerCmd(CWorkCmdInvoker &WorkCmdInvoker,bool bToLaserFocus)
{
}
//自动查找Z 轴焦点
void CCommonFlowMgr::AutoFindFocusFlow()
{
}
#endif
#if 1//打光斑功能
void CCommonFlowMgr::SetbLaserSpotMarkMode(bool b)
{
}
//创建光斑数据点
void CCommonFlowMgr::CreatLaserSpotMarkPt()
{
}
//检查数据安全性
bool CCommonFlowMgr::CheckLaserSpotData()
{
return true;
}
//打光斑流程
void CCommonFlowMgr::LaserSpotMarkFlow()
{
}
#endif
#if 1
//单条线段扫描test(用来看光斑找焦距)
void CCommonFlowMgr::OneLineLaserTest()
{
}
//扫描单条线段
void CCommonFlowMgr::OneLineLaserTestExt(Dbxy Pt1,Dbxy Pt2)
{
}
#endif
#if 1
//测试用
void CCommonFlowMgr::CollectMultiPointVecToFile()
{
}
#endif
#if 1
//检测光束质量的流程
bool CCommonFlowMgr::CheckLaserBeamFlow()
{
return true;
}
//移动到功率测量位置的流程(只是移动XYZ)
bool CCommonFlowMgr::MoveToPowMeasureFlow()
{
return true;
}
//通过测功率来判断当前功率密度和recipe 是否匹配
//如果打开自动调整的话,只调整Laser1Curr 的电流值
bool CCommonFlowMgr::CheckRecipeEnergyDensityFlow(double Laser1Curr)
{
return true;
}
#endif
#if 1//新的执行流程
//指令简易的流程
bool CCommonFlowMgr::ExcuteSimpleFlowType(eExcuteFlowType FlowType)
{
return true;
}
#endif
#if 1//job 相关流程
void CCommonFlowMgr::JobQueueCtrlFlow()
{
}
//暂停job cmd 流程
void CCommonFlowMgr::PauseJobQueueCtrlFlow()
{
}
//停止job cmd 流程
void CCommonFlowMgr::StopJobQueueCtrlFlow()
{
}
#endif
#if 1
//手动传输Wafer
bool CCommonFlowMgr::ManualTransferWaferFlow()
{
return true;
}
void CCommonFlowMgr::StartAutomationWorkFlowThread()
{
}
//启动自动生产流程
void CCommonFlowMgr::StartAutomationWorkFlow()
{
}
//停止自动生产流程
void CCommonFlowMgr::StopAutomationWorkFlow()
{
}
#endif

@ -0,0 +1,229 @@
#pragma once
#include "module.h"
#include "WorkCmdContainer.h"
#include "EnumDirection.h"
#include "WorkCmdInvoker.h"
//简易执行指令的流程
enum eExcuteFlowType
{
_ExcuteFlow_Null = 0,
_ExcuteFlow_Foup_LoadMap_Port1,
_ExcuteFlow_Foup_LoadMap_Port2,
_ExcuteFlow_Foup_Unload_Port1,
_ExcuteFlow_Foup_Unload_Port2,
_ExcuteFlow_Manual_Anneal_Start,//启动手动退火
};
//打光斑测试参数
class CLaserSpotMarkPar
{
public:
CLaserSpotMarkPar(void)
{
m_SpotGap = 2;//光斑点的X 方向间隔mm
m_SpotOffsetZ = 0.1;//光斑点的Z 轴间隔mm
m_SpotCntZ = 30;//正向点数
m_SpotCntF = 30;//负向点数
m_SpotMarkDelay = 2;//每个点开光时间ms
};
public:
double m_SpotGap;//光斑点的X 方向间隔mm
double m_SpotOffsetZ;//光斑点的Z 轴间隔mm
int m_SpotCntZ;//正向点数
int m_SpotCntF;//负向点数
int m_SpotMarkDelay;//每个点开光时间s
};
class CLaserSpotPt
{
public:
CLaserSpotPt(void)
{
m_AdjustZVal = 0;//Z轴调整值
};
public:
Dbxy m_Coord;
double m_AdjustZVal;//Z轴调整值
};
//XY 运动测试参数
class CXyMoveTestPar
{
public:
CXyMoveTestPar(void)
{
m_CycleTimes = 10;//循环次数
m_MoveSpeed = 200;// 移动速度X
};
public:
int m_CycleTimes;//循环次数
double m_MoveSpeed;// 移动速度
};
//运动测试移动点的数据
class CMovePtData
{
public:
CMovePtData(void)
{
};
public:
Dbxy m_MaxCoord;//最大值
Dbxy m_MinCoord;//最小值
Dbxy m_AvgCoord;//平均值
vector<Dbxy> m_PtVec;//测量点
};
class CTestLine
{
public:
CTestLine(void)
{
};
public:
Dbxy m_pt1;
Dbxy m_pt2;
};
//管理常用 的流程
class CCommonFlowMgr :public CModule
{
public:
CCommonFlowMgr(void);
~CCommonFlowMgr(void);
virtual CMFCPropertyGridProperty *CreatGridProperty();
virtual MODULE GetModuleType(){return _COMMON_FLOW_PROP;};
virtual void OnAppInitialize();
virtual void Draw(CDC* pDC);
virtual CString GetParDirName();
bool InitDeviceFlow(bool bConfirmMsgBox);
bool IsbConnectObj(){return m_bConnectObj;};
bool IsbShowErrMsg(){return m_bShowErrMsg;};
bool IsbStopWorkMsg(){return m_bStopWorkMsg;};
bool IsbShowStartMsg(){return m_bShowStartMsg;};
void SetErrMsg(CString s){m_ErrMsg = s;};
CString GetErrMsg(){return m_ErrMsg;};
bool MoveToPos(Dbxy MovePt,Dbxy TargetPt,double MotorZCoord);
bool CheckDeviceInitState();
double GetOneLineScanSpeed(){return m_OneLineScanSpeed;};
void SetOneLineScanSpeed(double val){m_OneLineScanSpeed = val;};
void OneLineLaserTest();
bool AtLaserSafePlace(Dbxy PlatformCoord);
void ManualMoveAsixXY(double MoveDis,DIRECTION MoveDir);
void ManualMoveAsixZ(double dis);
CXyMoveTestPar GetCurXyMoveTestPar(){return m_CurXyMoveTestPar;};
void SetCurXyMoveTestPar(CXyMoveTestPar par){m_CurXyMoveTestPar = par;};
void XyMoveTestFlow();
bool IsbXyMoveTesting(){return m_bXyMoveTesting;};
void XYMoveSaveCoord();
void OpenMoveTestObj();
void InitMoveRetList(CListCtrl &List);
void InsertMoveRetList(CListCtrl &List);
bool LaserPowCheckFlow();
CLaserSpotMarkPar GetLaserSpotMarkPar(){return m_LaserSpotMarkPar;};
void SetLaserSpotMarkPar(CLaserSpotMarkPar par){m_LaserSpotMarkPar = par;};
void CreatLaserSpotMarkPt();
void LaserSpotMarkFlow();
void SetbLaserSpotMarkMode(bool b);
bool IsbLaserSpotMarkMode(){return m_bLaserSpotMarkMode;};
bool IsbIniMotorZ(){return m_bIniMotorZ;};
bool IsbIniPlatfrom(){return m_bIniPlatfrom;};
int GetLightAlamTime(){return m_LightAlamTime;};
int CollectMultiMovePoint();
void CollectMultiPointVecToFile();
void PlanenessMeasureFlow();
bool CheckLaserBeamFlow();
bool CheckRecipeEnergyDensityFlow(double Laser1Curr);
bool MoveToPowMeasureFlow();
bool IsbKeepJobN2Air(){return m_bKeepJobN2Air;};
bool ManualTransferWaferFlow();
void JobQueueCtrlFlow();
void PauseJobQueueCtrlFlow();
void StopJobQueueCtrlFlow();
bool ExcuteSimpleFlowType(eExcuteFlowType FlowType);
void AutoFindFocusFlow();
void ManualCtrlPlatWaferFlow(bool bWaferOn);
void CloseLaserLddFlow();
bool IsbAutomationWorking(){return m_bAutomationWorking;};
bool IsbStopAutomationWork(){return m_bStopAutomationWork;};
void StartAutomationWorkFlowThread();
void StartAutomationWorkFlow();
void StopAutomationWorkFlow();
private:
bool CommWorkStart();
void CommWorkEnd();
void CreatAnnealScanCmd(CWorkCmdInvoker &CmdInvoker);
void InsertMoveRetListExt(CListCtrl &List,int line,int Idx,CMovePtData &MovePtData,X_OR_Y Xy);
void OneLineLaserTestExt(Dbxy Pt1,Dbxy Pt2);
void CalXYMoveTestResult(int MeasurePtCnt);
bool LaserPowCheckFlowExt();
void DrawLaserSpotPt(CDC* pDC);
bool CheckLaserSpotData();
void DrawTestLineVec(CDC* pDC);
void CreatAutoFindFocusInvokerCmd(CWorkCmdInvoker &WorkCmdInvoker,bool bToLaserFocus);
void CreatPowCheckPrepareCmd(CWorkCmdInvoker &CmdInvoker);
private:
//共通设定
bool m_bNeedInit;//是否需要初始化才能进行操作
bool m_bShowStartMsg;//在开始加工时是否对话框提示
bool m_bShowErrMsg;//运行时出错后对话框提示
CString m_ErrMsg;//错误信息
bool m_bStopWorkMsg;//点了停止按钮后是否提示对话框
double m_OneLineScanSpeed;//单条扫描线的速度
//初始化相关参数-----------------------------------------------------
bool m_bIniConfirmMsgBox;//是否弹出初始化确认对话框
bool m_bIniPlatfrom;//是否初始化电机平台
bool m_bIniMotorZ;//是否初始化电机Z
bool m_bInitedToProductPt;//初始化完成后是否返回上料点
bool m_bConnectObj;//是否连接多个obj 数据
bool m_bSetLightState;//是否设置警示灯状态
double m_MotorZSafeCoord;//Z 轴的安全坐标位置(保存值)
int m_CurDrawLineCnt;//当前绘制的线段计数器
int m_DrawLineGapCnt;//每间隔几条线绘制一次(保存值)
int m_TransferTestDelay;//传片测试延时ms
int m_OneLineAnnealTimeAdjsut;//单条线段退火时间的调整量ms
CXyMoveTestPar m_CurXyMoveTestPar;//当前的XY 运动测试参数
bool m_bXyMoveTesting;//是否正在XY 移动测试
int m_MoveTestDelay;//移动测试延时ms
vector<Dbxy> m_XyMoveTestVec;//移动测试坐标结果容器
vector<CMovePtData> m_MovePtDataVec;//测量点结果容器
bool m_bLaserSpotMarkMode;//当前是否为打光斑模式
vector<CLaserSpotPt> m_LaserSpotPtVec;//光斑点容器
CLaserSpotMarkPar m_LaserSpotMarkPar;//打光斑的参数
int m_LightAlamTime;//蜂鸣器时间
vector<CTestLine> m_CTestLineVec;
bool m_bKeepJobN2Air;//在job 运行时一直保持吹气
bool m_bCtrlN2Air;//是否控制氮气开关(调试时可以关闭)
bool m_bAutomationWorking;//是否正在自动生产中
bool m_bStopAutomationWork;//停止自动运行
};
extern CCommonFlowMgr *gCommonFlowMgr;

@ -0,0 +1,69 @@
#include "StdAfx.h"
#include "CommonParaMgr.h"
#include "Propertie.h"
#include "PropertieMgr.h"
#include "AuthorityMgr.h"
#include "LogMgr.h"
#include "FileMgr.h"
#include "CStringFuc.h"
#define COMM_PARA_FILE _T("\\CommPar\\CommPara.bin")
CCommonParaMgr *gCommonParaMgr = new CCommonParaMgr;
CCommonParaMgr::CCommonParaMgr(void)
{
}
CCommonParaMgr::~CCommonParaMgr(void)
{
}
//软件打开时
void CCommonParaMgr::OnAppInitialize()
{
//从文件中读取常用参数值
ReadCommonParaFile();
}
//从文件中读取常用参数值
void CCommonParaMgr::ReadCommonParaFile()
{
gLogMgr->WriteDebugLog("Func--->ReadCommonParaFile");
CFileMgr FileMgr;
CString FilePath;
FileMgr.GetFullFilePath(FilePath,COMM_PARA_FILE);//结果文件路径
vector<vector<CString>> StrVec;
FileMgr.ReadFileToStrVec(FilePath,StrVec);
m_CommonParaVec.clear();
int size = StrVec.size();
for(int k=0;k<size;k++)
{
if(StrVec[k].size() == 2)
{
CCommonPara CommonPara;
CommonPara.m_ParaName = StrVec[k][0];//参数的名字
CommonPara.m_ParaVal = CStringToDouble(StrVec[k][1]);//参数的值
m_CommonParaVec.push_back(CommonPara);
CString log;
log = CommonPara.m_ParaName + " : ";
log += StrVec[k][1];
gLogMgr->WriteDebugLog(log);
}
}
}
//通过名字获取参数值
double CCommonParaMgr::GetCommonParaVal(CString ParName)
{
int size = m_CommonParaVec.size();
for(int k=0;k<size;k++)
{
CCommonPara &CommonPara = m_CommonParaVec[k];
if(CommonPara.m_ParaName == ParName)
return CommonPara.m_ParaVal;
}
//没有找到
CString log;
log = "Err---->GetCommonPara : ";
log += ParName;
//gLogMgr->WriteDebugLog(log);
return 0;
}

@ -0,0 +1,34 @@
#pragma once
#include "module.h"
class CCommonPara
{
public:
CCommonPara(void)
{
m_ParaVal = 0;
};
public:
CString m_ParaName;
double m_ParaVal;
};
//常用参数管理
class CCommonParaMgr:public CModule
{
public:
CCommonParaMgr(void);
~CCommonParaMgr(void);
virtual void OnAppInitialize();//软件打开时
double GetCommonParaVal(CString ParName);
private:
void ReadCommonParaFile();
private:
vector<CCommonPara> m_CommonParaVec;
};
extern CCommonParaMgr *gCommonParaMgr;

@ -0,0 +1,28 @@
#include "StdAfx.h"
#include "CriticalSection.h"
//注意在使用临界区时,Unlock 之前不能抛出异常,避免临界区锁死
CCriticalSection gCriticalSection_LaserDevice;//主激光线程临界区
CCriticalSection gCriticalSection_RedLaserDevice;//辅助激光线程临界区
CCriticalSection gCriticalSection_WarningMsg;//报警消息线程临界区
CCriticalSection gCriticalSection_Secs;//Secs 通信线程临界区
CCriticalSection gCriticalSection_TransferArm;//机械手通信线程临界区
CCriticalSection gCriticalSection_PlcComm;//PLC 通信用临界区
CCriticalSection gCriticalSection_CassetteToAligner;//CassetteToAligner 线程临界区
CCriticalSection gCriticalSection_MonitoringOnAnnealProcess;//退火过程监控临界区
CCriticalSection gCriticalSection_WorkCmdInvoker;//用于cmd 临界区
CCriticalSection gCriticalSection_JobQueue;//用于JobQueue 临界区
CCriticalSection gCriticalSection_SendLog;//用于发送日志的临界区
CCriticalSection gCriticalSection_AutomationWork;
CCriticalSection gCriticalSection_TransferWaferInfo;
CCriticalSection gCriticalSection_ViewInvalidate;

@ -0,0 +1,29 @@
#pragma once
extern CCriticalSection gCriticalSection_LaserDevice;//主激光线程临界区
extern CCriticalSection gCriticalSection_RedLaserDevice;//辅助激光线程临界区
extern CCriticalSection gCriticalSection_WarningMsg;//报警消息线程临界区
extern CCriticalSection gCriticalSection_Secs;//Secs 通信线程临界区
extern CCriticalSection gCriticalSection_TransferArm;//机械手通信线程临界区
extern CCriticalSection gCriticalSection_PlcComm;//PLC 通信用临界区
extern CCriticalSection gCriticalSection_CassetteToAligner;//CassetteToAligner 线程临界区
extern CCriticalSection gCriticalSection_MonitoringOnAnnealProcess;//退火过程监控临界区
extern CCriticalSection gCriticalSection_WorkCmdInvoker;//用于cmd 临界区
extern CCriticalSection gCriticalSection_JobQueue;//用于JobQueue 临界区
extern CCriticalSection gCriticalSection_SendLog;//用于发送日志的临界区
extern CCriticalSection gCriticalSection_AutomationWork;
extern CCriticalSection gCriticalSection_TransferWaferInfo;
extern CCriticalSection gCriticalSection_ViewInvalidate;

@ -0,0 +1,100 @@
#include "StdAfx.h"
#include "DataPoint.h"
#include "GlobalDrawMgr.h"
#include "GlobalFunction.h"
CDataPoint::CDataPoint(Dbxy _pt)
{
m_bIsNode = false;//是否为节点
m_pt = _pt;
}
CDataPoint::CDataPoint()
{
m_bIsNode = false;//是否为节点
}
CDataPoint::~CDataPoint(void)
{
}
//返回绘制用的屏幕坐标
CPoint CDataPoint::GetDevicePt()
{
return gDraw->Dbxy2CPoint(m_pt);
}
#if 1
//根据操作类型来分发参数
void CDataPoint::Operate(SObjOperatePar &par)
{
switch(par.OpType)
{
case _OP_MOVE:
Move(par.MoveX,par.MoveY);
break;
case _OP_MIRROR:
Mirror(par.BasePt,par.xy);
break;
case _OP_ROTATO:
Rotato(par.BasePt,_360ToAngle(par.Angle));
break;
case _OP_STRETCH:
Stretch(par.BasePt,par.OldSize,par.Diff,par.xy);
break;
default:
break;
}
}
//移动
void CDataPoint::Move(double MoveX,double MoveY)
{
m_pt.x = m_pt.x+MoveX;
m_pt.y = m_pt.y+MoveY;
}
//拉伸
//BasePt 拉伸基准点
//Size 拉伸前的尺寸
//Diff 是旧尺寸和新尺寸的差
void CDataPoint::Stretch(Dbxy BasePt,double Size,double Diff,X_OR_Y xy)
{
if(Diff == 0)
return;
if(xy == _X)
{
m_pt.x = m_pt.x+Diff*((m_pt.x-BasePt.x)/Size);
}
else
{
m_pt.y = m_pt.y+Diff*((m_pt.y-BasePt.y)/Size);
}
}
//pt 为镜像基准点
void CDataPoint::Mirror(Dbxy pt,X_OR_Y xy)
{
if(xy == _X)
{
m_pt.x = m_pt.x+(pt.x-m_pt.x)*2;
}
else
{
m_pt.y = m_pt.y+(pt.y-m_pt.y)*2;
}
}
//Angle : 弧度角pt : 旋转中心点
void CDataPoint::Rotato(Dbxy pt,double Angle)
{
m_pt = RotatoPt(m_pt,Angle,pt);
}
#endif
bool CDataPoint::Equal(CDataPoint &pt)
{
return pt.GetPt().Equal(m_pt);
}
//判断两条线段是否连续
bool DbLine::IsSerialLine(DbLine &line)
{
if(m_pt1.Equal(line.m_pt1)||m_pt1.Equal(line.m_pt2)
||m_pt2.Equal(line.m_pt1)||m_pt2.Equal(line.m_pt2))
{
return true;
}
return false;
}

@ -0,0 +1,39 @@
#pragma once
#include "GlobalDefine.h"
//数据点的结构类型
class CDataPoint
{
public:
CDataPoint(Dbxy _pt);
CDataPoint(void);
~CDataPoint(void);
Dbxy GetPt(){return m_pt;};
void SetPt(Dbxy pt){m_pt = pt;};
CPoint GetDevicePt();
void Operate(SObjOperatePar &par);
bool IsNode(){return m_bIsNode;};
void SetIsNode(bool bIsNode){m_bIsNode = bIsNode;};
bool Equal(CDataPoint &pt);
private:
void Move(double MoveX,double MoveY);
void Mirror(Dbxy pt,X_OR_Y xy);
void Rotato(Dbxy pt,double Angle);
void Stretch(Dbxy BasePt,double Size,double MaxStep,X_OR_Y xy);
private:
Dbxy m_pt;//坐标值
bool m_bIsNode;//是否为节点
};
class DbLine
{
public:
DbLine(CDataPoint pt1,CDataPoint pt2):m_pt1(pt1),m_pt2(pt2){};
~DbLine(void){};
bool IsSerialLine(DbLine &line);
Dbxy GetPt1(){return m_pt1.GetPt();};
Dbxy GetPt2(){return m_pt2.GetPt();};
public:
CDataPoint m_pt1;
CDataPoint m_pt2;
};

@ -0,0 +1,207 @@
// ArrayDlg.cpp : 实现文件
//
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "DlgArray.h"
#include "afxdialogex.h"
// CDlgArray 对话框
IMPLEMENT_DYNAMIC(CDlgArray, CDialogEx)
CDlgArray::CDlgArray(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgArray::IDD, pParent)
{
}
CDlgArray::~CDlgArray()
{
}
void CDlgArray::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Text(pDX, IDC_ARRAY_CNT_H,m_ArrayPar.m_ArrayCntH);
DDX_Text(pDX, IDC_ARRAY_CNT_V, m_ArrayPar.m_ArrayCntV);
DDX_Text(pDX, IDC_ARRAY_OFFSET_H, m_ArrayPar.m_ArrayOffsetH);
DDX_Text(pDX, IDC_ARRAY_OFFSET_V, m_ArrayPar.m_ArrayOffsetV);
DDX_Text(pDX, IDC_ARRAY_CNT,m_ArrayPar.m_ArrayCnt);
DDX_Text(pDX, IDC_RADIUS, m_ArrayPar.m_Radius);
DDX_Text(pDX, IDC_GAP_ANGLE, m_ArrayPar.m_GapAngle);
DDX_Text(pDX, IDC_FILL_OFFSET, m_ArrayPar.m_FillOffset);
DDX_Text(pDX, IDC_FIIL_CNT, m_ArrayPar.m_FillCnt);
}
BEGIN_MESSAGE_MAP(CDlgArray, CDialogEx)
ON_BN_CLICKED(IDOK,OnBnClickedOk)
ON_BN_CLICKED(IDC_RECT, &CDlgArray::OnBnClickedRect)
ON_BN_CLICKED(IDC_CIRCLE, &CDlgArray::OnBnClickedCircle)
ON_BN_CLICKED(IDC_CIRCLE2, &CDlgArray::OnBnClickedCircle2)
END_MESSAGE_MAP()
BOOL CDlgArray::OnInitDialog()
{
CDialogEx::OnInitDialog();
((CButton *)GetDlgItem(IDC_RECT))->SetCheck(TRUE);
OnBnClickedRect();
UpdateData(FALSE);
return TRUE;
}
void CDlgArray::OnBnClickedRect()
{
m_ArrayPar.m_bRectArray = true;
m_ArrayPar.m_bCircleArray = false;
m_ArrayPar.m_bFillArray = false;
((CButton *)GetDlgItem(IDC_CIRCLE))->SetCheck(FALSE);
((CButton *)GetDlgItem(IDC_CIRCLE2))->SetCheck(FALSE);
CWnd *pWnd;
pWnd = GetDlgItem(IDC_STATIC4);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC5);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC6);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC7);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_ARRAY_CNT_H);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_ARRAY_CNT_V);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC1);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC2);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC3);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_CNT);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_RADIUS);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_GAP_ANGLE);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC8);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC9);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_FILL_OFFSET);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_FIIL_CNT);
pWnd->ShowWindow(SW_HIDE);
}
void CDlgArray::OnBnClickedCircle()
{
m_ArrayPar.m_bRectArray = false;
m_ArrayPar.m_bCircleArray = true;
m_ArrayPar.m_bFillArray = false;
((CButton *)GetDlgItem(IDC_RECT))->SetCheck(FALSE);
((CButton *)GetDlgItem(IDC_CIRCLE2))->SetCheck(FALSE);
CWnd *pWnd;
pWnd = GetDlgItem(IDC_ARRAY_CNT_H);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_CNT_V);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC4);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC5);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC6);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC7);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC1);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC2);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC3);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_ARRAY_CNT);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_RADIUS);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_GAP_ANGLE);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC8);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC9);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_FILL_OFFSET);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_FIIL_CNT);
pWnd->ShowWindow(SW_HIDE);
}
void CDlgArray::OnBnClickedOk()
{
UpdateData(TRUE);
//创建阵列管理对象
CArrayMgr ArrayMgr;
//创建阵列数据
ArrayMgr.Creat(m_ArrayPar);
OnOK();
}
void CDlgArray::OnBnClickedCircle2()
{
m_ArrayPar.m_bRectArray = false;
m_ArrayPar.m_bCircleArray = false;
m_ArrayPar.m_bFillArray = true;
((CButton *)GetDlgItem(IDC_RECT))->SetCheck(FALSE);
((CButton *)GetDlgItem(IDC_CIRCLE))->SetCheck(FALSE);
CWnd *pWnd;
pWnd = GetDlgItem(IDC_ARRAY_CNT_H);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_CNT_V);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC4);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC5);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC6);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC7);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC1);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC2);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC3);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_ARRAY_CNT);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_RADIUS);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_GAP_ANGLE);
pWnd->ShowWindow(SW_HIDE);
pWnd = GetDlgItem(IDC_STATIC8);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_STATIC9);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_FILL_OFFSET);
pWnd->ShowWindow(SW_SHOW);
pWnd = GetDlgItem(IDC_FIIL_CNT);
pWnd->ShowWindow(SW_SHOW);
}

@ -0,0 +1,28 @@
#pragma once
#include "ArrayMgr.h"
// CDlgArray 对话框
class CDlgArray : public CDialogEx
{
DECLARE_DYNAMIC(CDlgArray)
public:
CDlgArray(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgArray();
// 对话框数据
enum { IDD = IDD_ARRAY_DLG };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
afx_msg void OnBnClickedOk();
DECLARE_MESSAGE_MAP()
private:
SArrayPar m_ArrayPar;//阵列参数
public:
afx_msg void OnBnClickedRect();
afx_msg void OnBnClickedCircle();
afx_msg void OnBnClickedCircle2();
};

@ -0,0 +1,112 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "DlgAuthorityAccount.h"
#include "afxdialogex.h"
#include "MsgBox.h"
#include "AuthorityMgr.h"
#include "DlgAuthorityCreatAccount.h"
#include "DlgAuthorityPar.h"
IMPLEMENT_DYNAMIC(CDlgAuthorityAccount, CDialogEx)
CDlgAuthorityAccount::CDlgAuthorityAccount(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgAuthorityAccount::IDD, pParent)
{
m_CurSelIdx = -1;//当前选中索引
}
CDlgAuthorityAccount::~CDlgAuthorityAccount()
{
}
void CDlgAuthorityAccount::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_USER_LIST, m_UserList);
}
BEGIN_MESSAGE_MAP(CDlgAuthorityAccount, CDialogEx)
ON_NOTIFY(NM_CLICK, IDC_USER_LIST, &CDlgAuthorityAccount::OnNMClickUserList)
ON_BN_CLICKED(IDC_DEL_SEL, &CDlgAuthorityAccount::OnBnClickedDelSel)
ON_BN_CLICKED(IDC_CREAT, &CDlgAuthorityAccount::OnBnClickedCreatAccount)
ON_BN_CLICKED(IDC_OPEN_AUTH_PAR_DLG, &CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg)
END_MESSAGE_MAP()
//截获一部分键盘输入
BOOL CDlgAuthorityAccount::PreTranslateMessage(MSG* pMsg)
{
if(pMsg->message==WM_KEYDOWN)
{
char c = pMsg->wParam;
if(c==VK_RETURN || c==VK_ESCAPE)
{
return TRUE;
}
}
return CDialogEx::PreTranslateMessage(pMsg);
}
BOOL CDlgAuthorityAccount::OnInitDialog()
{
CDialogEx::OnInitDialog();
IniUserList();
UpdateUserList();
UpdateData(FALSE);
return TRUE;
}
void CDlgAuthorityAccount::IniUserList()
{
//设置风格
m_UserList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
int idx = 0;
m_UserList.InsertColumn(idx,"类型",LVCFMT_CENTER,120,-1);
idx++;
m_UserList.InsertColumn(idx,"用户名",LVCFMT_CENTER,150,-1);
}
void CDlgAuthorityAccount::UpdateUserList()
{
m_UserList.DeleteAllItems();
gAuthorityMgr->InsertToList(m_UserList);
UpdateData(FALSE);
}
//获取list 当前选择的行号
int CDlgAuthorityAccount::GetCurListIdx(CListCtrl &list)
{
POSITION pos = list.GetFirstSelectedItemPosition();
if (pos == NULL)
{
return -1;
}
else
{
while (pos)
{
int nItem = list.GetNextSelectedItem(pos);
return nItem;
}
}
return -1;
}
void CDlgAuthorityAccount::OnNMClickUserList(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
*pResult = 0;
m_CurSelIdx=GetCurListIdx(m_UserList);
}
void CDlgAuthorityAccount::OnBnClickedDelSel()
{
gAuthorityMgr->DelUser(m_CurSelIdx);
UpdateUserList();
}
void CDlgAuthorityAccount::OnBnClickedCreatAccount()
{
CDlgAuthorityCreatAccount dlg;
dlg.DoModal();
UpdateUserList();
}
void CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg()
{
if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_AuthorityEdit",true))
return;
CDlgAuthorityPar dlg;
dlg.DoModal();
}

@ -0,0 +1,29 @@
#pragma once
//用户管理
class CDlgAuthorityAccount : public CDialogEx
{
DECLARE_DYNAMIC(CDlgAuthorityAccount)
public:
CDlgAuthorityAccount(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgAuthorityAccount();
void IniUserList();
void UpdateUserList();
int GetCurListIdx(CListCtrl &list);
// 对话框数据
enum { IDD = IDD_USER_MGR };
private:
CListCtrl m_UserList;
int m_CurSelIdx;//当前选中索引
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
afx_msg BOOL PreTranslateMessage(MSG* pMsg);
afx_msg void OnNMClickUserList(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedDelSel();
afx_msg void OnBnClickedCreatAccount();
afx_msg void CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg();
};

@ -0,0 +1,93 @@
// DlgCreatAccount.cpp : 实现文件
//
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "DlgAuthorityCreatAccount.h"
#include "afxdialogex.h"
#include "AuthorityMgr.h"
#include "MsgBox.h"
// CDlgAuthorityCreatAccount 对话框
IMPLEMENT_DYNAMIC(CDlgAuthorityCreatAccount, CDialogEx)
CDlgAuthorityCreatAccount::CDlgAuthorityCreatAccount(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgAuthorityCreatAccount::IDD, pParent)
{
}
CDlgAuthorityCreatAccount::~CDlgAuthorityCreatAccount()
{
}
void CDlgAuthorityCreatAccount::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Text(pDX, IDC_NAME, m_Name);
DDX_Text(pDX, IDC_PASSWORD, m_PassWord1);
DDX_Text(pDX, IDC_PASSWORD2, m_PassWord2);
DDX_Control(pDX, IDC_AUTHORITY_COMB, m_AuthorityComb);
}
BEGIN_MESSAGE_MAP(CDlgAuthorityCreatAccount, CDialogEx)
ON_BN_CLICKED(IDOK, &CDlgAuthorityCreatAccount::OnBnClickedOk)
END_MESSAGE_MAP()
// CDlgAuthorityCreatAccount 消息处理程序
BOOL CDlgAuthorityCreatAccount::OnInitDialog()
{
CDialogEx::OnInitDialog();
IniAuthorityComb();
UpdateData(FALSE);
return TRUE;
}
//初始化AuthorityComb
void CDlgAuthorityCreatAccount::IniAuthorityComb()
{
eAuthorityType CurAuthority = gAuthorityMgr->GetCurAuthority();
int idx = 0;
m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Operator));
m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_OperatorAdmin));
m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Engineer));
m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Technics));
if(CurAuthority== _Authority_Factory)
{
m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Factory));
}
m_AuthorityComb.SetCurSel(0);
}
void CDlgAuthorityCreatAccount::OnBnClickedOk()
{
eAuthorityType CurAuthority = gAuthorityMgr->GetCurAuthority();
if(!UpdateData(TRUE))
return;
if(m_Name=="")
{
CMsgBox MsgBox;
MsgBox.Show("用户名不能为空!");
return;
}
if(m_PassWord1=="")
{
CMsgBox MsgBox;
MsgBox.Show("密码不能为空!");
return;
}
if(m_PassWord1 != m_PassWord2)
{
CMsgBox MsgBox;
MsgBox.Show("确认密码不一致!");
return;
}
CAccount Account;
Account.m_Name = m_Name;
Account.m_PassWord = m_PassWord1;
Account.m_Authority = (eAuthorityType)(m_AuthorityComb.GetCurSel()+1);//权限
gAuthorityMgr->AddAccount(Account);
CDialogEx::OnOK();
}

@ -0,0 +1,29 @@
#pragma once
// CDlgAuthorityCreatAccount 对话框
class CDlgAuthorityCreatAccount : public CDialogEx
{
DECLARE_DYNAMIC(CDlgAuthorityCreatAccount)
public:
CDlgAuthorityCreatAccount(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgAuthorityCreatAccount();
// 对话框数据
enum { IDD = IDD_AUTHORITY_CREAT_ACCOUNT };
private:
CString m_Name;
CString m_PassWord1;
CString m_PassWord2;
CComboBox m_AuthorityComb;
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
private:
void IniAuthorityComb();
public:
afx_msg void OnBnClickedOk();
};

@ -0,0 +1,119 @@
// DlgAuthorityMgr->cpp : 实现文件
//
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "DlgAuthorityLogin.h"
#include "afxdialogex.h"
#include "MsgBox.h"
#include "AuthorityMgr.h"
#include "LogMgr.h"
#include "GlobalFunction.h"
IMPLEMENT_DYNAMIC(CDlgAuthorityLogin, CDialogEx)
CDlgAuthorityLogin::CDlgAuthorityLogin(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgAuthorityLogin::IDD, pParent)
{
}
CDlgAuthorityLogin::~CDlgAuthorityLogin()
{
}
void CDlgAuthorityLogin::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Text(pDX, IDC_NAME, m_Name);
DDX_Text(pDX, IDC_PASSWORD, m_PassWord);
DDX_Control(pDX, NEW_LOGIN_BTN, m_LoginBtn);
}
BEGIN_MESSAGE_MAP(CDlgAuthorityLogin, CDialogEx)
ON_WM_PAINT()
ON_BN_CLICKED(NEW_LOGIN_BTN, &CDlgAuthorityLogin::OnBnClickedLogin)
ON_BN_CLICKED(CHILD_SHOW_WINDOW_MIN_BTN, &CDlgAuthorityLogin::OnBnClickedShowWindowMinBtn)
END_MESSAGE_MAP()
//截获一部分键盘输入
BOOL CDlgAuthorityLogin::PreTranslateMessage(MSG* pMsg)
{
if(pMsg->message==WM_KEYDOWN)
{
char c = pMsg->wParam;
if(c==VK_RETURN || c==VK_ESCAPE)
{
return TRUE;
}
}
return CDialogEx::PreTranslateMessage(pMsg);
}
void CDlgAuthorityLogin::OnCancel()
{
return;
//CDialogEx::OnCancel();
}
// CDlgAuthorityCreatAccount 消息处理程序
BOOL CDlgAuthorityLogin::OnInitDialog()
{
CDialogEx::OnInitDialog();
CRect cr;
GetClientRect(&cr);
ClientToScreen(&cr);
//设置对话框的位置
MoveWindow(2 ,0,cr.Width()+20,cr.Height()+20);
m_LoginBtn.SetUpColor(RGB_GREEN);
gAuthorityMgr->Lock();
gAuthorityMgr->SetbLoginDlgOpen(true);
UpdateData(FALSE);
return TRUE;
}
void CDlgAuthorityLogin::OnPaint()
{
{
//
// 给窗体添加背景
//
CPaintDC dc(this);
CRect rc;
GetClientRect(&rc);
CDC dcMem;
dcMem.CreateCompatibleDC(&dc);
CBitmap bmpBackground;
bmpBackground.LoadBitmap(IDB_BTN_IMG123);
BITMAP bitmap;
bmpBackground.GetBitmap(&bitmap);
CBitmap* pOldBitmap = dcMem.SelectObject(&bmpBackground);
dc.StretchBlt(0,0,bitmap.bmWidth,bitmap.bmHeight, &dcMem,0,0,bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
dcMem.SelectObject(pOldBitmap);
VERIFY(dcMem.DeleteDC());
}
}
//登录
void CDlgAuthorityLogin::OnBnClickedLogin()
{
if(!UpdateData(TRUE))
return;
if(gAuthorityMgr->Login(m_Name,m_PassWord))
{
gAuthorityMgr->SetbLoginDlgOpen(false);
OnOK();
}
}
void CDlgAuthorityLogin::OnBnClickedShowWindowMinBtn()
{
gLogMgr->WriteDebugLog("Func---->OnBnClickedShowWindowMinBtn");
GetFrame()->ShowWindowMin();
}

@ -0,0 +1,31 @@
#pragma once
#include "MyBttom.h"
// CDlgAuthorityLogin 对话框
//权限管理
class CDlgAuthorityLogin : public CDialogEx
{
DECLARE_DYNAMIC(CDlgAuthorityLogin)
public:
CDlgAuthorityLogin(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgAuthorityLogin();
virtual void OnCancel();
// 对话框数据
enum { IDD = IDD_AUTHORITY_LOGIN };
private:
CString m_Name;
CString m_PassWord;
CMyBottom m_LoginBtn;
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
afx_msg BOOL PreTranslateMessage(MSG* pMsg);
afx_msg void OnBnClickedLogin();
afx_msg void OnPaint();
afx_msg void OnBnClickedShowWindowMinBtn();
};

@ -0,0 +1,54 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgAuthorityPar.h"
#include "AuthorityMgr.h"
IMPLEMENT_DYNAMIC(CDlgAuthorityPar, CDialogEx)
BEGIN_MESSAGE_MAP(CDlgAuthorityPar, CDialogEx)
ON_BN_CLICKED(IDOK,OnBnClickedOk)
ON_CBN_SELCHANGE(IDC_AUTH_TYPE_COMBO, &CDlgAuthorityPar::OnCbnSelchangeAuthTypeCombo)
END_MESSAGE_MAP()
CDlgAuthorityPar::CDlgAuthorityPar(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgAuthorityPar::IDD, pParent)
{
m_CurAuthorityType = 0;
}
CDlgAuthorityPar::~CDlgAuthorityPar()
{
}
void CDlgAuthorityPar::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, NEW_AUTH_PAR_LIST, m_AuthorityParList);
DDX_Control(pDX, IDC_AUTH_TYPE_COMBO, m_AuthorityTypeCombo);
}
BOOL CDlgAuthorityPar::OnInitDialog()
{
CDialogEx::OnInitDialog();
gAuthorityMgr->InitAuthorityParList(m_AuthorityParList);
gAuthorityMgr->InitAuthorityTypeComb(m_AuthorityTypeCombo);
UpdateData(FALSE);
return TRUE;
}
void CDlgAuthorityPar::OnBnClickedOk()
{
gAuthorityMgr->UpdateAuthorityPar(m_AuthorityParList,m_CurAuthorityType);
gAuthorityMgr->SaveAuthorityParaFile();
OnOK();
}
void CDlgAuthorityPar::OnCbnSelchangeAuthTypeCombo()
{
gAuthorityMgr->UpdateAuthorityPar(m_AuthorityParList,m_CurAuthorityType);
m_CurAuthorityType = m_AuthorityTypeCombo.GetCurSel();
gAuthorityMgr->UpdateAuthorityParList(m_AuthorityParList,m_CurAuthorityType);
}

@ -0,0 +1,24 @@
#pragma once
class CDlgAuthorityPar : public CDialogEx
{
DECLARE_DYNAMIC(CDlgAuthorityPar)
public:
CDlgAuthorityPar(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgAuthorityPar();
// 对话框数据
enum { IDD = IDD_AUTHORITY_PAR_DLG };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
afx_msg void OnBnClickedOk();
DECLARE_MESSAGE_MAP()
private:
CListCtrl m_AuthorityParList;
CComboBox m_AuthorityTypeCombo;
int m_CurAuthorityType;
public:
afx_msg void OnCbnSelchangeAuthTypeCombo();
};

@ -0,0 +1,288 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildAlarmLog.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
#include "ProgramLaserTuiHuo.h"
IMPLEMENT_DYNAMIC(CDlgChildAlarmLog, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildAlarmLog, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildAlarmLog::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildAlarmLog::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildAlarmLog::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildAlarmLog::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildAlarmLog::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 20
CDlgChildAlarmLog::CDlgChildAlarmLog(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildAlarmLog::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildAlarmLog::~CDlgChildAlarmLog()
{
}
void CDlgChildAlarmLog::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildAlarmLog::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildAlarmLog::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildAlarmLog::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\AlarmLog\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildAlarmLog::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\AlarmLog\\");
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildAlarmLog::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildAlarmLog::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildAlarmLog::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildAlarmLog::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildAlarmLog::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildAlarmLog::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildAlarmLog::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildAlarmLog::UpdateDataList(CString FilePath)
{
}
void CDlgChildAlarmLog::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CString log("ReadFile : ");
log += strPath;
gLogMgr->WriteDebugLog(log);
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
*pResult = 0;
}
void CDlgChildAlarmLog::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildAlarmLog::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

@ -0,0 +1,46 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildAlarmLog : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildAlarmLog)
public:
CDlgChildAlarmLog(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildAlarmLog();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_ALARM_LOG };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,289 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildBeamDataHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildBeamDataHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildBeamDataHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildBeamDataHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildBeamDataHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildBeamDataHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildBeamDataHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildBeamDataHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 30
CDlgChildBeamDataHistory::CDlgChildBeamDataHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildBeamDataHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildBeamDataHistory::~CDlgChildBeamDataHistory()
{
}
void CDlgChildBeamDataHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildBeamDataHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildBeamDataHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildBeamDataHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\BeamData\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildBeamDataHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\BeamData\\");
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildBeamDataHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildBeamDataHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildBeamDataHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildBeamDataHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildBeamDataHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildBeamDataHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildBeamDataHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildBeamDataHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildBeamDataHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CString log("ReadFile : ");
log += strPath;
gLogMgr->WriteDebugLog(log);
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
if(strPath.Find(".bmp")!=-1)//图像
{
//用windows的图片查看器打开
PictureWindows(strPath);
}
*pResult = 0;
}
void CDlgChildBeamDataHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildBeamDataHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

@ -0,0 +1,45 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildBeamDataHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildBeamDataHistory)
public:
CDlgChildBeamDataHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildBeamDataHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_BEAM_HISTORY };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,282 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildCheckHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildCheckHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildCheckHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildCheckHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildCheckHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildCheckHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildCheckHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildCheckHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 20
CDlgChildCheckHistory::CDlgChildCheckHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildCheckHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildCheckHistory::~CDlgChildCheckHistory()
{
}
void CDlgChildCheckHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildCheckHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildCheckHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildCheckHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\CheckData\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildCheckHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\CheckData\\");
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildCheckHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildCheckHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildCheckHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildCheckHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildCheckHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildCheckHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildCheckHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildCheckHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildCheckHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
#if 1
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
#endif
}
*pResult = 0;
}
void CDlgChildCheckHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildCheckHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

@ -0,0 +1,45 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildCheckHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildCheckHistory)
public:
CDlgChildCheckHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildCheckHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_CHECK_HISTORY };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,288 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildConfigHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildConfigHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildConfigHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildConfigHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildConfigHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildConfigHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildConfigHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildConfigHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 20
CDlgChildConfigHistory::CDlgChildConfigHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildConfigHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildConfigHistory::~CDlgChildConfigHistory()
{
}
void CDlgChildConfigHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildConfigHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildConfigHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildConfigHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ConfigHistory\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildConfigHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ConfigHistory\\");
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildConfigHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildConfigHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildConfigHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildConfigHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildConfigHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildConfigHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildConfigHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildConfigHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildConfigHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CString log("ReadFile : ");
log += strPath;
gLogMgr->WriteDebugLog(log);
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
if(strPath.Find(".bmp")!=-1)//图像
{
//用windows的图片查看器打开
PictureWindows(strPath);
}
*pResult = 0;
}
void CDlgChildConfigHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildConfigHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

@ -0,0 +1,45 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildConfigHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildConfigHistory)
public:
CDlgChildConfigHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildConfigHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_CONFIG_HISTORY };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,45 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildDataAnalysis.h"
#include "WorkRecord.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildDataAnalysis, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildDataAnalysis, CMyDlgView)
END_MESSAGE_MAP()
CDlgChildDataAnalysis::CDlgChildDataAnalysis(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildDataAnalysis::IDD, pParent)
{
}
CDlgChildDataAnalysis::~CDlgChildDataAnalysis()
{
}
void CDlgChildDataAnalysis::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
}
BOOL CDlgChildDataAnalysis::OnInitDialog()
{
CMyDlgView::OnInitDialog();
UpdateData(FALSE);
return TRUE;
}
//ÏìÓ¦view ´ò¿ªµÄʱºò
void CDlgChildDataAnalysis::OnViewOpen()
{
}

@ -0,0 +1,24 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
class CDlgChildDataAnalysis : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildDataAnalysis)
public:
CDlgChildDataAnalysis(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildDataAnalysis();
virtual void OnViewOpen();//响应view 打开的时候
// 对话框数据
enum { IDD = IDD_CHILD_DATA_ANALYSIS };
private:
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
};

@ -0,0 +1,146 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildEventLog.h"
#include "WorkRecord.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildEventLog, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildEventLog, CMyDlgView)
ON_BN_CLICKED(IDC_CLEAR_LIST_BTN, &CDlgChildEventLog::OnBnClickedClearListBtn)
ON_BN_CLICKED(IDC_OPEN_LOG_DIR_BTN, &CDlgChildEventLog::OnBnClickedOpenLogDirBtn)
ON_CBN_SELCHANGE(IDC_LOG_TYPE_COMBO, &CDlgChildEventLog::OnCbnSelchangeLogTypeCombo)
ON_BN_CLICKED(IDC_STOP_REV_LOG_BTN, &CDlgChildEventLog::OnBnClickedStopRevLogBtn)
END_MESSAGE_MAP()
#define MAX_LOG_LIST_ROWS 1000//最大log 行数
CDlgChildEventLog::CDlgChildEventLog(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildEventLog::IDD, pParent)
{
m_bStopRevLog = false;//暂停接受新的log (不影响log 保存到文件)
}
CDlgChildEventLog::~CDlgChildEventLog()
{
}
void CDlgChildEventLog::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, NEW_REV_LOG_LIST, m_LaipuLaserLogList);
DDX_Control(pDX, NEW_LAIPU_DRAWING_LOG_LIST, m_LaipuDrawingLogList);
DDX_Control(pDX, IDC_LOG_TYPE_COMBO, m_SelLogTypeComb);
}
BOOL CDlgChildEventLog::OnInitDialog()
{
CMyDlgView::OnInitDialog();
InitLogList(m_LaipuLaserLogList);
InitLogList(m_LaipuDrawingLogList);
//初始化SelLogTypeComb
m_SelLogTypeComb.InsertString(0,"LaipuLaser");
m_SelLogTypeComb.InsertString(1,"LaipuDrawing");
m_SelLogTypeComb.SetCurSel(0);
m_CurLogListType = _LogListType_LaipuLaser;
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildEventLog::OnViewOpen()
{
}
//初始化日志列表
void CDlgChildEventLog::InitLogList(CListCtrl &List)
{
//设置风格
List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
int idx = 0;
List.InsertColumn(idx,"LOG",LVCFMT_LEFT,2000,-1);
idx++;
}
CListCtrl &CDlgChildEventLog::GetLogList(eLogListType LogListType)
{
if(LogListType==_LogListType_LaipuLaser)
return m_LaipuLaserLogList;
return m_LaipuDrawingLogList;
}
void CDlgChildEventLog::InsertLogToList(CString &LogStr,eLogListType LogListType)
{
if(!m_bStopRevLog)
{
InsertLogToListExt(LogStr,GetLogList(LogListType));
}
}
//插入一条log
void CDlgChildEventLog::InsertLogToListExt(CString &LogStr,CListCtrl &List)
{
int CurItemCount = List.GetItemCount();//当前的行数
if(CurItemCount>=MAX_LOG_LIST_ROWS)//数量超出则删除第一行
{
List.DeleteItem(0);
CurItemCount--;
}
//新插入一行
int idx = CurItemCount;
List.InsertItem(idx," ");//插入一行
List.SetItemText(idx,0,LogStr);
//显示最后一行
List.EnsureVisible(idx,FALSE);
}
void CDlgChildEventLog::OnBnClickedClearListBtn()
{
CListCtrl &List = GetLogList(m_CurLogListType);
List.DeleteAllItems();
gLogMgr->WriteDebugLog("Func---->OnBnClickedClearListBtn");
}
void CDlgChildEventLog::OnBnClickedOpenLogDirBtn()
{
gLogMgr->WriteDebugLog("Func---->OnBnClickedOpenLogDirBtn");
CString DirPath;
if(m_CurLogListType==_LogListType_LaipuLaser)
DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LogFile\\");
else
DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LogFile_DataMgr\\");
CFileMgr FileMgr;
FileMgr.OpenDir(DirPath);
}
void CDlgChildEventLog::OnCbnSelchangeLogTypeCombo()
{
gLogMgr->WriteDebugLog("Func---->OnCbnSelchangeLogTypeCombo");
int idx = m_SelLogTypeComb.GetCurSel();
if(idx==1)
{
GetDlgItem(NEW_REV_LOG_LIST)->ShowWindow(SW_HIDE);
GetDlgItem(NEW_LAIPU_DRAWING_LOG_LIST)->ShowWindow(SW_SHOW);
m_CurLogListType = _LogListType_LaipuDrawing;
}
else
{
GetDlgItem(NEW_REV_LOG_LIST)->ShowWindow(SW_SHOW);
GetDlgItem(NEW_LAIPU_DRAWING_LOG_LIST)->ShowWindow(SW_HIDE);
m_CurLogListType = _LogListType_LaipuLaser;
}
}
void CDlgChildEventLog::OnBnClickedStopRevLogBtn()
{
gLogMgr->WriteDebugLog("Func---->OnBnClickedStopRevLogBtn");
m_bStopRevLog = !m_bStopRevLog;
if(m_bStopRevLog)
GetDlgItem(IDC_STOP_REV_LOG_BTN)->SetWindowText("开始接收");
else
GetDlgItem(IDC_STOP_REV_LOG_BTN)->SetWindowText("暂停接收");
}

@ -0,0 +1,45 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
enum eLogListType
{
_LogListType_LaipuLaser = 0,
_LogListType_LaipuDrawing,
};
class CDlgChildEventLog : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildEventLog)
public:
CDlgChildEventLog(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildEventLog();
virtual void OnViewOpen();//响应view 打开的时候
void InsertLogToListExt(CString &LogStr,CListCtrl &List);
void InsertLogToList(CString &LogStr,eLogListType LogListType);
void InitLogList(CListCtrl &List);
CListCtrl &GetLogList(eLogListType LogListType);
// 对话框数据
enum { IDD = IDD_CHILD_EVENT_LOG };
private:
CListCtrl m_LaipuLaserLogList;
CListCtrl m_LaipuDrawingLogList;
CComboBox m_SelLogTypeComb;
eLogListType m_CurLogListType;
bool m_bStopRevLog;//暂停接受新的log (不影响log 保存到文件)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
afx_msg void OnBnClickedClearListBtn();
afx_msg void OnBnClickedOpenLogDirBtn();
afx_msg void OnCbnSelchangeLogTypeCombo();
afx_msg void OnBnClickedStopRevLogBtn();
};

@ -0,0 +1,291 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildJobHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildJobHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildJobHistory, CMyDlgView)
ON_BN_CLICKED(IDC_UPDATE_DATA_BTN, &CDlgChildJobHistory::OnBnClickedUpdateDataBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildJobHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildJobHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_EXPORT_BTN, &CDlgChildJobHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildJobHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define DATA_PATH "\\JobHistory\\"
#define Data_List_Item_Cnt 20
CDlgChildJobHistory::CDlgChildJobHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildJobHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildJobHistory::~CDlgChildJobHistory()
{
}
void CDlgChildJobHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildJobHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
#if 1
//响应view 打开的时候
void CDlgChildJobHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedUpdateDataBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildJobHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH);
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildJobHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH);
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildJobHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildJobHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildJobHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildJobHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
void CDlgChildJobHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
//响应节点展开的事件
void CDlgChildJobHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
#endif
#if 1
//更新数据
void CDlgChildJobHistory::OnBnClickedUpdateDataBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
//点击tree 对象
void CDlgChildJobHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CString log("ReadFile : ");
log += strPath;
gLogMgr->WriteDebugLog(log);
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
if(strPath.Find(".bmp")!=-1)//图像
{
//用windows的图片查看器打开
PictureWindows(strPath);
}
*pResult = 0;
}
//导出
void CDlgChildJobHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
//按日期查询
void CDlgChildJobHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
#endif

@ -0,0 +1,44 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildJobHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildJobHistory)
public:
CDlgChildJobHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildJobHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_JOB_HISTORY};
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedUpdateDataBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,285 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildLoginHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildLoginHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildLoginHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildLoginHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildLoginHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildLoginHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildLoginHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildLoginHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 20
CDlgChildLoginHistory::CDlgChildLoginHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildLoginHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildLoginHistory::~CDlgChildLoginHistory()
{
}
void CDlgChildLoginHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildLoginHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildLoginHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildLoginHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LoginRecord\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildLoginHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LoginRecord\\");
CString DateStr;
if(bByMonth)
DateStr = SelDate.Format("%Y\\%m\\");
else
DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildLoginHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildLoginHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildLoginHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildLoginHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildLoginHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildLoginHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildLoginHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildLoginHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildLoginHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
#if 1
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
#endif
}
*pResult = 0;
}
void CDlgChildLoginHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildLoginHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate,true); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

@ -0,0 +1,45 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildLoginHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildLoginHistory)
public:
CDlgChildLoginHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildLoginHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_USER_HISTORY };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByDate();
// 当前选中的日期
COleDateTime m_SelDate;
};

@ -0,0 +1,364 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildParaHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
#include "CStringFuc.h"
IMPLEMENT_DYNAMIC(CDlgChildParaHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildParaHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildParaHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildParaHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildParaHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildParaHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildParaHistory::OnBnClickedSearchByName)
END_MESSAGE_MAP()
#define PARA_MODIFY_DATA_PATH _T("\\ParaModifyRecord\\")
#define Data_List_Item_Cnt 20
CDlgChildParaHistory::CDlgChildParaHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildParaHistory::IDD, pParent)
{
}
CDlgChildParaHistory::~CDlgChildParaHistory()
{
}
void CDlgChildParaHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
}
BOOL CDlgChildParaHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildParaHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildParaHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ParaModifyRecord\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildParaHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ParaModifyRecord\\");
CString DateStr;
if(bByMonth)
DateStr = SelDate.Format("%Y\\%m\\");
else
DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildParaHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildParaHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildParaHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildParaHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildParaHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
//更新
void CDlgChildParaHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildParaHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildParaHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildParaHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
m_DataList.DeleteAllItems();
vector<vector<CString>> StrVec;
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
*pResult = 0;
}
void CDlgChildParaHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
//查找路径下的节点,递归函数
void CDlgChildParaHistory::GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName)
{
COleDateTime SelDateStart;
COleDateTime SelDateEnd = COleDateTime::GetCurrentTime();
CFileMgr FileMgr;
vector<CString> DirPathVec;//子目录路径
FileMgr.GetChildFileOrDirName(true,FindPath,DirPathVec,"");
//没有子目录表示根目录
if(DirPathVec.empty())
{
CString DataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(PARA_MODIFY_DATA_PATH);
int FindPathLen = FindPath.GetLength();
int DataPathLen = DataPath.GetLength();
if(DataPathLen>=FindPathLen)
return;
CString ChildDirName = FindPath.Right(FindPathLen-DataPathLen);//子节点的名称
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
bool bChild2Creat = false;
vector<CString> FilePathVec;//文件路径
FileMgr.GetChildFileOrDirName(false,FindPath,FilePathVec,"xlsx");
int size = FilePathVec.size();
for(int k=0;k<size;k++)
{
CString FileName = FileMgr.GetFileNameFromPath(FilePathVec[k],false);
//按SearchName 筛选
if(SearchName!="" && FileName.Find(SearchName)==-1)
{
continue;
}
if(!bChild2Creat)//创建Child2 节点
{
//按天插入节点
m_tree.InsertItem(ChildDirName, hChild);
if(m_bFirstDir)
{
m_hChild2 = m_tree.GetChildItem(hChild);
m_bFirstDir = false;
}
else
{
m_hChild2 = m_tree.GetNextItem(m_hChild2,TVGN_NEXT);
}
bChild2Creat = true;
}
//插入结果
m_tree.InsertItem(FileName,m_hChild2);
}
}
else//递归调用
{
int size = DirPathVec.size();
for(int k=0;k<size;k++)
{
CString ChildPath = DirPathVec[k]+"\\";
GetDriveDir_ByPath(hParent,ChildPath,SearchName);
}
}
}
void CDlgChildParaHistory::OnBnClickedSearchByName()
{
gLogMgr->WriteDebugLog("Func-->OnBnClickedSearchByName");
CString SearchName;
GetDlgItem(IDC_SEARCH_RECIPE_NAME)->GetWindowText(SearchName);
if(SearchName=="")
return;
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root");//插入根节点
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(PARA_MODIFY_DATA_PATH);
m_tree.InsertItem(path, m_hRoot);//在父节点hParent下添加盘符
m_bFirstDir = true;//第一个目录
GetDriveDir_ByPath(m_hRoot,path,SearchName);//自定义函数 获取驱动子项
//m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
ExpandTree(&m_tree,m_hRoot);//展开树的所有节点
}
void CDlgChildParaHistory::SearchByName(CString SearchName)
{
GetDlgItem(IDC_SEARCH_RECIPE_NAME)->SetWindowText(SearchName);
OnBnClickedSearchByName();
m_bFirstOpen = false;
}

@ -0,0 +1,48 @@
#pragma once
#include "MyDlgView.h"
#include "afxdtctl.h"
#include "ATLComTime.h"
class CDlgChildParaHistory : public CMyDlgView
{
DECLARE_DYNAMIC(CDlgChildParaHistory)
public:
CDlgChildParaHistory(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDlgChildParaHistory();
virtual void OnViewOpen();//响应view 打开的时候
void InitDataList();
void UpdateDataList(CString FilePath);
CString GetDateStr(CTime &DateTime);
void DelAllChildOfItem(HTREEITEM hItem);
// 对话框数据
enum { IDD = IDD_CHILD_RCP_PAR_HISTORY };
private:
CTreeCtrl m_MonitorDataTree;
HTREEITEM m_hRoot; //句柄 CTreeCtrl的根结点
CListCtrl m_DataList;
CString m_CurSelPath;//树中当前选中的文件或文件夹路径
HTREEITEM m_hChild2;//子级节点
bool m_bFirstDir;//第一个目录
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void GetLogicalDrives(HTREEITEM hParent);
void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false);
void GetDriveDir(HTREEITEM hParent);
CString GetFullPath(HTREEITEM hCurrent);
void AddSubDir(HTREEITEM hParent);
void SearchByName(CString SearchName);
void GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName);
afx_msg void OnBnClickedSearchBtn();
afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult);
afx_msg void OnBnClickedExport();
afx_msg void OnBnClickedSearchByName();
};

@ -0,0 +1,296 @@
#include "stdafx.h"
#include "LaiPuLaser.h"
#include "afxdialogex.h"
#include "DlgChildRealTimeDataHistory.h"
#include "GlobalFunction.h"
#include "LogMgr.h"
#include "FileMgr.h"
IMPLEMENT_DYNAMIC(CDlgChildRealTimeDataHistory, CMyDlgView)
BEGIN_MESSAGE_MAP(CDlgChildRealTimeDataHistory, CMyDlgView)
ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildRealTimeDataHistory::OnBnClickedSearchBtn)
ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildRealTimeDataHistory::OnTvnItemexpandedDataFoldeTree)
ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildRealTimeDataHistory::OnTvnSelchangedDataFoldeTree)
ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildRealTimeDataHistory::OnBnClickedExport)
ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildRealTimeDataHistory::OnBnClickedSearchByDate)
END_MESSAGE_MAP()
#define Data_List_Item_Cnt 60
CDlgChildRealTimeDataHistory::CDlgChildRealTimeDataHistory(CWnd* pParent /*=NULL*/)
: CMyDlgView(CDlgChildRealTimeDataHistory::IDD, pParent)
, m_SelDate(COleDateTime::GetCurrentTime())
{
}
CDlgChildRealTimeDataHistory::~CDlgChildRealTimeDataHistory()
{
}
void CDlgChildRealTimeDataHistory::DoDataExchange(CDataExchange* pDX)
{
CMyDlgView::DoDataExchange(pDX);
DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree);
DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList);
DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate);
}
BOOL CDlgChildRealTimeDataHistory::OnInitDialog()
{
CMyDlgView::OnInitDialog();
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS);
InitDataList();
UpdateData(FALSE);
return TRUE;
}
//响应view 打开的时候
void CDlgChildRealTimeDataHistory::OnViewOpen()
{
if(m_bFirstOpen)
{
OnBnClickedSearchBtn();
m_bFirstOpen = false;
}
}
//函数功能:获取驱动器 参数:路径名
void CDlgChildRealTimeDataHistory::GetLogicalDrives(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\RealTimeData\\");
m_tree.InsertItem(path,hParent); //在父节点hParent下添加盘符
}
void CDlgChildRealTimeDataHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\RealTimeData\\");
CString DateStr = SelDate.Format("%Y\\%m\\%d\\");
m_tree.InsertItem(path+ DateStr, hParent); //在父节点hParent下添加盘符
}
//函数功能:获取驱动盘符下所有子项文件夹
void CDlgChildRealTimeDataHistory::GetDriveDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
HTREEITEM hChild = m_tree.GetChildItem(hParent); //获取指定位置中的子项
while(hChild)
{
CString strText = m_tree.GetItemText(hChild); //检索列表中项目文字
if(strText.Right(1) != "\\") //从右边1开始获取从右向左nCount个字符
strText += _T("\\");
strText += "*.*";
//将当前目录下文件枚举并InsertItem树状显示
CFileFind file; //定义本地文件查找
BOOL bContinue = file.FindFile(strText); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
if(file.IsDirectory() && !file.IsDots()) //找到文件为内容且不为点"."
{
m_tree.InsertItem(file.GetFileName(),hChild); //添加盘符路径下树状文件夹
}
}
GetDriveDir(hChild); //递归调用
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
}
//函数功能:获取树项目全根路径
CString CDlgChildRealTimeDataHistory::GetFullPath(HTREEITEM hCurrent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strTemp;
CString strReturn = "";
while(hCurrent != m_hRoot)
{
strTemp = m_tree.GetItemText(hCurrent); //检索列表中项目文字
if(strTemp.Right(1) != "\\")
strTemp += "\\";
strReturn = strTemp + strReturn;
hCurrent = m_tree.GetParentItem(hCurrent); //返回父项目句柄
}
return strReturn;
}
//函数功能:添加子目录
void CDlgChildRealTimeDataHistory::AddSubDir(HTREEITEM hParent)
{
CTreeCtrl &m_tree = m_MonitorDataTree;
CString strPath = GetFullPath(hParent); //获取全路径
if(strPath.Find("xlsx")!=-1)
{
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
return;
}
if(strPath.Right(1) != "\\")
strPath += "\\";
strPath += "*.*";
CFileFind file;
BOOL bContinue = file.FindFile(strPath); //查找包含字符串的文件
while(bContinue)
{
bContinue = file.FindNextFile(); //查找下一个文件
//if(file.IsDirectory() && !file.IsDots())
if(!file.IsDots())
{
m_tree.InsertItem(file.GetFileName(),hParent);
}
}
}
//删除hItem 所有子节点
void CDlgChildRealTimeDataHistory::DelAllChildOfItem(HTREEITEM hItem)
{
CTreeCtrl &m_Tree = m_MonitorDataTree;
{
HTREEITEM hNextItem=NULL;
HTREEITEM hChildItem=m_Tree.GetChildItem(hItem);
while (hChildItem!=NULL)
{
hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT);
m_Tree.DeleteItem(hChildItem);
hChildItem=hNextItem;
}
}
}
//响应节点展开的事件
void CDlgChildRealTimeDataHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
CTreeCtrl &m_tree = m_MonitorDataTree;
TVITEM item = pNMTreeView->itemNew; //发送\接受关于树形视图项目信息
if(item.hItem == m_hRoot)
return;
//获取item.hItem 的第一个ChildItem
HTREEITEM hChild = m_tree.GetChildItem(item.hItem);
//删除当前的子节点(这样就能保持点开的时候是最新状态)
if(m_tree.ItemHasChildren(hChild))
return;
//插入子节点
while(hChild)
{
AddSubDir(hChild); //添加子目录
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //获取树形控件TVGN_NEXT下兄弟项
}
*pResult = 0;
}
void CDlgChildRealTimeDataHistory::OnBnClickedSearchBtn()
{
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot,TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}
void CDlgChildRealTimeDataHistory::InitDataList()
{
//设置风格
m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//设置列
//m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1);
CString s;
for(int k=0;k<Data_List_Item_Cnt;k++)
{
s.Format("Col%d",k+1);
m_DataList.InsertColumn(k,s,LVCFMT_CENTER,150,-1);
}
}
void CDlgChildRealTimeDataHistory::UpdateDataList(CString FilePath)
{
}
void CDlgChildRealTimeDataHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
// NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
TVITEM item = pNMTreeView->itemNew;
if(item.hItem == m_hRoot)
return;
CString strPath = GetFullPath(item.hItem);
int len = strPath.GetLength();
strPath.Delete(len-1,1);//删除最后一个'\'
gLogMgr->WriteDebugLog(strPath);
m_CurSelPath = strPath;
if(strPath.Find("xlsx")!=-1)
{
//删除所有的列
m_DataList.DeleteAllItems();
while (m_DataList.DeleteColumn(0));
vector<vector<CString>> StrVec;
CString log("ReadFile : ");
log += strPath;
gLogMgr->WriteDebugLog(log);
CFileMgr FileMgr;
FileMgr.ReadFileToStrVec(strPath,StrVec,true);
int size = StrVec.size();
for(int k=0;k<size;k++)
{
int size1 = StrVec[k].size();
m_DataList.InsertItem(k," ");//插入一行
if(k==0)//把第一行的名称写到列名上
{
CString s;
for(int i=0;(i<Data_List_Item_Cnt)&&(i<size1);i++)
{
m_DataList.InsertColumn(i,StrVec[k][i],LVCFMT_CENTER,150,-1);
}
}
for(int i=0;i<size1;i++)
{
if(i>=Data_List_Item_Cnt)
break;
m_DataList.SetItemText(k,i,StrVec[k][i]);//序号
}
}
}
*pResult = 0;
}
void CDlgChildRealTimeDataHistory::OnBnClickedExport()
{
CFileMgr FileMgr;
bool bFile = m_CurSelPath.Find(".xlsx") > 0;
CString destDir;
if (bFile)
{
CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("表格文件(*.xlsx)|*.xlsx"));
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
else
{
CFolderPickerDialog dlg(NULL, 0, this, 0);
if (dlg.DoModal() == IDOK)
{
destDir = dlg.GetPathName();
FileMgr.CopyDirOrFile(m_CurSelPath, destDir);
}
}
}
void CDlgChildRealTimeDataHistory::OnBnClickedSearchByDate()
{
UpdateData(TRUE);
CTreeCtrl &m_tree = m_MonitorDataTree;
m_tree.DeleteItem(m_hRoot);//全部删除
m_hRoot = m_tree.InsertItem("root"); //插入根节点
GetLogicalDrives(m_hRoot,m_SelDate); //自定义函数 获取驱动
GetDriveDir(m_hRoot); //自定义函数 获取驱动子项
m_tree.Expand(m_hRoot, TVE_EXPAND); //展开或折叠子项列表 TVE_EXPAND展开列表
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save