changeformatdlg.cpp

自己写的文件对话框操作程序

void CChangeFormatDlg::ReleaseFile(CFile* pFile, BOOL bAbort)
{
	ASSERT_KINDOF(CFile, pFile);
	if (bAbort)
		pFile->Abort(); // will not throw an exception
	else
		pFile->Close();
	delete pFile;
}

void CChangeFormatDlg::ReportSaveLoadException(LPCTSTR lpszPathName,
	CException* e, BOOL bSaving, UINT nIDPDefault)
{
	UINT nIDP = nIDPDefault;
	UINT nHelpContext = nIDPDefault;
	CString prompt;

	if (e != NULL)
	{
		ASSERT_VALID(e);
		if (e->IsKindOf(RUNTIME_CLASS(CUserException)))
			return; // already reported
		
		if (e->IsKindOf(RUNTIME_CLASS(CArchiveException)))
		{
			switch (((CArchiveException*)e)->m_cause)
			{
			case CArchiveException::badSchema:
			case CArchiveException::badClass:
			case CArchiveException::badIndex:
			case CArchiveException::endOfFile:
				nIDP = AFX_IDP_FAILED_INVALID_FORMAT;
				break;
			default:
				break;
			}
		}
		else if (e->IsKindOf(RUNTIME_CLASS(CFileException)))
		{
			TRACE1("Reporting file I/O exception on Save/Load with lOsError = $%lX.\n",
				((CFileException*)e)->m_lOsError);
			
			CFileException* pFileException = (CFileException*)e;
			if (pFileException->m_strFileName.IsEmpty())
				pFileException->m_strFileName = lpszPathName;
			
			LPTSTR lpszMessage = prompt.GetBuffer(255);
			ASSERT(lpszMessage != NULL);
			if (!e->GetErrorMessage(lpszMessage, 256, &nHelpContext))
			{
				switch (((CFileException*)e)->m_cause)
				{
				case CFileException::fileNotFound:
				case CFileException::badPath:
					nIDP = AFX_IDP_FAILED_INVALID_PATH;
					break;
				case CFileException::diskFull:
					nIDP = AFX_IDP_FAILED_DISK_FULL;
					break;
				case CFileException::accessDenied:
					nIDP = bSaving ? AFX_IDP_FAILED_ACCESS_WRITE :
					AFX_IDP_FAILED_ACCESS_READ;
					break;
					
				case CFileException::badSeek:
				case CFileException::generic:
				case CFileException::tooManyOpenFiles:
				case CFileException::invalidFile:
				case CFileException::hardIO:
				case CFileException::directoryFull:
					break;
					
				default:
					break;
				}
			}
			prompt.ReleaseBuffer();
		}
	}
	
	if (prompt.IsEmpty())
	{
		TCHAR szTitle[_MAX_PATH];
/*		if (afxData.bMarked4)*/
			GetFileTitle(lpszPathName, szTitle, _MAX_PATH);
// 在 Windows   3.x   上运行时使用下面的代码
// 		else
// 			lstrcpyn(szTitle, lpszPathName, _countof(szTitle));
		AfxFormatString1(prompt, nIDP, szTitle);
	}

	prompt += _T("请检查文档格式是否正确！");
	
	AfxMessageBox(prompt, MB_ICONEXCLAMATION, nHelpContext);
}

void CChangeFormatDlg::SetPathName(LPCTSTR lpszPathName)
{
	// store the path fully qualified
	TCHAR szFullPath[_MAX_PATH];
	strcpy(szFullPath, lpszPathName);
	CString strPathName = szFullPath;
	
	// add it to the file MRU list
	AfxGetApp()->AddToRecentFileList(strPathName);
}

void CChangeFormatDlg::SetModifiedFlag(BOOL bModified)
{
	ASSERT(this != NULL);
	m_bModified = bModified;
}

void CChangeFormatDlg::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		m_pMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
		CString spr = "天津港东";
		ar.WriteString(spr);
		ar.WriteString("\n");
		CString m_curTime;
		CTime curTime = CTime::GetCurrentTime();
		m_curTime = curTime.Format("%d/%m/%y %H:%M:%S");
		ar.WriteString(m_curTime);
		ar.WriteString("\n");
		ar.WriteString("\n");
	}


	// 比较文件类型
	if (m_szExt.CompareNoCase(_T(".spw")) == 0)
	{
		WL_Serialize(ar);
	}
	else if (m_szExt.CompareNoCase(_T(".stm")) == 0)
	{
		TE_Serialize(ar);
	}
	else if (m_szExt.CompareNoCase(_T(".sph")) == 0)
	{
		PH_Serialize(ar);
	}
	else if (m_szExt.CompareNoCase(_T(".spd")) == 0)
	{
		TD_Serialize(ar);
	}

	if (ar.IsStoring())
	{
		m_pMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_ENABLED);
	}
}

void CChangeFormatDlg::WL_Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		CString m_curOperator, m_curdComment;
		m_curOperator.Empty();
		m_curdComment.Empty();

		ar << m_curOperator;	
		ar << m_curdComment; 
		
		ar << m_Channal.strTitle;
		ar << m_Channal.nFlag;
        ar << m_Channal.nScanMode;
		ar << m_Channal.mDataMode;
		ar << m_Channal.dStartWL;
		ar << m_Channal.dEndWL;
		ar << m_Channal.dComment;
		ar << m_Channal.nScanSpeed;
		ar << m_Channal.nDelay;
		ar << m_Channal.nResponce;
		ar << m_Channal.nExSlit;
		ar << m_Channal.nEmSlit;
		ar << m_Channal.nFute;
		ar << m_Channal.dShutter;
		ar << m_Channal.dExwl;
		ar << m_Channal.nData.size(); 
		
		for (int j = 0; j < m_Channal.nData.size(); j++)
		{
			ar << m_Channal.nData[j].fX << m_Channal.nData[j].fY;
		}
	}
	else
	{
		ar >> m_Channal.strTitle;
		ar >> m_Channal.nFlag;
        ar >> m_Channal.nScanMode;
		//int sdf = 0;
		//ar >> sdf;
		//m_Channal.mDataMode = "ddd";
		ar >> m_Channal.mDataMode;//数据改变原数据不能用 若用许将此项改为int 型
		ar >> m_Channal.dStartWL;
		ar >> m_Channal.dEndWL;
		ar >> m_Channal.dComment;
		ar >> m_Channal.nScanSpeed;
		ar >> m_Channal.nDelay;
		ar >> m_Channal.nResponce;
		ar >> m_Channal.nExSlit;
		ar >> m_Channal.nEmSlit;
		ar >> m_Channal.nFute;
		ar >> m_Channal.dShutter;
		ar >> m_Channal.dExwl;
		int nCount;
		ar >> nCount;
 		m_Channal.nData.resize(nCount);
		
		for (int j = 0; j < nCount; j++)
		{
			ar >> m_Channal.nData[j].fX >> m_Channal.nData[j].fY;
			double sdfsdf = m_Channal.nData[j].fX;
			double fdfdf = m_Channal.nData[j].fY;
		}
	}
}

void CChangeFormatDlg::TE_Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		CString m_curOperator, m_curdComment;
		m_curOperator.Empty();
		m_curdComment.Empty();
		
		ar << m_curOperator;	
		ar << m_curdComment; 

		ar << m_Channal.strTitle;
		ar << m_Channal.nFlag;
		ar << m_Channal.nScanMode;
		ar << m_Channal.mDataMode;
		ar << m_Channal.dStartWL;
		ar << m_Channal.dEndWL;
		ar << m_Channal.dComment;
		ar << m_Channal.nScanSpeed;
		ar << m_Channal.nDelay;
		ar << m_Channal.nExSlit;
		ar << m_Channal.nEmSlit;
		ar << m_Channal.nFute;
		ar << m_Channal.nResponce;
		ar << m_Channal.dPrecision;
		ar << m_Channal.dExwl;
		ar << m_Channal.dActivity;
		ar << m_Channal.nCount;
		for (int j = 0; j < m_Channal.nCount; j++)
		{
			ar << m_Channal.nData[j].fX << m_Channal.nData[j].fY;
		}
	}
	else
	{
		ar >> m_Channal.strTitle;
		ar >> m_Channal.nFlag;
		ar >> m_Channal.nScanMode;
		//int sdfsdf = 0;
		//ar >> sdfsdf; //合并时需改进 扫描模式定义类型有变所以打开以前的数据有问题
		ar >> m_Channal.mDataMode;
		//m_Channal.mDataMode = "gg";
		ar >> m_Channal.dStartWL;
		ar >> m_Channal.dEndWL;
		ar >> m_Channal.dComment;
		ar >> m_Channal.nScanSpeed;
		ar >> m_Channal.nDelay;
		ar >> m_Channal.nExSlit;
		ar >> m_Channal.nEmSlit;
		ar >> m_Channal.nFute;
		ar >> m_Channal.nResponce;
		ar >> m_Channal.dPrecision;
		ar >> m_Channal.dExwl;
		ar >> m_Channal.dActivity;
		ar >> m_Channal.nCount;
		m_Channal.nData.resize(m_Channal.nCount);
		
		for (int j = 0; j < m_Channal.nCount; j++)
		{
			ar >> m_Channal.nData[j].fX >> m_Channal.nData[j].fY;
		}
	}
}

void CChangeFormatDlg::PH_Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		ar << m_PH_Channal.ColumType;
		ar << m_PH_Channal.StandardGudingEX;
		ar << m_PH_Channal.StandardGudingEM;
        ar << m_PH_Channal.m_nthroghZero;
		ar << m_PH_Channal.m_dK1;
		ar << m_PH_Channal.m_dK2;
		ar << m_PH_Channal.m_dK3;
		ar << m_PH_Channal.m_dK4;
        ar << 20;//m_PH_Channal.nStandardrealCount;
		
		for (int j = 0;j < 20/*m_PH_Channal.nStandardrealCount*/;j++)
		{
			ar << m_PH_Channal.m_dINCStandardSampleCal[j];			
			ar << m_PH_Channal.m_dINCStandardSampleEnergy[j];		
			ar << m_PH_Channal.nStandardHasbeenTest[j];
		}
		
		ar << m_PH_Channal.nCurView;
        ar << m_PH_Channal.TestType;
		ar << m_PH_Channal.TestMethod;
        ar << m_PH_Channal.nStandardCount;
		ar << m_PH_Channal.nSampleTestCount;
		ar << m_PH_Channal.TestMethodType;


		CString m_curOperator, m_curdComment;
		m_curOperator.Empty();
		m_curdComment.Empty();
		
		ar << m_curOperator;	
		ar << m_curdComment; 
		for (int i = 0;i<6;i++)
		{
			ar << m_PH_Channal.StandardTestEX[i];
			ar << m_PH_Channal.StandardTestEM[i];
		}
		for (i = 0;i < m_PH_Channal.nStandardCount;i++)
		{
			ar << m_PH_Channal.nStandardChannal[i].dTestnum;
			ar << m_PH_Channal.nStandardChannal[i].dTestConc; 
			ar << m_PH_Channal.nStandardChannal[i].strTitle;
			ar << m_PH_Channal.nStandardChannal[i].SampleComment;
			ar << m_PH_Channal.nStandardChannal[i].nCount;
			for (int j =0;j < m_PH_Channal.nStandardChannal[i].nCount;j++)
			{
				ar << m_PH_Channal.nStandardChannal[i].m_vecSamplePoint[j].dX;
			}
		}
		for (i =0;i < m_PH_Channal.nSampleTestCount;i++)
		{
			ar << m_PH_Channal.nSampleChannal[i].dTestnum;
			ar << m_PH_Channal.nSampleChannal[i].dTestConc; 
			ar << m_PH_Channal.nSampleChannal[i].strTitle;
			ar << m_PH_Channal.nSampleChannal[i].SampleComment;
			ar << m_PH_Channal.nSampleChannal[i].nCount;
			for (int j =0;j < m_PH_Channal.nSampleChannal[i].nCount;j++)
			{
				ar << m_PH_Channal.nSampleChannal[i].m_vecSamplePoint[j].dX;
			}
		}
	}
	else
	{
		ar >> m_PH_Channal.ColumType;
		ar >> m_PH_Channal.StandardGudingEX;
		ar >> m_PH_Channal.StandardGudingEM;
        ar >> m_PH_Channal.m_nthroghZero;
		for (int j = 0;j < 20;j++)
		{
			ar >> m_PH_Channal.m_dINCStandardSampleCal[j];			
			ar >> m_PH_Channal.m_dINCStandardSampleEnergy[j];		
			ar >> m_PH_Channal.nStandardHasbeenTest[j];
		}
		
		ar >> m_PH_Channal.nCurView;
		ar >> m_PH_Channal.TestType;
		ar >> m_PH_Channal.TestMethod;
        ar >> m_PH_Channal.nStandardCount;
		ar >> m_PH_Channal.nSampleTestCount;
		ar >> m_PH_Channal.TestMethodType;
		for (int i = 0;i<6;i++)
		{
			ar >> m_PH_Channal.StandardTestEX[i];
			ar >> m_PH_Channal.StandardTestEM[i];
		}
		
		for (i = 0;i < m_PH_Channal.nStandardCount;i++)
		{
			ar >> m_PH_Channal.nStandardChannal[i].dTestnum;
			ar >> m_PH_Channal.nStandardChannal[i].dTestConc; 
			ar >> m_PH_Channal.nStandardChannal[i].strTitle;
			ar >> m_PH_Channal.nStandardChannal[i].SampleComment;
			ar >> m_PH_Channal.nStandardChannal[i].nCount;
            m_PH_Channal.nStandardChannal[i].m_vecSamplePoint.resize(m_PH_Channal.nStandardChannal[i].nCount);
			for (int j =0;j < m_PH_Channal.nStandardChannal[i].nCount;j++)
			{
				ar >> m_PH_Channal.nStandardChannal[i].m_vecSamplePoint[j].dX;
			}
			
		}
		for ( i =0;i < m_PH_Channal.nSampleTestCount;i++)
		{
			ar >> m_PH_Channal.nSampleChannal[i].dTestnum;
			ar >> m_PH_Channal.nSampleChannal[i].dTestConc; 
			ar >> m_PH_Channal.nSampleChannal[i].strTitle;
			ar >> m_PH_Channal.nSampleChannal[i].SampleComment;
			ar >> m_PH_Channal.nSampleChannal[i].nCount;
            m_PH_Channal.nSampleChannal[i].m_vecSamplePoint.resize(m_PH_Channal.nSampleChannal[i].nCount);
			for (int j =0;j < m_PH_Channal.nSampleChannal[i].nCount;j++)
			{
				ar >> m_PH_Channal.nSampleChannal[i].m_vecSamplePoint[j].dX;
			}
		}
	}
}

void CChangeFormatDlg::TD_Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		ar << m_TD_Channal.m_3DEX_Start_WL;			
		ar << m_TD_Channal.m_3DEX_End_WL;			
		ar << m_TD_Channal.m_3DEX_Interval_WL;	
		ar << m_TD_Channal.m_3DEM_inter; 
		ar << m_TD_Channal.m_3DEM_Start_WL;		
		ar << m_TD_Channal.m_3DEM_End_WL;			
		ar << m_TD_Channal.m_3DEM_Interval_WL;
		ar << m_TD_Channal.m_3DNumPerNM;
		ar << m_TD_Channal.m_3DRealCurveNum;
		
		for (int j = 0;j<m_TD_Channal.m_3DRealCurveNum;j++)
		{
			ar << m_TD_Channal.m_3DPointNum[j];
		}
		
        for (int i = 0;i<m_TD_Channal.m_3DRealCurveNum;i++)
        {
			for (int j = 0;j<m_TD_Channal.m_3DPointNum[i];j++)
			{
				double TempZ = m_TD_Channal.m_p3DData[i][j];
				ar << TempZ;
			}
        }
		
		ar << m_TD_Channal.spectraname;  
		ar << m_TD_Channal.Oper;
		ar << m_TD_Channal.Comment;           
		ar << m_TD_Channal.Instrument;       
		ar << m_TD_Channal.Measurement;       
		ar << m_TD_Channal.speed;            
		ar << m_TD_Channal.EX_Slit;            
		ar << m_TD_Channal.EM_Slit;             
		ar << m_TD_Channal.Voltage;           
		ar << m_TD_Channal.spectra_correct;     
	    ar << m_TD_Channal.shutter;
	}
	else
	{

		if (m_TD_Channal.m_3DPointNum != NULL)
		{
			delete [] (m_TD_Channal.m_3DPointNum);
			m_TD_Channal.m_3DPointNum = NULL;
		}

		if (m_TD_Channal.m_p3DData != NULL)
		{
			for (int i = 0;i < m_TD_Channal.m_3DRealCurveNum;i++)
			{
				delete [] (m_TD_Channal.m_p3DData[i]);
				m_TD_Channal.m_p3DData[i] = NULL;
			}
			delete [] m_TD_Channal.m_p3DData;
			m_TD_Channal.m_p3DData = NULL;
		}

		ar >> m_TD_Channal.m_3DEX_Start_WL;			
		ar >> m_TD_Channal.m_3DEX_End_WL;			
		ar >> m_TD_Channal.m_3DEX_Interval_WL;		
		
		ar >> m_TD_Channal.m_3DEM_inter;  
		ar >> m_TD_Channal.m_3DEM_Start_WL;			
		ar >> m_TD_Channal.m_3DEM_End_WL;			
		ar >> m_TD_Channal.m_3DEM_Interval_WL;		
		
		ar >> m_TD_Channal.m_3DNumPerNM;
		ar >> m_TD_Channal.m_3DRealCurveNum;
        m_TD_Channal.m_3DPointNum = new int[m_TD_Channal.m_3DRealCurveNum];
		for (int i = 0;i<m_TD_Channal.m_3DRealCurveNum;i++)
		{
			ar >> m_TD_Channal.m_3DPointNum[i];
		}
		m_TD_Channal.exnum = m_TD_Channal.m_3DRealCurveNum;
		m_TD_Channal.emnum = (m_TD_Channal.m_3DEM_End_WL - m_TD_Channal.m_3DEM_Start_WL)/m_TD_Channal.m_3DEM_inter + 1;
		
		m_TD_Channal.m_p3DData = new double*[m_TD_Channal.m_3DRealCurveNum];
        for (i = 0;i<m_TD_Channal.m_3DRealCurveNum;i++)
        {
			m_TD_Channal.m_p3DData[i] = new double[m_TD_Channal.emnum];
		}
		for (i = 0;i < m_TD_Channal.m_3DRealCurveNum;i++)
		{
			for (int j = 0;j < m_TD_Channal.emnum;j++)
			{
				m_TD_Channal.m_p3DData[i][j] = 0.0;
			}
		}
		
		for ( i = 0;i<m_TD_Channal.m_3DRealCurveNum;i++)
        {
			for (int j = 0;j<m_TD_Channal.m_3DPointNum[i];j++)
			{
				double TempZ;
				ar >> TempZ;
				m_TD_Channal.m_p3DData[i][j] = TempZ;
				
			}
        }
		m_TD_Channal.exwl = m_TD_Channal.m_3DEX_Start_WL;
		m_TD_Channal.emwl = m_TD_Channal.m_3DEM_Start_WL;
		ar >> m_TD_Channal.spectraname;  
		ar >> m_TD_Channal.Oper;
		ar >> m_TD_Channal.Comment;           
		ar >> m_TD_Channal.Instrument;       
		ar >> m_TD_Channal.Measurement;       
		ar >> m_TD_Channal.speed;            
		ar >> m_TD_Channal.EX_Slit;            
		ar >> m_TD_Channal.EM_Slit;             
		ar >> m_TD_Channal.Voltage;           
		ar >> m_TD_Channal.spectra_correct;     
	    ar >> m_TD_Channal.shutter;   
	}
}