#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
	#include <Windows.h>
#endif // WIN32
#include "slf.h"
#include <QDir>
#include <QDateTime>
#include <QString>
#pragma execution_character_set("utf-8")
int RepSize[12]={4,
	sizeof(int),
	sizeof(short),
	sizeof(long long),
	sizeof(float),
	sizeof(double),
	sizeof(char),
	sizeof(char),
	sizeof(unsigned char),
	sizeof(unsigned short),
	sizeof(unsigned int),
	sizeof(unsigned int)
};

const char *Rep_STR[]={
	"INT","SHORT","LONG","FLOAT","DOUBLE","STRING","CHAR","UCHAR","USHORT","UINT","ULONG"
};
int Slf_Int(float depth,float stdep,float rlev)
{
	float ddepnum=(depth-stdep)/rlev;
	int First=0;
	if(ddepnum>=0) First=(int)(ddepnum+0.5);
	else First=(int)(ddepnum-0.5);
	return First;
}
CString MemName(CString wellname,CString Curve)
{
	CString cs=wellname+("_")+Curve;
	return 	cs.GetString();
}

wchar_t* AnsiToUnicode(const char* szStr)
{
	int nLen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, NULL, 0 );
	if (nLen == 0)
	{
		return NULL;
	}
	wchar_t* pResult = new wchar_t[nLen];
	MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, pResult, nLen );
	return pResult;
}
int IsMappingMem(const char *MemName)
{
	QString slf1=MemName;
	slf1.replace("\\","/");
	slf1.replace(".","_");
	wchar_t *pname=AnsiToUnicode(slf1.toStdString().c_str());
	HANDLE	hMapFile = OpenFileMapping(FILE_MAP_READ, 
		false,
		pname);
	DWORD fInit =hMapFile>0?1:0;
	// (GetLastError() == ERROR_ALREADY_EXISTS);
	CloseHandle(hMapFile);
	return fInit;
}
bool MappingMem(HANDLE *hHandle,LPSTR *hMem,int len,const char* name)
{
	QString slf1=name;
	slf1.replace("\\","/");
	slf1.replace(".","_");
	wchar_t *pname=AnsiToUnicode(slf1.toStdString().c_str());
	HANDLE	hMapFile = OpenFileMapping(FILE_MAP_READ|FILE_MAP_WRITE, 
		false,
		pname);
	if(!hMapFile)
	{
		*hHandle = CreateFileMapping((HANDLE)-1, 
			(LPSECURITY_ATTRIBUTES) NULL, 
			PAGE_READWRITE, 
			(DWORD)0, 
			(DWORD)len,            // size: low 32-bits
			pname);     // name of map object
	}
	else *hHandle=hMapFile;
	delete pname;
	if (*hHandle == NULL) {
		return FALSE;
	}
	*hMem =      (LPSTR )MapViewOfFile(
		*hHandle,     // object to map view of
		FILE_MAP_WRITE, // read/write access
		0,              // high offset:  map from
		0,              // low offset:   beginning
		0);             // default: map entire file
	if (*hMem == NULL) return FALSE;	
	return TRUE;
}

void CloseView(HANDLE hMapObject,LPVOID lpvMem)
{
	if(lpvMem)UnmapViewOfFile(lpvMem);
	if(hMapObject)CloseHandle(hMapObject);	
}

time_t StringToTime(char * szTime) 
{ 
    struct tm tm1; 
	memset(&tm1,0,sizeof(tm));
	time_t time1;
	sscanf(szTime, "%4d-%2d-%2d %2d:%2d:%2d",    
		&tm1.tm_year, 
		&tm1.tm_mon, 
		&tm1.tm_mday, 
		&tm1.tm_hour, 
		&tm1.tm_min, 
		&tm1.tm_sec);              
	tm1.tm_year -= 1900; 
	tm1.tm_mon --; 
	tm1.tm_isdst=-1;   
	time1 = mktime(&tm1); 
	return time1;
} 

void CSlfIO::InitWis(int BlockLen,int MaxObjectNumber, int MachineType)
{
	m_Head.BlockLen=BlockLen;
	m_Head.MaxObjectNumber=MaxObjectNumber;
	m_Head.MachineType=MachineType;
	m_Head.ObjectNumber=0;
	m_Head.EntryOffset=sizeof(Slf_HEAD)+10;
	m_Head.DataOffset=(int)((m_Head.EntryOffset+sizeof(Slf_OBJECT_ENTRY)*m_Head.MaxObjectNumber)/(float)BlockLen+(float)0.5)*BlockLen;
	m_Head.FileSize=m_Head.DataOffset;
	time_t createTime;
	gmtime(&createTime);
	m_Head.TimeCreate=(unsigned int)createTime;
	strcpy(m_Head.Reserved,"WIS 1.0");
	WriteWisHead();
	m_ObjectEntry=new Slf_OBJECT_ENTRY[m_Head.MaxObjectNumber];
	Slf_Info_Head=new char *[m_Head.MaxObjectNumber];
	for(int i=0;i<m_Head.MaxObjectNumber;i++) Slf_Info_Head[i]=NULL;
	WriteWisObjectEntry();
}
int CSlfIO::ReadWisHead()
{
	mFile->seek(10L);
	return mFile->read(reinterpret_cast<char*>(&m_Head),sizeof(Slf_HEAD));
}
int CSlfIO::WriteWisHead()
{
	mFile->seek(0);
	char buf[100];
	int len=mFile->read(buf,10);
	if(len>=10) mFile->seek(10);
	else mFile->write("WIS 1.0   ",10);
	if(m_Head.MaxObjectNumber==0) {
		AfxMessageBox("错误文件头！");
		return 0;
	}
	mFile->write(reinterpret_cast<char*>(&m_Head),sizeof(Slf_HEAD));
	mFile->flush();
	return 1;
}
int CSlfIO::ReadWisObjectEntry()
{
	mFile->seek(m_Head.EntryOffset);
	int sz=sizeof(Slf_OBJECT_ENTRY);
	return mFile->read(reinterpret_cast<char*>(m_ObjectEntry),sizeof(Slf_OBJECT_ENTRY)*m_Head.ObjectNumber);
}
bool CSlfIO::IsObject(int index)
{
	if(index<0) return false;
	int FieldNum=GetSlfTableFieldCount(index);
	if(FieldNum<1)
	{
		return 0;
	}
	int rec=GetSlfTableRecordCount(index);
	int reclen=GetSlfTableRecordLength(index);
	Slf_TABLE_ENTRY obj;
	GetSlfObjectEntry(index,&obj);
	Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldNum];
	memset(pf,0,sizeof(Slf_OBJECT_FIELD)*FieldNum);
	GetSlfTableFieldInfo(index,pf);
	int pos=0;
	if(pf[0].Start>10000000) {
		delete []pf;
		return 0;
	}
	if(pf[0].Start<=-4.3160208e+008) {
		delete []pf;
		return 0;
	}
	if(pf[0].RepCode<0||pf[0].RepCode>REPR_ULONG){
		delete []pf;
		return 0;
	}
	if(pf[0].CodeLength<0){
		delete []pf;
		return 0;
	}
	if(FieldNum>1) {
		if(pf[1].CodeLength<=0) {
			delete []pf;
			return 0;
		}
		if(pf[1].ArrayNum<0) {
			delete []pf;
			return 0;
		}
		if(pf[1].RepCode<0) {
			delete []pf;
			return 0;
		}
	}
	delete []pf;
	return true;
}
int   CSlfIO::WriteWisObjectEntry()
{
	mFile->seek(m_Head.EntryOffset);
	for(int i=0;i<m_Head.ObjectNumber;i++)
	{
		strupr(m_ObjectEntry[i].Name);
	}
	mFile->write(reinterpret_cast<char*>(m_ObjectEntry),sizeof(Slf_OBJECT_ENTRY)*m_Head.ObjectNumber);
	mFile->flush();
	return 1;
}
int   CSlfIO::WriteWisObjectEntry(int index,Slf_OBJECT_ENTRY *pEntry)
{
	if(index<0) return 0;
	mFile->seek(m_Head.EntryOffset+sizeof(Slf_OBJECT_ENTRY)*index);
	if(pEntry) mFile->write(reinterpret_cast<char*>(pEntry),sizeof(Slf_OBJECT_ENTRY));
	else mFile->write(reinterpret_cast<char*>(&m_ObjectEntry[index]),sizeof(Slf_OBJECT_ENTRY));
	mFile->flush();
	return 1;
}
bool CSlfIO::InitChannelValue(int index)
{
	Slf_CHANNEL *m_Channel =(Slf_CHANNEL *)Slf_Info_Head[index];
	if(index>-1&&index<m_Head.MaxObjectNumber) {
		strcpy(m_Channel->AliasName,"none");
		strcpy(m_Channel->AliasUnit,"none");
		m_Channel->CodeLen=0;
		m_Channel->NumOfDimension=1;
		return TRUE;
	}
	return FALSE;
}
int CSlfIO::ReadWisChannelInfo(int index,Slf_CHANNEL *pInfo)
{
	int i=0;
	mFile->seek(m_ObjectEntry[index].Position);
	if(pInfo) i=mFile->read(reinterpret_cast<char*>(pInfo),sizeof(Slf_CHANNEL));
	else i=mFile->read(Slf_Info_Head[index],sizeof(Slf_CHANNEL));
	return i;
}
int CSlfIO::WriteWisChannelInfo(int index,Slf_CHANNEL *pInfo)
{
	mFile->seek(m_ObjectEntry[index].Position);
	char *buf=new char[m_Head.BlockLen+1];
	if(pInfo) {
		memmove(buf,pInfo, sizeof(Slf_CHANNEL));
		mFile->write(buf,m_Head.BlockLen);
		if(Slf_Info_Head[index]) memmove(Slf_Info_Head[index],pInfo, sizeof(Slf_CHANNEL));
	}
	else
	{
		memmove(buf,Slf_Info_Head[index], sizeof(Slf_CHANNEL));
		mFile->write(buf,m_Head.BlockLen);
	}
	mFile->flush();
	delete []buf;
	return 1;
}
int CSlfIO::ReadWisStreamInfo(int index)
{
	mFile->seek(m_ObjectEntry[index].Position);
	return mFile->read(Slf_Info_Head[index],sizeof(DWORD));
}
int   CSlfIO::WriteWisStreamInfo(int index)
{
	mFile->seek(m_ObjectEntry[index].Position);
	mFile->write(Slf_Info_Head[index],sizeof(DWORD));
	mFile->flush();
	return 1;
}
bool CSlfIO::ExpandWisObject(int index, DWORD BlockNum)
{
	//	return 0;
	DWORD point1,point,pos=m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
	int j=0,len=WisFindFreeSpace(BlockNum,index);
	if(len<=0) return FALSE;
	char *buffer=new char [len+1];
	point =m_Head.FileSize;
	point1=m_Head.FileSize+m_Head.BlockLen*BlockNum;
	while(point>=pos) {
		if(point<len) break;
		point-=len;
		mFile->seek(point);
		mFile->read(buffer,len);
		if(point1<len) break;
		point1-=len;
		mFile->seek(point1);
		mFile->write(buffer,len);
	}
	memset(buffer,0,len);
	mFile->seek(pos);
	mFile->write(buffer,len);
	mFile->flush();
	delete []buffer;

	for(j=index+1;j<m_Head.ObjectNumber;j++) {
		m_ObjectEntry[j].Position+=m_Head.BlockLen*BlockNum;
	}
	m_ObjectEntry[index].BlockNum+=BlockNum;
	WriteWisObjectEntry();
	m_Head.FileSize+=len;
	WriteWisHead();
	return TRUE;
}
int CSlfIO::WisFindFreeSpace(DWORD BlockNum,int nExceptIndex)
{
	DWORD len=BlockNum*m_Head.BlockLen+m_Head.FileSize;
	mFile->resize(len);
	if(mFile->size()==len) return BlockNum*m_Head.BlockLen;
	return 0;
}
CSlfIO::CSlfIO()
{
	mHandle=NULL;
	m_Value=NULL;
	m_ObjectEntry=NULL;
	m_SlfObjectEntry=NULL;
	Slf_Info_Head=NULL;
	mFile=NULL;
	IsWis=0;
	memset((char *)&m_SlfHead,0,sizeof(m_SlfHead));
	memset((char *)&m_Head,0,sizeof(m_Head));
	IsChange=false;
	isShengLi=0;
} 
CSlfIO::CSlfIO(const char* LogName,int FileType)
{
	mHandle=NULL;
	m_Value=NULL;
	m_ObjectEntry=NULL;
	m_SlfObjectEntry=NULL;
	Slf_Info_Head=NULL;
	mFile=NULL;
	IsWis=FileType;
	memset((char *)&m_SlfHead,0,sizeof(m_SlfHead));
	memset((char *)&m_Head,0,sizeof(m_Head));
	if(!Open(LogName,modeReadWrite,1024,1024,0,FileType))
	{    
		AfxMessageBox("Open File Error !");
	};
	isShengLi=0;
}       
CSlfIO::~CSlfIO()
{
	Close();
}
QString ConvertDataByFloat(float fValue)
{
	if(fValue<0)
		return "";
	if(abs(fValue)<0.000001)//等于0
	{
		return "";
	}
	if(abs(fValue-9999999)<0.000001)//等于9999999为0
	{
		return "0";
	}
	QString szTemp=QString::number(fValue,'f',6);
	QString szBit(szTemp[0]);
	int nBit =szBit.toInt();
	//小于6
	if(nBit<6)
	{
		szTemp = szTemp.mid(1,szTemp.size()-1);
		szTemp = QString::number(szTemp.toFloat(),'f',nBit);
		return szTemp;
	}
	else
	{
		szTemp = szTemp.mid(1,szTemp.size()-1);
		szTemp = QString::number(szTemp.toFloat(),'f',0);
		return szTemp;
	}
}
float ConvertDataByString(QString szText)
{
	//空
	if(szText.isEmpty())
		return -99999.f;

	bool bOK;
	float fTemp = szText.toFloat(&bOK);
	//转换失败
	if(!bOK)
		return -99999.f;
	//等于0
	if(abs(fTemp)<0.000001)
	{
		return 9999999.f;
	}

	//小于0
	if(fTemp<0)
		return -99999.f;;
	//有小数点
	if(szText.contains("."))
	{
		auto rList =szText.split(".");
		int nNum =rList[1].size();
		//不超过6
		if(nNum>6)
			nNum =6;
		if(nNum==0)//无小数点
			szText.insert(0,QString::number(7));
		else
			szText.insert(0,QString::number(nNum));
	}
	//无小数点
	else
		szText.insert(0,QString::number(7));
	return szText.toFloat();
}

bool  CSlfIO::Open(const char* LogName,unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType,int FileType)
{
	CString cs=LogName;
	strcpy(m_LogFileName,LogName);
	if(nOpenFlags==modeCreate) {
		return Open(nOpenFlags,BlockLen,MaxObjectNumber,MachineType,FileType);
	}
	else if(nOpenFlags==modeRead) {
		QFileInfo w(m_LogFileName);
		if(w.isFile()) {
		}
		else return false;
	}
	char buf[20];
	DWORD r;
	QString cs1=m_LogFileName;
	int i=cs1.lastIndexOf("\\");
	int j=cs1.lastIndexOf("/");
	if(j>i) i=j;
	cs1=cs1.left(i);
	QDir dir;
	if(!dir.exists(cs1)) dir.mkdir(cs1);
	if(dir.exists(m_LogFileName)) {
		QFile* aFile=new QFile(m_LogFileName);
		aFile->open(QIODevice::ReadWrite);
		if(aFile->read(&buf[0],8)==8) {//文件已存在
			typedef struct tagSlf3_FILE_MESSAGE
			{
				//起始位置	变量名称	字节长度	描  述
				char	AreaName[64];//	64	油矿名称
				char	OilCompanyName[64];//	64	公司名称
				char	WellName[64];//	64	井名
				char	WellType[20];//	20	井类型：直井、斜井
				float	Xcoor;//	4	大地x坐标
				float	Ycoor;//	4	大地y坐标
				float	Altitude;//	4	海拔高度
				float	Kelly;//	4	补心高度
				float	StartDepth;//	4	起始深度
				float	EndDepth;//	4	终止深度
				__time32_t	StartDrillDate;//	4	开钻时间
				__time32_t	EndDrillDate;//	4	完钻时间
				__time32_t  LoggingDate;//	4	测井时间

				char LogCompanyName[64];//	64 测井公司
				char LoggingTeam[32];// 	20	测井队
				char Operator[32];//	20	操作员
				char LoggingSerial[32];//	20	测井系列
				float Well_Bottom_Temperature;//井底温度

				float Mud_Density[10];
				float Mud_Viscosity[10];
				float Mud_Resistivity[10];

				float Bit_Diameter[10];
				float Bushing_Detpth[10];
				float Bushing_Inside_Diameter[10];
				float Bushing_Outside_Diameter[10];
				float Bit_Depth[10];
				char Mud_Property[32];//泥浆性能
				char YqType[32];//仪器类型：skd3000、h2530、5700
				char JB[32];//井别：开发、探井、采油井、注水井
				float LoggingDepth;//测时井深
				float azca;//闭合方位,磁偏角
				float TVD;//	备注
				float X0,Y0,Z0;//	起始测点位置坐标偏移量
				float Mud_Temp;//	泥浆温度
				char Intor[12];//	备注
				char IntDepths[12];//	备注
				char audit[32];
				char Prog[32];
				float WaterLoss;
				char Item[32];
				char Reserved[10];//	备注
			}Slf3_FILE_MESSAGE;
			typedef struct tagSlf_FILE_MESSAGE31
			{
				//起始位置	变量名称	字节长度	描  述
				char	AreaName[64];//	64	油矿名称
				char	OilCompanyName[64];//	64	公司名称
				char	WellName[64];//	64	井名
				char	WellAliasName[64];//绘图需要的井名
				char	WellType[20];//	20	井类型：直井、斜井
				double	Xcoor;//	4	大地x坐标
				double	Ycoor;//	4	大地y坐标
				float	Altitude;//	4	海拔高度
				float	Kelly;//	4	补心高度
				float	StartDepth;//	4	起始深度
				float	EndDepth;//	4	终止深度
				__time32_t	StartDrillDate;//	4	开钻时间
				__time32_t	EndDrillDate;//	4	完钻时间
				__time32_t  LoggingDate;//	4	测井时间

				char LogCompanyName[64];//	64 测井公司
				char LoggingTeam[32];// 	20	测井队
				char Operator[32];//	20	操作员
				char LoggingSerial[32];//	20	测井系列
				float Well_Bottom_Temperature;//井底温度

				float Mud_Density[10];
				float Mud_Viscosity[10];
				float Mud_Resistivity[10];
				float Bit_Diameter[10];
				float Bushing_Detpth[10];
				float Bushing_Inside_Diameter[10];
				float Bushing_Outside_Diameter[10];
				float Bit_Depth[10];
				char Mud_Property[32];//泥浆性能
				char YqType[32];//仪器类型：skd3000、h2530、5700
				char JB[32];//井别：开发、探井、采油井、注水井
				float LoggingDepth;//测时井深
				float azca;//闭合方位,磁偏角
				float TVD;//	备注
				double X0,Y0;
				float Z0;//	起始测点位置坐标偏移量
				float Mud_Temp;//	泥浆温度
				char Intor[12];//	备注
				char IntDepths[12];//	备注
				char audit[32];
				char Prog[32];
				float WaterLoss;
				char Item[32];
				char Reserved[10];//	备注
			}Slf31_FILE_MESSAGE;
			typedef struct tagSlf_FILE_MESSAGE32
			{
				//起始位置	变量名称	字节长度	描  述
				char	AreaName[64];//	64	油矿名称
				char	OilCompanyName[64];//	64	公司名称
				char	WellName[64];//	64	井名
				char	WellAliasName[64];//绘图需要的井名
				char	WellType[20];//	20	井类型：直井、斜井
				double	Xcoor;//	4	大地x坐标
				double	Ycoor;//	4	大地y坐标
				float	Altitude;//	4	海拔高度
				float	Kelly;//	4	补心高度
				float	StartDepth;//	4	起始深度
				float	EndDepth;//	4	终止深度
				__time32_t	StartDrillDate;//	4	开钻时间
				__time32_t	EndDrillDate;//	4	完钻时间
				__time32_t  LoggingDate;//	4	测井时间

				char LogCompanyName[64];//	64 测井公司
				char LoggingTeam[32];// 	20	测井队
				char Operator[32];//	20	操作员
				char LoggingSerial[32];//	20	测井系列
				float Well_Bottom_Temperature;//井底温度

				float Mud_Density[10];
				float Mud_Viscosity[10];
				float Mud_Resistivity[10];
				float Bit_Diameter[10];
				float Bushing_Detpth[10];
				float Bushing_Inside_Diameter[10];
				float Bushing_Outside_Diameter[10];
				float Bit_Depth[10];
				char Mud_Property[32];//泥浆性能
				char YqType[32];//仪器类型：skd3000、h2530、5700
				char JB[32];//井别：开发、探井、采油井、注水井
				float LoggingDepth;//测时井深
				float azca;//闭合方位,磁偏角
				float TVD;//	备注
				double X0,Y0;
				float Z0;//	起始测点位置坐标偏移量
				float Mud_Temp;//	泥浆温度
				char Intor[12];//	备注
				char IntDepths[12];//	备注
				char audit[32];
				char Prog[32];
				float WaterLoss;
				char Item[32];
				char temp[1024];
				char Reserved[12];//	备注
			}Slf32_FILE_MESSAGE;

			typedef struct tagSlf3_FILE_HEAD
			{
				//起始位置	变量名称	字节长度	描  述
				char    Version[12];//	12	版本号
				DWORD	BinaryType;//	4	二进制数据标准
				DWORD	TableNumber;//	4	已存储表个数
				DWORD	MaxTableNumber;//	4	预留最大表个数
				DWORD	TableMessageLength;//	4	表基本信息长度
				__time32_t	TimeCreate;//	32	文件产生时间
				/////////////////////////////////////
				Slf3_FILE_MESSAGE WellMessage;
			}Slf3_FILE_HEAD;
			typedef struct tagSlf31_FILE_HEAD
			{
				//起始位置	变量名称	字节长度	描  述
				char    Version[12];//	12	版本号
				DWORD	BinaryType;//	4	二进制数据标准
				DWORD	TableNumber;//	4	已存储表个数
				DWORD	MaxTableNumber;//	4	预留最大表个数
				DWORD	TableMessageLength;//	4	表基本信息长度
				__time32_t	TimeCreate;//	32	文件产生时间
				/////////////////////////////////////
				Slf31_FILE_MESSAGE WellMessage;
			}Slf_FILE_HEAD31;
			typedef struct tagSlf32_FILE_HEAD
			{
				//起始位置	变量名称	字节长度	描  述
				char    Version[12];//	12	版本号
				DWORD	BinaryType;//	4	二进制数据标准
				DWORD	TableNumber;//	4	已存储表个数
				DWORD	MaxTableNumber;//	4	预留最大表个数
				DWORD	TableMessageLength;//	4	表基本信息长度
				__time32_t	TimeCreate;//	32	文件产生时间
				/////////////////////////////////////
				Slf32_FILE_MESSAGE WellMessage;
			}Slf_FILE_HEAD32;
			buf[7]=0;
			if(stricmp(buf,"Slf 2.0")==0||stricmp(buf,"Slf 3.0")==0) {
				char *p=(char *)&m_SlfHead;
				int off=(char *)&m_SlfHead.WellMessage-p;
				aFile->seek(0);
				Slf_FILE_HEAD31 slf;
				Slf3_FILE_HEAD slf3;
				aFile->read((char *)&slf3,sizeof(Slf3_FILE_HEAD));

				Slf_TABLE_ENTRY *slf3en=new Slf_TABLE_ENTRY[slf3.MaxTableNumber];
				memset(slf3en,0,sizeof(Slf_TABLE_ENTRY)*slf3.MaxTableNumber);
				int len=sizeof(Slf_FILE_HEAD31)-sizeof(Slf3_FILE_HEAD);
				for(int i=0;i<slf3.TableNumber;i++) {
					aFile->seek(sizeof(Slf3_FILE_HEAD)+i*slf3.TableMessageLength);
					aFile->read((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
					slf3en[i].Position+=len;
					for(int j=0;j<slf3en[i].RecondNum;j++){
						slf3en[i].DataRecord[j].DataPosition+=len;
					}
				}
				memset(&slf,0,sizeof(Slf_FILE_HEAD31));
				memmove(&slf,&slf3,off);

				strcpy(slf.Version,"Slf 3.1");
				slf.WellMessage.Altitude=slf.WellMessage.Altitude;

				slf.WellMessage.AreaName[64];//	64	油矿名称
				memmove(slf.WellMessage.OilCompanyName,slf3.WellMessage.OilCompanyName,sizeof(slf.WellMessage.OilCompanyName));//	64	公司名称
				memmove(slf.WellMessage.WellName,slf3.WellMessage.WellName,sizeof(slf.WellMessage.WellName));//[64];//	64	井名
				memmove(slf.WellMessage.WellAliasName,slf3.WellMessage.WellName,sizeof(slf.WellMessage.WellAliasName));//绘图需要的井名
				memmove(slf.WellMessage.WellType,slf3.WellMessage.WellType,sizeof(slf.WellMessage.WellType));//	20	井类型：直井、斜井
				slf.WellMessage.Xcoor=slf3.WellMessage.Xcoor;//	4	大地x坐标
				slf.WellMessage.Ycoor=slf3.WellMessage.Ycoor;//	4	大地y坐标
				slf.WellMessage.Altitude=slf3.WellMessage.Altitude;//	4	海拔高度
				slf.WellMessage.Kelly=slf3.WellMessage.Kelly;//	4	补心高度
				slf.WellMessage.StartDepth=slf3.WellMessage.StartDepth;//	4	起始深度
				slf.WellMessage.EndDepth=slf3.WellMessage.EndDepth;//	4	终止深度
				memmove((char *)&slf.WellMessage.StartDrillDate,(char *)&slf3.WellMessage.StartDrillDate,sizeof((char *)&slf.WellMessage.StartDrillDate));//	4	开钻时间
				memmove((char *)&slf.WellMessage.EndDrillDate,(char *)&slf3.WellMessage.LoggingDate,sizeof(slf.WellMessage.LoggingDate));//	4	完钻时间
				memmove((char *)&slf.WellMessage.LoggingDate,(char *)&slf3.WellMessage.LoggingDate,sizeof(slf.WellMessage.LoggingDate));//	4	测井时间

				memmove(slf.WellMessage.LogCompanyName,slf3.WellMessage.LogCompanyName,sizeof(slf.WellMessage.LogCompanyName));//[64];//	64 测井公司
				memmove(slf.WellMessage.LoggingTeam,slf3.WellMessage.LoggingTeam,sizeof(slf.WellMessage.LoggingTeam));// 	20	测井队
				memmove(slf.WellMessage.Operator,slf3.WellMessage.Operator,sizeof(slf.WellMessage.Operator));//	20	操作员
				memmove(slf.WellMessage.LoggingSerial,slf3.WellMessage.LoggingSerial,sizeof(slf.WellMessage.LoggingSerial));//	20	测井系列
				slf.WellMessage.Well_Bottom_Temperature=slf3.WellMessage.Well_Bottom_Temperature;//井底温度
				for(int i=0;i<10;i++) {
					slf.WellMessage.Mud_Density[i]=slf3.WellMessage.Mud_Density[i];
					slf.WellMessage.Mud_Viscosity[i]=slf3.WellMessage.Mud_Viscosity[i];
					slf.WellMessage.Mud_Resistivity[i]=slf3.WellMessage.Mud_Resistivity[i];
					slf.WellMessage.Bit_Diameter[i]=slf3.WellMessage.Bit_Diameter[i];
					slf.WellMessage.Bushing_Detpth[i]=slf3.WellMessage.Bushing_Detpth[i];
					slf.WellMessage.Bushing_Inside_Diameter[i]=slf3.WellMessage.Bushing_Inside_Diameter[i];
					slf.WellMessage.Bushing_Outside_Diameter[i]=slf3.WellMessage.Bushing_Outside_Diameter[i];
					slf.WellMessage.Bit_Depth[i]=slf3.WellMessage.Bit_Depth[i];
				}
				memmove(slf.WellMessage.Mud_Property,slf3.WellMessage.Mud_Property,sizeof(slf.WellMessage.Mud_Property));//泥浆性能
				memmove(slf.WellMessage.YqType,slf3.WellMessage.YqType,sizeof(slf.WellMessage.YqType));//仪器类型：skd3000、h2530、5700
				memmove(slf.WellMessage.JB,slf3.WellMessage.JB,sizeof(slf.WellMessage.JB));//井别：开发、探井、采油井、注水井
				slf.WellMessage.LoggingDepth=slf3.WellMessage.LoggingDepth;//测时井深
				slf.WellMessage.azca=slf3.WellMessage.azca;//闭合方位,磁偏角
				slf.WellMessage.TVD=slf3.WellMessage.TVD;//	备注
				slf.WellMessage.X0=slf3.WellMessage.X0;
				slf.WellMessage.Y0=slf3.WellMessage.Y0;
				slf.WellMessage.Z0=slf3.WellMessage.Z0;//	起始测点位置坐标偏移量
				slf.WellMessage.Mud_Temp=slf3.WellMessage.Mud_Temp;//	泥浆温度
				memmove(slf.WellMessage.Intor,slf3.WellMessage.Intor,sizeof(slf.WellMessage.Intor));//	备注
				memmove(slf.WellMessage.IntDepths,slf3.WellMessage.IntDepths,sizeof(slf.WellMessage.IntDepths));//	备注
				memmove(slf.WellMessage.audit,slf3.WellMessage.audit,sizeof(slf.WellMessage.audit));
				memmove(slf.WellMessage.Prog,slf3.WellMessage.Prog,sizeof(slf.WellMessage.Prog));
				slf.WellMessage.WaterLoss=slf3.WellMessage.WaterLoss;
				memmove(slf.WellMessage.Item,slf3.WellMessage.Item,sizeof(slf.WellMessage.Item));
				memmove(slf.WellMessage.Reserved,slf3.WellMessage.Reserved,sizeof(slf3.WellMessage.Reserved));//	备注

				char *buffer=new char [len+1];
				long pos=sizeof(Slf3_FILE_HEAD);
				long point =aFile->size();
				long point1=aFile->size()+len;
				while(point>=pos) {
					if(point<len) break;
					point-=len;
					aFile->seek(point);
					aFile->read(buffer,len);
					if(point1<len) break;
					point1-=len;
					aFile->seek(point1);
					aFile->write(buffer,len);
				}
				aFile->seek(0);
				aFile->write((char*)&slf,sizeof(Slf_FILE_HEAD));
				for(int i=0;i<slf3.TableNumber;i++) {
					aFile->seek(sizeof(Slf_FILE_HEAD)+i*slf.TableMessageLength);
					aFile->write((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
				}
				aFile->flush();
				delete []buffer;
				delete slf3en;
	//			QString cs=buf;
	//			cs+="该数据格式不再支持,请重新创建该文件！";
	//			AfxMessageBox(cs);
	//			return false;
			}
			if(stricmp(buf,"wis 1.0")==0||stricmp(buf,"SLF 1.0")==0) IsWis=1;
			else if(stricmp(buf,"Slf 2.0")==0||
				stricmp(buf,"Slf 3.0")==0||stricmp(buf,"Slf 3.1")==0)
			{
				IsWis=0;
			}
			else if(stricmp(buf,"Slf 3.2")==0)
			{
				Slf_FILE_HEAD slf;
				Slf_FILE_HEAD32 slf32;
				char *p=(char *)&slf;
				int off=(char *)&slf.WellMessage.Reserved-p;
				aFile->seek(0);
				aFile->read((char *)&slf32,sizeof(Slf_FILE_HEAD32));
				if(slf32.WellMessage.Kelly)slf32.WellMessage.Kelly=ConvertDataByString(QString::number(slf32.WellMessage.Kelly,'f',2));
				if(slf32.WellMessage.Bit_Diameter[0])slf32.WellMessage.Bit_Diameter[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[0],'f',2));
				if(slf32.WellMessage.Bit_Depth[0])slf32.WellMessage.Bit_Depth[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[0],'f',2 ));
				if(slf32.WellMessage.Bit_Diameter[1])slf32.WellMessage.Bit_Diameter[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[1],'f',2 ));
				if(slf32.WellMessage.Bit_Depth[1])slf32.WellMessage.Bit_Depth[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[1],'f',2 ));
				if(slf32.WellMessage.Bit_Diameter[2])slf32.WellMessage.Bit_Diameter[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[2],'f',2));
				if(slf32.WellMessage.Bit_Depth[2])slf32.WellMessage.Bit_Depth[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[2],'f',2 ));
				if(slf32.WellMessage.Bit_Diameter[3])slf32.WellMessage.Bit_Diameter[3]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[3],'f',2));
				if(slf32.WellMessage.Bit_Depth[3])slf32.WellMessage.Bit_Depth[3]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[3],'f',2 ));
				if(slf32.WellMessage.Bushing_Inside_Diameter[0])slf32.WellMessage.Bushing_Inside_Diameter[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[0],'f',2) );
				if(slf32.WellMessage.Bushing_Detpth[0])slf32.WellMessage.Bushing_Detpth[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[0],'f',2));
				if(slf32.WellMessage.Bushing_Inside_Diameter[1])slf32.WellMessage.Bushing_Inside_Diameter[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[1],'f',2) );
				if(slf32.WellMessage.Bushing_Detpth[1])slf32.WellMessage.Bushing_Detpth[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[1],'f',2));
				if(slf32.WellMessage.Bushing_Inside_Diameter[2])slf32.WellMessage.Bushing_Inside_Diameter[2]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[2],'f',2) ));
				if(slf32.WellMessage.Bushing_Detpth[2])slf32.WellMessage.Bushing_Detpth[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[2],'f',2));
				if(slf32.WellMessage.Bushing_Outside_Diameter[0])slf32.WellMessage.Bushing_Outside_Diameter[0]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[0],'f',2)));
				if(slf32.WellMessage.Bushing_Outside_Diameter[1])slf32.WellMessage.Bushing_Outside_Diameter[1]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[1],'f',2)));
				if(slf32.WellMessage.Bushing_Outside_Diameter[2])slf32.WellMessage.Bushing_Outside_Diameter[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[2],'f',2));

				memset(&slf,0,sizeof(Slf_FILE_HEAD));
				memmove(&slf,&slf32,off);
				memmove(&slf.WellMessage.Reserved,&slf32.WellMessage.Reserved,10);
				Slf_TABLE_ENTRY *slf3en=new Slf_TABLE_ENTRY[slf32.MaxTableNumber];
				memset(slf3en,0,sizeof(Slf_TABLE_ENTRY)*slf32.MaxTableNumber);
				int len=sizeof(Slf_FILE_HEAD32)-sizeof(Slf_FILE_HEAD);
				for(int i=0;i<slf32.TableNumber;i++) {
					aFile->seek(sizeof(Slf_FILE_HEAD32)+i*slf32.TableMessageLength);
					aFile->read((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
					slf3en[i].Position-=len;
					for(int j=0;j<slf3en[i].RecondNum;j++){
						slf3en[i].DataRecord[j].DataPosition-=len;
					}
				}
				strcpy(slf.Version,"Slf 3.1");
				long length=aFile->size();
				char *buffer=new char [len+1];
				long point =sizeof(Slf_FILE_HEAD32);
				long point1=sizeof(Slf_FILE_HEAD);

				while(point<length) {
					aFile->seek(point);
					aFile->read(buffer,len);
					aFile->seek(point1);
					aFile->write(buffer,len);
					point+=len;
					point1+=len;
				}
				aFile->seek(0);
				aFile->write((char*)&slf,sizeof(Slf_FILE_HEAD));
				for(int i=0;i<slf32.TableNumber;i++) {
					aFile->seek(sizeof(Slf_FILE_HEAD)+i*slf.TableMessageLength);
					aFile->write((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
				}
				aFile->resize(length-len);
				aFile->flush();
				delete []buffer;
				delete slf3en;
				
				IsWis=0;
			}
			else {
				IsWis=0;
				aFile->close();
				delete aFile;
				return false;
			}
		}
		else IsWis=0;//新文件
		aFile->close();
		delete aFile;
	}
	else IsWis=0;
	return Open(nOpenFlags,BlockLen,MaxObjectNumber,MachineType,IsWis);
}
bool  CSlfIO::BackUpFile()
{
	QDir ss;
	QString temp=m_LogFileName;
	int pos=temp.indexOf("logdata",0,Qt::CaseInsensitive);
	if(pos>-1)
	{
		QString tt=temp.left(pos+8);
		tt+="/temp/#backup/";
		ss.mkdir(tt);
		temp=tt;
	}
	QString temp1=temp+"1.slf";
	int i=1;
	char buf[100];
	while(ss.exists(temp1))
	{
		if(i>2)
		{
			QString temp2;
			for(int j=1;j<i;j++)
			{
				sprintf(buf,"%d.slf",j);
				temp2=temp+buf;
				sprintf(buf,"%d.slf",j+1);
				temp1=temp+buf;
				if(j==1) QFile::remove(temp2);
				QFile::rename(temp1,temp2);
			}
			break;
		}
		i++;
		sprintf(buf,"%d.slf",i);
		temp1=temp+buf;
	}
	bool l=QFile::copy(m_LogFileName,temp1);
	return l;
}

bool  CSlfIO::OpenWis(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
{
	IsWis=1;
	if(nOpenFlags==modeCreate)
 	{
		// Attach a CFile object to the handle we have.
		mFile=new QFile(m_LogFileName);
		mFile->open(QIODevice::ReadWrite);
		InitWis(BlockLen, MaxObjectNumber, MachineType);
		mFile->flush();
		return TRUE;
	}
	else {
		int isexit=0;
		QFileInfo w(m_LogFileName);
		if(w.isFile()) isexit=1;
		if(nOpenFlags&modeRead&&!(nOpenFlags&modeWrite)&&!isexit) return FALSE;
		mFile=new QFile(m_LogFileName);
		mFile->open(QIODevice::ReadWrite);
		if(nOpenFlags&modeReadWrite&&!isexit) {
			InitWis(BlockLen, MaxObjectNumber, MachineType);
			mFile->flush();
		}
		ReadWisHead();
		if(m_Head.MaxObjectNumber<=0) {
//			AfxMessageBox("文件信息错误！");
			return FALSE;
		}
		m_ObjectEntry=new Slf_OBJECT_ENTRY[m_Head.MaxObjectNumber];
		Slf_Info_Head=new char *[m_Head.MaxObjectNumber];
		for(int i=0;i<m_Head.MaxObjectNumber;i++) Slf_Info_Head[i]=NULL;
		ReadWisObjectEntry();
		for(int i=0;i<m_Head.ObjectNumber;i++)
		{
			strupr(m_ObjectEntry[i].Name);
		}
		return TRUE;
	}
	return FALSE;
}
void  CSlfIO::Clear()
{
	if(!mFile) return;
	mFile->flush();
	mFile->close();
	delete mFile;
	mFile=NULL;
//	QFileInfo w(m_LogFileName);
//	if(w.isFile()) {
//	}
//	else return;
	mFile=new QFile(m_LogFileName);
	mFile->open(QIODevice::ReadWrite);
	{
		int TableNumber=m_SlfHead.TableNumber;
		if(mFile&&m_SlfObjectEntry) 
		{
			ReadSlfHead();
			ReadSlfObjectEntry();
			int num=0;
			for(int index=m_SlfHead.TableNumber;index<m_SlfHead.MaxTableNumber;index++)
			{
				Slf_Info_Head[index]=NULL;
			}
			for(int index=0;index<m_SlfHead.TableNumber;index++) {
				if(m_SlfObjectEntry[index].Status==OBJECT_DISCARD) {
					num++;
				}
			}
			for(int j=0;j<num;j++)
			{
				for(int index=m_SlfHead.TableNumber-1;index>=0;index--) 
				{
					if(m_SlfObjectEntry[index].Status==OBJECT_DISCARD)
					{
						DiscardSlfObjectData(index);
						memmove((char *)&m_SlfObjectEntry[index],(char *)&m_SlfObjectEntry[index+1],sizeof(Slf_TABLE_ENTRY)*(m_SlfHead.TableNumber-index));

						if(Slf_Info_Head[index]) {
							Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
							delete []temp1->pField;
							delete []temp1;
							for(int i=index;i<m_SlfHead.TableNumber;i++) {
								if(i<m_SlfHead.MaxTableNumber-1) Slf_Info_Head[i]=Slf_Info_Head[i+1];
								else Slf_Info_Head[i]=NULL;
							}
							Slf_Info_Head[m_SlfHead.TableNumber]=NULL;
						}

						WriteSlfObjectEntry();
						if(m_SlfHead.TableNumber>0)m_SlfHead.TableNumber--;
						if((int)m_SlfHead.TableNumber<0) m_SlfHead.TableNumber=0;
						WriteSlfHead();
						break;
					}
				}
			}
		}
	}
}
void  CSlfIO::Close()
{
	Clear();
	if(mFile){
		mFile->flush();
		mFile->close();
		//CloseHandle(mFile->m_hFile);
		delete mFile;
		mFile=NULL;
	}
	if(m_ObjectEntry)delete []m_ObjectEntry;
	if(m_SlfObjectEntry)delete []m_SlfObjectEntry;
	if(Slf_Info_Head) {
		if(IsWis) {
			for(int i=0;i<m_Head.MaxObjectNumber;i++) 
				if(Slf_Info_Head[i]) {
					delete Slf_Info_Head[i];
					Slf_Info_Head[i]=NULL;
				}
		}
		else {
			for(int i=0;i<m_SlfHead.MaxTableNumber;i++) 
				if(Slf_Info_Head[i]) {
					CloseSlfTable(i);
//					delete Slf_Info_Head[i];
//					Slf_Info_Head[i]=NULL;
				}
		}
		delete [] Slf_Info_Head;
	}
	m_ObjectEntry=NULL;
	m_SlfObjectEntry=NULL;
	Slf_Info_Head=NULL;
}
void  CSlfIO::GetWisHead(Slf_HEAD* pHead)
{
	memmove(pHead,&m_Head,sizeof(Slf_HEAD));
}
void  CSlfIO::Convert(char*,DWORD,WORD)
{
}
//Object Operations
int  CSlfIO::FindWisObjectIndex(const char* namee,int status)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	for(int i=0;i<m_Head.ObjectNumber;i++) {
		if(strcmp(name,m_ObjectEntry[i].Name)==0) {
			if(status==-1) return i;
			if(status==m_ObjectEntry[i].Status) return i;
		}
	}
	return -1;
}
int CSlfIO::FindWisObjectName(char* name,short Attribute, short SubAttribute, int status)
{
	for(int i=0;i<m_Head.ObjectNumber;i++) 
	{
		if(strcmp(name,m_ObjectEntry[i].Name)==0) 
		{
			if(Attribute>-1) 
			{
				if(m_ObjectEntry[i].Attribute==Attribute) 
				{
					if(SubAttribute>-1) 
					{
						if(m_ObjectEntry[i].SubAttribute==SubAttribute) 
						{
							if(status>-1) 
							{
								if(m_ObjectEntry[i].Status==status) return i;
								continue;//else return -1;
							}
							else return i;
						}
						continue;//else return -1;
					}
					else if(status>-1) 
					{
						if(m_ObjectEntry[i].Status==status) return i;
						continue;//else return -1;
					}
					else return i;
				}
				continue;//else return -1;
			}
			else if(SubAttribute>-1) 
			{
				if(m_ObjectEntry[i].SubAttribute==SubAttribute) 
				{
					if(status>-1)
					{
						if(m_ObjectEntry[i].Status==status) return i;
						continue;//else return -1;
					}
					else return i;
				}
				continue;//else return -1;
			} 
			else if(status>-1) 
			{
				if(m_ObjectEntry[i].Status==status) return i;
				continue;//else return -1;
			}
			else return i;
		}
	}
	return -1;
}
bool  CSlfIO::DeleteWisObject(const char* namee)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	int index=FindWisObjectName((char *)name,-1,-1,OBJECT_NORMAL);
	if(index>-1) {
		m_ObjectEntry[index].Status=OBJECT_DELETE;
		WriteWisObjectEntry();
		return TRUE;
	}
	else return FALSE;
}
bool  CSlfIO::DiscardWisObject(const char* namee)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	int index=FindWisObjectName((char *)name,-1,-1,OBJECT_DELETE);
	if(index<0) index=FindWisObjectName((char *)name);
	return DiscardWisObject(index);
}
bool CSlfIO::DiscardWisObject(int index)
{
	if(index>-1&&index<m_Head.ObjectNumber) {
		int i=0;
		DWORD point,point1;
		char *buffer=new char[m_Head.BlockLen+1];
		point1=m_ObjectEntry[index].Position;
		point =m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
		while(point<m_Head.FileSize){
			mFile->seek(point);
			mFile->read(buffer,m_Head.BlockLen);
			mFile->seek(point1);
			mFile->write(buffer,m_Head.BlockLen);
			point+=m_Head.BlockLen;
			point1+=m_Head.BlockLen;
		}
		mFile->flush();
		delete []buffer;
		DWORD len=m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
		m_Head.FileSize-=len;
		if(Slf_Info_Head[index]) {
			delete []Slf_Info_Head[index];
			Slf_Info_Head[index]=NULL;
		}
		for(i=index+1;i<m_Head.ObjectNumber;i++) m_ObjectEntry[i].Position-=len;
		for(i=index  ;i<m_Head.ObjectNumber;i++) {
			if(i<m_Head.MaxObjectNumber-1)
				memmove(&m_ObjectEntry[i],&m_ObjectEntry[i+1],sizeof(Slf_OBJECT_ENTRY));
			else memset(&m_ObjectEntry[i],0,sizeof(Slf_OBJECT_ENTRY));
		}
		for(i=index  ;i<m_Head.ObjectNumber;i++)
		{
			if(i<m_Head.MaxObjectNumber-1) Slf_Info_Head[i]=Slf_Info_Head[i+1];
			else Slf_Info_Head[i]=NULL;
		}
		Slf_Info_Head[m_Head.ObjectNumber-1]=NULL;
		m_Head.ObjectNumber--;
		WriteWisObjectEntry();
		WriteWisHead();
		mFile->resize(m_Head.FileSize);
		
		return TRUE;
	}
	return FALSE;
}
bool  CSlfIO::RenameWisObject(int index,const char* newNamee)
{
	char newName[128];
	strcpy(newName,newNamee);
	strupr((char *)newName);
	int ind=FindWisObjectName(newName);
	if(ind>=0) return false;
	if(index>-1) {
		memmove(m_ObjectEntry[index].Name,newName,sizeof(m_ObjectEntry[index].Name));
		WriteWisObjectEntry();
		if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
			Slf_CHANNEL m_Channel;
			ReadWisChannelInfo(index,&m_Channel);

			memmove(m_Channel.DimInfo[0].Name,newName,sizeof(m_Channel.DimInfo[0].Name));
			WriteWisChannelInfo(index,&m_Channel);
		}
		return TRUE;
	}
	else return FALSE;
}
bool  CSlfIO::RenameWisObject(const char* oldName,const char* newNamee)
{
	int index=FindWisObjectIndex(oldName);
	return RenameWisObject(index,newNamee);
}
bool  CSlfIO::CopyWisObject(const char* oldName,const char* newName, bool bFailExist)
{
	if(m_Head.ObjectNumber>=m_Head.MaxObjectNumber) return false;
	int index=FindWisObjectIndex(oldName);
	if(index<0) return FALSE;
	index=FindWisObjectIndex(newName);
	if(index>=0&&bFailExist) return FALSE;
	if(index>=0) {
		char back[200];
		strcpy(back,newName);
		strcat(back,".bak");
		CString sss;
			sss.Format("CopyWisObject    %s",back);
			AfxMessageBox(sss);
		RenameObject(newName,back);
	}
	index=FindWisObjectIndex(oldName);//whp add 2011.10.30 如果没有词句，index=-1，m_ObjectEntry[index].BlockNum是个很大的数字
	char *buffer=new char[m_Head.BlockLen+1];
	DWORD point1,point2;
	point1=m_ObjectEntry[index].Position;
	point2=m_Head.FileSize;
	for(DWORD i=0;i<m_ObjectEntry[index].BlockNum;i++) {
		mFile->seek(point1);
		mFile->read(buffer,m_Head.BlockLen);
		mFile->seek(point2);
		mFile->write(buffer,m_Head.BlockLen);
		point1+=m_Head.BlockLen;
		point2+=m_Head.BlockLen;
	}
	mFile->flush();
	memmove(&m_ObjectEntry[m_Head.ObjectNumber],&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
	m_ObjectEntry[m_Head.ObjectNumber].Position=m_Head.FileSize;
	memmove(m_ObjectEntry[m_Head.ObjectNumber].Name,newName,sizeof(m_ObjectEntry[m_Head.ObjectNumber].Name));
	if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
		Slf_CHANNEL temp;
		ReadWisChannelInfo(index,&temp);		
		memmove(temp.DimInfo[0].Name,newName,sizeof(temp.DimInfo[0].Name));
		WriteWisChannelInfo(m_Head.ObjectNumber,&temp);
	}
	m_Head.FileSize+=m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
	m_Head.ObjectNumber++;
	WriteWisObjectEntry();
	WriteWisHead();
	delete []buffer;
	return TRUE;
}
bool  CSlfIO::UnDeleteWisObject(const char* name)
{
	int index=FindWisObjectIndex(name);
	if(index>-1) {
		m_ObjectEntry[index].Status=OBJECT_NORMAL;
		WriteWisObjectEntry();
		return TRUE;
	}
	else return FALSE;
}
WORD  CSlfIO::GetWisObjectCount()
{
	return m_Head.ObjectNumber;
}
void  CSlfIO::GetAllWisObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count)
{
	if(count<=0) count=m_Head.ObjectNumber;
	memmove(pEntry,m_ObjectEntry,sizeof(Slf_OBJECT_ENTRY)*count);
}
void  CSlfIO::GetWisObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry)
{
	memmove(pEntry,&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
}
void  CSlfIO::SetWisObjectReserved(int index,char* pEntry)
{
	int len=strlen(pEntry);
	if(len>=32) len=31;
	memmove(&m_ObjectEntry[index].Reserved,pEntry,len);
	m_ObjectEntry[index].Reserved[len]=0;
	WriteWisObjectEntry();
}
bool  CSlfIO::GetWisObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry)
{
	int index=FindWisObjectIndex(name);
	if(index>-1) {
		GetWisObjectEntry(index,pEntry);
		return TRUE;
	}
	else return FALSE;
}
void  CSlfIO::GetWisObjectAttribute(int index,short* Attribute, short* SubAttribute)
{
	*Attribute=m_ObjectEntry[index].Attribute;
	*SubAttribute=m_ObjectEntry[index].SubAttribute;
	if(m_ObjectEntry[index].Attribute==TABLE_OBJECT) *SubAttribute=m_ObjectEntry[index].SubAttribute+CARD_OBJECT;
}
bool CSlfIO::GetWisObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
{
	int index=FindWisObjectIndex(name);
	if(index>-1) {
		GetWisObjectAttribute(index,Attribute, SubAttribute);
		return TRUE;
	}
	else return FALSE;
}
//Channel Operations
int CSlfIO::OpenWisChannel(const char *name)
{
	Slf_CHANNEL m_Channel;
	for(int i=0;i<m_Head.ObjectNumber;i++) {
		if(m_ObjectEntry[i].Attribute==CHANNEL_OBJECT) {
			ReadWisChannelInfo(i,&m_Channel);
			if(m_ObjectEntry[i].Status==OBJECT_NORMAL&&(/*strcmp(m_Channel.AliasName,name)==0||*/strcmp(m_ObjectEntry[i].Name,name)==0)) {
				if(!Slf_Info_Head[i])Slf_Info_Head[i]=new char[sizeof(Slf_CHANNEL)];
				memmove(Slf_Info_Head[i],&m_Channel,sizeof(Slf_CHANNEL));
				return i;
			}
		}
	}
	return -1;
}
int CSlfIO::OpenWisChannel(const char *namee,short Attribute)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	Slf_CHANNEL m_Channel;
	for(int i=0;i<m_Head.ObjectNumber;i++) {
		if(m_ObjectEntry[i].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[i].SubAttribute==Attribute) {
			ReadWisChannelInfo(i,&m_Channel);
			if(m_ObjectEntry[i].Status==OBJECT_NORMAL&&(/*strcmp(m_Channel.AliasName,name)==0||*/strcmp(m_ObjectEntry[i].Name,name)==0)) {
				if(!Slf_Info_Head[i])Slf_Info_Head[i]=new char[sizeof(Slf_CHANNEL)];
				memmove(Slf_Info_Head[i],&m_Channel,sizeof(Slf_CHANNEL));
				return i;
			}
		}
	}
	return -1;
}
DWORD CSlfIO::ComputerWisChannelLength(Slf_CHANNEL *pInfo,unsigned char nDimension)
{
	return (DWORD)(pInfo->DimInfo[(int)nDimension].Samples*pInfo->DimInfo[(int)nDimension].Size);
}
DWORD CSlfIO::ComputerWisChannelLength(int index)
{
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	int fmtsize;
	if(m_ObjectEntry[index].SubAttribute==FMT_OBJECT) fmtsize=sizeof(int);
	else if(m_ObjectEntry[index].SubAttribute==TDT_OBJECT) fmtsize=sizeof(double);
	else fmtsize=0;
	return (DWORD)(m_Channel->DimInfo[0].Size+fmtsize);
}
int CSlfIO::GetWisChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen)
{
	return 1;
}
bool  CSlfIO::SetWisChannelPointNum(int index, DWORD nPointNum, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	if(mFile->seek(m_ObjectEntry[index].Position+m_Head.BlockLen)>=0) {
		mFile->write(reinterpret_cast<char*>(&nPointNum),sizeof(DWORD));
		mFile->flush();
	}
	return TRUE;
}
DWORD CSlfIO::GetWisChannelPointNum(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	DWORD nPointNum=0;
	if(mFile->seek(m_ObjectEntry[index].Position+m_Head.BlockLen)>=0) {
		mFile->read(reinterpret_cast<char*>(&nPointNum),sizeof(DWORD));
	}
	return nPointNum;
}
int  CSlfIO::CreateWisChannel(short SubAttribute,const char *namee,Slf_CHANNEL* pInfo,bool bFailExist)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	int index=FindWisObjectName((char *)name,1,-1,OBJECT_NORMAL);//int index=FindWisObjectIndex(name);
	int BlockNum,PointNum=pInfo->DimInfo[0].Samples;
	if(PointNum==0) PointNum=pInfo->DimInfo[0].MaxSamples;
	if(SubAttribute==FMT_OBJECT) BlockNum=mod((pInfo->DimInfo[0].Size+sizeof(DWORD))*PointNum+sizeof(DWORD),m_Head.BlockLen);
	else if(SubAttribute==TDT_OBJECT) BlockNum=mod((pInfo->DimInfo[0].Size+sizeof(double))*PointNum,m_Head.BlockLen);
	else BlockNum=mod(pInfo->DimInfo[0].Size*PointNum,m_Head.BlockLen);
	pInfo->DimInfo[0].MaxSamples=BlockNum*m_Head.BlockLen/pInfo->DimInfo[0].Size;
	if(index<0) {
		index=m_Head.ObjectNumber++;
		if(!Slf_Info_Head[index]){
			Slf_Info_Head[index]=new char [sizeof(Slf_CHANNEL)];
			//TODO aiya
			//assert(AfxIsValidAddress(Slf_Info_Head[index], sizeof(Slf_CHANNEL), FALSE));
		}
		if(SubAttribute==FMT_OBJECT) pInfo->DimInfo[0].Samples=0;
		memmove(Slf_Info_Head[index],pInfo,sizeof(Slf_CHANNEL));
		m_ObjectEntry[index].SubAttribute=SubAttribute;
		m_ObjectEntry[index].Attribute=CHANNEL_OBJECT;
		m_ObjectEntry[index].Position=m_Head.FileSize;
		m_ObjectEntry[index].BlockNum=1;
		memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
		m_ObjectEntry[index].Status=0;
		time_t createTime;
		gmtime(&createTime);
		m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
		m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
		strcpy(m_ObjectEntry[index].Reserved,"WANG WEI ");
		WriteWisObjectEntry();
		WriteWisChannelInfo(index);//,pInfo);
		m_Head.FileSize+=m_Head.BlockLen;
		ExpandWisObject(index,BlockNum);
		if(SubAttribute==FMT_OBJECT) SetWisChannelPointNum(index,PointNum);
		return index;
	}
	else if(bFailExist) {
		if(!Slf_Info_Head[index]) Slf_Info_Head[index]=new char [sizeof(Slf_CHANNEL)];
		ReadWisChannelInfo(index);
		Slf_CHANNEL *temp=(Slf_CHANNEL *) Slf_Info_Head[index];
		if(temp->DimInfo[0].Delta!=pInfo->DimInfo[0].Delta) 
			WisChannelResamples(index,temp->DimInfo[0].Delta);
		if(temp->DimInfo[0].MaxSamples!=pInfo->DimInfo[0].MaxSamples) 
			ExpandWisChannel(index,0,temp->DimInfo[0].MaxSamples,temp->DimInfo[0].MaxSamples);
		m_ObjectEntry[index].SubAttribute=SubAttribute;
		//	 memmove(Slf_Info_Head[index],pInfo,sizeof(Slf_CHANNEL));
		WriteWisObjectEntry();
		//	 WriteWisChannelInfo(index);
		return index;
	}
	return -1;
}
DWORD CSlfIO::SeekWisChannel(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	int dim=0,fmtsize=0;
	DWORD samples=0;
	DWORD point,len;
	if(samples1>0) {dim=0;samples=samples1;}
	if(samples2>0) {dim=1;samples=samples2;}
	if(samples3>0) {dim=2;samples=samples3;}
	if(samples4>0) {dim=3;samples=samples4;}
	if(dim==0&&samples==0)samples=1;
	if(m_ObjectEntry[index].SubAttribute==FMT_OBJECT) fmtsize=sizeof(int);
	else if(m_ObjectEntry[index].SubAttribute==TDT_OBJECT) fmtsize=sizeof(double);
	else fmtsize=0;
	point=m_ObjectEntry[index].Position+m_Head.BlockLen+fmtsize;
	len=ComputerWisChannelLength(index)*(samples-1);
	point+=len;
	point=mFile->seek(point);	
	return samples;
}
DWORD CSlfIO::WriteWisChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	int SamplesPos=SeekWisChannel(index,samples1,samples2,samples3,samples4);
	int BlockNum=mod((SamplesPos+num-1)*ComputerWisChannelLength(index)+m_Head.BlockLen-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	if(BlockNum>0) {
		ExpandWisObject(index,BlockNum);
		SeekWisChannel(index,samples1,samples2,samples3,samples4);
		m_Channel->DimInfo[0].MaxSamples=(m_ObjectEntry[index].BlockNum-1)*m_Head.BlockLen/m_Channel->DimInfo[0].Size;
		WriteWisChannelInfo(index);
		SeekWisChannel(index,samples1,samples2,samples3,samples4);
	}
	if(SamplesPos+num-1>(int)m_Channel->DimInfo[0].Samples) {
		m_Channel->DimInfo[0].Samples=SamplesPos+num-1;
		WriteWisChannelInfo(index);
		SeekWisChannel(index,samples1,samples2,samples3,samples4);
	}
	int l=num*ComputerWisChannelLength(index);
	mFile->write(buffer,l);
	mFile->flush();
	return l;
}
DWORD CSlfIO::ReadWisChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	int samples=SeekWisChannel(index,samples1,samples2,samples3,samples4);
	int len=num*ComputerWisChannelLength(index);
	return mFile->read(buffer,len);
}
bool CSlfIO::ExpandWisChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples)
{
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	if(nTopSamples>m_Channel->DimInfo[0].MaxSamples) {
		int len=nTopSamples*ComputerWisChannelLength(index);
		DWORD BlockNum=mod(len,m_Head.BlockLen)+1-m_ObjectEntry[index].BlockNum;
		m_Channel->DimInfo[nDimension].Samples=nSamples;
		m_Channel->DimInfo[nDimension].MaxSamples=(m_ObjectEntry[index].BlockNum-1+BlockNum)*m_Head.BlockLen/m_Channel->DimInfo[nDimension].Size;
		WriteWisChannelInfo(index);
		ExpandWisObject(index,BlockNum);
	}
	else if(nTopSamples<m_Channel->DimInfo[0].MaxSamples) {
		int len=nTopSamples*ComputerWisChannelLength(index);
		int SBlockNum=mod(len,m_Head.BlockLen)+1;
		if(SBlockNum<1) return FALSE;
		int BlockNum =m_ObjectEntry[index].BlockNum-SBlockNum;
		if(BlockNum<1) return FALSE;
		m_Channel->DimInfo[nDimension].Samples=nSamples;
		m_Channel->DimInfo[nDimension].MaxSamples=SBlockNum*m_Head.BlockLen/m_Channel->DimInfo[nDimension].Size;
		//		WriteWisChannelInfo(index);
		char *buffer=new char[m_Head.BlockLen+1];
		DWORD point,point1;
		point1=m_ObjectEntry[index].Position+SBlockNum*m_Head.BlockLen;
		point =m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
		while(point<m_Head.FileSize){
			mFile->seek(point);
			mFile->read(buffer,m_Head.BlockLen);
			mFile->seek(point1);
			mFile->write(buffer,m_Head.BlockLen);
			point+=m_Head.BlockLen;
			point1+=m_Head.BlockLen;
		}
		mFile->flush();
		delete []buffer;
		m_ObjectEntry[index].BlockNum-=BlockNum;
		m_Head.FileSize-=BlockNum*m_Head.BlockLen;;
		for(int i=index+1;i<m_Head.ObjectNumber;i++) m_ObjectEntry[i].Position-=BlockNum*m_Head.BlockLen;
		WriteWisObjectEntry();
		WriteWisHead();
		mFile->resize(m_Head.FileSize);
		return FALSE;
	}
	return 1;
}
bool CSlfIO::MoveWisChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal)
{
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	char *buffer=new char[m_Channel->DimInfo[nDimension].Size+1];
	DWORD point,point1,point2;
	int lenn=0;
	nStart--;nTotal--;
	point=m_ObjectEntry[index].Position+m_Head.BlockLen;
	for(int i=1;i<nDimension;i++) lenn+=m_Channel->DimInfo[i].Size*m_Channel->DimInfo[i].MaxSamples;
	if(nMove<0) {
		if(nStart+nMove<0) nStart=-nMove;
		for(int j=nStart;j<=(int)nTotal;j++) {
			point1=point+lenn+m_Channel->DimInfo[0].Size*j;
			point2=point+lenn+m_Channel->DimInfo[0].Size*(j+nMove);
			mFile->seek(point1);
			mFile->read(buffer,m_Channel->DimInfo[nDimension].Size);
			mFile->seek(point2);
			mFile->write(buffer,m_Channel->DimInfo[nDimension].Size);
		}
		mFile->flush();
	}
	else {
		if(nTotal+nMove>=m_Channel->DimInfo[0].Samples) {
			int mm=nTotal+nMove-m_Channel->DimInfo[0].Samples;
			m_Channel->DimInfo[0].Samples+=mm;
			if(nTotal+nMove>=m_Channel->DimInfo[0].MaxSamples) {
				nTotal=m_Channel->DimInfo[0].MaxSamples-nMove;
				m_Channel->DimInfo[0].Samples=m_Channel->DimInfo[0].MaxSamples;
			}
			WriteWisChannelInfo(index);
		}
		for(int j=nTotal;j>=(int)nStart;j--) {
			point1=point+lenn+m_Channel->DimInfo[0].Size*j;
			point2=point+lenn+m_Channel->DimInfo[0].Size*(j+nMove);
			mFile->seek(point1);
			mFile->read(buffer,m_Channel->DimInfo[nDimension].Size);
			mFile->seek(point2);
			mFile->write(buffer,m_Channel->DimInfo[nDimension].Size);
		}
		mFile->flush();
	}
	delete buffer;
	return 1;
}
bool  CSlfIO::OrderWisChannel(int index, unsigned char nDimension, int nMethod)
{
	return 1;
}
bool CSlfIO::CorrectWisChannel(int index, unsigned char nDimension, float delta)
{
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	m_Channel->DimInfo[nDimension].StartVal+=delta;
	WriteWisChannelInfo(index);
	return 1;
}
void CSlfIO::SetData(int RepCode,char *buffer,float *yy)
{
	switch(RepCode)
	{
	case REPR_INT:  //0
		(*((int*)buffer))=(int)*yy;
		break;
	case REPR_SHORT: //1
		(*((short *)buffer))=(short)*yy;
		break;
	case REPR_LONG://2
		(*((long *)buffer))=(long)*yy;
		break;
	case REPR_FLOAT://3
		(*((float *)buffer))=*yy;
		break;
	case REPR_DOUBLE://4
		(*((double *)buffer))=(double)*yy;
		break;
	case REPR_CHAR://5
		(*((char *)buffer))=(char)*yy;
		break;
	case REPR_UCHAR://6
		(*((unsigned char *)buffer))=(unsigned char)*yy;
		break;
	case REPR_USHORT://7
		(*((unsigned short *)buffer))=(unsigned short)*yy;
		break;
	case REPR_UINT://8
		(*((unsigned int *)buffer))=(unsigned int)*yy;
		break;
	case REPR_ULONG://9
		(*((unsigned long *)buffer))=(unsigned long )*yy;
		break;
	case REPR_STRING://10
		//			*yy=-99999;
		break;
	}
}
float CSlfIO::GetData(int RepCode,char *buffer,float *yy)
{
	switch(RepCode)
	{
	case REPR_INT:  //0
		*yy=(float)(*((int*)buffer));
		break;
	case REPR_SHORT: //1
		*yy=(float)(*((short *)buffer));
		break;
	case REPR_LONG://2
		*yy=(float)(*((long *)buffer));
		break;
	case REPR_FLOAT://3
		*yy=(float)(*((float *)buffer));
		break;
	case REPR_DOUBLE://4
		*yy=(float)(*((double *)buffer));
		break;
	case REPR_CHAR://5
		*yy=(float)(*((char *)buffer));
		break;
	case REPR_UCHAR://6
		*yy=(float)(*((unsigned char *)buffer));
		break;
	case REPR_USHORT://7
		*yy=(float)(*((unsigned short *)buffer));
		break;
	case REPR_UINT://8
		*yy=(float)(*((unsigned int *)buffer));
		break;
	case REPR_ULONG://9
		*yy=(float)(*((unsigned long *)buffer));
		break;
	case REPR_STRING://10
		*yy=-99999;
		break;
	}
	return *yy;
}
void CSlfIO::GetData(int RepCode,char *buffer,char *format,char *buf)
{
	switch(RepCode)
	{
	case REPR_INT:  //0
		sprintf(buf,format,*(int*)buffer);
		break;
	case REPR_SHORT: //1
		sprintf(buf,format,*(short *)buffer);
		break;
	case REPR_LONG://2
		sprintf(buf,format,*(long *)buffer);
		break;
	case REPR_FLOAT://3
		sprintf(buf,format,*(float *)buffer);
		break;
	case REPR_DOUBLE://4
		sprintf(buf,format,*(double *)buffer);
		break;
	case REPR_CHAR://5
		sprintf(buf,format,*(char *)buffer);
		break;
	case REPR_UCHAR://6
		sprintf(buf,format,*(unsigned char *)buffer);
		break;
	case REPR_USHORT://7
		sprintf(buf,format,*(unsigned short *)buffer);
		break;
	case REPR_UINT://8
		sprintf(buf,format,*(unsigned int *)buffer);
		break;
	case REPR_ULONG://9
		sprintf(buf,format,*(unsigned long *)buffer);
		break;
	case REPR_STRING://10
		strcpy(buf,buffer);
		break;
	}
}
void  CSlfIO::WisChannelResamples(int index,float newDelta)
{
	Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
	Slf_CHANNEL mych,mych1;
	if(m_Channel->DimInfo[0].Delta==newDelta) return;
	if(FindWisObjectIndex("NEWNAME")>-1) DiscardWisObject("NEWNAME");
	if(!CopyWisObject((const char* )m_ObjectEntry[index].Name,(const char* )"NEWNAME")) return;
	ReadWisChannelInfo(index,&mych);
	mych.DimInfo[0].Samples   =(DWORD)((mych.DimInfo[0].Delta*mych.DimInfo[0].Samples   )/newDelta+0.5);
	ExpandWisChannel(index,0,mych.DimInfo[0].Samples,mych.DimInfo[0].Samples);
	//	ReadWisChannelInfo(index,&mych);
	mych.DimInfo[0].Delta=newDelta;
	WriteWisChannelInfo(index,&mych);
	ReadWisChannelInfo(index);
	int mIndex=OpenWisChannel("NEWNAME");
	float dep,yy1,yy2,yy;
	int k1,k2;
	DWORD num,num1;
	int Pos=0;
	ReadWisChannelInfo(mIndex,&mych1);
	if(m_ObjectEntry[index].SubAttribute==CURVE_OBJECT) {
		num1=mych1.DimInfo[0].Samples*mych1.DimInfo[0].Size;
		char *buffer1=new char[num1+1];
		ReadWisChannel(mIndex,(char *)buffer1,mych1.DimInfo[0].Samples,1,0,0,0);
		num=mych.DimInfo[0].Samples*mych.DimInfo[0].Size;
		char *buffer=new char[num+1];
		for(DWORD i=0;i<mych.DimInfo[0].Samples;i++) {
			dep=i*newDelta;
			k1=dep/mych1.DimInfo[0].Delta+0.5;
			k2=dep/mych1.DimInfo[0].Delta+1.5;
			Pos=k1*mych.CodeLen;
			GetData(mych.RepCode,&buffer1[Pos],&yy1);
			Pos=k2*mych.CodeLen;
			GetData(mych.RepCode,&buffer1[Pos],&yy2);
			// add by whp 2004.1.13
			if(k1==k2)yy=yy1;
			else yy=yy1+(yy2-yy1)*(i*mych.DimInfo[0].Delta-k1*mych1.DimInfo[0].Delta)/((k2-k1)*mych1.DimInfo[0].Delta);
			Pos=i*mych.CodeLen;
			SetData(mych.RepCode,&buffer[Pos],&yy);
		}
		WriteWisChannel(index,(char *)buffer,mych.DimInfo[0].Samples,1,0,0,0);
		delete []buffer;
		delete []buffer1;
	}
	else if(m_ObjectEntry[index].SubAttribute==WAVE_OBJECT) {
		num1=mych1.DimInfo[0].Size;
		char *buffer=new char[num1+1];
		for(DWORD i=0;i<mych.DimInfo[0].Samples;i++) {
			dep=i*newDelta;
			k1=dep/mych1.DimInfo[0].Delta+0.5;
			ReadWisChannel(mIndex,buffer,1,0,k1);
			WriteWisChannel(index,buffer,1,0,i+1);
		}
		delete []buffer;
	}
	CloseChannel(mIndex);
	DiscardWisObject("NEWNAME");
}
void  CSlfIO::CloseChannel(int index)
{
	if(index<0) return ;
	if(IsWis) {
		if(Slf_Info_Head[index])delete Slf_Info_Head[index];
		Slf_Info_Head[index]=NULL;
	}
	else CloseSlfTable(index);
}
//Table Opeartions

int CSlfIO::OpenWisTable(const char*namee)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	int index;
	index=FindWisObjectName((char *)name,(short)TABLE_OBJECT);
	if(index>-1) {
		if(m_ObjectEntry[index].Status!=OBJECT_NORMAL) return -1;
		if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
		Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
		SeekWisTable(index,-1);
		mFile->read(Slf_Info_Head[index],sizeof(Slf_TABLE_HEAD));
		m_Table->Length=GetWisTableRecordLength(index);
		return index;
	}
	return -1;
}
int CSlfIO::CreateWisTable(short SubAttribute,const char* namee,DWORD length,bool bFailExist)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);
	int index=FindWisObjectName((char *)name,(short)TABLE_OBJECT);
	if(index>-1) {
		if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
		if(bFailExist) return index;
		m_ObjectEntry[index].SubAttribute=SubAttribute;
		time_t createTime;
		gmtime(&createTime);
		m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
		WriteWisObjectEntry();
		return index;
	}
	index=m_Head.ObjectNumber++;
	if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
	m_ObjectEntry[index].SubAttribute=SubAttribute;
	m_ObjectEntry[index].Position=m_Head.FileSize;
	memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
	m_ObjectEntry[index].Attribute=TABLE_OBJECT;
	m_ObjectEntry[index].Status=0;

	time_t createTime;
	gmtime(&createTime);
	m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
	m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;

	strcpy(m_ObjectEntry[index].Reserved,"WANG WEI !");
	m_ObjectEntry[index].BlockNum=0;
	WriteWisObjectEntry();
	int BlockNum=mod(length+sizeof(Slf_TABLE),m_Head.BlockLen);
	if(BlockNum>0) ExpandWisTable(index,BlockNum);
	return index;
}
bool  CSlfIO::CloseTable(int index)
{
	if(index<0) return FALSE;
	if(Slf_Info_Head[index]) {
		if(!IsWis) {
			Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
			delete []temp1->pField;
		}
		delete []Slf_Info_Head[index];
	}
	Slf_Info_Head[index]=NULL;
	return TRUE;
}
bool  CSlfIO::SeekWisTable(int index, int OffsetCount, DWORD dwMoveMode)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	int len=0;
	if(OffsetCount<0) len=0;
	else if(OffsetCount==0) len=sizeof(Slf_TABLE_HEAD);
	else len=sizeof(Slf_TABLE_HEAD)+m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD)+(OffsetCount-1)*m_Table->Length;
	return SeekWisStream(index,len, dwMoveMode);
}
int   CSlfIO::GetWisTableRecordCount(int index)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	return m_Table->RecordCount;
}
int CSlfIO::GetWisTableFieldCount(int index)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	if(!m_Table) return 0;
	return m_Table->FieldCount;
}
int CSlfIO::GetMaxObjectNumber()
{
	if(IsWis) return m_Head.MaxObjectNumber;
	return m_SlfHead.MaxTableNumber;
}
int CSlfIO::GetObjectStatus(int index)
{
	if(IsWis) return m_ObjectEntry[index].Status;
	return m_SlfObjectEntry[index].Status;
}

int CSlfIO::SetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];

	SeekWisTable(index,-1);
	mFile->seek(sizeof(Slf_TABLE_HEAD)+SEEK_CUR);
	for(int i=0;i<m_Table->FieldCount;i++){
		mFile->write(reinterpret_cast<char*>(&FieldInfo[i]),sizeof(Slf_TABLE_FIELD_OLD));
	}
	mFile->flush();
	if(FieldInfo) return 1;
	else return 0;
}	 

int CSlfIO::SetWisTableHead(int index,DWORD RecordCount,DWORD FieldCount,Slf_TABLE_FIELD *FieldInfo)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	m_Table->RecordCount=RecordCount;
	m_Table->FieldCount=FieldCount;
	if(FieldInfo) {
		m_Table->Length=0;
		for(int i=0;i<(int)m_Table->FieldCount;i++)
		{
			m_Table->Length+=FieldInfo[i].Length;
		}
	}
	SeekWisTable(index,-1);
	mFile->write(reinterpret_cast<char*>(m_Table),sizeof(Slf_TABLE_HEAD));
	for(int i=0;i<FieldCount;i++)
	{
		mFile->write(reinterpret_cast<char*>(&FieldInfo[i]),sizeof(Slf_TABLE_FIELD_OLD));
	}
	mFile->flush();
	if(FieldInfo) return 1;
	else return 0;
}	 

bool  CSlfIO::SetWisTableRecordCount(int index,int Count)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	SeekWisTable(index,-1);
	m_Table->RecordCount=Count;
	mFile->write(reinterpret_cast<char*>(m_Table),sizeof(DWORD));
	mFile->flush();
	return 1;
}

bool  CSlfIO::ExpandWisTable(int index,DWORD BlockNum)
{
	return ExpandWisObject(index,BlockNum);
}

bool  CSlfIO::GetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	SeekWisTable(index);
	int len=m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD);
	Slf_TABLE_FIELD_OLD*pOd=new Slf_TABLE_FIELD_OLD[m_Table->FieldCount+1];
	int len1=mFile->read(reinterpret_cast<char*>(pOd),len);
	for(int i=0;i<m_Table->FieldCount;i++){
		memmove(FieldInfo[i].Name,pOd[i].Name,sizeof(FieldInfo->Name));
		memmove(FieldInfo[i].HZName,pOd[i].HZName,sizeof(FieldInfo->Name));
		FieldInfo[i].Unit[0]=0;
		FieldInfo[i].HZUnit[0]=0;
		FieldInfo[i].RepCode=pOd[i].RepCode;
		FieldInfo[i].Length=pOd[i].Length;
		FieldInfo[i].Reserved=0;
	}
	delete pOd;
	if(len==len1){
		return TRUE;
	}
	else return FALSE;
}

int CSlfIO::GetWisTableRecordLength(int index)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	Slf_TABLE_FIELD buf;
	SeekWisTable(index);
	m_Table->Length=0;
	for(int i=0;i<(int)m_Table->FieldCount;i++) {
		mFile->read(reinterpret_cast<char*>(&buf),sizeof(Slf_TABLE_FIELD_OLD));
		m_Table->Length+=buf.Length;
	}
	return m_Table->Length;
}
int CSlfIO::ReadWisTable(int index, int count, void *buffer)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	if(count<1) return 0;
	SeekWisTable(index,count);
	return mFile->read(reinterpret_cast<char*>(buffer),m_Table->Length);
}
int CSlfIO::mod(int a,int b)
{
	if(a<0||b<0) return -1;
	if(a%b==0) return a/b;
	else return a/b+1;
}
int CSlfIO::WriteWisTable(int index, int count, void *buffer)
{
	Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
	if(count<1) return 0;
	int BlockNum=mod(count*m_Table->Length+m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD)+sizeof(Slf_TABLE_HEAD)-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
	if(BlockNum>0) ExpandWisTable(index,BlockNum);
	if((DWORD)count>m_Table->RecordCount) {
		m_Table->RecordCount=count;
		SetWisTableRecordCount(index,count);
	}
	SeekWisTable(index,count);
	mFile->write(reinterpret_cast<char*>(buffer),m_Table->Length);
	mFile->flush();
	return 1;
}

//Stream Operations     
int CSlfIO::OpenWisStream(const char* namee)
{
	char name[256];
	strcpy(name,namee);
	strupr((char *)name);
	int index=FindWisObjectName((char *)name,(short)STREAM_OBJECT);
	if(index>-1) {
		if(m_ObjectEntry[index].Status!=OBJECT_NORMAL) return -1;
		if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
		ReadWisStreamInfo(index);
		return index;
	}
	return -1;
}
int CSlfIO::CreateWisStream(short SubAttribute,const char *namee,DWORD length,bool bFailExist)
{
	char name[128];
	strcpy(name,namee);
	strupr((char *)name);//对象名为大写
	int index=FindWisObjectName((char *)name,(short)STREAM_OBJECT);
	if(index>-1) {
		if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
		if(bFailExist) return index;
		m_ObjectEntry[index].SubAttribute=SubAttribute;
		time_t createTime;
		gmtime(&createTime);
		m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
		WriteWisObjectEntry();
		return index;
	}
	index=m_Head.ObjectNumber++;
	if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
	m_ObjectEntry[index].SubAttribute=SubAttribute;
	m_ObjectEntry[index].Position=m_Head.FileSize;
	memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
	m_ObjectEntry[index].Attribute=STREAM_OBJECT;
	m_ObjectEntry[index].Status=0;

	time_t createTime;
	gmtime(&createTime);
	m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
	m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;

	strcpy(m_ObjectEntry[index].Reserved,"WANG WEI !");
	m_ObjectEntry[index].BlockNum=0;
	int BlockNum=mod(length,m_Head.BlockLen);
	if(BlockNum>0) ExpandWisStream(index,BlockNum);
	SetWisStreamLength(index, (DWORD)0);
	return index;
}
void  CSlfIO::CloseStream(int index)
{
	if(index<0) return;
	if(IsWis) {
		if(Slf_Info_Head[index]) {
			delete []Slf_Info_Head[index];
		}
		Slf_Info_Head[index]=NULL;
	}
	else CloseSlfTable(index);
}
bool  CSlfIO::SetWisStreamLength(int index, DWORD length)
{
	Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
	SeekWisStream(index);
	mFile->write((const char *)&length,sizeof(DWORD));
	mFile->flush();
	m_Stream->Length=length;
	DWORD len=length;
	if(len==length) return TRUE;
	else return FALSE;
}
bool  CSlfIO::ExpandWisStream(int index, DWORD BlockNum)
{
	return ExpandWisObject(index,BlockNum);
}
bool  CSlfIO::SeekWisStream(int index, int lMove, DWORD dwMoveMode)
{
	DWORD point;
	if(dwMoveMode==0) point=m_ObjectEntry[index].Position+lMove;
	else if(dwMoveMode==1) point=m_ObjectEntry[index].Position+lMove;
	else {
		if(index+1>=m_Head.ObjectNumber) point=m_Head.FileSize-lMove;
		else point=m_ObjectEntry[index+1].Position-lMove;
	}
	mFile->seek(point);
	return 1;
}
bool  CSlfIO::ReadWisStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
{
	SeekWisStream(index, sizeof(DWORD));
	*lpBytesRead=mFile->read(buffer,length);
	if(*lpBytesRead==length) return TRUE;
	else return FALSE;
}
bool  CSlfIO::WriteWisStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
{
	Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
	int BlockNum=mod(length+sizeof(DWORD)-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
	if(BlockNum>0) ExpandWisStream(index,BlockNum);
	m_Stream->Length=length;
	WriteWisStreamInfo(index);
	SeekWisStream(index, sizeof(DWORD));
	mFile->write(buffer,length);
	mFile->flush();
	*lpBytesWrite=length;
	if(*lpBytesWrite==length) return TRUE;
	else return FALSE;
}
DWORD CSlfIO::GetWisStreamLength(int index)
{
	Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
	ReadWisStreamInfo(index);
	return m_Stream->Length;
}
DWORD CSlfIO::GetWisObjectLength(char *name)
{
	int index=FindWisObjectName(name);
	if(index<0) return 0;
	return m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
}
bool CSlfIO::CopyWisObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len)
{
	int index=FindWisObjectName(name);
	if(index<0) return NULL;
	memmove(my,&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
	mFile->seek(m_ObjectEntry[index].Position);
	mFile->read(buffer,Len);
	return TRUE;
}
bool CSlfIO::CopyFromWisFile(Slf_OBJECT_ENTRY *my,char *buffer,int Len)
{
	int index=FindWisObjectName(my->Name);
	if(index>=0) return FALSE;
	memmove(&m_ObjectEntry[m_Head.ObjectNumber],my,sizeof(Slf_OBJECT_ENTRY));
	m_ObjectEntry[m_Head.ObjectNumber].Position=m_Head.FileSize;
	mFile->seek(m_Head.FileSize);
	mFile->write(buffer,Len);
	mFile->flush();
	m_Head.FileSize+=Len;
	m_Head.ObjectNumber++;
	WriteWisHead();
	WriteWisObjectEntry();
	return TRUE;
}
bool CSlfIO::CopyFromWisFile(CSlfIO &Source,char *Name)
{
	if(!Source.mFile) return FALSE;
	if(Source.IsWis) {
		int len=Source.GetWisObjectLength(Name);
		if(len==0) return FALSE;
		char *buf=new char[len+1];
		if(!buf) return FALSE;
		Slf_OBJECT_ENTRY obje;
		if(Source.GetWisObjectEntry(Name,&obje)) {
			if(Source.CopyWisObjectToMem(&obje,Name,buf,len)) {
				if(CopyFromWisFile(&obje,buf,len)) {
					delete buf;
					return TRUE;
				}
			}
		}
		delete buf;
	}
	return FALSE;
}
bool CSlfIO::CopyFromWisFile(CSlfIO &Source,char *Name,char *newName)
{
	if(!Source.mFile) return FALSE;
	if(Source.IsWis) {
		int len=Source.GetWisObjectLength(Name);
		if(len==0) return FALSE;
		char *buf=new char[len+1];
		if(!buf) return FALSE;
		Slf_OBJECT_ENTRY obje;
		if(Source.GetWisObjectEntry(Name,&obje)) {
			if(Source.CopyWisObjectToMem(&obje,Name,buf,len)) {
				strcpy(obje.Name,newName);
				if(CopyFromWisFile(&obje,buf,len)) {
					delete buf;
					return TRUE;
				}
			}
		}
		delete buf;
	}
	return FALSE;
}

void  CSlfIO::Pack()
{
	if(IsWis) WisPack();
	else SlfPack();
}
void CSlfIO::Init(int BlockLen,int MaxObjectNumber, int MachineType)
{
	if(IsWis) InitWis(BlockLen,MaxObjectNumber,MachineType);
	else InitSlf(BlockLen,MaxObjectNumber,MachineType);
}
int CSlfIO::ReadHead()
{
	if(IsWis) return ReadWisHead();
	else return ReadSlfHead();
}
int CSlfIO::WriteHead()
{
	if(IsWis) return WriteWisHead();
	else return WriteSlfHead();
}
int CSlfIO::ReadObjectEntry()
{
	if(IsWis) return ReadWisObjectEntry();
	else return ReadSlfObjectEntry();
}

int   CSlfIO::WriteObjectEntry()
{
	if(IsWis) return WriteWisObjectEntry();
	else return WriteSlfObjectEntry();
}
int CSlfIO::ReadChannelInfo(int index,Slf_CHANNEL *pInfo)
{
	return ReadWisChannelInfo(index,pInfo);
}
int CSlfIO::WriteChannelInfo(int index,Slf_CHANNEL *pInfo)
{
	return WriteWisChannelInfo(index,pInfo);
}
int CSlfIO::ReadStreamInfo(int index)
{
	if(IsWis) return ReadWisStreamInfo(index);
	else return ReadSlfStreamInfo(index);
}
int   CSlfIO::WriteStreamInfo(int index)
{
	if(IsWis) return WriteWisStreamInfo(index);
	else return WriteSlfStreamInfo(index);
}
bool CSlfIO::ExpandObject(int index, DWORD BlockNum)
{
	if(IsWis) return ExpandWisObject(index,BlockNum);
	else return 1;//ExpandSlfObject(index,BlockNum);
}
int CSlfIO::FindFreeSpace(DWORD BlockNum,int nExceptIndex)
{
	if(IsWis) return WisFindFreeSpace(BlockNum,nExceptIndex);
	else return 1;//SlfFindFreeSpace(BlockNum,nExceptIndex);
}
bool  CSlfIO::Open(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType,int FileType)
{

	CString s;
	char cs[MAX_PATH+100]="SlfOpen_";
	strcat(cs,m_LogFileName);
	s=cs;
	s.Replace("\\","_");
	s.Replace(":","_");
	s.Replace(".","_");
	s.Replace(" ","_");
	s.Replace("#","_");
	//cs=s.GetString();
	//strcpy(cs,s.GetString());
	//TODO
	//MappingMem(&mHandle,(LPSTR *)&m_Value,4,s.GetString());
	if(FileType) return OpenWis(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
	else return OpenSlf(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
}
void  CSlfIO::WisPack()
{
	for(int i=0;i<m_Head.ObjectNumber;i++) 
		if(m_ObjectEntry[i].Status==OBJECT_DELETE) DiscardWisObject(i);
}
void  CSlfIO::SlfPack()
{
	for(int i=0;i<m_SlfHead.TableNumber;i++) 
		if(m_SlfObjectEntry[i].Status==OBJECT_DELETE)
			{
				DiscardSlfObject(i);
		}
		/*
	for(int i=0;i<m_SlfHead.TableNumber;i++)
	{
		if(m_SlfObjectEntry[i].RecondNum>1) 
		{
			int rec=GetSlfTableRecordCount(i);
			SetSlfTableRecordCount(i,rec);
		}
	}*/
}
//Object Operations
int  CSlfIO::FindObjectIndex(const char* namee)
{
	if(IsWis) return FindWisObjectIndex(namee);
	else return FindSlfObjectIndex(namee);
}
int CSlfIO::FindObjectName(char* name,short Attribute, short SubAttribute, int status,int otype)
{
	if(IsWis) return FindWisObjectName(name,Attribute,SubAttribute,status);
	else return FindSlfObjectName(name,Attribute,SubAttribute,status,otype);
}
bool  CSlfIO::DeleteObject(const char* namee)
{
	if(IsWis) return DeleteWisObject(namee);
	else return DeleteSlfObject(namee);
}
bool  CSlfIO::DiscardObject(const char* namee)
{
	if(IsWis) return DiscardWisObject(namee);
	else return DiscardSlfObject(namee);
}
bool CSlfIO::DiscardObject(int index)
{
	if(IsWis) return DiscardWisObject(index);
	else return DiscardSlfObject(index);
}
bool  CSlfIO::RenameObject(int index,const char* newNamee)
{
	if(IsWis) return RenameWisObject(index,newNamee);
	else return RenameSlfObject(index,newNamee);
}
bool  CSlfIO::RenameObject(const char* oldName,const char* newNamee)
{
	if(IsWis) return RenameWisObject(oldName,newNamee);
	else return RenameSlfObject(oldName,newNamee);
}
bool  CSlfIO::CopyObject(const char* oldName,const char* newName, bool bFailExist)
{
	if(IsWis) return CopyWisObject(oldName,newName,bFailExist);
	else return CopySlfObject(oldName,newName,bFailExist);
}
bool  CSlfIO::UnDeleteObject(const char* name)
{
	if(IsWis) return UnDeleteWisObject(name);
	else return UndeleteSlfObject(name);
}
WORD  CSlfIO::GetObjectCount()
{
	if(IsWis) return GetWisObjectCount();
	else return GetSlfObjectCount();
}
void  CSlfIO::GetAllObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count)
{
	if(IsWis) return GetAllWisObjectEntry(pEntry,count);
	else return GetAllSlfObjectEntry((Slf_TABLE_ENTRY *)pEntry,count);
}
bool  CSlfIO::GetObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry)
{
	if(IsWis) return GetWisObjectEntry(name,pEntry);
	else {
		Slf_TABLE_ENTRY my;
		if(GetSlfObjectEntry(name,&my)) {
			memmove((char *)pEntry->Name,my.Name,sizeof(pEntry->Name));
			pEntry->Status=my.Status;
			if(my.Type==CURVE_OBJECT||my.Type==TDT_OBJECT||my.Type==FMT_OBJECT) {
				pEntry->Attribute=CHANNEL_OBJECT;
				pEntry->SubAttribute=my.Type;
			}
			else if(my.Type==CARD_OBJECT) {
				pEntry->Attribute=STREAM_OBJECT;
				pEntry->SubAttribute=PARA_OBJECT;
			}
			else if(my.Type>CARD_OBJECT) {
				pEntry->Attribute=TABLE_OBJECT;
				pEntry->SubAttribute=my.Type-CARD_OBJECT;
			}
			return TRUE;
		}
		else return FALSE;
	}
}
void  CSlfIO::SetObjectReserved(int index,char* pEntry)
{
	if(IsWis) return SetWisObjectReserved(index,pEntry);
	else return SetSlfObjectReserved(index,pEntry);
}
void  CSlfIO::GetObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry)
{
	if(IsWis) return GetWisObjectEntry(index,pEntry);
	else {
		Slf_TABLE_ENTRY my;
		GetSlfObjectEntry(index,&my);
		memmove((char *)pEntry->Name,my.Name,sizeof(pEntry->Name));
		pEntry->Status=my.Status;
		if(my.Type==CURVE_OBJECT||my.Type==TDT_OBJECT||my.Type==FMT_OBJECT) {
			pEntry->Attribute=CHANNEL_OBJECT;
			pEntry->SubAttribute=my.Type;
		}
		else if(my.Type==CARD_OBJECT) {
			pEntry->Attribute=STREAM_OBJECT;
			pEntry->SubAttribute=PARA_OBJECT;
		}
		else if(my.Type>CARD_OBJECT) {
			pEntry->Attribute=TABLE_OBJECT;
			pEntry->SubAttribute=my.Type-CARD_OBJECT;
		}
	}
}
void  CSlfIO::GetObjectAttribute(int index,short* Attribute, short* SubAttribute)
{
	if(IsWis) return GetWisObjectAttribute(index,Attribute,SubAttribute);
	else return GetSlfObjectAttribute(index,Attribute,SubAttribute);
}
bool CSlfIO::GetObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
{
	if(IsWis) return GetWisObjectAttribute(name,Attribute,SubAttribute);
	else return GetSlfObjectAttribute(name,Attribute,SubAttribute);
}
//Channel Operations
int CSlfIO::OpenChannel(const char *name)
{
	if(IsWis) return OpenWisChannel(name);
	else return OpenSlfChannel(name);
}
int CSlfIO::OpenChannel(const char *namee,short Attribute)
{
	if(IsWis) return OpenWisChannel(namee,Attribute);
	else return OpenSlfChannel(namee,Attribute);
}
DWORD CSlfIO::ComputerChannelLength(Slf_CHANNEL *pInfo,unsigned char nDimension)
{
	return ComputerWisChannelLength(pInfo,nDimension);
}
DWORD CSlfIO::ComputerChannelLength(int index)
{
	if(IsWis) return ComputerWisChannelLength(index);
	else return ComputerSlfChannelLength(index);
}
int CSlfIO::GetChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen)
{
	return GetWisChannelDefaultValue(pInfo,nDimension,buffer,buflen);
}
bool  CSlfIO::SetChannelPointNum(int index, DWORD nPointNum, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	return SetWisChannelPointNum(index,nPointNum,samples1,samples2,samples3,samples4);
}
DWORD CSlfIO::GetChannelPointNum(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	return GetWisChannelPointNum(index,samples1,samples2,samples3,samples4);
}
int  CSlfIO::CreateChannel(short SubAttribute,const char *namee,Slf_CHANNEL* pInfo,bool bFailExist)
{
	return CreateWisChannel(SubAttribute,namee,pInfo,bFailExist);
}
DWORD CSlfIO::SeekChannel(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	return SeekWisChannel(index,samples1,samples2,samples3,samples4);
}
DWORD CSlfIO::WriteChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	return WriteWisChannel(index,buffer,num,samples1,samples2,samples3,samples4);
}
DWORD CSlfIO::ReadChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
{
	return ReadWisChannel(index,buffer,num,samples1,samples2,samples3,samples4);
}
bool CSlfIO::ExpandChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples)
{
	return ExpandWisChannel(index,nDimension,nSamples,nTopSamples);
}
bool CSlfIO::MoveChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal)
{
	return MoveWisChannel(index,nDimension,nStart,nMove,nTotal);
}
bool  CSlfIO::OrderChannel(int index, unsigned char nDimension, int nMethod)
{
	return OrderWisChannel(index,nDimension,nMethod);
}
bool CSlfIO::CorrectChannel(int index, unsigned char nDimension, float delta)
{
	return CorrectWisChannel(index,nDimension,delta);
}
void  CSlfIO::ChannelResamples(int index,float newDelta)
{
	if(IsWis) return WisChannelResamples(index,newDelta);
	else return SlfTableResamples(index,newDelta);
}
//Table Opeartions

int CSlfIO::OpenTable(const char*namee)
{
	if(IsWis) return OpenWisTable(namee);
	else return OpenSlfTable(namee);
}
int CSlfIO::CreateTable(short SubAttribute,const char* namee,DWORD length,bool bFailExist)
{
	if(IsWis) return CreateWisTable(SubAttribute-CARD_OBJECT,namee,length,bFailExist);
	else return CreateSlfTable(SubAttribute,namee,NULL,length,NULL,bFailExist);
}
int CSlfIO::CreateTable(short Attribute,const char* name,const char* hzname,DWORD FieldNum,Slf_OBJECT_FIELD *pField,bool bFailExist)
{
	if(IsWis) {
		int index=CreateWisTable(Attribute,name,0,bFailExist);
		if(index>-1) {
			Slf_TABLE_FIELD *pTable_Field=new Slf_TABLE_FIELD[FieldNum+1];
			for(int i=0;i<FieldNum;i++) {
				strncpy(pTable_Field[i].Name,pField[i].Name,16);
				strncpy(pTable_Field[i].HZName,pField[i].HZName,16);
				strncpy(pTable_Field[i].Unit,pField[i].Unit,16);
				strncpy(pTable_Field[i].HZUnit,pField[i].HZUnit,16);
				pTable_Field[i].RepCode=pField[i].RepCode;
				pTable_Field[i].Length=pField[i].CodeLength;
				pTable_Field[i].Reserved=0;
			}
			SetWisTableHead(index,0,FieldNum,pTable_Field);
			delete pTable_Field;
		}
		return index;
	}
	else return CreateSlfTable(Attribute,name,hzname,FieldNum,pField,bFailExist);
}
bool  CSlfIO::SeekTable(int index, int OffsetCount, DWORD dwMoveMode)
{
	if(IsWis) return SeekWisTable(index,OffsetCount,dwMoveMode);
	else return SeekSlfTable(index,OffsetCount,dwMoveMode);
}
int   CSlfIO::GetTableRecordCount(int index)
{
	if(IsWis) return GetWisTableRecordCount(index);
	else return GetSlfTableRecordCount(index);
}
int   CSlfIO::GetTableFieldCount(int index)
{
	if(IsWis) return GetWisTableFieldCount(index);
	else return GetSlfTableFieldCount(index);
}
int CSlfIO::SetTableHead(int index,DWORD RecordCount,DWORD FieldCount,Slf_TABLE_FIELD *FieldInfo)
{
	if(IsWis) return SetWisTableHead(index,RecordCount,FieldCount,FieldInfo);
	else {
		Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
        QString strMojibake = "屯";		//乱码判断
        QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
		for(int i=0;i<FieldCount;i++) {
			pf[i].ArrayNum=1;
			pf[i].CodeLength=FieldInfo[i].Length;
			pf[i].RepCode=FieldInfo[i].RepCode;
			pf[i].DefVal=-9999.0;

            if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");
            if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);
            if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);

			int len=sizeof(pf[i].Name);
			if(len>strlen(FieldInfo[i].Name)) len=strlen(FieldInfo[i].Name);
			strncpy(pf[i].Name,FieldInfo[i].Name,len);
			pf[i].Name[len]=0;
			len=sizeof(pf[i].HZName);
			if(len>strlen(FieldInfo[i].HZName)) len=strlen(FieldInfo[i].HZName);
			strncpy(pf[i].HZName,FieldInfo[i].HZName,len);
			pf[i].HZName[len]=0;
			len=sizeof(pf[i].Unit);
			if(len>strlen(FieldInfo[i].Unit)) len=strlen(FieldInfo[i].Unit);
			strncpy(pf[i].Unit,FieldInfo[i].Unit,len);
			pf[i].Unit[len]=0;

			len=sizeof(pf[i].HZUnit);
			if(len>strlen(FieldInfo[i].HZUnit)) len=strlen(FieldInfo[i].HZUnit);
			strncpy(pf[i].HZUnit,FieldInfo[i].HZUnit,len);
			pf[i].HZUnit[len]=0;

			*(DWORD *)&pf[i].Reserved=FieldInfo[i].Reserved;
			pf[i].SamplePoint=1;
			pf[i].Rlev=1;
			pf[i].Start=1;
			pf[i].Vmax=-99999;
			pf[i].Vmin=99999;
			pf[i].Sequence=0;
		}
		SetSlfTableHead(index,RecordCount,FieldCount,pf);
		delete []pf;
		return 1;
	}
}

bool  CSlfIO::SetTableRecordCount(int index,int Count)
{
	if(IsWis) return SetWisTableRecordCount(index,Count);
	else return SetSlfTableRecordCount(index,Count);
}
bool  CSlfIO::ExpandTable(int index,DWORD BlockNum)
{
	if(IsWis) return ExpandWisTable(index,BlockNum);
	else return ExpandSlfTable(index,BlockNum);
}

bool  CSlfIO::SetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
{
	if(index<0) return 0;
	if(IsWis) return SetWisTableFieldInfo(index,FieldInfo);
	else {
		int FieldCount=m_SlfObjectEntry[index].FieldNum;
		Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
		GetSlfTableFieldInfo(index,pf);
        QString strMojibake = "屯";		//乱码判断
        QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
		for(int i=0;i<FieldCount;i++) {

			int len=strlen(FieldInfo[i].Name);
			if(len>sizeof(pf[i].Name)) len=sizeof(pf[i].Name);
			strncpy(pf[i].Name,FieldInfo[i].Name,len);
			pf[i].Name[len]=0;

            if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);

			len=strlen(FieldInfo[i].HZName);
			if(len>sizeof(pf[i].HZName)) len=sizeof(pf[i].HZName);
			strncpy(pf[i].HZName,FieldInfo[i].HZName,sizeof(pf[i].HZName));
			pf[i].HZName[len]=0;
            if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");

			len=strlen(FieldInfo[i].Unit);
			if(len>sizeof(pf[i].Unit)) len=sizeof(pf[i].Unit);
			strncpy(pf[i].Unit,FieldInfo[i].Unit,sizeof(pf[i].Unit));
			pf[i].Unit[len]=0;

            if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);

			len=strlen(FieldInfo[i].HZUnit);
			if(len>sizeof(pf[i].HZUnit)) len=sizeof(pf[i].HZUnit);
			strncpy(pf[i].HZUnit,FieldInfo[i].HZUnit,sizeof(pf[i].HZUnit));
			pf[i].HZUnit[len]=0;
		}
		SetSlfTableFieldInfo(index,pf,FALSE);
		delete []pf;
		return 1;
	}
}

bool  CSlfIO::GetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
{
	memset(FieldInfo,0,sizeof(Slf_TABLE_FIELD));
	if(index<0) return 0;
	if(IsWis) return GetWisTableFieldInfo(index,FieldInfo);
	else {
		int FieldCount=m_SlfObjectEntry[index].FieldNum;
		Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
		memset(pf,0,sizeof(Slf_OBJECT_FIELD)*FieldCount);
		GetSlfTableFieldInfo(index,pf);
        QString strMojibake = "屯";		//乱码判断
        QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
		for(int i=0;i<FieldCount;i++) {
			FieldInfo[i].Length=pf[i].CodeLength;
			FieldInfo[i].RepCode=pf[i].RepCode;

			strncpy(FieldInfo[i].Name,pf[i].Name,sizeof(FieldInfo[i].Name));

			strncpy(FieldInfo[i].HZName,pf[i].HZName,sizeof(FieldInfo[i].HZName));
            if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);

            if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");
			strncpy(FieldInfo[i].Unit,pf[i].Unit,sizeof(FieldInfo[i].Unit));

			strncpy(FieldInfo[i].HZUnit,pf[i].HZUnit,sizeof(FieldInfo[i].HZUnit));

            if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);
			FieldInfo[i].Reserved=*(DWORD *)&pf[i].Reserved;
		}
		delete []pf;
		return 1;
	}
}
int CSlfIO::GetTableRecordLength(int index)
{
	if(IsWis) return GetWisTableRecordLength(index);
	else return GetSlfTableRecordLength(index);
}
int CSlfIO::ReadTable(int index, int RecNo, void *buffer)
{
	if(IsWis) return ReadWisTable(index,RecNo,buffer);
	else {
		return ReadSlfTable(index, RecNo, buffer,RecNo-1);
	}
}
int CSlfIO::WriteTable(int index, int RecNo, void *buffer)
{
	if(IsWis) return WriteWisTable(index,RecNo,buffer);
	else return WriteSlfTable(index,RecNo,buffer,RecNo-1);
}

//Stream Operations     
int CSlfIO::OpenStream(const char* namee)
{
	if(IsWis) return OpenWisStream(namee);
	else return OpenSlfStream(namee);
}
int CSlfIO::CreateStream(short SubAttribute,const char *namee,DWORD length,bool bFailExist)
{
	if(IsWis) return CreateWisStream(SubAttribute,namee,length,bFailExist);
	else return CreateSlfStream(SubAttribute,namee,length,bFailExist);
}
bool  CSlfIO::SetStreamLength(int index, DWORD length)
{
	if(IsWis) return SetWisStreamLength(index,length);
	else return SetSlfStreamLength(index,length);
}
bool  CSlfIO::ExpandStream(int index, DWORD BlockNum)
{
	if(IsWis) return ExpandWisStream(index,BlockNum);
	else return ExpandSlfStream(index,BlockNum);
}
bool  CSlfIO::SeekStream(int index, int lMove, DWORD dwMoveMode)
{
	if(IsWis) return SeekWisStream(index,lMove,dwMoveMode);
	else return SeekSlfStream(index,lMove,dwMoveMode);
}
bool  CSlfIO::ReadStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
{
	if(IsWis) return ReadWisStream(index,length,lpBytesRead,buffer);
	else return ReadSlfStream(index,length,lpBytesRead,buffer);
}
bool  CSlfIO::WriteStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
{
	if(IsWis) return WriteWisStream(index,length,lpBytesWrite,buffer);
	else return WriteSlfStream(index,length,lpBytesWrite,buffer);
}
DWORD CSlfIO::GetStreamLength(int index)
{
	if(IsWis) return GetWisStreamLength(index);
	else return GetSlfStreamLength(index);
}
DWORD CSlfIO::GetObjectLength(char *name)
{
	if(IsWis) return GetWisObjectLength(name);
	else return GetSlfTableLength(name);
}
bool CSlfIO::CopyObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len)
{
	if(IsWis) return CopyWisObjectToMem(my,name,buffer,Len);
	else {
		Slf_TABLE_MESSAGE ss;
		return CopySlfObjectToMem(&ss,name,buffer,Len);
	}
}
bool CSlfIO::CopyFromFile(CSlfIO &Source,char *Name,char *NewObject)
{
	if(IsWis) return CopyFromWisFile(Source,Name,NewObject);
	else return CopyFromSLFFile(Source,Name,NewObject);
}
bool CSlfIO::CopyFromFile(CSlfIO &Source,char *Name)
{
	if(IsWis) return CopyFromWisFile(Source,Name);
	else return CopyFromSLFFile(Source,Name);
}
int CSlfIO::OpenSlfTable(int index,short att)
{
	if(index<0) return -1;
	short Source_Attribute=GetObjectType(index);
	if(att!=-1&&Source_Attribute!=att) {
		return -1;
	}
	if(index>-1) {
		if(!Slf_Info_Head[index]) {
			Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
		}
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		temp1->Table=m_SlfObjectEntry[index];
		Slf_OBJECT_FIELD *FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
		GetSlfTableFieldInfo(index,FieldInfo);
		temp1->pField=FieldInfo;
	}
	return index;
}
int CSlfIO::OpenSlfTable(const char*name,short att)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return -1;
	return OpenSlfTable(index,att);
}
int CSlfIO::CreateSlfTable(short Attribute,const char* name,const char* hzname,DWORD FieldNum,Slf_OBJECT_FIELD *pField,bool bFailExist)
{
	int index=FindSlfObjectIndex(name);
	if(index>-1) return index;
	index=m_SlfHead.TableNumber;
	m_SlfHead.TableNumber++;
	WriteSlfHead();
	m_SlfObjectEntry[index].RecondNum=1;
	int len=strlen(name);
	if(len>=64) len=63;
	strncpy(m_SlfObjectEntry[index].Name,name,len);
	m_SlfObjectEntry[index].Name[len]=0;
	if(!hzname) {
		strcpy(m_SlfObjectEntry[index].HZName,m_SlfObjectEntry[index].Name);
	}
	else {
		int len=strlen(hzname);
		if(len>=64) len=63;
		strncpy(m_SlfObjectEntry[index].HZName,hzname,len);
		m_SlfObjectEntry[index].HZName[len]=0;
	}
	m_SlfObjectEntry[index].SerialID=0;//	2	所属系列代码
	strcpy(m_SlfObjectEntry[index].DataSource,"create");//	20	数据来源
	m_SlfObjectEntry[index].Type=Attribute;//	2	表类型
	m_SlfObjectEntry[index].Status=0;//	2	表删除标志
	m_SlfObjectEntry[index].FieldNum=FieldNum;//	4	字段个数
	m_SlfObjectEntry[index].Position=mFile->size();
	m_SlfObjectEntry[index].DataRecord[0].DataPosition=m_SlfObjectEntry[index].Position+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;//	4	原始数据体存储的位置
	m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=0;
	mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition);
	for(int i=0;i<10;i++) {
		m_SlfObjectEntry[index].DataRecord[i+1].DataPosition=0;
		m_SlfObjectEntry[index].DataRecord[i+1].DataRecordNum=0;
	}
	m_SlfObjectEntry[index].IsSave=0;//	2	是否自动备份原始数据
	m_SlfObjectEntry[index].ChangeNum=1;//	2	修改次数
	/////////////////////////////////////////////
	//
	Slf_TABLE_History*pHistory=new Slf_TABLE_History[m_SlfObjectEntry[index].ChangeNum];//	76	修改历史信息描述结构变量数组

	//	m_SlfObjectEntry[index].pSLF_TABLE_History=pHistory;

	for(int i=0;i<m_SlfObjectEntry[index].ChangeNum;i++) {
		pHistory[i].StartRecord=0;
		pHistory[i].EndRecord=0;
		pHistory[i].Time=0;
		strcpy(pHistory[i].UserName,"ww");
	}

	delete pHistory;
	if(!Slf_Info_Head[index]) Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
	WriteSlfObjectEntry(index);
	if(pField) {
		Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[FieldNum];
		memmove(pFieldInfo,pField,sizeof(Slf_OBJECT_FIELD)*FieldNum);
		SetSlfTableFieldInfo(index,pFieldInfo);
	}
	return index;
}
bool CSlfIO:: WriteSlfHistory(int index,Slf_TABLE_History*pHistory)
{
	if(index<0) return 0;
	unsigned int POS=sizeof(Slf_FILE_HEAD)+index*m_SlfHead.TableMessageLength+sizeof(Slf_TABLE_ENTRY);
	if(m_SlfObjectEntry[index].ChangeNum>0) POS+=(m_SlfObjectEntry[index].ChangeNum-1)*sizeof(Slf_TABLE_History);
	mFile->seek(POS);//,QFile::begin
	for(int i=0;i<m_SlfObjectEntry[index].ChangeNum;i++) {
		mFile->write((char *)&pHistory[i],sizeof(Slf_TABLE_History));
	}
	mFile->flush();
	return 1;
}
bool CSlfIO:: CloseSlfTable(int index)
{
	if(index<0) return false;
	if(Slf_Info_Head[index]) {
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		delete []temp1->pField;
		delete temp1;
		Slf_Info_Head[index]=NULL;
	}
	return 1;
}
bool CSlfIO:: SeekSlfTable(int index, int OffsetCount, DWORD dwMoveMode)
{
	return 1;
}
int  CSlfIO:: GetSlfTableRecordCount(int index)
{
	int rec=0;
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
	}
	return rec;
}
int  CSlfIO:: SetSlfTableHead(int index,DWORD REC,DWORD FieldNum,Slf_OBJECT_FIELD *field)
{
	if(index<0) return 0;
	if(!field) return 0;
	m_SlfObjectEntry[index].FieldNum=FieldNum;
	if(m_SlfHead.TableNumber<=0) {
		mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);
		m_SlfHead.TableNumber++;
		WriteSlfHead();
	}
	unsigned int pos=mFile->size();
	m_SlfObjectEntry[index].RecondNum=(REC>0?1:0);
	m_SlfObjectEntry[index].Position=pos;
	m_SlfObjectEntry[index].DataRecord[0].DataPosition=pos+FieldNum*sizeof(Slf_OBJECT_FIELD);
	m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=REC;
	WriteSlfObjectEntry(index);
	Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[FieldNum];
	memmove(pFieldInfo,field,sizeof(Slf_OBJECT_FIELD)*FieldNum);
	SetSlfTableFieldInfo(index,pFieldInfo);
	pos=m_SlfObjectEntry[index].DataRecord[0].DataPosition+GetSlfTableRecordLength(index,field)*REC;
	mFile->resize(pos);
	mFile->flush();
	return m_SlfHead.TableNumber;
}
bool CSlfIO:: SetSlfTableRecordCount(int index,int Count)
{
	if(index<0) return 0;
	int leng=GetSlfTableLength(index);
	int rec=GetSlfTableRecordCount(index);
	int reclen=GetSlfTableRecordLength(index);
	int len=0;
	if(rec>Count) {
		len=rec;
	}
	else len=Count;
	unsigned long long lenn=len*reclen;
	char *buf=new char[lenn+1];
	memset(buf,0,lenn);
	if(leng) {
		ReadSlfTable(index,rec,buf);
		DiscardSlfObjectData(index,false);
	}
	WriteSlfTable(index,Count,buf);
	delete buf;
	return 1;
}
bool CSlfIO:: ExpandSlfTable(int index,int RecNum)
{
	if(m_SlfObjectEntry[index].RecondNum>10)
	{
		int rec=GetSlfTableRecordCount(index);
		SetSlfTableRecordCount(index,rec);
	}
	if(RecNum<0) {
		Slf_OBJECT_FIELD *FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
		GetSlfTableFieldInfo(index,FieldInfo);
		int reclen=GetSlfTableRecordLength(index,FieldInfo);
		for(int i=m_SlfObjectEntry[index].RecondNum;i>0;i--) {
			m_SlfObjectEntry[index].DataRecord[i].DataPosition=m_SlfObjectEntry[index].DataRecord[i-1].DataPosition;
			m_SlfObjectEntry[index].DataRecord[i].DataRecordNum=m_SlfObjectEntry[index].DataRecord[i-1].DataRecordNum;
		}
		m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();
		m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=-RecNum;
		mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition+m_SlfObjectEntry[index].DataRecord[0].DataRecordNum*reclen);
		m_SlfObjectEntry[index].RecondNum++;
		FieldInfo[0].Start+=RecNum*FieldInfo[0].Rlev;
		SetSlfTableFieldInfo(index,FieldInfo);
		delete FieldInfo;
		WriteSlfObjectEntry(index);
	}
	else {
		int reclen=GetSlfTableRecordLength(index);
		m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum=RecNum;
		m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition=mFile->size();
		mFile->resize(m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition+reclen*RecNum);
		m_SlfObjectEntry[index].RecondNum++;
		WriteSlfObjectEntry(index);
	}
	return 1;
}
int  CSlfIO:: GetSlfTableFieldCount(int index)
{
	if(index<0) return 0;
	if(!m_SlfObjectEntry) return 0;
	return m_SlfObjectEntry[index].FieldNum;
}
Slf_OBJECT_FIELD * CSlfIO:: GetSlfTableFieldInfo(int index)
{
	Slf_OBJECT_FIELD *FieldInfo=NULL;
	if(index<0) return NULL;
	if(!Slf_Info_Head[index]){
		Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
		GetSlfTableFieldInfo(index,FieldInfo);
		temp1->pField=FieldInfo;
	}
	else {
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		FieldInfo=temp1->pField;
	}
	return FieldInfo;
}
bool CSlfIO:: GetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo)
{
	if(index<0) return 0;
	if(!FieldInfo) return 0;
	mFile->seek(m_SlfObjectEntry[index].Position);//,QFile::begin
	for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
		mFile->read((char *)&FieldInfo[i],sizeof(Slf_OBJECT_FIELD));
	}
	return 1;
}
bool CSlfIO:: SetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo,bool SetNewFieldInfo)
{
	if(index<0) return 0;
	if(!FieldInfo) return 0;
	mFile->seek(m_SlfObjectEntry[index].Position);//,QFile::begin
	for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
		mFile->write((char *)&FieldInfo[i],sizeof(Slf_OBJECT_FIELD));
	}
	mFile->flush();
	if(Slf_Info_Head[index]&&SetNewFieldInfo) 
	{
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		temp1->pField=FieldInfo;
	}
	return 1;
}
int  CSlfIO:: GetSlfTableRecordLength(int index,Slf_OBJECT_FIELD *FieldInfo)
{
	if(index<0) return 0;
	int reclen=0;
	int Flag=0;
	if(!FieldInfo) {
		if(!Slf_Info_Head[index]){
			if(m_SlfObjectEntry[index].FieldNum<0||m_SlfObjectEntry[index].FieldNum>1024) return 0;
			FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
			GetSlfTableFieldInfo(index,FieldInfo);
			Flag=1;
		}
		else {
			Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
			FieldInfo=temp1->pField;
		}
	}
	for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) 
	{
		if(FieldInfo[i].Sequence) continue;
		reclen+=FieldInfo[i].ArrayNum*FieldInfo[i].CodeLength*FieldInfo[i].SamplePoint;
	}
	if(Flag) delete []FieldInfo;
	return reclen;
}
int  CSlfIO:: GetSlfTableFieldOffset(int index,int FieldNo,Slf_OBJECT_FIELD *FieldInfo)
{
	int reclen=0;
	int Flag=0;
	if(!FieldInfo) {
		if(!Slf_Info_Head[index]){
			FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
			GetSlfTableFieldInfo(index,FieldInfo);
			Flag=1;
		}
		else {
			Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
			FieldInfo=temp1->pField;
		}
	}
	for(int i=0;i<FieldNo;i++) {
		if(FieldInfo[i].Sequence) continue;
		reclen+=FieldInfo[i].ArrayNum*FieldInfo[i].CodeLength*FieldInfo[i].SamplePoint;
	}
	if(Flag) delete []FieldInfo;
	return reclen;
}

int  CSlfIO:: ReadSlfTable(int index, int RecNum, void *buffer,int FirstRec)
{
	int i=0;
	if(RecNum<=0) {
		RecNum=0;
		for(i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
			RecNum+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
		}
	}
	if(!buffer) return RecNum;
	if(FirstRec<0) {
		RecNum-=FirstRec;
		FirstRec=-FirstRec;
	}
	unsigned int point;
	int reclen=GetSlfTableRecordLength(index);
	int len=0,pos=0;
	int rec=0,rec1=0,rec2=0,rec3=0;
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		rec1=rec;
		rec3=rec;
		rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
		rec2=rec;
		if(rec<FirstRec) {
			continue;
		}
		if(rec1<FirstRec) rec1=FirstRec;
		if(rec>RecNum) {
			rec=RecNum;
		}
		point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+(rec1-rec3)*reclen;
		mFile->seek(point);//,QFile::begin
		char *buff=(char *)buffer;
		len=(rec-rec1)*reclen;
		mFile->read((char *)&buff[pos],len);
		pos+=len;
		if(rec2>RecNum) break;
	}
	return RecNum-FirstRec;
}
int  CSlfIO:: DeleteSlfTableRecord(int index,int RecNum,int FirstRec)
{
	unsigned int len=GetSlfTableLength(index);
	int reclen=GetSlfTableRecordLength(index);
	int rec=GetSlfTableRecordCount(index);
	char *buff=new char[len+1];
	ReadSlfTable(index,rec,buff);
	SetSlfTableRecordCount(index,rec-(RecNum-FirstRec));
	memmove(&buff[FirstRec*reclen],&buff[RecNum*reclen],(rec-RecNum)*reclen);
	WriteSlfTable(index,rec-(RecNum-FirstRec),buff);
	delete []buff;
	return 1;
}

int  CSlfIO:: ReadSlfTableFieldData(int index,int FieldNo,int RecNo,void *buffer,int FirstRec,int Count)
{
	if(index<0) return 0;
	Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
	unsigned int point,pos=0;
	int reclen=GetSlfTableRecordLength(index,FieldInfo);
	int recpos=GetSlfTableFieldOffset(index,FieldNo,FieldInfo);
	int len=FieldInfo[FieldNo].CodeLength*FieldInfo[FieldNo].SamplePoint*FieldInfo[FieldNo].ArrayNum,rec=0;
	if(Count) len=Count*FieldInfo[FieldNo].CodeLength;
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		for(int j=0;j<m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;j++) {
			if(rec>=FirstRec&&rec<RecNo) {
				point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+j*reclen+recpos;
				mFile->seek(point);
				char *buff=(char *)buffer;
				mFile->read((char *)&buff[pos],len);
				pos+=len;
			}
			rec++;
		}
	}
	return RecNo-FirstRec;
}
int  CSlfIO:: FindSlfFieldNo(int index,char *FieldName)
{
	if(index<0) return -1;
	Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
	for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
		if(stricmp(FieldInfo[i].Name,FieldName)==0||stricmp(FieldInfo[i].HZName,FieldName)==0) {
			return i;
		}
	}
	return -1;
}
int  CSlfIO:: WriteSlfTableFieldData(int index,int FieldNo,int RecNum,void *buffer,int FirstRec,int Count)
{
	if(index<0) return 0;
	int ma=GetSlfTableRecordCount(index);
	if(RecNum>ma) SetSlfTableRecordCount(index,RecNum);
	Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
	unsigned int point,pos=0;
	int reclen=GetSlfTableRecordLength(index,FieldInfo);
	int recpos=GetSlfTableFieldOffset(index,FieldNo,FieldInfo);
	int len=FieldInfo[FieldNo].CodeLength*FieldInfo[FieldNo].SamplePoint*FieldInfo[FieldNo].ArrayNum,rec=0;
	if(Count) len=Count*FieldInfo[FieldNo].CodeLength;
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		for(int j=0;j<m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;j++) {
			if(rec>RecNum) break;
			if(rec>=FirstRec&&rec<RecNum) {
				point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+j*reclen+recpos;
				mFile->seek(point);//QFile::begin
				char *buff=(char *)buffer;
				mFile->write((char *)&buff[pos],len);
				pos+=len;
			}
			rec++;
		}
	}
	mFile->flush();
	return RecNum-FirstRec;
}

int CSlfIO:: WriteSlfTable(int index, int EndRec, void *buffer,int FirstRec)
{
	if(!buffer) return 0;
	int reclen=GetSlfTableRecordLength(index);
	if(FirstRec<0) {
		if(m_SlfObjectEntry[index].RecondNum>10) {
			int rec=GetSlfTableRecordCount(index);
			SetSlfTableRecordCount(index,rec);
		}
		Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
		for(int i=m_SlfObjectEntry[index].RecondNum;i>0;i--) {
			m_SlfObjectEntry[index].DataRecord[i].DataPosition=m_SlfObjectEntry[index].DataRecord[i-1].DataPosition;
			m_SlfObjectEntry[index].DataRecord[i].DataRecordNum=m_SlfObjectEntry[index].DataRecord[i-1].DataRecordNum;
		}
		m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();
		m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=-FirstRec;
		mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition+m_SlfObjectEntry[index].DataRecord[0].DataRecordNum*reclen);//,CFile::begin);
		m_SlfObjectEntry[index].RecondNum++;
		WriteSlfObjectEntry(index);
		FieldInfo[0].Start+=FirstRec*FieldInfo[0].Rlev;
		SetSlfTableFieldInfo(index,FieldInfo);
		EndRec=EndRec-FirstRec;
		FirstRec=0;
	}
	int rec=GetSlfTableRecordCount(index);
	if(EndRec>rec) {
		if(m_SlfObjectEntry[index].RecondNum>10) {	
			SetSlfTableRecordCount(index,rec);
		}
		if(rec<=0) m_SlfObjectEntry[index].RecondNum=0; 
		m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition=mFile->size();
		m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum=EndRec-rec;
		mFile->resize(m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition+m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum*reclen);//,CFile::begin);
		m_SlfObjectEntry[index].RecondNum++;
		WriteSlfObjectEntry(index);
	}
	unsigned int point;
	int len=0,pos=0;
	rec=0;
	int rec1=0,rec2=0,rec3=0;
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		rec1=rec;
		rec3=rec;
		rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
		rec2=rec;
		if(rec<FirstRec) {
			continue;
		}
		if(rec1<FirstRec) rec1=FirstRec;
		if(rec>EndRec) {
			rec=EndRec;
		}
		len=(rec-rec1)*reclen;
		point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+(rec1-rec3)*reclen;
		mFile->seek(point);//,QFile::begin
		char *buff=(char *)buffer;
		mFile->write((char *)&buff[pos],len);
		pos+=len;
		if(rec2>EndRec) break;
	}
	mFile->flush();
	return EndRec-FirstRec;
}
void CSlfIO:: InitSlf(int BlockLen,int MaxObjectNumber, int MachineType)
{
	/////////////////////////////////////
	// set head
	memset(&m_SlfHead,0,sizeof(Slf_HEAD));
	strcpy(m_SlfHead.Version,"Slf 3.1");
	m_SlfHead.BinaryType=MachineType;//	4	二进制数据标准
	m_SlfHead.TableNumber=0;//	4	已存储表个数
	m_SlfHead.MaxTableNumber=MaxObjectNumber;//	4	预留最大表个数
	//	m_SlfHead.FileSize;//	4	文件大小
	m_SlfHead.TableMessageLength=BlockLen;//	4	表基本信息长度
	struct tm *newtime;
	time_t ltime;
	char buff[80];
	time( &ltime );

	// Obtain coordinated universal time:
	m_SlfHead.TimeCreate = (__time32_t)ltime ; // C4996
	// Note: _gmtime64 is deprecated; consider using _gmtime64_s
	strcpy(m_SlfHead.WellMessage.Reserved,"WANGWEI");
	if(!Slf_Info_Head) Slf_Info_Head=new char *[m_SlfHead.MaxTableNumber];
	for(int i=0;i<m_SlfHead.MaxTableNumber;i++) Slf_Info_Head[i]=NULL;

	if(!m_SlfObjectEntry)m_SlfObjectEntry=new Slf_TABLE_ENTRY[m_SlfHead.MaxTableNumber];
	memset(m_SlfObjectEntry,0,sizeof(Slf_TABLE_ENTRY)*m_SlfHead.MaxTableNumber);
	WriteSlfHead();
	WriteSlfObjectEntry();
}
void CSlfIO:: SetSlfMessage(Slf_FILE_MESSAGE mssage)
{
	memmove(&m_SlfHead.WellMessage,&mssage,sizeof(Slf_FILE_MESSAGE));
	/*
	m_SlfHead.WellMessage.Kelly=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Kelly));
	m_SlfHead.WellMessage.Bit_Diameter[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[0]));
	m_SlfHead.WellMessage.Bit_Depth[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[0] ));
	m_SlfHead.WellMessage.Bit_Diameter[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[1] ));
	m_SlfHead.WellMessage.Bit_Depth[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[1] ));
	m_SlfHead.WellMessage.Bit_Diameter[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[2]));
	m_SlfHead.WellMessage.Bit_Depth[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[2] ));
	m_SlfHead.WellMessage.Bit_Diameter[3]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[3]));
	m_SlfHead.WellMessage.Bit_Depth[3]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[3] ));
	m_SlfHead.WellMessage.Bushing_Inside_Diameter[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[0]) );
	m_SlfHead.WellMessage.Bushing_Detpth[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[0]));
	m_SlfHead.WellMessage.Bushing_Inside_Diameter[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[1]) );
	m_SlfHead.WellMessage.Bushing_Detpth[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[1]));
	m_SlfHead.WellMessage.Bushing_Inside_Diameter[2]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[2]) ));
	m_SlfHead.WellMessage.Bushing_Detpth[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[2]));
	m_SlfHead.WellMessage.Bushing_Outside_Diameter[0]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[0])));
	m_SlfHead.WellMessage.Bushing_Outside_Diameter[1]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[1])));
	m_SlfHead.WellMessage.Bushing_Outside_Diameter[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[2]));
	*/
	WriteSlfHead();
}
void CSlfIO:: GetSlfMessage(Slf_FILE_MESSAGE &mssage)
{
	if(strstr(m_SlfHead.Version,"Slf 3.0")) {
		if(m_SlfHead.WellMessage.Xcoor==0&&m_SlfHead.WellMessage.Ycoor==0) {
//			m_SlfHead.WellMessage.Xcoor=m_SlfHead.WellMessage.Xcoor1;
//			m_SlfHead.WellMessage.Ycoor=m_SlfHead.WellMessage.Ycoor1;
		}
	}
	memmove(mssage.AreaName,&m_SlfHead.WellMessage,sizeof(Slf_FILE_MESSAGE));
	/*
	mssage.Kelly=ConvertDataByFloat(mssage.Kelly).toFloat();
	mssage.Bit_Diameter[0]=ConvertDataByFloat(mssage.Bit_Diameter[0] ).toFloat();
	mssage.Bit_Depth[0]=ConvertDataByFloat(mssage.Bit_Depth[0] ).toFloat();
	mssage.Bit_Diameter[1]=ConvertDataByFloat(mssage.Bit_Diameter[1] ).toFloat();
	mssage.Bit_Depth[1]=ConvertDataByFloat(mssage.Bit_Depth[1] ).toFloat();
	mssage.Bit_Diameter[2]=ConvertDataByFloat(mssage.Bit_Diameter[2]).toFloat();
	mssage.Bit_Depth[2]=ConvertDataByFloat(mssage.Bit_Depth[2] ).toFloat();
	mssage.Bit_Diameter[3]=ConvertDataByFloat(mssage.Bit_Diameter[3]).toFloat();
	mssage.Bit_Depth[3]=ConvertDataByFloat(mssage.Bit_Depth[3] ).toFloat();
	mssage.Bushing_Inside_Diameter[0]=ConvertDataByFloat(mssage.Bushing_Inside_Diameter[0] ).toFloat();
	mssage.Bushing_Detpth[0]=ConvertDataByFloat(mssage.Bushing_Detpth[0]).toFloat();
	mssage.Bushing_Inside_Diameter[1]=ConvertDataByFloat(mssage.Bushing_Inside_Diameter[1] ).toFloat();
	mssage.Bushing_Detpth[1]=ConvertDataByFloat(mssage.Bushing_Detpth[1]).toFloat();
	mssage.Bushing_Inside_Diameter[2]=(ConvertDataByFloat(mssage.Bushing_Inside_Diameter[2] )).toFloat();
	mssage.Bushing_Detpth[2]=ConvertDataByFloat(mssage.Bushing_Detpth[2]).toFloat();
	mssage.Bushing_Outside_Diameter[0]=(ConvertDataByFloat(mssage.Bushing_Outside_Diameter[0] )).toFloat();
	mssage.Bushing_Outside_Diameter[1]=(ConvertDataByFloat(mssage.Bushing_Outside_Diameter[1] )).toFloat();
	mssage.Bushing_Outside_Diameter[2]=ConvertDataByFloat(mssage.Bushing_Outside_Diameter[2] ).toFloat();
	*/
}
int  CSlfIO:: ReadSlfHead()
{
	mFile->seek(0);
	int len=sizeof(Slf_FILE_HEAD);
	mFile->read((char *)&m_SlfHead,len);
	return 1;
}
int  CSlfIO:: WriteSlfHead()
{
	mFile->seek(0);
	if(m_SlfHead.MaxTableNumber<=0) {
		AfxMessageBox("文件头错误！");
		return 0;

	}
	mFile->write((char *)&m_SlfHead,sizeof(Slf_FILE_HEAD));
	mFile->flush();
	return 1;
}
int  CSlfIO:: ReadSlfObjectEntry()
{
	for(int i=0;i<m_SlfHead.TableNumber;i++) {
		int a=sizeof(Slf_TABLE_ENTRY);
		int x=mFile->pos();
		mFile->seek(sizeof(Slf_FILE_HEAD)+i*m_SlfHead.TableMessageLength);
		mFile->read((char *)&m_SlfObjectEntry[i],sizeof(Slf_TABLE_ENTRY));
	}
	return -1;
}
int  CSlfIO:: WriteSlfObjectEntry()
{
	for(int i=0;i<m_SlfHead.TableNumber;i++) {
		WriteSlfObjectEntry(i);
	}
	return 1;
}

bool CSlfIO:: OpenSlf(const char* LogName,unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
{
	strcpy(m_LogFileName,LogName);
	return OpenSlf(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
}
bool  CSlfIO::OpenSlf(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
{
	IsWis=false;
	if(nOpenFlags==modeCreate) 	
	{
		mFile=new QFile(m_LogFileName);
		mFile->open(QIODevice::ReadWrite);
		InitSlf(BlockLen, MaxObjectNumber, MachineType);
		mFile->flush();
		mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
		return TRUE;
	}
	else {
		QFile f;
		if(f.exists(m_LogFileName)) {
			mFile=new QFile(m_LogFileName);
			mFile->open(QIODevice::ReadWrite);
			ReadSlfHead();
/*			if(m_SlfHead.MaxTableNumber<=0) {
				m_SlfHead.MaxTableNumber=1024;
				m_SlfHead.TableMessageLength=1024;
				m_SlfHead.TableNumber=1024;
			}
			*/
			if(m_SlfHead.MaxTableNumber<=0) {
				InitSlf(BlockLen, MaxObjectNumber, MachineType);
				mFile->flush();
				mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
				return true;
			}
			Slf_Info_Head=new char *[m_SlfHead.MaxTableNumber];
			for(int i=0;i<m_SlfHead.MaxTableNumber;i++) Slf_Info_Head[i]=NULL;

			m_SlfObjectEntry=new Slf_TABLE_ENTRY[m_SlfHead.MaxTableNumber];
			memset(m_SlfObjectEntry,0,sizeof(Slf_TABLE_ENTRY)*m_SlfHead.MaxTableNumber);

			ReadSlfObjectEntry();
			for(int i=0;i<m_SlfHead.TableNumber;i++)
			{
				strupr(m_SlfObjectEntry[i].Name);
/*				if(strlen(m_SlfObjectEntry[i].Name)==0)
				{
					int a=1;
					m_SlfHead.TableNumber=i;
					strcpy(m_SlfHead.Version,"Slf 3.1");
					WriteSlfHead();
					break;
				}
				*/
			}
		}
		else {
			mFile=new QFile(m_LogFileName);
			mFile->open(QIODevice::ReadWrite);
			InitSlf(BlockLen, MaxObjectNumber, MachineType);
			mFile->flush();
			mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
		}

		return TRUE;
	}
	return FALSE;
}
void CSlfIO:: GetSlfHead(Slf_FILE_HEAD* pHead)
{
	*pHead=m_SlfHead;
	//	return -1;
}
DWORD CSlfIO::GetSlfTableLength(char *name)//长度
{
	int index=FindSlfObjectIndex(name);
	if(index>-1) return GetSlfTableLength(index);
	else return 0;
}
DWORD CSlfIO::GetSlfTableLength(int index)//长度
{
	if(index<0) return 0;
	int rec=0;
	int reclen=GetSlfTableRecordLength(index);
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
	}
	return rec*reclen;//+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
}
//Object Operations
int  CSlfIO::FindSlfObjectIndex(const char* namee,int status)
{
	if(!m_SlfObjectEntry) return -1;
	char name[128];
	strcpy(name,namee);
	for(int i=0;i<m_SlfHead.TableNumber;i++) {
		if(stricmp(name,m_SlfObjectEntry[i].Name)==0||stricmp(name,m_SlfObjectEntry[i].HZName)==0) {
			if(status==-1) return i;
			if(status==m_SlfObjectEntry[i].Status) return i;
		}
	}
	return -1;
}

int CSlfIO::  FindSlfObjectName(char* name,short Attribute, short SubAttribute, int status,int otype)
{
	for(int i=0;i<m_SlfHead.TableNumber;i++) 
	{
		if(stricmp(name,m_SlfObjectEntry[i].Name)==0||stricmp(name,m_SlfObjectEntry[i].HZName)==0) 
		{
			if(Attribute>-1) 
			{
				if(m_SlfObjectEntry[i].Type==Attribute) 
				{
					if(SubAttribute>-1) 
					{
						if(m_SlfObjectEntry[i].Type==SubAttribute) 
						{
							if(status>-1) 
							{
								if(otype>-1) {
									if(m_SlfObjectEntry[i].Status>=status) return i;
								}
								else if(m_SlfObjectEntry[i].Status==status) return i;
								continue;//else return -1;
							}
							else return i;
						}
						continue;//else return -1;
					}
					else if(status>-1) 
					{
						if(otype>-1) {
							if(m_SlfObjectEntry[i].Status>=status) return i;
						}
						else if(m_SlfObjectEntry[i].Status==status) return i;
						continue;//else return -1;
					}
					else return i;
				}
				else if(otype>-1) {
					if(m_SlfObjectEntry[i].Type>=Attribute) return i;
				}
				continue;//else return -1;
			}
			else if(SubAttribute>-1) 
			{
				if(m_SlfObjectEntry[i].Type==SubAttribute) 
				{
					if(status>-1)
					{
						if(m_SlfObjectEntry[i].Status==status) return i;
						continue;//else return -1;
					}
					else return i;
				}
				continue;//else return -1;
			} 
			else if(status>-1) 
			{
				if(m_SlfObjectEntry[i].Status==status) return i;
				continue;//else return -1;
			}
			else return i;
		}
	}
	return -1;
}

bool CSlfIO:: DeleteSlfObject(const char* name)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return 0;
	m_SlfObjectEntry[index].Status=OBJECT_DELETE;
	WriteSlfObjectEntry(index);
	return 1;
}
bool CSlfIO:: WriteSlfObjectEntry(int index,Slf_TABLE_ENTRY *obj)
{
	if(index<0) return 0;
	mFile->seek(sizeof(Slf_FILE_HEAD)+index*m_SlfHead.TableMessageLength);//,QFile::begin
	if(obj)
	{
		mFile->write((char *)obj,sizeof(Slf_TABLE_ENTRY));
		memmove(&m_SlfObjectEntry[index],obj,sizeof(Slf_TABLE_ENTRY));
	}
	else mFile->write((char *)&m_SlfObjectEntry[index],sizeof(Slf_TABLE_ENTRY));
	if(Slf_Info_Head[index]) {
		Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
		temp1->Table=m_SlfObjectEntry[index];
	}
	mFile->flush();
	return 1;
}
bool CSlfIO:: DiscardSlfObject(const char* name)
{
	int index=FindSlfObjectIndex(name,-1);
	if(index<0) return false;
	return DiscardSlfObject(index);
}
bool CSlfIO:: DiscardSlfObjectData(int index,bool DeleteField)
{
	if(index<0) return 0;
	int dlen=0;
	int reclen=GetSlfTableRecordLength(index);
	for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
		DWORD point,point1;
		point1=m_SlfObjectEntry[index].DataRecord[i].DataPosition;
		point =point1+m_SlfObjectEntry[index].DataRecord[i].DataRecordNum*reclen;
		unsigned int len=mFile->size();
		dlen=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum*reclen;
		if(len<point)
		{
			break;
		}
		DWORD size=len-point;
		while((int)size<0)
		{
			size/=2;
		}
		int le=size;
		char *buffer=new char[size+1];
		while(point<len){
			if(point+le>len) 
			{
				le=len-point;
			}
			mFile->seek(point);
			mFile->read(buffer,le);
			mFile->seek(point1);
			mFile->write(buffer,le);
			point+=le;
			point1+=le;
		}
		mFile->flush();
		delete []buffer;

		mFile->resize(len-dlen);
		for(int k=0;k<m_SlfHead.TableNumber;k++) {
			if(m_SlfObjectEntry[k].Position>m_SlfObjectEntry[index].DataRecord[i].DataPosition)
			{
				m_SlfObjectEntry[k].Position-=dlen;
			}
			for(int j=0;j<m_SlfObjectEntry[k].RecondNum;j++)
			{   
				if(m_SlfObjectEntry[k].DataRecord[j].DataPosition>m_SlfObjectEntry[index].DataRecord[i].DataPosition) 
				{
					m_SlfObjectEntry[k].DataRecord[j].DataPosition-=dlen;
				}
			}
		}
	}

	if(DeleteField){
		DWORD point,point1;
		point1=m_SlfObjectEntry[index].Position;
		point =point1+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
		unsigned int len=mFile->size();
		DWORD size=len-point;
		while((int)size<0)
		{
			size/=2;
		}
		int le=size;
		char *buffer=new char[size+1];
		while(point<len){
			if(point+le>len) 
			{
				le=len-point;
			}
			mFile->seek(point);
			mFile->read(buffer,le);
			mFile->seek(point1);
			mFile->write(buffer,le);
			point+=le;
			point1+=le;
		}
		mFile->flush();
		delete []buffer;
		mFile->resize(len-sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum);
		dlen=sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
		for(int k=0;k<m_SlfHead.TableNumber;k++) {
			if(m_SlfObjectEntry[k].Position>m_SlfObjectEntry[index].Position) 
			{
				m_SlfObjectEntry[k].Position-=dlen;
			}
			for(int j=0;j<m_SlfObjectEntry[k].RecondNum;j++) {
				if(m_SlfObjectEntry[k].DataRecord[j].DataPosition>m_SlfObjectEntry[index].Position) 
				{
					m_SlfObjectEntry[k].DataRecord[j].DataPosition-=dlen;
				}
			}
		}
		m_SlfObjectEntry[index].Position=mFile->size();
	}
	else if(!DeleteField) {
		m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();;
	}
	m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=0;
	m_SlfObjectEntry[index].RecondNum=0;
	WriteSlfObjectEntry();
	return 1;
}

bool CSlfIO:: DiscardSlfObject(int index)
{
	if(index<0) return FALSE;
	m_SlfObjectEntry[index].Status=OBJECT_DISCARD;
	WriteSlfObjectEntry(index);
	char Name[200];
	strcpy(Name,"Discard_");
	strcat(Name,m_SlfObjectEntry[index].Name);
	RenameSlfObject(index,Name);
	return 1;
}
bool CSlfIO:: RenameSlfObject(const char* oldName,const char* newName)
{
	int index=FindSlfObjectIndex(oldName);
	if(index<0) return 0;
	return RenameSlfObject(index,newName);
}
bool CSlfIO:: RenameSlfObject(int index,const char* newName)
{
	if(index<0) return 0;
	if(FindSlfObjectIndex(newName)>-1&&strcmp(m_SlfObjectEntry[index].Name,newName)==0) return false;
	strcpy(m_SlfObjectEntry[index].Name,newName);
	strcpy(m_SlfObjectEntry[index].HZName,newName);
	WriteSlfObjectEntry(index);
	return 1;
}
bool CSlfIO:: CopySlfObject(const char* oldName,const char* newName, bool bFailExist)
{
	int index=FindSlfObjectIndex(oldName);
	if(index<0) {
		return 0;
	}
	int reclen=GetSlfTableRecordLength(index);
	unsigned int leng=GetSlfTableLength((char *)oldName);
	if(leng<1) {
		return 0;
	}
	int ind=FindSlfObjectIndex(newName);
	if(ind>=0) {
		if(bFailExist) return 1;
		else DiscardSlfObjectData(ind);
	}
	else ind=m_SlfHead.TableNumber++;
	m_SlfObjectEntry[ind]=m_SlfObjectEntry[index];
	strcpy(m_SlfObjectEntry[ind].Name,newName);
	strcpy(m_SlfObjectEntry[ind].HZName,newName);
	unsigned int Pos=mFile->size();
	m_SlfObjectEntry[ind].Position=Pos;
	m_SlfObjectEntry[ind].RecondNum=1;
	m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum=0;
	m_SlfObjectEntry[ind].DataRecord[0].DataPosition=Pos+
		sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[ind].FieldNum;
	Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[m_SlfObjectEntry[ind].FieldNum];
	GetSlfTableFieldInfo(index,pf);
	if(Slf_Info_Head[ind]) {
		SetSlfTableFieldInfo(ind,pf,1);
	}
	else {
		SetSlfTableFieldInfo(ind,pf);
		delete []pf;
	}
	WriteSlfObjectEntry(ind);
	WriteSlfHead();
	char *buf=new char[leng+1];
	int RecNum=ReadSlfTable(index,0,buf);
	WriteSlfTable(ind,RecNum,buf);
	delete []buf;
	return 1;
}
bool CSlfIO:: UndeleteSlfObject(const char* name)
{
	int index=FindSlfObjectIndex(name,OBJECT_DELETE);
	if(index<0) return 0;
	m_SlfObjectEntry[index].Status=OBJECT_NORMAL;
	WriteSlfObjectEntry(index);
	return 1;
}
WORD CSlfIO:: GetSlfObjectCount()
{
	return m_SlfHead.TableNumber;
}
void CSlfIO:: GetAllSlfObjectEntry(Slf_TABLE_ENTRY* pEntry,WORD count)
{
	if(count<=0) count=m_SlfHead.MaxTableNumber;
	memmove(pEntry,m_SlfObjectEntry,sizeof(Slf_TABLE_ENTRY)*count);
}
void CSlfIO:: GetSlfObjectEntry(int index,Slf_TABLE_ENTRY* pEntry)
{
	if(index>-1) *pEntry=m_SlfObjectEntry[index];
}
void CSlfIO:: SetSlfObjectReserved(int index,char * pEntry)
{
	if(index>-1&&pEntry) {
		int len=strlen(pEntry);
		if(len>=32) len=31;
		memmove(m_SlfObjectEntry[index].DataSource,pEntry,len);
		m_SlfObjectEntry[index].DataSource[len]=0;
		WriteSlfObjectEntry(index);
	}
}
void CSlfIO:: GetSlfObjectAttribute(int index,short* Attribute, short* SubAttribute)
{
	if(index>=0) {
		*SubAttribute=m_SlfObjectEntry[index].Type;
		*Attribute=1;
		if(m_SlfObjectEntry[index].Type==CURVE_OBJECT||m_SlfObjectEntry[index].Type==TDT_OBJECT||m_SlfObjectEntry[index].Type==FMT_OBJECT) {
			*Attribute=CHANNEL_OBJECT;
			*SubAttribute=m_SlfObjectEntry[index].Type;
		}
		else if(m_SlfObjectEntry[index].Type==CARD_OBJECT) {
			*Attribute=STREAM_OBJECT;
			*SubAttribute=PARA_OBJECT;
		}
		else if(m_SlfObjectEntry[index].Type>CARD_OBJECT) {
			*Attribute=TABLE_OBJECT;
			*SubAttribute=m_SlfObjectEntry[index].Type-CARD_OBJECT;
		}
	}
}
bool CSlfIO:: GetSlfObjectEntry(const char* name,Slf_TABLE_ENTRY* pEntry)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return 0;
	*pEntry=m_SlfObjectEntry[index];
	return 1;
}
bool CSlfIO:: GetSlfObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return 0;
	GetSlfObjectAttribute(index,Attribute,SubAttribute);
	return 1;
}

int  CSlfIO:: OpenSlfStream(const char* name)
{
	int index=FindSlfObjectName((char *)name,CARD_OBJECT);
	if(index<0)return -1;
	return OpenSlfTable(name);
}
int  CSlfIO:: CreateSlfStream(short SubAttribute,const char *name,DWORD length,bool bFailExist,const char *hzname)
{
	Slf_OBJECT_FIELD field;
	memset((char *)&field,0,sizeof(Slf_OBJECT_FIELD));
	field.ArrayNum=1;
	field.CodeLength=1;
	field.RepCode=6;
	field.SamplePoint=1;//length;
	field.Rlev=1;
	field.Start=0;
	field.Sequence=0;
	int index=CreateSlfTable(CARD_OBJECT,name,hzname,1,&field,bFailExist);
	if(index>-1) SetSlfTableRecordCount(index,length);
	return index;
}
bool CSlfIO:: ExpandSlfStream(int index, DWORD BlockNum)
{
	return 1;
}
void CSlfIO:: CloseSlfStream(int index)
{
}
bool CSlfIO:: SetSlfStreamLength(int index, DWORD length)
{
	return SetSlfTableRecordCount(index,length);	
}
bool CSlfIO:: SeekSlfStream(int index, int lMove, DWORD dwMoveMode)
{
	return 1;
}
bool CSlfIO:: ReadSlfStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
{
	*lpBytesRead=ReadSlfTable(index, length, buffer,0);
	return 1;
}
bool CSlfIO:: WriteSlfStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
{
	*lpBytesWrite=WriteSlfTable(index, length,(void *) buffer,0);
//	SetSlfTableRecordCount(index,length);
	return 1;
}
DWORD CSlfIO::GetSlfStreamLength(int index)
{
	return GetSlfTableLength(index);
}
int CSlfIO:: ReadSlfStreamInfo(int index)
{
	return 1;
}
int CSlfIO:: WriteSlfStreamInfo(int index)
{
	return 1;
}
int   CSlfIO::OpenSlfChannel(const char *name)
{
	int index=FindSlfObjectName((char *)name);
	if(index<0) return -1;
	int curvetype=GetObjectType(name);
	if(curvetype>=CARD_OBJECT||curvetype==0) return -1; 
	return OpenSlfTable(name);
}
int   CSlfIO::OpenSlfChannel(const char *name,short Attribute)
{
	int index=FindSlfObjectName((char *)name);
	if(index<0) return -1;
	int curvetype=GetObjectType(name);
	if(curvetype>=CARD_OBJECT||curvetype==0) return -1; 
	return OpenSlfTable(name);
}
DWORD CSlfIO::ComputerSlfChannelLength(int index)
{
	return GetSlfTableRecordLength(index);
}
bool  CSlfIO::CorrectSlfTableField(int index, unsigned char nDimension, float delta)
{
	if(index<0) return 0;
	Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
	GetSlfTableFieldInfo(index,pFieldInfo);
	pFieldInfo[nDimension].Start+=delta;
	SetSlfTableFieldInfo(index,pFieldInfo,0);
	delete []pFieldInfo;
	return 1;
}
bool CSlfIO::CopySlfObjectToMem(Slf_TABLE_MESSAGE *my,char *name,char *buffer,int Len)
{
	int index=FindSlfObjectName(name);
	if(index<0) return NULL;
	memmove(&my->Table,&m_SlfObjectEntry[index],sizeof(Slf_TABLE_ENTRY));
	GetSlfTableFieldInfo(index,my->pField);
	ReadSlfTable(index,0,buffer,0);
	return TRUE;
}

bool CSlfIO::CopyFromSLFFile(Slf_TABLE_MESSAGE *my,char *buffer,int Len)
{
	int index=FindSlfObjectName(my->Table.Name);
	if(index>=0) return FALSE;
	memmove(&m_SlfObjectEntry[m_SlfHead.TableNumber],&my->Table,sizeof(Slf_TABLE_ENTRY));
	int rec=GetSlfTableRecordCount(m_SlfHead.TableNumber);
	m_SlfObjectEntry[m_SlfHead.TableNumber].Position=mFile->size();
	m_SlfObjectEntry[m_SlfHead.TableNumber].RecondNum=1;
	m_SlfObjectEntry[m_SlfHead.TableNumber].DataRecord[0].DataPosition=
		m_SlfObjectEntry[m_SlfHead.TableNumber].Position+m_SlfObjectEntry[m_SlfHead.TableNumber].FieldNum*sizeof(Slf_OBJECT_FIELD);
	m_SlfObjectEntry[m_SlfHead.TableNumber].DataRecord[0].DataRecordNum=rec;
	SetSlfTableFieldInfo(m_SlfHead.TableNumber,my->pField);
	WriteSlfTable(m_SlfHead.TableNumber,rec,buffer);
	m_SlfHead.TableNumber++;
	WriteSlfHead();
	WriteSlfObjectEntry();
	return TRUE;
}

bool CSlfIO::CopyFromSLFFile(CSlfIO &Source,char *Name,char *newName)
{
	if(!Source.mFile) return FALSE;
	if(Source.IsWis) return FALSE;
	int len=Source.GetSlfTableLength(Name);
	if(len==0) return FALSE;
	char *buf=new char[len+1];
	if(!buf) return FALSE;
	int index=Source.FindSlfObjectIndex(Name);
	Slf_TABLE_MESSAGE obje;
	int FieldNum=Source.GetSlfTableFieldCount(index);
	obje.pField=new Slf_OBJECT_FIELD[FieldNum];
	if(Source.GetSlfObjectEntry(Name,&obje.Table)&&Source.GetSlfTableFieldInfo(index,obje.pField)) {
		if(Source.CopySlfObjectToMem(&obje,Name,buf,len)) {
			strcpy(obje.Table.Name,newName);
			if(CopyFromSLFFile(&obje,buf,len)) {
				delete obje.pField;
				delete buf;
				return TRUE;
			}
		}
	}
	delete obje.pField;
	delete buf;
	return FALSE;
}

bool CSlfIO::CopyFromSLFFile(CSlfIO &Source,char *Name)
{
	if(!Source.mFile) return FALSE;
	if(Source.IsWis) return FALSE;
	int len=Source.GetSlfTableLength(Name);
	if(len==0) return FALSE;
	char *buf=new char[len+1];
	if(!buf) return FALSE;
	int index=Source.FindSlfObjectIndex(Name);
	Slf_TABLE_MESSAGE obje;
	int FieldNum=Source.GetSlfTableFieldCount(index);
	obje.pField=new Slf_OBJECT_FIELD[FieldNum];
	if(Source.GetSlfObjectEntry(Name,&obje.Table)&&Source.GetSlfTableFieldInfo(index,obje.pField)) {
		if(Source.CopySlfObjectToMem(&obje,Name,buf,len)) {
			if(CopyFromSLFFile(&obje,buf,len)) {
				delete obje.pField;
				delete buf;
				return TRUE;
			}
		}
	}
	delete obje.pField;
	delete buf;
	return FALSE;
}
void  CSlfIO::SlfTableResamples(int index,float newDelta)
{
	if(index<0) return;
	int reclen=GetSlfTableRecordLength(index);
	unsigned int leng=GetSlfTableLength(index);
	int rec=GetSlfTableRecordCount(index);
	if(leng<1) return;
	Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
	GetSlfTableFieldInfo(index,pf);
	if(pf->Rlev==newDelta) {
		delete []pf;
		return;
	}
	char oldname[200];
	strcpy(oldname,m_SlfObjectEntry[index].Name);
	strcat(oldname,".OLD");
	int ind=FindSlfObjectIndex(oldname);
	if(ind>=0) {
		DiscardSlfObjectData(ind);
	}
	else {
		ind=m_SlfHead.TableNumber++;
	}
	m_SlfObjectEntry[ind]=m_SlfObjectEntry[index];
	memmove(m_SlfObjectEntry[index].Name,oldname,sizeof(m_SlfObjectEntry[index].Name));
	memmove(m_SlfObjectEntry[index].HZName,oldname,sizeof(m_SlfObjectEntry[index].HZName));
	unsigned int Pos=mFile->size();
	m_SlfObjectEntry[ind].Position=Pos;
	m_SlfObjectEntry[ind].RecondNum=1;
	m_SlfObjectEntry[ind].DataRecord[0].DataPosition=Pos+
		sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[ind].FieldNum;
	float orlev=pf->Rlev;
	m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum=(rec*pf->Rlev)/newDelta+0.5;
	pf->Rlev=newDelta;
	SetSlfTableFieldInfo(ind,pf);

	//char *obuf=new char[reclen*m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum+1];
	//char *buf=new char[leng+1];
	DWORD MaxLen=reclen*m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum+1;
	if(MaxLen<leng+1)MaxLen=leng+1;
	char *obuf=new char[MaxLen+10];
	char *buf=new char[MaxLen+10];
	int RecNum=ReadSlfTable(index,0,buf);
	float dep,yy1,yy2,yy;
	int k1,k2;
	DWORD num,num1;
	int Pos1=0;
	for(DWORD i=0;i<m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum;i++) {
		dep=i*newDelta;
		k1=dep/orlev+0.5;
		k2=dep/orlev+1.5;

		while(dep < k1*orlev)
			k1--;
		while(dep > k2*orlev)
			k2++;
		while( (k2 - 1)*orlev > dep)
			k2--;
		while( (k1 + 1)*orlev < dep)
			k1++;
		if(k1*reclen+1>=MaxLen) k1=MaxLen-1;
		if(k2*reclen+1>=MaxLen) k2=k1;
		if(k1<0) k1=0;
		if(k2<0) k2=0;
		Pos1=0;
		for(int k=0;k<m_SlfObjectEntry[ind].FieldNum;k++) 
		{
			if(pf[k].Sequence) continue;
			for(int j=0;j<pf[k].ArrayNum*pf[k].SamplePoint;j++) {
				Pos=k1*reclen+Pos1+j*pf[k].CodeLength;
				GetData(pf[k].CodeLength,&buf[Pos],&yy1);
				Pos=k2*reclen+Pos1+j*pf[k].CodeLength;
				GetData(pf[k].CodeLength,&buf[Pos],&yy2);
				if(k1==k2)yy=yy1;
				else yy=yy1+(yy2-yy1)*(dep-k1*orlev)/((k2-k1)*orlev);
				Pos=i*reclen+Pos1+j*pf[k].CodeLength;
				SetData(pf[k].CodeLength,&obuf[Pos],&yy);
			}
			Pos1+=pf[k].ArrayNum*pf[k].SamplePoint*pf[k].CodeLength;
		}
	}
	WriteSlfTable(ind,m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum,obuf);
	Slf_TABLE_ENTRY ol=m_SlfObjectEntry[index];
	m_SlfObjectEntry[index]=m_SlfObjectEntry[ind];
	strcpy(m_SlfObjectEntry[ind].Name,ol.Name);
	strcpy(m_SlfObjectEntry[ind].HZName,ol.HZName);
	m_SlfObjectEntry[ind].RecondNum=ol.RecondNum;
	for(int i=0;i<ol.RecondNum;i++) {
		m_SlfObjectEntry[ind].DataRecord[i].DataPosition=ol.DataRecord[i].DataPosition;
		m_SlfObjectEntry[ind].DataRecord[i].DataRecordNum=ol.DataRecord[i].DataRecordNum;
	}
	m_SlfObjectEntry[ind].Position=ol.Position;
	WriteSlfObjectEntry();
	WriteSlfHead();
	delete []buf;
	delete []obuf;
	delete []pf;
}
void  CSlfIO::MoveSlfTable(int index,int RecFirst,int RecEnd,int Move)
{
	if(index<0) return;
	int rec=GetSlfTableRecordCount(index);
	int reclen=GetSlfTableRecordLength(index);
	unsigned int leng=GetSlfTableLength(index);
	Slf_OBJECT_FIELD *pf=GetSlfTableFieldInfo(index);
	if(RecFirst==0&&RecEnd==rec) {
		pf[0].Start+=Move*pf[0].Rlev;
		SetSlfTableFieldInfo(index,pf);
	}
	else {
		char *buf=new char[leng+1];
		ReadSlfTable(index,RecEnd,buf,RecFirst);
		int nrecf=RecFirst+Move;
		int nrece=RecEnd+Move;
		WriteSlfTable(index,nrece,buf,nrecf);
		delete []buf;
	}
}
void  CSlfIO::SetObjectName(const  char *Name,const  char *Alias,const  char *Unit,const  char *AliasUnit,short Attribute, short SubAttribute, int status,int otype)
{
	int index=FindObjectName((char *)&Name,Attribute,SubAttribute,status,otype);
	if(index>-1) {
		SetObjectName(index,NULL,Alias,Unit,AliasUnit);
	}
}
void  CSlfIO::SetObjectName(int index, const  char *Name,const  char *Alias,const  char *Unit,const  char *AliasUnit)
{
	if(IsWis) {
		if(Name) {
			int len=sizeof(m_ObjectEntry[index].Name);
			if(len>strlen(Name)) len=strlen(Name);
			memmove(m_ObjectEntry[index].Name,Name,len);
			if(len<sizeof(m_ObjectEntry[index].Name))m_ObjectEntry[index].Name[sizeof(Name)]=0;
			WriteObjectEntry();
		}
		if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
			Slf_CHANNEL info;
			ReadChannelInfo(index,&info);
			if(Unit){
				int len=sizeof(info.Unit);
				if(len>strlen(Unit)) len=strlen(Unit);
				memmove(info.Unit,Unit,len);
				if(len<sizeof(info.Unit)) info.Unit[len]=0; 
			}
			if(Alias){
				int len=sizeof(info.AliasName);
				if(len>strlen(Unit)) len=strlen(Alias);
				memmove(info.AliasName,Alias,len);
				if(len<sizeof(info.AliasName)) info.AliasName[len]=0; 
			}
			if(AliasUnit){
				int len=sizeof(sizeof(info.AliasUnit));
				if(len>strlen(AliasUnit)) len=strlen(AliasUnit);
				memmove(info.AliasUnit,AliasUnit,len);
				if(len<sizeof(info.AliasUnit)) info.AliasUnit[len]=0; 
			}
			WriteChannelInfo(index,&info);
		}
		else {
		}
	}
	else {
		if(Name) {
			int len=sizeof(m_SlfObjectEntry[index].Name);
			if(len>strlen(Name)) len=strlen(Name);
			memmove(m_SlfObjectEntry[index].Name,Name,len);
			if(len<sizeof(m_SlfObjectEntry[index].Name))m_SlfObjectEntry[index].Name[len]=0;
		}

		if(Alias) {
			int len=sizeof(m_SlfObjectEntry[index].HZName);
			if(len>strlen(Alias)) len=strlen(Alias);
			memmove(m_SlfObjectEntry[index].HZName,Alias,len);
			if(len<sizeof(m_SlfObjectEntry[index].HZName))m_SlfObjectEntry[index].HZName[len]=0;
		}
		if(Unit){
			int len=sizeof(m_SlfObjectEntry[index].Unit);
			if(len>strlen(Unit)) len=strlen(Unit);
			memmove(m_SlfObjectEntry[index].Unit,Unit,len);
			if(len<sizeof(m_SlfObjectEntry[index].Unit))m_SlfObjectEntry[index].Unit[len]=0;
		}
		if(AliasUnit) {
			int len=sizeof(m_SlfObjectEntry[index].HZUnit);
			if(len>strlen(AliasUnit)) len=strlen(AliasUnit);
			memmove(m_SlfObjectEntry[index].HZUnit,AliasUnit,len);
			if(len<sizeof(m_SlfObjectEntry[index].HZUnit))m_SlfObjectEntry[index].HZUnit[len]=0;
		}
		WriteSlfObjectEntry();
	}
}

void  CSlfIO::GetObjectName(int index, char *Name,char *Unit,char *Alias,char *AliasUnit)
{
	if(IsWis) {
		memmove(Name,m_ObjectEntry[index].Name,sizeof(m_ObjectEntry[index].Name));
		Name[sizeof(m_ObjectEntry[index].Name)]=0;
		if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
			Slf_CHANNEL info;
			ReadChannelInfo(index,&info);
			if(Unit)memmove(Unit,info.Unit,sizeof(info.Unit));
			if(Alias)memmove(Alias,info.AliasName,sizeof(info.AliasName));
			if(AliasUnit)memmove(AliasUnit,info.AliasUnit,sizeof(info.AliasUnit));
		}
		else {
			if(Unit)Unit[0]=0;
			if(Alias)Alias[0]=0;
			if(AliasUnit)AliasUnit[0]=0;
		}
	}
	else {
		memmove(Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
		if(Alias)memmove(Alias,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
		if(Unit)memmove(Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
		if(AliasUnit) memmove(AliasUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
	}
}
//whp add
short  CSlfIO::GetObjectType(int index)
{
	if(IsWis) return GetWisObjectType(index);
	else return GetSlfObjectType(index);
}
short CSlfIO::GetObjectType(const char* name)
{
	if(IsWis) return GetWisObjectType(name);
	else return GetSlfObjectType(name);
}
short CSlfIO:: GetSlfObjectType(int index)
{
	if(index>=0)return m_SlfObjectEntry[index].Type;
	else return -1;
}
short CSlfIO:: GetSlfObjectType(const char* name)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return -1;
	return GetSlfObjectType(index);
}
short  CSlfIO::GetWisObjectType(int index)
{
	if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==CURVE_OBJECT)return CURVE_OBJECT;
	if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==WAVE_OBJECT)return WAVE_OBJECT;
	if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==FMT_OBJECT)return FMT_OBJECT;
	if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==TDT_OBJECT)return TDT_OBJECT;
	if(m_ObjectEntry[index].Attribute==STREAM_OBJECT)return CARD_OBJECT;
	else return 0;
}
short CSlfIO::GetWisObjectType(const char* name)
{
	int index=FindWisObjectIndex(name);
	if(index>-1) {
		return GetWisObjectType(index);
	}
	else return -1;
}
//whp add 2011.12.18
bool CSlfIO::UndeleteSlfObject(int index)
{
	if(index<0) return 0;
	m_SlfObjectEntry[index].Status=OBJECT_NORMAL;
	WriteSlfObjectEntry(index);
	return 1;
}
bool CSlfIO:: UnDeleteObject(int index)
{
	if(IsWis) return 0;
	else return UndeleteSlfObject(index);
}
void CSlfIO::GetSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF* pBaseInf)
{
	if(index>-1) 
	{
		memmove(pBaseInf->Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
		memmove(pBaseInf->HZName,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
		memmove(pBaseInf->Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
		memmove(pBaseInf->HZUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
		memmove(pBaseInf->DataSource,m_SlfObjectEntry[index].DataSource,sizeof(m_SlfObjectEntry[index].DataSource));
		memmove(pBaseInf->LogCopanyName,m_SlfObjectEntry[index].LogCopanyName,sizeof(m_SlfObjectEntry[index].LogCopanyName));
		memmove(pBaseInf->LoggingTeam,m_SlfObjectEntry[index].LoggingTeam,sizeof(m_SlfObjectEntry[index].LoggingTeam));
		memmove(pBaseInf->Operator,m_SlfObjectEntry[index].Operator,sizeof(m_SlfObjectEntry[index].Operator));
		memmove(&pBaseInf->LoggingDate,&m_SlfObjectEntry[index].LoggingDate,sizeof(m_SlfObjectEntry[index].LoggingDate));
	}
}
bool CSlfIO:: GetSlfObjectBaseInf(const char* name,Slf_OBJECT_BASE_INF* pBaseInf)
{
	int index=FindSlfObjectIndex(name);
	if(index<0) return 0;
	memmove(pBaseInf->Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
	memmove(pBaseInf->HZName,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
	memmove(pBaseInf->Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
	memmove(pBaseInf->HZUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
	memmove(pBaseInf->DataSource,m_SlfObjectEntry[index].DataSource,sizeof(m_SlfObjectEntry[index].DataSource));
	memmove(pBaseInf->LogCopanyName,m_SlfObjectEntry[index].LogCopanyName,sizeof(m_SlfObjectEntry[index].LogCopanyName));
	memmove(pBaseInf->LoggingTeam,m_SlfObjectEntry[index].LoggingTeam,sizeof(m_SlfObjectEntry[index].LoggingTeam));
	memmove(pBaseInf->Operator,m_SlfObjectEntry[index].Operator,sizeof(m_SlfObjectEntry[index].Operator));
	memmove(&pBaseInf->LoggingDate,&m_SlfObjectEntry[index].LoggingDate,sizeof(m_SlfObjectEntry[index].LoggingDate));
	return 1;
}
bool CSlfIO:: WriteSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF *pBaseInf)
{
	if(index<0) return 0;
	memmove(m_SlfObjectEntry[index].Name,pBaseInf->Name,sizeof(pBaseInf->Name));
	memmove(m_SlfObjectEntry[index].HZName,pBaseInf->HZName,sizeof(pBaseInf->HZName));
	memmove(m_SlfObjectEntry[index].Unit,pBaseInf->Unit,sizeof(pBaseInf->Unit));
	memmove(m_SlfObjectEntry[index].HZUnit,pBaseInf->HZUnit,sizeof(pBaseInf->HZUnit));
	memmove(m_SlfObjectEntry[index].DataSource,pBaseInf->DataSource,sizeof(pBaseInf->DataSource));
	memmove(m_SlfObjectEntry[index].LogCopanyName,pBaseInf->LogCopanyName,sizeof(pBaseInf->LogCopanyName));
	memmove(m_SlfObjectEntry[index].LoggingTeam,pBaseInf->LoggingTeam,sizeof(pBaseInf->LoggingTeam));
	memmove(m_SlfObjectEntry[index].Operator,pBaseInf->Operator,sizeof(pBaseInf->Operator));
	memmove(&m_SlfObjectEntry[index].LoggingDate,&pBaseInf->LoggingDate,sizeof(pBaseInf->LoggingDate));
	WriteSlfObjectEntry(index,&m_SlfObjectEntry[index]);
	return 1;
}
char* CSlfIO::GetSlfFileName()
{
	return m_LogFileName;
}
void WriteShiftMessage(CSlfIO&mem,CString &szBuffer,QString name,QString card)
{
	CString szBuffer1="";
	DWORD bytes_write;
	char cardname[200]="Run_depth_Records";
	if(!card.isEmpty()) strcpy(cardname,card.toStdString().c_str());
	int index_result = mem.CreateStream(PARA_OBJECT,cardname,16384,FALSE);
	int len=mem.GetStreamLength(index_result);
	if(len>0) {
		char *buff=new char[len+1];
		DWORD lb=0;
		mem.ReadStream(index_result,len,&lb,buff);
		QString cs=szBuffer.GetString();
		QDateTime current_date_time =QDateTime::currentDateTime();
		QString strStartTime = current_date_time.toString("dd-MM-yyyy hh:mm:ss");
		if(!card.isEmpty()) szBuffer1=name+" "+strStartTime+"\r\n"+cs+"\r\nEND\r\n"+buff;
		else {
			QString css=name+" ";
			css+=strStartTime+"\r\n";
			css+=cs+"END\r\n";
			int len=strlen(buff);
			if(len>0)
			{
				buff[len]=0;
				QString csss=buff;
				szBuffer1=csss+"\r\n"+css;
			}
			else szBuffer1=css;
		}
		cs=szBuffer1.GetString();
		len=strlen(cs.toStdString().c_str());
		mem.WriteStream(index_result,len+1,&lb,szBuffer1.GetString());
		delete buff;
	}
}

#ifndef WIN32
char *strupr(char *str){
char *orign=str;
for (; *str!='\0'; str++)
*str = toupper(*str);
return orign;
}
#endif


QDataStream & operator << (QDataStream & out, const tagSlf_FILE_HEAD & aSlf_FILE_HEAD) { 
	out << aSlf_FILE_HEAD.Version ; 
	return out; 
}