logplus/DataMgr/src/DataManagger.cpp

#include <QFileDialog>
#include <QScrollBar>
#include <qformlayout.h>
#include <QInputDialog>
#include <QListWidget>
#include <QCompleter>
#include <qtablewidget.h>
//#include "io.h"
#include <QMessageBox>
#include "DataManagger.h"
#include "InDefTableDlg.h"
#include "DataHelper.h"
// #include "DataImport.h"
// #include "ObjWellLogTABLE.h"
// #include "CreateNewCurveDlg.h"
//#include "TableTBCurve.h"
#include "CurvePropertyEdit.h"
#include "cdialog.h"//"MyListDlg.h"
#include "CurveComputerDlg.h"
// #include "UnitConvertDlg.h"
#include "StatisticsDlg.h"
#include "Statistics2Dlg.h"
#include "CurveComputePage.h"
// #include "CopyObjectDlg.h"
// #include "WaveComposeDlg.h"//2020.4.14 合成阵列曲线
#include "ShowWave.h"//波列曲线预览
#include "ShowCurve.h"//2020.5.12常规曲线预览
#include <QEventLoop>
// #include "tableproeditdlg.h"
#include "CreateNewTableDlg.h"
#include "BaseFun.h"
#include "DepthProgress.h"
#include "geometryutils.h"
extern  DEFAULTTABLE *DefauleTable;//[DefTabNum];
extern  int DefTabNum;
//extern char *DataTypea[];
//extern int DataLengtha[];
//namespace Ui{
//	class SigelForm;
//	class MultForm;
//}
CDataManagger::CDataManagger()
{
	DataHelper::InitDefauleTable();//whp add 2019.11.21 初始化系统缺省表结构
}

CDataManagger::~CDataManagger()
{
	DataHelper::DelDefauleTable();//清除系统缺省表缓存  whp add 2019.11.21
}
DEFAULTTABLE *CDataManagger::GetDefauleTable()
{
	return DefauleTable;
}
int CDataManagger::GetDefTabNum()
{
	return DefTabNum;
}
//交互导入数据表
//whp change 2020.3.9 for 统一离散数据入口
void CDataManagger::execInDefTable(int curitemType,
	const QString& showWellName,
	const QString& wellFileName,const QString& inFile)//const QString& wellFileName)
{
	QString DataFile=inFile;//whp add 2020.3.9 for 统一离散数据入口
    if(DataFile=="")DataFile = QFileDialog::getOpenFileName(NULL,"打开表数据文件",::GetDataPath(),
		"表数据文件(*.txt;*.prn;*.csv;*.las)");
	if(DataFile=="")return;

	CInDefTableDlg *pDlg=new CInDefTableDlg(curitemType,NULL);
	//pDlg->CurItemType=curitemType;
	pDlg->FileName=DataFile;
	//20191227
	if(curitemType)
	{
		pDlg->m_sigWell->comboBox_WellName->addItem(showWellName);
	}
	pDlg->m_pUI->tableWidget->setSortingEnabled(true); 
	pDlg->m_pUI->lineEdit->setText(DataFile);//输入文件
	if(DataHelper::m_IsGc)
		DataHelper::InitDefauleTable();
	QStringList temptable;
	for(int i=0;i<DefTabNum;i++){
		pDlg->m_pUI->comboBox_Table->addItem(DefauleTable[i].TableAliasName);//系统缺省表列表
		temptable << DefauleTable[i].TableAliasName;
	}
	pDlg->m_pUI->comboBox_Table->addItem("自定义数据表");
	temptable << "自定义数据表";

    QCompleter *completer = new QCompleter(temptable);
	//int t = DefTabNum;
    // QCompleter completer2[100] = {temptable};
	pDlg->m_pUI->comboBox_Table->setEditable(true);
    pDlg->m_pUI->comboBox_Table->setCompleter(completer);
	//pDlg->m_pUI->comboBox_Table->autoCompletion();
	
	//delete completer;
	pDlg->WellFileName=wellFileName;
	if(!pDlg->Init())
		return;
	pDlg->exec();
}
// //数据对象拷贝
// void CDataManagger::CopyObject(int curitemType,const QString& WellName,const QString& WellRoundName)
// {
// 	CCopyObjectDlg *pDlg=new CCopyObjectDlg();
// 	pDlg->curitemType=curitemType;
// 	pDlg->WellName=WellName;
// 	pDlg->WellRoundFileName=WellRoundName;
// 	pDlg->Init();
// 	pDlg->exec();
// }
//数据表自动导入
//whp change 2020.3.9 for 统一离散数据入口
//void CDataManagger::dataInTable(const QStringList& lst)
void CDataManagger::dataInTable(int curitemType,QString& showWellName,QString& wellFileName)
{
	//AfxMessageBox("ddd");
	QStringList listFiles = QFileDialog::getOpenFileNames(NULL,"打开表数据文件",::GetDataPath(),
		"表数据文件(*.txt;*.prn;*.csv;*.las)");
	if(listFiles.size()<1)return ;
	char mfi[300];
	//2020.7.14 for 单文件导入都要进交互界面
	FILE *fp=fopen(listFiles[0].toStdString().c_str(),"rt");
	if(fp)
	{
		fscanf(fp,"%s",mfi);
		if(stricmp(mfi,"wellname")) curitemType=1;
		fclose(fp);
	}
	if(curitemType&&wellFileName.isEmpty())
	{
		QFileInfo ss(listFiles[0]);
		wellFileName=ss.baseName();
        QString path=GetLogdataPath()+"例子2"/*::GetProject()->GetName()*/;//zzzzz
		path+="/#";
		path+=ss.baseName();
		QString slfpath=path;
		path+="/"+ss.baseName();
		path+=".slf";
		wellFileName=path;
		QDir sss;
		if(!sss.exists(path))
		{
			if(QMessageBox::information(NULL,"提示",path+"\n文件不存在，创建文件？",QMessageBox::Yes,QMessageBox::No)!=QMessageBox::Yes) return;
		}
		CreateDir((char*)slfpath.toStdString().c_str());
	}
	if(listFiles.size()==1)
	{
		execInDefTable(curitemType,showWellName,wellFileName,listFiles.at(0));
		return ;
	}
	//
	std::vector<QString> fileNameVec;//表文件名
	std::vector<QStringList> zdNameVec;//表字段名
	std::vector<int>HaveWellName;//首列是否是井名，“WELLNAME”标示
	std::vector<vector<int>>zdLen;
	std::vector<vector<int>>zdType;
	//whp change 2020.3.9 for 统一离散数据入口
	//listFiles=DataHelper::GetVlidTable(listFiles);
	QStringList BadlistFiles;
	listFiles=DataHelper::GetVlidTable(curitemType,listFiles,BadlistFiles);
	
	if(listFiles.size()==0)
	{
			if(BadlistFiles.size()==1)execInDefTable(curitemType,showWellName,wellFileName,BadlistFiles.at(0));
			else
			{
				//设置对话框类型：0-只有列表框，1-左列表，右文本，2-只有文本框
				CDialog *pDlg=new CDialog();
				pDlg->setDialogType(2);
				if(!curitemType)pDlg->setTitle("多井离散表数据加载");
				else pDlg->setTitle("单井离散表数据加载");
				pDlg->setTiShi(0,"您所选择的下列文件全部无法识别");
				pDlg->setTiShi(1,"建议您选择单文件打开，进入交互加载");
				pDlg->setMessage(BadlistFiles.join("\r\n"));
				pDlg->exec();
			}
			return ;
	}
	int *DefaultNo=new int[listFiles.size()];
	int TableNum=0;
	char *pLine=new char[50000];

	foreach(QString strFileName, listFiles)
	{
		fileNameVec.push_back(strFileName);
		QFile file(strFileName);
		if(!file.open(QIODevice::ReadOnly )) continue;
//		QTextStream textstream( &file );
//		QString line = textstream.readLine();

		file.readLine(pLine,50000);
		QByteArray line=pLine;

		while(DataHelper::IsNullLine(line)){
			file.readLine(pLine,50000);
			line=pLine;
		}
		QStringList StrList,StrListZD=GetStringList(line);//=line.split(",");
		zdNameVec.push_back(StrListZD);
		int PosWN=0;//井名字段位置
		if(StrListZD.at(0).toUpper().indexOf("WELLNAME")>=0)PosWN=1;//if(StrListZD.at(0).toUpper()=="WELLNAME")PosWN=1;
		HaveWellName.push_back(PosWN);
		int ColNum=StrListZD.size();
		int *FieldType=new int[ColNum];
		for(int i=0;i<ColNum;i++)FieldType[i]=1;//1-int,2-short,3-long,4-float,5-double,6-string
#pragma region 根据字段内容确定字段值类型
		//非数值，则为string；数值：有小数点，即为float，否则为int
		while(!file.atEnd())
		{
			file.readLine(pLine,50000);
			QByteArray line=pLine;
			if(DataHelper::IsNullLine(line))continue;
			QStringList StrList=GetStringList(line);
			int DataCol=StrList.size();
			for(int i=0;i<ColNum;i++)
			{
				if(i>=DataCol)continue;//缺失数据5
				QString ss=StrList.at(i);
				if(FieldType[i]==1){if(DataHelper::StrType(ss)!=FieldType[i])FieldType[i]=DataHelper::StrType(ss);}
				else if(FieldType[i]==4){if(DataHelper::StrType(ss)==6)FieldType[i]=6;}
			}
		}
#pragma endregion 根据字段内容确定字段值类型
		DefaultNo[TableNum++]=DataHelper::GetSimilarTable(ColNum-PosWN,&FieldType[PosWN]);//匹配缺省表，返回缺省表序号
		vector<int>m_zdLen;
		vector<int>m_zdType;
		for(int i=0;i<ColNum;i++)
		{
			m_zdType.push_back(FieldType[i]);
			int ZdLen=RepSize[FieldType[i]];if(FieldType[i]==6)ZdLen=128;
			m_zdLen.push_back(ZdLen);
		}
		zdType.push_back(m_zdType);
		zdLen.push_back(m_zdLen);
		delete []FieldType;
		file.close();
	}
	delete pLine;

	QStringList OutTableName;
	QStringList OutWellName;//导入井名
	int HaveDefaultTable=0;//匹配上的缺省表个数
	//whp add 20200107
	CDialog *pDlg=new CDialog();//CMyListDlg *pDlg=new CMyListDlg();
//设置对话框类型：0-只有列表框，1-左列表，右文本，2-只有文本框
//beCheck点击确定时是否需要对"导入井名"和"导入表名"列字符串进行有效性检查
	if(BadlistFiles.size()==0)pDlg->setDialogType(0,1);
	else pDlg->setDialogType(1,1);
	if(!curitemType)
	{
		pDlg->setTitle("导入多井离散表数据");
		pDlg->setTiShi(0,"请注意检查和完善“导入井名”和“导入表名”信息");
		pDlg->setTiShi(1,"是否继续导入当前数据文件？是--点击确认，否--点击取消");
		
	}
	else 
	{
		pDlg->setTitle("导入单井离散表数据");
		pDlg->setTiShi(0,"请注意检查和完善“导入表名”信息");
		if(curitemType==1)pDlg->setTiShi(1,"您确认将所选择的数据文件导入到当前井中？是--点击确认，否--点击取消");
		else pDlg->setTiShi(1,"您确认将所选择的数据文件导入到当前井次文件中？是--点击确认，否--点击取消");
	}
	if(BadlistFiles.size())
	{
			pDlg->setTiShi(2,"您所选择的下列文件无法识别");
			pDlg->setTiShi(3,"建议您选择单文件打开，进入交互加载");
			pDlg->setMessage(BadlistFiles.join("\r\n"));
	}
	QStringList head;
	head<<"输入文件名"<<"导入井名"<<"匹配表名"<<"导入表名";
	pDlg->init(TableNum,4,head);
	for(int m=0;m<TableNum;m++)
	{
		QString tablename=listFiles[m],wellname=showWellName;
		if(!curitemType)wellname="";//当前选择项是“井”
		//ww change 2020.3.13 for 对路径分隔符要进行2种识别
		//tablename=tablename.right(tablename.length()-tablename.lastIndexOf("\\")-1);
		int index=tablename.lastIndexOf("/");
		int index1=tablename.lastIndexOf("\\");
		if(index1>index) {
			index=index1;
		}
		tablename=tablename.mid(index+1);
		pDlg->setItem(m,0,tablename);//listFiles[m]));
		tablename=tablename.left(tablename.lastIndexOf("."));
		//文件名中包含井名，如well1_table
		if(tablename.indexOf("_")>0)
		{
			if(!curitemType)wellname=tablename.left(tablename.lastIndexOf("_"));
			tablename=tablename.right(tablename.length()-tablename.lastIndexOf("_")-1);
		}
		if(DefaultNo[m]>=0){
			tablename=DefauleTable[DefaultNo[m]].TableName;
			HaveDefaultTable++;
		}
		OutTableName.append(tablename);

		if(HaveWellName[m])
		{
			pDlg->setItem(m,1,"多井");
			pDlg->setFlags(m,1,Qt::NoItemFlags);
		}
		else pDlg->setItem(m,1,wellname);
		if(DefaultNo[m]>=0)pDlg->setItem(m,2,OutTableName[m]);
		else pDlg->setItem(m,2,"");
		pDlg->setItem(m,3,OutTableName[m]);
		pDlg->setCheckState(m,0,Qt::Checked);
		pDlg->setFlags(m,2,Qt::NoItemFlags);
	}
	if(pDlg->exec()==QDialog::Rejected)
	{
		delete []DefaultNo;
		delete pDlg;
		pDlg=NULL;
		return ;
	}
    bool *IsCheck=new bool[TableNum];
	OutTableName.clear();
	for(int i=0;i<TableNum;i++){
		QString ss=pDlg->getItem(i,1);
		IsCheck[i]=pDlg->getCheckState(i,0);
		OutTableName.append(pDlg->getItem(i,3)) ;
		OutWellName.append(pDlg->getItem(i,1)) ;
		
	}
	int count=0;
#pragma region 导入表
	
	
	int ret=0;//QMessageBox提示返回值Yes、AllYes、No、AllNo（覆盖、全覆盖、放弃、全放弃）
	//
	//进度提示
	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
	DepthProgress dp;
	dp.CreatProgress(0,listFiles.size(),"开始导入表格数据...");
	for(int m=0;m<listFiles.size();m++)//foreach(QString strFileName, listFiles)
	{
		CLogIO *logio=new CLogIO();
		dp.SetDepth(m+1);
		if(!IsCheck[m])continue;
		QString tablename;
		tablename=OutTableName[m];
		char tn[100];
		QString fi;
		strcpy(tn,tablename.toStdString().c_str());
		if(HaveWellName[m])continue;//&&(OutWellName[m]=="多井"))continue;
		if(OutWellName[m]==showWellName)
		{
				fi=wellFileName;
				logio->Open(fi.toStdString().c_str(),CSlfIO::modeReadWrite);
		}
		else 
		{
            // CObjWell * pWell =CDataImport::GetWellByName(OutWellName[m]);
            // if(!pWell) continue;
            // if(pWell->GetWellFileName().isEmpty())
            // {
            // 	fi=GetLogdataPath()+GetProject()->GetName()+"\\#"+OutWellName[m];
            // 	CreateDir((char *)fi.toStdString().c_str());
            // 	fi+="\\"+OutWellName[m]+".slf";
            // 	pWell->SetWellFileName(fi);
            // 	logio->Open(fi.toStdString().c_str(),CSlfIO::modeCreate,1024,1024,MACHINE_TYPE,0);
            // 	Slf_FILE_MESSAGE mssage;
            // 	logio->GetFileMessage(mssage);
            // 	int len=strlen(OutWellName[m].toStdString().c_str());
            // 	strncpy(mssage.WellName,OutWellName[m].toStdString().c_str(),len);
            // 	mssage.WellName[len]=0;
            // 	logio->SetFileMessage(mssage);
            // }
            // else
            // {
            // 	fi=pWell->GetWellFileName();
            // 	if(!logio->Open(fi.toStdString().c_str(),CSlfIO::modeReadWrite))continue;
            // }
		}
		int iIndex=logio->OpenTable(tn);
		//whp change 2020.3.9 for 当数据表存在时，给出提示
		if(iIndex>=0)
		{
			if(ret!=QMessageBox::YesAll&&ret!=QMessageBox::NoAll)
			{
				QMessageBox box(QMessageBox::Warning,"提示","文件"+fi+"中已存在数据表"+tablename);
				box.setStandardButtons (QMessageBox::Yes|QMessageBox::No|QMessageBox::YesAll|QMessageBox::NoAll);
				box.setButtonText (QMessageBox::Yes,QString("覆盖当前\r\n已存在数据表"));
				box.setButtonText (QMessageBox::YesAll,QString("覆盖所有\r\n已存在数据表"));
				box.setButtonText (QMessageBox::No,QString("放弃当前\r\n数据表加载"));
				box.setButtonText (QMessageBox::NoAll,QString("放弃所有\r\n已存在数据表加载"));
				ret=box.exec();
			}
			if(ret==QMessageBox::NoAll||ret==QMessageBox::No)
			{
				logio->CloseTable(iIndex);
				logio->Close();
				continue;
			}
			else
			{
				logio->DeleteSlfObject(tn);
				iIndex=-1;
			}
		}
		//
		if (iIndex < 0)
		{
			QString name,len,ty,bk,hz;
			for(int i=0;i<zdNameVec[m].size();i++)
			{
				if(DefaultNo[m]>=0)
				{
					name+= QString(QLatin1String(DefauleTable[DefaultNo[m]].tinfo[i].Name));
					len+=QString::number(DefauleTable[DefaultNo[m]].tinfo[i].CodeLength);//Length);
					ty+=QString::number(DefauleTable[DefaultNo[m]].tinfo[i].RepCode);
					bk+="0";
					hz+=QString(QLatin1String(DefauleTable[DefaultNo[m]].tinfo[i].Name));
				}
				else 
				{
					name+=zdNameVec[m].at(i);
					len+=QString::number(zdLen[m].at(i));
					ty+=QString::number(zdType[m].at(i));
					bk+="0";
					hz+=zdNameVec[m].at(i);
				}
				if(i<zdNameVec[m].size()-1) {
					name+=",";
					len+=",";
					ty+=",";
					bk+=",";
					hz+=",";
				}
			}
			char cname[500],clen[500],cty[500],cbk[500],chz[500];
			strcpy(cname,name.toStdString().c_str());
			strcpy(clen,len.toStdString().c_str());
			strcpy(cty,ty.toStdString().c_str());
			strcpy(cbk,bk.toStdString().c_str());
			strcpy(chz,hz.toStdString().c_str());
			iIndex=logio->Open_Set_Table(tablename.toStdString().c_str(),0,zdNameVec[m].size(),
				cname,
				clen,//字段长度
				cty,//字段类型
				cbk,
				chz
				);//字段备注
		}
		int rec=logio->GetTableRecordCount(iIndex);		
		int tcount=logio->GetTableFieldCount(iIndex);
		Slf_TABLE_FIELD *field=new Slf_TABLE_FIELD[tcount+1];
		logio->GetTableFieldInfo(iIndex,field);
		int reclen=logio->GetTableRecordLength(iIndex);
		char *Buffer=new char[reclen+1];
		QFile file(fileNameVec[m]);
		file.open(QIODevice::ReadOnly );
		file.readLine(pLine,50000);
		QByteArray line=pLine;
		while(DataHelper::IsNullLine(line)) {
			file.readLine(pLine,50000);
			line=pLine;
		}
		int lineNo=0;
		while(!file.atEnd())
		{
			file.readLine(pLine,50000);
			QByteArray line=pLine;
			if(DataHelper::IsNullLine(line))continue;
			//
			QStringList StrList=GetStringList(line);
			int DataCol=StrList.size();
			int len=0;
			for(int i=0;i<tcount;i++) 
			{
				QString DataStr="-9999.";
				if(i<DataCol)DataStr=StrList[i];
				if(field[i].RepCode!=6) 
				{
					float buf=DataStr.toFloat();
					logio->SetData(field[i].RepCode,&Buffer[len],(float *)&buf);
				}
				else {
					strncpy(&Buffer[len],DataStr.toStdString().c_str(),field[i].Length);
				}
				len+=field[i].Length;
			}
			logio->WriteTable(iIndex,lineNo+1,Buffer);
			lineNo++;
		}
		if(lineNo>rec) rec=lineNo;
		logio->SetTableRecordCount(iIndex,rec);
		delete []Buffer;
		delete []field;
		logio->CloseTable(iIndex);
		count++;
		delete logio;
        // pai::graphics::CDataImport::ChangetoSlf(fi,NULL);
	}
#pragma region 导入多井
	for(int m=0;m<listFiles.size();m++)//输入数据表文件
	{
		dp.SetDepth(m+1);
		if(!IsCheck[m])continue;
		if(!HaveWellName[m])continue;//OutWellName[m]!="多井")continue;
		QString tablename;
		tablename=OutTableName[m];
		char tn[100];
		QString fi;
		strcpy(tn,tablename.toStdString().c_str());
		QStringList WellNameList;
		//搜索当前文件包含井名
		QFile file(listFiles[m]);
		file.open(QIODevice::ReadOnly );
		file.readLine(pLine,50000);
		QByteArray line=pLine;
		while(DataHelper::IsNullLine(line))
		{
			file.readLine(pLine,50000);
			line=pLine;
		}
		while(!file.atEnd())
		{
			file.readLine(pLine,50000);
			QByteArray line=pLine;
			if(DataHelper::IsNullLine(line))continue;
			QStringList StrList=GetStringList(line);
            bool flag=0;
			QString DataStr=StrList[0].toUpper();
			for(int j=0;j<WellNameList.size();j++)
			{
				if(WellNameList.at(j)!=DataStr)continue;
				flag=1;break;
			}
			if(!flag)WellNameList.append(DataStr);
		}
		//导入
		int outnum=0;
		for(int n=0;n<WellNameList.size();n++)//导入井名
		{
            // CObjWell * pWell =CDataImport::GetWellByName(WellNameList.at(n));
            // if(!pWell) continue;
            CLogIO *logio=new CLogIO();
            // QString fi;
            // if(pWell->GetWellFileName().isEmpty())
            // {
            // 	fi=GetLogdataPath()+GetProject()->GetName()+"\\#"+WellNameList.at(n);
            // 	CreateDir((char *)fi.toStdString().c_str());
            // 	fi+="\\"+WellNameList.at(n)+".slf";
            // 	pWell->SetWellFileName(fi);
            // 	logio->Open(fi.toStdString().c_str(),CSlfIO::modeCreate,1024,1024,MACHINE_TYPE,0);
            // 	Slf_FILE_MESSAGE mssage;
            // 	logio->GetFileMessage(mssage);
            // 	int len=strlen(WellNameList.at(n).toStdString().c_str());
            // 	strncpy(mssage.WellName,WellNameList.at(n).toStdString().c_str(),len);
            // 	mssage.WellName[len]=0;
            // 	logio->SetFileMessage(mssage);
            // }
            // else
            // {
            // 	fi=pWell->GetWellFileName();
            // 	if(logio->Open(fi.toStdString().c_str(),CSlfIO::modeReadWrite))
            // 	{
            // 		int iIndex=logio->OpenTable(tablename.toStdString().c_str());
            // 		if(iIndex>=0)
            // 		{
            // 			//logio->DeleteSlfObject(tablename.toStdString().c_str());
            // 			//whp change 2020.3.9 for 当数据表存在时，给出提示

            // 			if(ret!=QMessageBox::YesAll&&ret!=QMessageBox::NoAll)
            // 			{
            // 				QMessageBox box(QMessageBox::Warning,"提示","文件"+fi+"中已存在数据表"+tablename);
            // 				box.setStandardButtons (QMessageBox::Yes|QMessageBox::No|QMessageBox::YesAll|QMessageBox::NoAll);
            // 				box.setButtonText (QMessageBox::Yes,QString("覆盖当前\r\n已存在数据表"));
            // 				box.setButtonText (QMessageBox::YesAll,QString("覆盖所有\r\n已存在数据表"));
            // 				box.setButtonText (QMessageBox::No,QString("放弃当前\r\n数据表加载"));
            // 				box.setButtonText (QMessageBox::NoAll,QString("放弃所有\r\n已存在数据表加载"));
            // 				ret=box.exec();
            // 			}
            // 			if(ret==QMessageBox::NoAll||ret==QMessageBox::No)
            // 			{
            // 				logio->CloseTable(iIndex);
            // 				logio->Close();
            // 				continue;
            // 			}
            // 			else
            // 			{
            // 				logio->DeleteSlfObject(tablename.toStdString().c_str());
            // 				iIndex=-1;
            // 			}


            // 		}
            // 	}
            // }
			QString name,len,ty,bk,hz;
			for(int i=0;i<zdNameVec[m].size()-1;i++)
			{
				if(DefaultNo[m]>=0)
				{
					name+= QString(QLatin1String(DefauleTable[DefaultNo[m]].tinfo[i].Name));
					len+=QString::number(DefauleTable[DefaultNo[m]].tinfo[i].CodeLength);//Length);
					ty+=QString::number(DefauleTable[DefaultNo[m]].tinfo[i].RepCode);
					bk+="0";
					hz+=QString(QLatin1String(DefauleTable[DefaultNo[m]].tinfo[i].Name));
				}
				else 
				{
					name+=zdNameVec[m].at(i+1);
					len+=QString::number(zdLen[m].at(i+1));
					ty+=QString::number(zdType[m].at(i+1));
					bk+="0";
					hz+=zdNameVec[m].at(i+1);
				}
				if(i<zdNameVec[m].size()-2) {
					name+=",";
					len+=",";
					ty+=",";
					bk+=",";
					hz+=",";
				}
			}
			char cname[500],clen[500],cty[500],cbk[500],chz[500];
			strcpy(cname,name.toStdString().c_str());
			strcpy(clen,len.toStdString().c_str());
			strcpy(cty,ty.toStdString().c_str());
			strcpy(cbk,bk.toStdString().c_str());
			strcpy(chz,hz.toStdString().c_str());
			int iIndex=logio->Open_Set_Table(tablename.toStdString().c_str(),0,zdNameVec[m].size()-1,
				cname,
				clen,//字段长度
				cty,//字段类型
				cbk,
				chz
				);//字段备注
			int rec=logio->GetTableRecordCount(iIndex);		
			int tcount=logio->GetTableFieldCount(iIndex);
			Slf_TABLE_FIELD *field=new Slf_TABLE_FIELD[tcount+1];
			logio->GetTableFieldInfo(iIndex,field);
			int reclen=logio->GetTableRecordLength(iIndex);
			char *Buffer=new char[reclen+1];
			QFile file(fileNameVec[m]);
			file.open(QIODevice::ReadOnly );
			file.readLine(pLine,50000);
			QByteArray line=pLine;
			int lineNo=0;
			while(!file.atEnd())
			{
				file.readLine(pLine,50000);
				QByteArray line=pLine;
				if(line=="")continue;//whp add 2020.3.11 for 剔除空行
				QStringList StrList=GetStringList(line);//line.split(",");
				//whp add 2020.3.11 for 剔除空行
                bool IsNullLine=1;
				for(int kk=0;kk<StrList.size();kk++)
				{
					if(StrList.at(kk)!="")
					{
						IsNullLine=0;break;
					}
				}
				if(IsNullLine)continue;
				//
				if(StrList[0].toUpper()!=WellNameList[n])continue;
				int DataCol=StrList.size();
				int len=0;
				for(int i=0;i<tcount;i++) 
				{
					QString DataStr="-9999.";
					if(i<DataCol)DataStr=StrList[i+1];
					if(field[i].RepCode!=6) 
					{
						float buf=DataStr.toFloat();
						logio->SetData(field[i].RepCode,&Buffer[len],(float *)&buf);
					}
					else {
						strncpy(&Buffer[len],DataStr.toStdString().c_str(),field[i].Length);
					}
					len+=field[i].Length;
				}
				logio->WriteTable(iIndex,lineNo+1,Buffer);
				lineNo++;
			}
			if(lineNo>rec) rec=lineNo;
			logio->SetTableRecordCount(iIndex,rec);
			delete []Buffer;
			delete []field;
			logio->CloseTable(iIndex);
            // pai::graphics::CDataImport::ChangetoSlf(fi,NULL);
			delete logio;
			outnum++;
		}
		if(outnum)count++;
	}
#pragma endregion 导入多井
	//QApplication::restoreOverrideCursor();
	delete pDlg;
	pDlg=NULL;
	delete []IsCheck;
	delete []DefaultNo;
#pragma endregion 导入表
	QApplication::restoreOverrideCursor();
	if(BadlistFiles.size()!=1)AfxMessageBox("完成"+QString::number(count)+"个表数据文件导入！");
	else 
		{
			QString ss="而数据文件"+BadlistFiles.at(0)+"无法自动识别，即将进入交互导入";
			AfxMessageBox("完成"+QString::number(count)+"个表数据文件导入！\r\n\r\n"+ss);
	}
	//return BadlistFiles;//whp add 2020.3.9 for 统一离散数据入口
	if(BadlistFiles.size()!=1)return;
	execInDefTable(curitemType,showWellName,wellFileName,BadlistFiles.at(0));//加载自由数据表
}
//曲线数值统计
void CDataManagger::DataStatistics(int Type,const QString& FileName,const QString& CurveName)
{
    CLogIO logio(FileName.toStdString().c_str(),(unsigned int)CLogIO::modeReadWrite);
    if(!logio.mFile) return ;
    Slf_CURVE info;
    int index=logio.OpenChannel(CurveName.toStdString().c_str());
    if(index<0)return;
    logio.CloseChannel(index);
    logio.Close();
    if(!Type)
    {
        CStatisticsDlg *pDlg=new CStatisticsDlg();
        pDlg->FileName=FileName;
        pDlg->CurveName=CurveName;
        pDlg->init();
        //pDlg->exec();
        //delete pDlg;
        //pDlg=NULL;
    }
    else
    {
        CStatistics2Dlg *pDlg=new CStatistics2Dlg();
        pDlg->FileName=FileName;
        pDlg->CurveName=CurveName;
        pDlg->init();
        //pDlg->exec();
        //delete pDlg;
        //pDlg=NULL;
    }
}

void CDataManagger::DataStatistics(int Type,
        const QString& FileName,
        const QString& CurveName,
        QWidget* parent)
    {

    CLogIO logio(FileName.toStdString().c_str(),(unsigned int)CLogIO::modeReadWrite);
    if(!logio.mFile) return ;
    Slf_CURVE info;
    int index=logio.OpenChannel(CurveName.toStdString().c_str());
    if(index<0)return;
    logio.CloseChannel(index);
    logio.Close();
    if(!Type)
    {
		
        CStatisticsDlg *pDlg1=parent->findChild<CStatisticsDlg*>("statView");
        if(NULL == pDlg1 )
        {
            pDlg1=new CStatisticsDlg(parent,0);
            pDlg1->setObjectName("statView");
        }
		
    /*	int width=parent->width();
        int height=parent->height();
        pDlg->resize(QSize(width,height));*/
        pDlg1->FileName=FileName;
        pDlg1->CurveName=CurveName;
        pDlg1->init();
        pDlg1->show();
        //pDlg->exec();
        //delete pDlg;
        //pDlg=NULL;
    }
    //whp add 2020.5.11 for 波列数据编辑和管理 波列曲线数值统计
    else
    {
	 
    CStatistics2Dlg *pDlg2=parent->findChild<CStatistics2Dlg*>("stat2View");
    if(NULL == pDlg2 )
    {
        pDlg2=new CStatistics2Dlg(parent,0);
        pDlg2->setObjectName("stat2View");
    }

        pDlg2->FileName=FileName;
        pDlg2->CurveName=CurveName;
        pDlg2->init();
        pDlg2->show();
    }
}
//  //whp add 2020.4.9 for 波列曲线预览
// void CDataManagger::DisplayWave(const QString& FileName,const QString& WaveName)
// {
// 	CLogIO *logio=new CLogIO();
// 	if(!logio->Open(FileName.toStdString().c_str(),CSlfIO::modeRead))
// 	{
// 		delete logio;
// 		QMessageBox::warning(NULL,"提示","打开文件"+FileName+"错误");
// 		return ;
// 	}
// 	int index=logio->OpenWave(WaveName.toStdString().c_str());
// 	if(index<0){
// 		delete logio;
// 		return;
// 	}
// 	logio->CloseWave(index);
// 	delete logio;
// 	ShowWave *pDlg=new ShowWave();
// 	pDlg->FileName=FileName,pDlg->WaveName=WaveName;
// 	pDlg->init();
// 	pDlg->show();
// }
// //whp add 2020.5.12 for 常规曲线预览
// void CDataManagger::DisplayCurve(const QString& FileName,const QString& CurveName)
// {
// 	CLogIO *logio=new CLogIO();
// 	if(!logio->Open(FileName.toStdString().c_str(),CSlfIO::modeRead))
// 	{
// 		delete logio;
// 		QMessageBox::warning(NULL,"提示","打开文件"+FileName+"错误");
// 		return ;
// 	}

// 	int index = logio->OpenCurve(CurveName.toStdString().c_str());
// 	if(index<0) {
// 		delete logio;
// 		return;
// 	}

// 	logio->CloseCurve(index);
// 	delete logio;

// 	ShowCurve *pDlg = new ShowCurve();
// 	pDlg->FileName = FileName,pDlg->CurveName = CurveName;
// 	pDlg->init();
// 	pDlg->show();
// }
void CDataManagger::CurvePropertyEdit(int Type,
        const QString& FileName,
        const QString& CurveName,
        QWidget* parent)
    {

        CCurvePropertyEditDlg *pDlg=new CCurvePropertyEditDlg(parent,0);
        connect(pDlg,SIGNAL(destroyed()),this,SLOT(slotCurvePropertyGc()));
        pDlg->FileName=FileName;
        pDlg->CurveName=CurveName;
        pDlg->Type=Type;
        pDlg->init();
        pDlg->show();

    }

void CDataManagger::CurveCompute(const QString& FileName,
        const QStringList& CurveNameList,
        QWidget* parent)
    {

    if(CurveNameList.count()==1)
    {
        CurveComputePage *pPage=parent->findChild<CurveComputePage*>("computeV");
        if(NULL == pPage)
        {
            pPage=new CurveComputePage(parent);
            pPage->setObjectName("computeV");
        }
        connect(pPage,SIGNAL(signalCompute(QStringList)),this,SLOT(slotCurveComputeGc(QStringList)));
        pPage->CurveCompute(FileName,CurveNameList);
        pPage->init();
        pPage->show();
    }
    else
    {
        CCurveComputerDlg *pDlg=new CCurveComputerDlg();
        pDlg->FileName=FileName;
        pDlg->CurveNameList=CurveNameList;
        pDlg->init();//FileName, CurveNameList);
        //pDlg->exec();
        //delete pDlg;
        //pDlg=NULL;
    }
}

void CDataManagger::slotCurveComputeGc(QStringList listCurveNames)
{
    // PaiObject::m_EventAgent.ObjectPropertyChanged(GetProject(),"Compute",listCurveNames);
}

void CDataManagger::slotCurvePropertyGc()
{
    // pai::graphics::CDataImport::ChangetoSlf(m_fileName,NULL);
}
// void CDataManagger::CurvePropertyEdit(int Type,const QString& FileName,const QString& CurveName)
// {
// 	CCurvePropertyEditDlg *pDlg=new CCurvePropertyEditDlg();
// 	pDlg->FileName=FileName;
// 	pDlg->CurveName=CurveName;
// 	pDlg->Type=Type;
// 	pDlg->init();
// 	//波列
// 	//if (Type == 1)
// 	{
// 		pDlg->setWindowFlags(Qt::WindowStaysOnTopHint);
// 		pDlg->show();
// 		QEventLoop loop;
// 		connect(pDlg,SIGNAL(signalsCloseed()),&loop,SLOT(quit()),Qt::UniqueConnection);
// 		loop.exec();
// 		delete pDlg;
// 		pDlg=NULL;
		 
// 	}


// 	pai::graphics::CDataImport::ChangetoSlf(FileName,NULL);
// }
// //表属性编辑
// QString CDataManagger::TableProEdit(const QString& wellname,const QString& tablename)
// {
// 	TableProEditDlg *pDlg=new TableProEditDlg();
// 	pDlg->FileName=wellname;
// 	pDlg->TableName=tablename;
// 	pDlg->init();
// 	if(pDlg->exec()==QDialog::Accepted)
// 	{
// 		QString cs=pDlg->TableName;
// 		delete pDlg;
// 		return cs;
// 	}
// 	else {
// 		delete pDlg;
// 		return "";
// 	}
// }

QString CDataManagger::Curve2ResultTable(const QString& wellname,const QString& curvename)
{
	CLogIO *logio=new CLogIO();
	if(!logio->Open(wellname.toStdString().c_str(),CSlfIO::modeRead))
	{
		delete logio;
		QMessageBox::warning(NULL,"提示","打开文件"+wellname+"错误");
		return "";
	}

	int index=logio->OpenCurve(curvename.toStdString().c_str());
	if(index<0) {
		delete logio;
		return "";
	}
	
	//gen curve data
	Slf_CURVE Info;
	logio->GetCurveInfo(index,&Info);
	if(Info.EndDepth < Info.StartDepth)
		return "";
	DWORD count=(Info.EndDepth - Info.StartDepth)/Info.DepLevel+2.5;
	float* vVdl;
	vVdl=new float[count];
	logio->ReadCurve(index, Info.StartDepth, count, vVdl);
	logio->CloseCurve(index);

	//gen RESULT layer data
	int Num = 0;
	float *layerSDEP = new float[count];
	float *layerEDEP = new float[count];
	int *layerRESULT = new int[count];
	for(int i = 0; i < (Info.EndDepth - Info.StartDepth)/Info.DepLevel; i++){
		if(vVdl[i] > 0){//find headDep
			layerSDEP[Num] = Info.StartDepth + i*Info.DepLevel;
			if(abs(round(vVdl[i]) - vVdl[i]) > 0.01){
				return "";
			}
			layerRESULT[Num] = vVdl[i];
			while(1){
				i++;
				if(i == (Info.EndDepth - Info.StartDepth)/Info.DepLevel) break;
				if(vVdl[i] != layerRESULT[Num]){
					layerEDEP[Num] = Info.StartDepth + (i-1)*Info.DepLevel;
					if(layerEDEP[Num] < layerSDEP[Num]) layerEDEP[Num] = layerSDEP[Num];
					break;
				}
			}
			Num++;
			i--;
		}
	}

	//gen new table name
	int a = 1;
	QString newTableName = curvename + "_" + QString::number(a, 10);
	while(1){
		if(logio->FindObjectIndex(newTableName.toStdString().c_str()) >= 0)
		{
			a++;
			newTableName = curvename + "_" + QString::number(a, 10);	
		}
		else
			break;
	}

	LAYER_DATA m_Result;
	int iIndex = logio->OpenTable(newTableName.toStdString().c_str());
	if (iIndex < 0)
	{
		iIndex=logio->Open_Set_Table(newTableName.toStdString().c_str(),0,22,
			"NO,SDEP,EDEP,ZONE,RESULTNO,THICK,TT,MDEPTH1,MDEPTH2,MDEPTH3,MDEPTH4,MDEPTH5,MDEPTH6,MDEPTH7,MDEPTH8,MDEPTH9,MDEPTH10,OIL,POOROIL,OILWATER,GAS,POORGAS,GASWATER,WATERGAS,DEST1,DEST2,DEST3,DEST4,DEST5,DEST6,DEST7,DEST8,DEST9,DEST10",
			"4,4,4,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,48,48,48,48,48,48,48,48,48,48",//字段长度
			"1,4,4,6,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6",//字段类型
				"0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0");//字段备注
	}
	logio->SetTableRecordCount(iIndex, Num);
	for(int j = 0; j < Num; j++) {
		//memset(&m_Result,0,sizeof(LAYER_DATA));
		m_Result.Order = j+1;
		m_Result.EndDepth=layerEDEP[j];
		m_Result.StartDepth=layerSDEP[j];
		m_Result.Thick=m_Result.EndDepth-m_Result.StartDepth;
		m_Result.Result = layerRESULT[j];
		//int n=layerNameVec[j].size();
		//if(n>8) n=8;
		//strncpy(m_Result.Zone,layerNameVec[j].toStdString().c_str(),n);
		logio->WriteTable(iIndex,j+1,&m_Result);
	}
	logio->CloseTable(iIndex);
	
	delete logio;
	delete []layerSDEP;
	delete []layerEDEP;
	delete []layerRESULT;
	delete []vVdl;
	return "";
}

// //表转曲线
// QString CDataManagger::Table2Curve(const QString& wellname,const QString& tablename)
// {
// 	int defalutVal = 38;

// 	CLogIO logio(wellname.toStdString().c_str(),(unsigned int)CLogIO::modeReadWrite);
// 	if(!logio.mFile) return "";
// 	int index=logio.FindSlfObjectIndex(tablename.toStdString().c_str());
// 	if(index<0) return "";
// 	//char name[64],HzName[64];
// 	//logio.GetObjectName(index,(char *)&name,NULL,(char *)&HzName);
// 	index=logio.OpenTable(tablename.toStdString().c_str());

// 	int fNum=logio.GetSlfTableFieldCount(index);
// 	Slf_OBJECT_FIELD *info=new Slf_OBJECT_FIELD[fNum+1];
// 	logio.GetSlfTableFieldInfo(index,&info[0]);
//     bool ifSDEP = false;
//     bool ifEDEP = false;
//     bool ifRESULT = false;
// 	for(int i=0;i<fNum;i++)
// 	{
// 		if(QString(QLatin1String(info[i].Name)) == "SDEP")
// 			ifSDEP = true;
// 		if(QString(QLatin1String(info[i].Name)) == "EDEP")
// 			ifEDEP = true;
// 		if(QString(QLatin1String(info[i].Name)) == "RESULTNO")
// 			ifRESULT = true;
// 	}
// 	if(ifSDEP && ifEDEP && ifRESULT)
// 	{
// 		QStringList ResultList;
// 		QString ConfigName = ::GetConfPath() + "RESULT.ini";
// 		QFile InFile3(ConfigName);
// 		if( !InFile3.open(QIODevice::ReadOnly ) )
// 		{
// 			QMessageBox::warning(NULL, "提示", "打开解释结论配置文件" + ConfigName + "错误");
// 		}
// 		else
// 		{
// 			QTextStream textstream3( &InFile3 );
// 			QString line;
// 			while(!textstream3.atEnd())
// 			{
// 				line = textstream3.readLine();
// 				if(line.length() <= 1)
// 					continue;
// 				ResultList.append(line);
// 			}
// 			InFile3.close();
// 		}

// 		float frontD = 0;
// 		float lastD = 0;


// 		int recordcount=logio.GetTableRecordCount(index);
// 		float depRange = 0;
// 		float frontDV = 0;
// 		float lastDV = 0;
// 		char *buf1 = new char [20];
// 		char *buf2 = new char [20];
// 		char *buf3 = new char [20];
// 		float *layerEDep = new float[recordcount];
// 		float *layerSDep = new float[recordcount];
// 		float *layerType = new float[recordcount];
// 		for(int i = 0; i < recordcount; i++)
// 		{
// 			logio.GetTableFieldData(index, "SDEP", buf1, i+1);
// 			logio.GetTableFieldData(index, "EDEP", buf2, i+1);
// 			logio.GetTableFieldData(index, "RESULTNO", buf3, i+1);
// 			layerSDep[i] = atof(buf1);
// 			layerEDep[i] = atof(buf2);
// 			depRange = layerEDep[i] - layerSDep[i];
// 			frontDV = depRange * frontD;
// 			lastDV = depRange * lastD;
// 			layerSDep[i] += frontDV;
// 			layerEDep[i] -= lastDV;
// 			depRange = layerEDep[i] - layerSDep[i];
// 			if(depRange <= 0)
// 				layerEDep[i] = layerSDep[i] + 0.1;
// 			QString str(buf3);
			
// 			for(int j = 0; j < ResultList.size(); j++){
// 				layerType[i] = defalutVal-1;
// 				if(ResultList[j] == str){
// 					layerType[i] = j+1;
// 					break;
// 				}
// 			}
// 		}
// 		logio.CloseTable(index);

// 		//CLogIO logio(wellname.toStdString().c_str(),(unsigned int)CLogIO::modeReadWrite);
// 		//if(!logio.mFile) return ;
		
// 		int a = 1;
// 		QString newCurveName = tablename + "_" + QString::number(a, 10);
// 		while(1){
// 			if(logio.FindObjectIndex(newCurveName.toStdString().c_str()) >= 0)
// 			{
// 				a++;
// 				newCurveName = tablename + "_" + QString::number(a, 10);
				
// 			}
// 			else
// 				break;
// 		}

// 		float StartDepth=999999;
// 		float EndDepth=-999999;
// 		int count=logio.GetObjectCount();
// 		for(int i=0;i<count;i++)
// 		{
// 			if(logio.GetObjectStatus(i)!=OBJECT_NORMAL) continue;
// 			short curvetype=logio.GetObjectType(i);
// 			if(curvetype == CURVE_OBJECT)
// 			{
// 				Slf_CURVE acurveinfo;
// 				logio.GetCurveInfo(i,&acurveinfo);
// 				if(acurveinfo.StartDepth<StartDepth) StartDepth=acurveinfo.StartDepth;
// 				if(acurveinfo.EndDepth>EndDepth) EndDepth=acurveinfo.EndDepth;
// 			}
// 		}

// 		Slf_CURVE Slf_curve;
// 		memset(&Slf_curve,0,sizeof(Slf_CURVE));
// 		strcpy(Slf_curve.Name,newCurveName.toStdString().c_str());
// 		strcpy(Slf_curve.AliasName,newCurveName.toStdString().c_str());
// 		strcpy(Slf_curve.Unit,"");
// 		strcpy(Slf_curve.AliasUnit,"");
// 		Slf_curve.RepCode=1;
// 		Slf_curve.CodeLen=4;
// 		Slf_curve.MinValue=99999;
// 		Slf_curve.MaxValue=-99999;
// 		Slf_curve.DefVal=0;
// 		Slf_curve.StartDepth = StartDepth;
// 		Slf_curve.EndDepth = EndDepth;
// 		Slf_curve.DepLevel = 0.025;
// 		strcpy(Slf_curve.DepthUnit,"m");
// 		strcpy(Slf_curve.DepthHZUnit,"m");
// 		logio.CreateCurve(&Slf_curve,true);

// 		DWORD num=(Slf_curve.EndDepth-Slf_curve.StartDepth)/Slf_curve.DepLevel+1.5;
// 		float *val=new float[num];
// 		float curD;
// 		for(int i = 0; i < num; i++){
// 			curD = StartDepth + i * Slf_curve.DepLevel;
// 			val[i] = defalutVal;
// 			for(int j = 0; j < recordcount; j++){
// 				if(curD >= layerSDep[j] && curD <= layerEDep[j]){
// 					val[i] = layerType[j];
// 					break;
// 				}
// 			}
// 		}
			
// 		index=logio.OpenCurve(Slf_curve.Name);
// 		if(index > -1) {
// 			logio.WriteCurve(index,Slf_curve.StartDepth,num,val);
// 			logio.CloseCurve(index);
// 		}
// 		delete []val;
// 		logio.Close();
// 		return newCurveName;
// 	}
// 	else
// 	{
// 		logio.CloseTable(index);
// 		logio.Close();
// 		QMessageBox msg;//对话框设置父组件
// 		msg.setWindowTitle("生成曲线");//对话框标题
// 		msg.setText("无法在表格中找到相关深度或结论信息!");//对话框提示文本
// 		msg.setIcon(QMessageBox::Information);//设置图标类型
// 		msg.setStandardButtons(QMessageBox::Ok);//对话框上包含的按钮
// 		msg.exec();

// 		return "";
// 	}
// }

//whp 2020.7.21
//创建新表 
QString CDataManagger::CreateNewTable(const QString& wellname)
{
    if(DataHelper::m_IsGc)DataHelper::InitDefauleTable();
    CCreateNewTableDlg *pDlg=new CCreateNewTableDlg();
    pDlg->FileName=wellname;
    if(pDlg->exec()==QDialog::Accepted)
    {
        QString cs=pDlg->TableName;
        delete pDlg;
        return cs;
    }
    else {
        delete pDlg;
        return "";
    }
}
// QString CDataManagger::CreateNewCurve(const QString& wellname)
// {
// 	CCreateNewCurveDlg *pDlg=new CCreateNewCurveDlg();
// 	pDlg->wellname=wellname;
// 	QString Curvename="";

// 	if(pDlg->exec()==QDialog::Accepted){
// 		Curvename=pDlg->CurveName;
// 	}
// 	delete pDlg;
// 	pDlg=NULL;
// 	return Curvename;
// }
// //单位转换
// void CDataManagger::UnitConvert(const QString& FileName)//,CObjWelllogRound* pround)
// {
// 	CMemRdWt *mrw=new CMemRdWt();
// 	if(!mrw->Open(FileName.toStdString().c_str(),CSlfIO::modeReadWrite))
// 	{
// 		delete mrw;
// 		QMessageBox::warning(NULL,"提示","打开文件"+FileName+"错误\r\n");
// 		return ;
// 	}
// 	int ObjectNumber=mrw->GetObjectCount();
// 	int CurveCount=0,WaveCount=0;
// 	char Name[200];
// 	for(int i=0;i<ObjectNumber;i++)
// 	{
// 		if(mrw->GetObjectStatus(i)!=OBJECT_NORMAL)
// 		{
// 			continue;
// 		}
// 		mrw->GetObjectName(i,Name);
// 		short Attribute,SubAttribute;
// 		Attribute=mrw->GetObjectType(i);
// 		if(Attribute==CURVE_OBJECT)
// 		{
// 			CurveCount++;
// 		}
// 		else if(Attribute==WAVE_OBJECT)
// 		{
// 			WaveCount++;
// 		}
// 	}
// 	delete mrw;
// 	if(CurveCount+WaveCount==0)
// 	{
// 		QMessageBox::warning(NULL,"提示","您所选择的文件中没有曲线存在\r\n");
// 		return;
// 	}
// 	CUnitConvertDlg *pDlg=new CUnitConvertDlg();
// 	pDlg->FileName=FileName;
// 	//pDlg->pround=pround;
// 	pDlg->init();
// 	pDlg->exec();
// 	delete pDlg;
// 	pDlg=NULL;
// 	pai::graphics::CDataImport::ChangetoSlf(FileName,NULL);
// }
// //whp add 2020.4.14  合成阵列曲线
// QString CDataManagger::WaveCompose(const QString& FileName,const QStringList& CurveNameList)
// {
// 	CWaveComposeDlg *pDlg=new CWaveComposeDlg();
// 		pDlg->FileName=FileName;
// 		pDlg->CurveNameList=CurveNameList;
// 		pDlg->init();
// 		pDlg->show();//exec();
// 	QString WaveName="";
// 	return WaveName;
// }
void CDataManagger::accept2()
{
// 	QDialog*pd=(QDialog*)sender();
// 	int sdep=m_edit1->text().toFloat();
// 	int edep=m_edit2->text().toFloat();
// 	if(sdep>edep)
// 	{
// 		QMessageBox::information(pd,"提示","起始深度不能大于终止深度！",QMessageBox::Yes);
// 		return;
// 	}
// 	QString newCurve;
// 	CMemRdWt *mrw=new CMemRdWt();
// 	if(!mrw->Open(m_FileName.toStdString().c_str(),CSlfIO::modeReadWrite)) {
// 		delete mrw;
// 		return;
// 	}
// 	QString m_Function=m_edit3->text();
// 	m_Function.toUpper();
// 	m_Function.replace("\"DEPTH\"","CURRENT_HD.DEP");
// 	float CurveValue,rlev;
// 	Function fun;
// 	int noi=fun.GetExpress(m_Function);
// 	if(noi<0)
// 	{
// 		delete mrw;
// 		return ;//输入公式中没有“=”号，或含有不能处理的字符
// 	}
// 	//检查公式合理性
// 	for(int j=0;j<noi;j++)
// 	{
// 		fun.val[j]=j+1;
// 	}
// 	fun.prog=fun.TempProg;
// 	int re=fun.get_exp(&CurveValue);
// 	if(re>0)
// 	{
// 		static char *e[]={
// 			"语法错误",//"syntax error.",
// 			"不对称的括号",//"unbalanced parentheses",
// 			"非法运算符"//"no expression present"
// 		};
// 		QMessageBox::warning(NULL,"提示",QString(QLatin1String(e[re-1]))+m_Function);
// 		delete mrw;
// 		return ;
// 	}
// 	char name[20];
// 	strcpy(name,fun.csOutName.toStdString().c_str());
// 	int index[20];
// 	int index1=mrw->OpenTable(m_ObjList.at(0)->GetName().toStdString().c_str());
// 	if(index1<0) {
// 		delete mrw;
// 		return;
// 	}
// 	int fcount=mrw->GetTableFieldCount(index1);
// 	if(fcount<1) {
// 		delete mrw;
// 		AfxMessageBox("表无效！");
// 		return;
// 	}

// 	int rcount=mrw->GetTableRecordCount(index1);
// 	Slf_TABLE_FIELD *pInfo=new Slf_TABLE_FIELD[fcount+1];
// 	mrw->GetTableFieldInfo(index1,pInfo);
// 	QStringList strs;
// 	for(int j=0;j<fcount;j++)
// 	{
// 		strs.append(QString(pInfo[j].Name).toUpper());
// 	}
// 	QString Name=QString(name).toUpper();
	
// 	int oindexfield=strs.indexOf(Name);
// 	if(oindexfield<0) {
// 		AfxMessageBox(Name+"不存在，表格计算不支持创建新字段，无法进行计算！");
// 		delete mrw;
// 		delete []pInfo;
// 		return;
// 	}
// 	for(int i=0;i<noi;i++)
// 	{
// 		if(fun.csName[i]=="CURRENT_HD.DEP")continue;
// 		index[i]=strs.indexOf(fun.csName[i]);
// 		if(index[i]<0) {
// 			AfxMessageBox(fun.csName[i]+"不存在！");
// 			delete mrw;
// 			delete []pInfo;
// 			return;
// 		}
// 	}
// 	QString newnm=m_ObjList.at(0)->GetName()+"1";
// 	delete []pInfo;
// 	{
// 		//生成导入曲线
// 		int sdep=m_edit1->text().toFloat();
// 		int edep=m_edit2->text().toFloat();
// 		int sample=edep-sdep;
// 		int oindex=mrw->OpenTable((char*)newnm.toStdString().c_str());
// 		if(oindex<0) {
// 			mrw->CopyObject(m_ObjList.at(0)->GetName().toStdString().c_str(),newnm.toStdString().c_str());
// 			oindex=mrw->OpenTable((char*)newnm.toStdString().c_str());
// 		}
// 		for (int i=0; i<sample; i++)
// 		{
// 			for(int j=0;j<noi;j++)
// 			{
// 				if(fun.csName[j]=="CURRENT_HD.DEP") fun.val[j]=sdep+i;
// 				else {
// 					mrw->GetTableFieldData(index1,index[j],i+1,(char*)&fun.val[j]);
// 				}
// 			}
// 			fun.prog=fun.TempProg;
// 			fun.get_exp(&CurveValue);
// 			mrw->SetTableFieldData(oindex,oindexfield,(char*)&CurveValue,i+1);
// 		}
// 		mrw->CloseTable(oindex);
// 	}

// 	CObjWellLogTABLE *a=dynamic_cast<CObjWellLogTABLE *>(m_ObjList.at(0));
// //	AddToWellRound(newnm,a,GetClassID_WellLogTABLE(),TABLEE_OBJECT);
// 	CObjWelllogRound *pWelllogRound=dynamic_cast<CObjWelllogRound*>(a->GetWelllogRound());
// 	if(pWelllogRound) {
// 		PaiObject*pBase=pWelllogRound->GetObjectByName(newnm,GetClassID_WellLogTABLE());
// 		if(!dynamic_cast<CObjWellLogTABLE *>(pBase)){
// 			CObjWellLog * acurve=new CObjWellLogTABLE();
// 			if(acurve) {
// 				acurve->m_ObjectType=TABLEE_OBJECT;
// 				acurve->SetName(newnm);
// 				acurve->SetAliasName(newnm);
// 				acurve->SetSlfFileName(a->GetSlfFileName());
// 				acurve->SetWell(pWelllogRound->GetWell());
// 				pWelllogRound->AddChild(acurve);
// 			}
// 		}
// 	}
// 	Slf_FILE_MESSAGE msag;
// 	mrw->GetFileMessage(msag);
// 	delete mrw;
// 	GetObjectEvent().OnDeAttchData(a->GetSlfFileName(),newnm);
// 	GetObjectEvent().OnRefreshData(a->GetSlfFileName(),newnm,this);
// /*
// 	QStringList CurveNames;
// 	CurveNames.push_back(msag.WellName);
// 	CurveNames.push_back(m_FileName);

// 	CurveNames.push_back(newnm);
// 	PaiObject::m_EventAgent.ObjectPropertyChanged(GetProject(),"Compute",CurveNames);
// */
// 	QMessageBox::information(m_pDialog,"提示","计算完毕！",QMessageBox::Ok);
}
void CDataManagger::accept1()
{
// 	QDialog*pd=(QDialog*)sender();
// 	int sdep=m_edit1->text().toFloat();
// 	int edep=m_edit2->text().toFloat();
// 	if(sdep>edep)
// 	{
// 		QMessageBox::information(pd,"提示","起始深度不能大于终止深度！",QMessageBox::Yes);
// 		return;
// 	}
// 	QString newCurve;
// 	CMemRdWt *mrw=new CMemRdWt();
// 	if(!mrw->Open(m_FileName.toStdString().c_str(),CSlfIO::modeReadWrite)) {
// 		delete mrw;
// 		return;
// 	}
// 	QString m_Function=m_edit3->text();
// 	m_Function.toUpper();
// 	m_Function.replace("\"DEPTH\"","CURRENT_HD.DEP");
//     bool OutCurveExist=1;
// 	float CurveValue,rlev;
// 	Function fun;
// 	int noi=fun.GetExpress(m_Function);
// 	if(noi<0)
// 	{
// 		delete mrw;
// 		return ;//输入公式中没有“=”号，或含有不能处理的字符
// 	}
// 	//检查公式合理性
// 	for(int j=0;j<noi;j++)
// 	{
// 		fun.val[j]=j+1;
// 	}
// 	fun.prog=fun.TempProg;
// 	int re=fun.get_exp(&CurveValue);
// 	if(re>0)
// 	{
// 		static char *e[]={
// 			"语法错误",//"syntax error.",
// 			"不对称的括号",//"unbalanced parentheses",
// 			"非法运算符"//"no expression present"
// 		};
// 		QMessageBox::warning(pd,"提示",QString(QLatin1String(e[re-1]))+m_Function);
// 		delete mrw;
// 		return ;
// 	}
// 	char name[20];
// 	strcpy(name,fun.csOutName.toStdString().c_str());
// 	int in=mrw->FindObjectIndex(name);
// 	if(in>=0)
// 	{
// 		short objectType=mrw->GetObjectType(in);
// 		short Attribute,SubAttribute;
// 		mrw->GetObjectAttribute(in,&Attribute,&SubAttribute);
// 		if(mrw->GetObjectStatus(in)!=0)//删除状态
// 		{
// 			QMessageBox::warning(m_pDialog,"提示",fun.csOutName+"曲线已存在，但该曲线处于删除状态，无法进行计算 !!!");
// 			delete mrw;
// 			return ;
// 		}
// 		if(objectType >CARD_OBJECT||objectType==0||objectType==CURVE_OBJECT)
// 		{

// 		}
// 		else
// 		{
// 			QMessageBox::warning(m_pDialog,"提示",fun.csOutName+"对象已存在，但其属性不是曲线 !!!");
// 			delete mrw;
// 			return ;
// 		}
// 	}
// 	else
// 	{   //     导入曲线不存在
// 		QString ss="目标曲线"+fun.csOutName+"不存在 \n 是否生成  ？\n";
// 		int flag = QMessageBox::warning(m_pDialog,tr("提示"),ss,QMessageBox::Yes,QMessageBox::No);
// 		if(flag != QMessageBox::Yes){
// 			delete mrw;
// 			return ;
// 		}
// 		OutCurveExist=0;
// 	}
// 	int index[20],indexout;
// 	float MinRlev=9999;
// 	DWORD CurveSample[20];
// 	float CurveRlev[20];
// 	Slf_CURVE info;
// 	for(int i=0;i<noi;i++)
// 	{
// 		if(fun.csName[i]=="CURRENT_HD.DEP")continue;
// 		if(mrw->GetObjectType(fun.csName[i].toStdString().c_str())!=CURVE_OBJECT)
// 		{
// 			QMessageBox::warning(m_pDialog,"提示","输入曲线"+fun.csName[i]+"不是曲线类型，不能进行计算!!!\r\n请参考常规曲线计算规则，输入正确的计算公式");
// 			delete mrw;
// 			return ;
// 		}
// 		index[i]=mrw->OpenCurve(fun.csName[i].toStdString().c_str());
// 		if(index[i]<0)
// 		{
// 			delete mrw;
// 			QMessageBox::warning(m_pDialog,"提示","打开曲线"+fun.csName[i]+"出错，不能进行计算!!!");
// 			return ;
// 		}
// 		mrw->GetCurveInfo(index[i],&info);
// 		if(MinRlev>info.DepLevel)MinRlev=info.DepLevel;
// 		CurveRlev[i]=info.DepLevel;
// 	}
// 	if(MinRlev==9999)MinRlev=0.125;//表达式中没有实际曲线，只有CURRENT_HD.DEP“深度”标识
// 	//生成导入曲线

// 	if(OutCurveExist==0)
// 	{
// 		indexout=-1;
// 		for(int i=0;i<noi;i++)
// 		{
// 			if(fun.csName[i]=="CURRENT_HD.DEP")continue;
// 			mrw->GetCurveInfo(index[i],&info);
// 			sprintf(info.AliasName,"%s",fun.csOutName.toStdString().c_str());
// 			sprintf(info.Name,"%s",fun.csOutName.toStdString().c_str());
// 			info.StartDepth=m_edit1->text().toFloat();
// 			info.EndDepth=m_edit2->text().toFloat();
// 			indexout=mrw->OpenCurve(&info);
// 			break;
// 		}
// 		if(indexout==-1)//表达式中没有实际曲线，只有CURRENT_HD.DEP“深度”标识
// 		{
// 			newCurve=fun.csOutName;
// 			sprintf(info.AliasName,"%s",fun.csOutName.toStdString().c_str());
// 			sprintf(info.Name,"%s",fun.csOutName.toStdString().c_str());
// 			info.StartDepth=m_edit1->text().toFloat();
// 			info.EndDepth=m_edit2->text().toFloat();
// 			info.DepLevel=0.125;
// 			info.CodeLen=4;
// 			info.RepCode=4;
// 			info.DefVal=-999.25;
// 			info.MaxValue=100;
// 			info.MinValue=0;
// 			strcpy(info.DepthHZUnit,"米");
// 			strcpy(info.DepthUnit,"m");
// 			strcpy(info.Unit,"");
// 			strcpy(info.AliasUnit,"");
// 			indexout=mrw->OpenCurve(&info);
// 		}
// 	}
// 	else
// 	{
// 		indexout=mrw->OpenCurve(fun.csOutName.toStdString().c_str());
// 		if(indexout>-1)mrw->GetCurveInfo(indexout,&info);
// 	}
// 	if(indexout<0)
// 	{
// 		delete mrw;
// 		QMessageBox::warning(m_pDialog,"提示","导入曲线不存在，而且输入曲线中没有可参考的常规曲线，无法进行曲线计算\r\n请参考常规曲线计算规则，输入正确的计算公式");
// 		return ;
// 	}
// 	//检查导入曲线深度
// 	rlev = info.DepLevel;
// 	sdep = info.StartDepth;
// 	edep = info.EndDepth ;
// 	if(MinRlev>rlev)MinRlev=rlev;
// 	if ( m_edit1->text().toFloat() < sdep-rlev || m_edit2->text().toFloat() > edep+rlev)
// 	{
// 		int flag=QMessageBox::warning(m_pDialog,"提示","导入曲线的深度范围("+m_edit1->text()+"--"+m_edit2->text()+")超出输入曲线("+QString::number(sdep)+"--"+QString::number(edep)+"\n继续计算吗?",QMessageBox::Yes,QMessageBox::No);
// 		if(flag != QMessageBox::Yes){
// 			delete mrw;
// 			return ;
// 		}
// 	}
// 	int sample=(int)((m_edit2->text().toFloat()-m_edit1->text().toFloat())/rlev+1.5);//0.5);
// 	int sampleIn=(int)((m_edit2->text().toFloat()-m_edit1->text().toFloat())/MinRlev+1.5);//0.5);
// 	float **indata,*outdata;
// 	indata=new float*[noi];
// 	outdata=new float[sample+10];
// 	float *tDep,*aDep;
// 	tDep=new float[sample];
// 	for(int k=0; k<sample; k++) tDep[k]=sdep+k*rlev;
// 	for(int j=0;j<noi;j++)
// 	{
// 		if(fun.csName[j]=="CURRENT_HD.DEP")continue;
// 		indata[j]=new float[sampleIn];
// 		//whp change 2018.10.15 保证读写一致
// 		CurveSample[j]=(m_edit2->text().toFloat()-m_edit1->text().toFloat())/CurveRlev[j]+1.5;//0.5;
// 		mrw->ReadCurve(index[j],m_edit1->text().toFloat(),CurveSample[j],&indata[j][0]);
// 		if(fabs(CurveRlev[j]-rlev)/rlev>0.1)
// 		{
// 			aDep=new float[CurveSample[j]];
// 			for(int k=0; k<CurveSample[j]; k++) aDep[k]=sdep+k*CurveRlev[j];
// 			Resample::ReSampling(&indata[j][0],CurveSample[j],1,aDep,tDep,sample);
// 			delete []aDep;
// 		}
// 	}
// 	for (int i=0; i<sample; i++)
// 	{
// 		//sdep = sdeps + rlev * i;
// 		for(int j=0;j<noi;j++)
// 		{
// 			if(fun.csName[j]=="CURRENT_HD.DEP")fun.val[j]=m_edit1->text().toFloat()+i*rlev;
// 			else fun.val[j]=indata[j][i];
// 		}
// 		fun.prog=fun.TempProg;
// 		fun.get_exp(&CurveValue);
// 		outdata[i]=CurveValue;
// 		//2013.11.20 whp add for 为曲线计算添加数值类型选项：常规，不控制数值大小；方位：控制到0-360

// 	}
// 	mrw->WriteCurve(indexout,m_edit1->text().toFloat(),sample,&outdata[0]);
// 	delete []tDep;

// 	for (int i=0; i<noi;i++)
// 	{
// 		if(fun.csName[i]=="CURRENT_HD.DEP")continue;
// 		mrw->CloseCurve(index[i]);
// 	}
// 	mrw->CloseCurve(indexout);

// 	for(int j=0;j<noi;j++)
// 	{
// 		if(fun.csName[j]=="CURRENT_HD.DEP")continue;
// 		delete indata[j];
// 	}
// 	delete []indata;
// 	delete []outdata;
// 	Slf_FILE_MESSAGE msag;
// 	mrw->GetFileMessage(msag);
// 	delete mrw;
// 	GetObjectEvent().OnDeAttchData(m_FileName,fun.csOutName);
// 	GetObjectEvent().OnRefreshData(m_FileName,fun.csOutName,this);

// 	QStringList CurveNames;
// 	CurveNames.push_back(msag.WellName);
// 	CurveNames.push_back(m_FileName);
// 	CurveNames.push_back(fun.csOutName);
// 	if(!newCurve.isEmpty())CurveNames.push_back(newCurve);
// 	PaiObject::m_EventAgent.ObjectPropertyChanged(GetProject(),"Compute",CurveNames);

// 	QMessageBox::information(m_pDialog,"提示","计算完毕！",QMessageBox::Ok);
}
//曲线计算
// void CDataManagger::CurveCompute(QList<CObjWellLog*>objs,int no)
// {
// 	m_ObjList=objs;
// 	if(objs.count()==1)
// 	{
// 		QString FileName=objs.at(0)->GetSlfFileName();
// 		QDialog dialog(NULL);
// 		dialog.setModal(false);
// 		m_pDialog=&dialog;
// 		Qt::WindowFlags flags = dialog.windowFlags();
// 		flags |= Qt::WindowStaysOnTopHint;
// 		flags &= ~Qt::WindowContextHelpButtonHint;
// 		dialog.setWindowFlags(flags);
// 		dialog.setWindowTitle(QString("曲线计算"));
// 		QFormLayout form(&dialog);
// 		m_FileName=FileName;
// 		CMemRdWt *mrw=new CMemRdWt();
// 		if(!mrw->Open(FileName.toStdString().c_str(),CSlfIO::modeReadWrite)) {
// 			delete mrw;
// 			return;
// 		}
// 		int index=mrw->OpenTable(objs.at(0)->GetName().toStdString().c_str());
// 		if(index<0) {
// 			delete mrw;
// 			return;
// 		}
// 		int fcount=mrw->GetTableFieldCount(index);
// 		if(fcount<1) {
// 			delete mrw;
// 			AfxMessageBox("表无效！");
// ;			return;
// 		}

// 		int rcount=mrw->GetTableRecordCount(index);
// 		Slf_TABLE_FIELD *pInfo=new Slf_TABLE_FIELD[fcount+1];
// 		mrw->GetTableFieldInfo(index,pInfo);
// 		delete mrw;
// 		if(no>=fcount) no=fcount-1;
// 		if(no<0) no=0;
// 		m_CurveName=pInfo[no].Name;
// 		delete []pInfo;
// 		// 开始深度
// 		QString value1 = QString("开始层号: ");
// 		QLineEdit *edit1 = new QLineEdit(&dialog);
// 		m_edit1=edit1;
// 		form.addRow(value1, edit1);
// 		edit1->setText(QString::number(0));
// 		// 终止深度
// 		QString value2 = QString("终止层号: ");
// 		QLineEdit *edit2 = new QLineEdit(&dialog);
// 		m_edit2=edit2;
// 		form.addRow(value2, edit2);
// 		edit2->setText(QString::number(rcount));
// 		//计算公式
// 		QString value3 = QString("计算公式: ");
// 		QLineEdit *edit3 = new QLineEdit(&dialog);
// 		form.addRow(value3, edit3);

// 		QString ss=m_CurveName+"=1.0*"+m_CurveName+"+0.0";
// 		edit3->setText(ss);
// 		m_edit2=edit2;
// 		m_edit3=edit3;
// 		QString value4 = QString("\n常用数学运算符:\n    加:+,减:-,乘:*,除:/,取余:%,乘方:^,对数:!\n")+
// 			QString("    如：PAR =SP/CAL+RT^2.5-10!AC\n    10!表示取以10为底的对数,1! 表示取自然对数");
// 		QString value5 = QString("\n规则及约定:\n    1、输入对象必须是常规曲线名、深度标识或常量\n")+
// 			QString("      如:GR=2*GR+5；GR2=45；TEMP=18+0.038*\"DEPTH\"\n")+
// 			QString("      其中：\"DEPTH\"表示深度；\n")+
// 			QString("    2、当导入曲线不存在时:\n      如果有输入曲线存在，程序自动根据第一条输入曲线的属性产生导入曲线；\n")+
// 			QString("      否则，程序自动产生一条浮点类型的导入曲线，采样间隔为0.125。");
// 		form.addRow(new QLabel(value4));
// 		form.addRow(new QLabel(value5));
// 		// Add Cancel and OK button
// 		QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
// 			Qt::Horizontal, &dialog);
// 		form.addRow(&buttonBox);
// 		QObject::connect(&buttonBox, SIGNAL(accepted()), this, SLOT(accept2()));
// 		QObject::connect(&buttonBox, SIGNAL(rejected()), &dialog, SLOT(reject()));
// 		// Process when OK button is clicked
// 		dialog.show();
// 		if (dialog.exec() == QDialog::Accepted)
// 		{
// 		}
// //		pai::graphics::CDataImport::ChangetoSlf(FileName,NULL);
// 	}
// }

// void CDataManagger::CurveCompute(const QString& FileName,const QStringList& CurveNameList)
// {
// 	m_CurveNameList=CurveNameList;
// 	if(CurveNameList.count()==1)
// 	{
// 		QDialog dialog(NULL);
// 		dialog.setModal(false);
// 		m_pDialog=&dialog;
// 		Qt::WindowFlags flags = dialog.windowFlags();
// 		flags |= Qt::WindowStaysOnTopHint;
// 		flags &= ~Qt::WindowContextHelpButtonHint;
// 		dialog.setWindowFlags(flags);
// 		dialog.setWindowTitle(QString("曲线计算"));
// 		QFormLayout form(&dialog);
// 		QString CurveName=CurveNameList[0];
		
// 		m_CurveName=CurveNameList[0];
// 		m_FileName=FileName;
// 		CMemRdWt *mrw=new CMemRdWt();
// 		if(!mrw->Open(FileName.toStdString().c_str(),CSlfIO::modeReadWrite)) {
// 			delete mrw;
// 			return;
// 		}
// 		int index=mrw->OpenCurve(CurveName.toStdString().c_str());
// 		if(index<0) {
// 			delete mrw;
// 			return;
// 		}
// 		Slf_CURVE pInfo;
// 		mrw->GetCurveInfo(index,&pInfo);
// 		Slf_FILE_MESSAGE msag;
// 		mrw->GetFileMessage(msag);
// 		delete mrw;
// 		// 开始深度
// 		QString value1 = QString("开始深度: ");
// 		QLineEdit *edit1 = new QLineEdit(&dialog);
// 		m_edit1=edit1;
// 		form.addRow(value1, edit1);
// 		edit1->setText(QString::number(pInfo.StartDepth));
// 		edit1->setValidator(new QDoubleValidator(-9999999,9999999,6,this));

// 		// 终止深度
// 		QString value2 = QString("终止深度: ");
// 		QLineEdit *edit2 = new QLineEdit(&dialog);
// 		edit2->setValidator(new QDoubleValidator(-9999999,9999999,6,this));
// 		m_edit2=edit2;
// 		form.addRow(value2, edit2);
// 		edit2->setText(QString::number(pInfo.EndDepth));
// 		//计算公式
// 		QString value3 = QString("计算公式: ");
// 		QLineEdit *edit3 = new QLineEdit(&dialog);
// 		form.addRow(value3, edit3);
// 		QString ss=CurveName+"=1.0*"+CurveName+"+0.0";
// 		edit3->setText(ss);
// 		m_edit2=edit2;
// 		m_edit3=edit3;
// 		QString value4 = QString("\n常用数学运算符:\n    加:+,减:-,乘:*,除:/,取余:%,乘方:^,对数:!\n")+
// 			QString("    如：PAR =SP/CAL+RT^2.5-10!AC\n    10!表示取以10为底的对数,1! 表示取自然对数");
// 		QString value5 = QString("\n规则及约定:\n    1、输入对象必须是常规曲线名、深度标识或常量\n")+
// 			QString("      如:GR=2*GR+5；GR2=45；TEMP=18+0.038*\"DEPTH\"\n")+
// 			QString("      其中：\"DEPTH\"表示深度；\n")+
// 			QString("    2、当导入曲线不存在时:\n      如果有输入曲线存在，程序自动根据第一条输入曲线的属性产生导入曲线；\n")+
// 			QString("      否则，程序自动产生一条浮点类型的导入曲线，采样间隔为0.125。");
// 		form.addRow(new QLabel(value4));
// 		form.addRow(new QLabel(value5));
// 		// Add Cancel and OK button
// 		QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
// 			Qt::Horizontal, &dialog);
// 		form.addRow(&buttonBox);
// 		QObject::connect(&buttonBox, SIGNAL(accepted()), this, SLOT(accept1()));
// 		QObject::connect(&buttonBox, SIGNAL(rejected()), &dialog, SLOT(reject()));
// 		// Process when OK button is clicked
// 		dialog.show();
// 		if (dialog.exec() == QDialog::Accepted)
// 		{
// 		}
// 		pai::graphics::CDataImport::ChangetoSlf(FileName,NULL);
// 	}
// 	else
// 	{
// 		CCurveComputerDlg *pDlg=new CCurveComputerDlg();
// 		pDlg->FileName=FileName;
// 		pDlg->CurveNameList=CurveNameList;
// 		pDlg->init();//FileName, CurveNameList);
// 		pDlg->setModal(false);
// 		Qt::WindowFlags flags = pDlg->windowFlags();
// 		flags |= Qt::WindowStaysOnTopHint;
// 		pDlg->setWindowFlags(flags);
// 		pDlg->exec();
// 		delete pDlg;
// 		pDlg=NULL;
// 		pai::graphics::CDataImport::ChangetoSlf(FileName,NULL);
// 		QMessageBox::information(NULL,"提示","计算完毕！",QMessageBox::Ok);
// 	}
// }

void CDataManagger::CallDisplayWaveOrCurve(int Type, const QString& FileName,
    const QString& CurveName, QWidget* parent)
{
    CLogIO *logio=new CLogIO();
    if(!logio->Open(FileName.toStdString().c_str(),CSlfIO::modeRead))
    {
        delete logio;
        QMessageBox::warning(NULL,"提示","打开文件"+FileName+"错误");
        return ;
    }

    //常规曲线
    if (Type == 0)
    {
        int index=logio->OpenCurve(CurveName.toStdString().c_str());
        if(index<0) {
            delete logio;
            return;
        }
        logio->CloseCurve(index);
        delete logio;
        ShowCurve *pDlg=parent->findChild<ShowCurve*>("curveView");
        if(NULL == pDlg)
        {
            pDlg=new ShowCurve(parent);
            pDlg->setObjectName("curveView");
        }
        pDlg->FileName=FileName;
        pDlg->CurveName=CurveName;
        pDlg->init();
        pDlg->show();
        //波列 1
    }else
    {
        int index=logio->OpenWave(CurveName.toStdString().c_str());
        if(index<0) {
            delete logio;
            return;
        }
        logio->CloseWave(index);
        delete logio;
        ShowWave *pDlgwage=parent->findChild<ShowWave*>("waveView");
        if(NULL == pDlgwage)
        {
            pDlgwage=new ShowWave(parent);
            pDlgwage->setObjectName("waveView");
        }
        pDlgwage->FileName=FileName;
        pDlgwage->WaveName=CurveName;
        pDlgwage->init();
        pDlgwage->show();
    }

}

// void CDataManagger::CallDisplayCurveVerChange(int Type, const QString& FileName,
// 	const QString& CurveName, QWidget* parent, int value, float tipValue)
// {
// 	//常规曲线
// 	if (Type == 0)
// 	{
// 		ShowCurve *pDlg=parent->findChild<ShowCurve*>("curveView");
// 		if(NULL == pDlg)
// 		{
// 			pDlg=new ShowCurve(parent);
// 			pDlg->setObjectName("curveView");
// 			pDlg->FileName=FileName;
// 			pDlg->CurveName=CurveName;
// 			pDlg->init();
// 			pDlg->show();
// 		}
		
// 		pDlg->linkVerDeptSliderValueChange(value, tipValue);
		
// 	}
	
// }

// void CDataManagger::sendTableP2Mgr(QWidget* parent, QScrollBar *p,  QTableWidget *t)
// {
// 	ShowCurve *pDlg = parent->findChild<ShowCurve*>("curveView");
// 	if(NULL == pDlg) return;

// 	pDlg->setTableBro(p);
// 	pDlg->setCurveTable(t);
// }

/*
void CDataManagger::ListMessage(const QString& listName,const QStringList& header,const QStringList& listMessage)
{
	CMyListDlg *pDlg=new CMyListDlg();
	pDlg->setWindowTitle(listName);
	int col=header.size();
	int row=listMessage.size()/header.size();
	pDlg->init(row,col,header);
	for(int i=0;i<row;i++)
	{
		for(int j=0;j<col;j++)
			pDlg->m_pUI->tableWidget->setItem(i,j,new QTableWidgetItem(listMessage.at(i*col+j)));
	}
	pDlg->exec();
}*/