fileio.cpp

Linux/windows 环境下跨平台开发程序

	delete Notary;
	Notary = 0L;
	delete Cache;
	Cache = 0L;
	if(!name || !defs.IniFile || strcmp(name, defs.IniFile))
		ErrorBox("An error occured during read.");
	return false;
}

bool InitVarsGO(descIO *Desc)
{
	int i;
	AxisDEF *ax;
	TextDEF *tx;

	for(i = 0; Desc[i].label; i++) {
		switch(Desc[i].type & 0xff) {
		case typNZINT:
		case typINT:
			*(int*)Desc[i].ptr = 0;			
			break;
		case typNZLFLOAT:
		case typLFLOAT:
			*(double*)Desc[i].ptr = 0.0;
			break;
		case typDWORD:
			*(DWORD*)Desc[i].ptr = 0x0L;
			break;
		case typULONG:
			*(unsigned long*)Desc[i].ptr = 0L;
			break;
		case typFRECT:
			((fRECT*)Desc[i].ptr)->Xmin = ((fRECT*)Desc[i].ptr)->Xmax =
				((fRECT*)Desc[i].ptr)->Ymin = ((fRECT*)Desc[i].ptr)->Ymax = 0.0;
			break;
		case typNZLFPOINT:
		case typLFPOINT:
			((lfPOINT*)Desc[i].ptr)->fx = ((lfPOINT*)Desc[i].ptr)->fy = 0.0;
			break;
		case typPOINT3D:
			((fPOINT3D*)Desc[i].ptr)->fx = ((fPOINT3D*)Desc[i].ptr)->fy =
				((fPOINT3D*)Desc[i].ptr)->fz = 0.0;
			break;
		case typPTRAXDEF:
		case typAXDEF:
			ax = (Desc[i].type & 0xff) == typAXDEF ? (AxisDEF *)Desc[i].ptr : *(AxisDEF **)Desc[i].ptr;
			if(!ax) break;
			ax->owner = 0L;		ax->flags = 0L;		ax->breaks = 0L;	ax->nBreaks = 0;
			ax->min = ax->max = ax->Start = ax->Step = 0.0f;
			ax->loc[0].fx = ax->loc[0].fy = ax->loc[0].fz = 0.0f;
			ax->loc[1].fx = ax->loc[1].fy = ax->loc[1].fz = 0.0f;
			ax->Center.fx = ax->Center.fy = ax->Radius = 0.0f;
			break;
		case typLINEDEF:
			((LineDEF*)Desc[i].ptr)->width = defs.GetSize(SIZE_HAIRLINE);
			((LineDEF*)Desc[i].ptr)->patlength = defs.GetSize(SIZE_PATLENGTH);
			((LineDEF*)Desc[i].ptr)->color = ((LineDEF*)Desc[i].ptr)->pattern = 0x0L;
			break;
		case typFILLDEF:
			((FillDEF*)Desc[i].ptr)->type = FILL_NONE;
			((FillDEF*)Desc[i].ptr)->color = 0x00ffffffL;
			((FillDEF*)Desc[i].ptr)->scale = 1.0f;
			((FillDEF*)Desc[i].ptr)->hatch = (LineDEF*)0L;
			((FillDEF*)Desc[i].ptr)->color2 = 0x00ffffffL;
			break;
		case typGOBJ:
			*(GraphObj **)Desc[i].ptr = (GraphObj*)0L;
			break;
		case typOBJLST:
			*Desc[i].count = 0L;
			*(GraphObj ***)Desc[i].ptr = (GraphObj**)0L;
			break;
		case typIPLST:
			*Desc[i].count = 0L;
			*(POINT **)Desc[i].ptr = (POINT*)0L;
			break;
		case typFPLST:
			*Desc[i].count = 0L;
			*(lfPOINT **)Desc[i].ptr = (lfPOINT*)0L;
			break;
		case typFPLST3D:
			*Desc[i].count = 0L;
			*(fPOINT3D **)Desc[i].ptr = (fPOINT3D*)0L;
			break;
		case typTEXT:
			*(char **)Desc[i].ptr = (char*)0L;
			break;
		case typTXTDEF:
			tx = (TextDEF *)Desc[i].ptr;
			tx->ColTxt = 0x0L,			tx->ColBg = 0x00ffffffL;
			tx->fSize = defs.GetSize(SIZE_TEXT);
			tx->RotBL = tx->RotCHAR = 0.0;
			tx->Align = tx->Mode = tx->Style = tx->Font = 0L;
			tx->text = 0L;
			break;
		case typPTRTXTDEF:
			*(TextDEF**)Desc[i].ptr = (TextDEF*)0L;
			break;
			}
		if(Desc[i].type & typLAST) break;
		}
	return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Save object data to memory block
static unsigned char *SavVarBuf = 0L;
static long SavVarSize = 0,	SavVarPos = 0;
void SavVarInit(long len)
{
	if(SavVarBuf) free(SavVarBuf);
	SavVarBuf = (unsigned char *)malloc(SavVarSize = len+4096);
	SavVarPos = 0;
}

bool SavVarAdd(void *ptr, int size)
{
	int len;

	if(SavVarBuf) {
		len = sizeof(unsigned char *) + sizeof(int) + size;
		while (SavVarSize <= SavVarPos+len) {
			if(!(SavVarBuf = (unsigned char *)realloc(SavVarBuf, SavVarSize + 4096))) return false;
			SavVarSize += 4096;
			}
		memcpy(SavVarBuf+SavVarPos, &ptr, sizeof(unsigned char *));
		SavVarPos += sizeof(unsigned char *);
		memcpy(SavVarBuf+SavVarPos, &size, sizeof(int));	SavVarPos += sizeof(int);
		memcpy(SavVarBuf+SavVarPos, ptr, size);				SavVarPos += size;
		return true;
		}
	return false;
}

void *SavVarFetch()
{
	void *tmp;

	SavVarAdd(0L, 0);				
	tmp = SavVarBuf = (unsigned char *)realloc(SavVarBuf, SavVarPos);
	SavVarSize = SavVarPos = 0;		SavVarBuf = 0L;
	return tmp;
}

bool SaveVarGO(descIO *Desc)
{
	int i;
	AxisDEF *ax;
	TextDEF *tx;

	for(i = 0; Desc[i].label; i++) {
		switch(Desc[i].type & 0xff){
		case typNZINT:
		case typINT:
			SavVarAdd(Desc[i].ptr, sizeof(int));
			break;
		case typNZLFLOAT:
		case typLFLOAT:
			SavVarAdd(Desc[i].ptr, sizeof(double));
			break;
		case typDWORD:
			SavVarAdd(Desc[i].ptr, sizeof(DWORD));
			break;
		case typULONG:
			SavVarAdd(Desc[i].ptr, sizeof(unsigned long));
			break;
		case typFRECT:
			SavVarAdd(Desc[i].ptr, sizeof(fRECT));
			break;
		case typNZLFPOINT:
		case typLFPOINT:
			SavVarAdd(Desc[i].ptr, sizeof(lfPOINT));
			break;
		case typPOINT3D:
			SavVarAdd(Desc[i].ptr, sizeof(fPOINT3D));
			break;
		case typAXDEF:
		case typPTRAXDEF:
			ax = (Desc[i].type & 0xff) == typAXDEF ? (AxisDEF *)Desc[i].ptr : *(AxisDEF **)Desc[i].ptr;
			if(ax) {
				SavVarAdd(ax, sizeof(AxisDEF));
				if(ax->breaks && ax->nBreaks) {
					SavVarAdd(ax->breaks, ax->nBreaks * sizeof(lfPOINT));
					}
				}
			break;
		case typLINEDEF:
			SavVarAdd(Desc[i].ptr, sizeof(LineDEF));
			break;
		case typFILLDEF:
			SavVarAdd(Desc[i].ptr, sizeof(FillDEF));
			break;
		case typGOBJ:	case typOBJLST:		//not supported
			break;
		case typIPLST:						//probably in the future
			break;
		case typFPLST:
			break;
		case typFPLST3D:
			SavVarAdd(*((void **)Desc[i].ptr), sizeof(fPOINT3D) * (*Desc[i].count));
			break;
		case typTEXT:
			if(*(char**)(Desc[i].ptr)) SavVarAdd(Desc[i].ptr, strlen(*(char**)(Desc[i].ptr))+1);
			break;
		case typTXTDEF:
		case typPTRTXTDEF:
			tx = (Desc[i].type &0xff) == typTXTDEF ? (TextDEF *)Desc[i].ptr : *(TextDEF **)Desc[i].ptr;
			if(tx) SavVarAdd(tx, sizeof(TextDEF) - sizeof(char*));
			break;
			}
		if(Desc[i].type & typLAST) break;
		}
	return false;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Graphic object member funtions for IO
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bool
svgOptions::FileIO(int rw)
{
	descIO Desc[] = {
		{"tagAttr", typTEXT, &svgattr, 0L},
		{"Script", typLAST | typTEXT, &script, 0L}};

	switch(rw) {
	case INIT_VARS:
		return InitVarsGO(Desc);
	case FILE_READ:
		return ExecInput(Desc);
		}
	return false;
}

bool
Symbol::FileIO(int rw)
{
	descIO Desc[] = {
		{"Type", typNZINT, &type, 0L},
		{"ssRef", typIPLST, &ssRef, &cssRef},
		{"Idx", typINT, &idx, 0L},
		{"Pos", typLFPOINT, &fPos, 0L},
		{"Size", typLFLOAT, &size, 0L},
		{"Line", typLINEDEF, &SymLine, 0L},
		{"FillCol", typDWORD, &SymFill.color, 0L},
		{"Text", typPTRTXTDEF, &SymTxt, 0L},
		{"Name", typLAST | typTEXT, &name, 0L}};

	switch(rw) {
	case SAVE_VARS:
		return SaveVarGO(Desc);
	case INIT_VARS:
		InitVarsGO(Desc);
		size = parent ? parent->GetSize(SIZE_SYMBOL): defs.GetSize(SIZE_SYMBOL);
		SymLine.color = parent ? parent->GetColor(COL_SYM_LINE) : defs.Color(COL_SYM_LINE);
		SymLine.width = parent ? parent->GetSize(SIZE_SYM_LINE) : defs.GetSize(SIZE_SYM_LINE);
		SymFill.type = FILL_NONE;
		SymFill.color = parent ? parent->GetColor(COL_SYM_FILL) : defs.Color(COL_SYM_FILL);
		SymFill.scale = 1.0f;
		SymFill.hatch = (LineDEF *) 0L;
		return true;
	case FILE_READ:
		ExecInput(Desc);
		SymFill.hatch = (LineDEF *) 0L;
		return true;
	case FILE_WRITE:
		return ExecOutput(Notary->RegisterGO(this), "Symbol", Desc);
		}
	return false;
}


bool
Bubble::FileIO(int rw)
{
	descIO Desc[] = {
		{"Type", typNZINT, &type, 0L},
		{"ssRef", typIPLST, &ssRef, &cssRef},
		{"Pos", typLFPOINT, &fPos, 0L},
		{"Size", typLFLOAT, &fs, 0L},
		{"Line", typLINEDEF, &BubbleLine, 0L},
		{"FillLine", typLINEDEF, &BubbleFillLine, 0L},
		{"Fill", typFILLDEF, &BubbleFill, 0L},
		{"Name", typLAST | typTEXT, &name, 0L}};

	switch(rw) {
	case SAVE_VARS:
		return SaveVarGO(Desc);
	case INIT_VARS:
		InitVarsGO(Desc);
		BubbleLine.width = defs.GetSize(SIZE_BUBBLE_LINE);
		BubbleFillLine.width = defs.GetSize(SIZE_BUBBLE_HATCH_LINE);
		BubbleLine.color = BubbleFillLine.color = defs.Color(COL_BUBBLE_LINE);
		BubbleFill.color = defs.Color(COL_BUBBLE_FILL);
		ssRef = 0L;
		return true;
	case FILE_READ:
		ExecInput(Desc);
		BubbleFill.hatch = &BubbleFillLine;
		return true;
	case FILE_WRITE:
		return ExecOutput(Notary->RegisterGO(this), "Bubble", Desc);
		}
	return false;
}

bool
Bar::FileIO(int rw)
{
	descIO Desc[] = {
		{"Type", typINT, &type, 0L},
		{"ssRef", typIPLST, &ssRef, &cssRef},
		{"Pos", typLFPOINT, &fPos, 0L},
		{"Size", typLFLOAT, &size, 0L},
		{"Org", typLFPOINT, &BarBase, 0L},
		{"Line", typLINEDEF, &BarLine, 0L},
		{"Fill", typFILLDEF, &BarFill, 0L},
		{"FillLine", typLINEDEF, &HatchLine, 0L},
		{"Name", typLAST | typTEXT, &name, 0L}};

	switch(rw) {
	case SAVE_VARS:
		return SaveVarGO(Desc);
	case INIT_VARS:
		InitVarsGO(Desc);
		type = BAR_VERTB;
		memcpy(&BarFill, defs.GetFill(), sizeof(FillDEF));
		if(BarFill.hatch) memcpy(&HatchLine, BarFill.hatch, sizeof(LineDEF));
		BarFill.hatch = &HatchLine;
		memcpy(&BarLine, defs.GetOutLine(), sizeof(LineDEF));
		size = parent ? parent->GetSize(SIZE_BAR): defs.GetSize(SIZE_BAR);
		mo = 0L;
		mrc.left = mrc.right = mrc.top = mrc.bottom = 0;
		return true;
	case FILE_READ:
		ExecInput(Desc);
		BarFill.hatch = &HatchLine;
		return true;
	case FILE_WRITE:
		return ExecOutput(Notary->RegisterGO(this), "Bar", Desc);
		}
	return false;
}

void
DataLine::FileValues(char *name, int type, double start, double step)
{
	FILE *file;
	int i, c;
	double fx;
	lfPOINT *tfp;

	if(!(file = fopen(name, "r"))) {
		sprintf(TmpTxt, "DataLine: open failed for file \"%s\"", name);
		ErrorBox(TmpTxt);
		return;
		}
	if(Values) free(Values);
	if(!(Values = (lfPOINT*)calloc( nPnt = 1000, sizeof(lfPOINT)))){
		fclose(file);
		return;
		}
	switch(type) {
	case 1:				//x and y values
		i = 0;
		do {
			c = fscanf(file, "%lf%lf", &Values[i].fx, &Values[i].fy);
			i++;
			if(i >= nPnt &&(tfp = (lfPOINT*)realloc(Values, (nPnt+1000)*sizeof(lfPOINT)))){
				Values = tfp;			nPnt += 1000;
				}
			else if(i >= nPnt) break;
			}while(c == 2);
		i--;
		break;
	case 2:				//only y values
		i = 0;	fx = start;
		do {
			c = fscanf(file, "%lf", &Values[i].fy);
			Values[i].fx = fx;
			i++;	fx += step;
			if(i >= nPnt &&(tfp = (lfPOINT*)realloc(Values, (nPnt+1000)*sizeof(lfPOINT)))){
				Values = tfp;			nPnt += 1000;
				}
			}while(c == 1);
		i--;
		break;
		}
	nPntSet = i-1;
	fclose(file);
}

bool
DataLine::FileIO(int rw)
{
	long i;
	char *file1 = 0L;
	char *file2 = 0L;
	double Start = 0.0f, Step = 0.0f;
	descIO Desc[] = {
		{"Type", typNZINT, &type, 0L},
		{"ssXref", typTEXT, &ssXref, 0L},
		{"ssYref", typTEXT, &ssYref, 0L},
		{"BgCol", typDWORD, &BgColor, 0L},
		{"Line", typLINEDEF, &LineDef, 0L},
		{"Data", typFPLST, &Values, &i},
		{"file_xy", typTEXT, &file2, 0L},
		{"start_x", typNZLFLOAT, &Start, 0L},
		{"step_x", typNZLFLOAT, &Step, 0L},
		{"file_y", typLAST | typTEXT, &file1, 0L}};

	switch(rw) {
	case SAVE_VARS:
		return SaveVarGO(Desc);
	case INIT_VARS:
		InitVarsGO(Desc);
		isPolygon = false;
		nPnt = nPntSet = cp = 0;
		memcpy(&LineDef, defs.GetLine(), sizeof(LineDEF));
		BgColor = defs.Color(COL_BG);
		pts = 0L;		dirty = true;	mo = 0L;
		mrc.left = mrc.right = mrc.top = mrc.bottom = 0;
		min.fx = min.fy = max.fx = max.fy = 0.0;
		return true;
	case FILE_READ:
		ExecInput(Desc);
		nPnt = i;
		nPntSet = i-1;
		if(file2)FileValues(file2, 1, 0.0, 1.0);
		else if(file1)FileValues(file1, 2, Start, fabs(Step) > defs.min4log ? Step : 1.0);
		if(file1) free(file1);
		if(file2) free(file2);
		if(i && Values)return true;
		break;
	case FILE_WRITE:
		i = nPntSet+1;
		return ExecOutput(Notary->RegisterGO(this), "DataLine", Desc);
		}
	return false;
}

bool
DataPolygon::FileIO(int rw)
{
	long i;
	char *file1 = 0L;
	char *file2 = 0L;
	double Start = 0.0f, Step = 0.0f;
	descIO Desc[] = {
		{"Type", typNZINT, &type, 0L},
		{"ssXref", typTEXT, &ssXref, 0L},
		{"ssYref", typTEXT, &ssYref, 0L},
		{"BgCol", typDWORD, &BgColor, 0L},
		{"Line", typLINEDEF, &LineDef, 0L},
		{"FillLine", typLINEDEF, &pgFillLine, 0L},
		{"Fill", typFILLDEF, &pgFill, 0L},
		{"Data", typFPLST, &Values, &i},
		{"file_xy", typTEXT, &file2, 0L},
		{"start_x", typNZLFLOAT, &Start, 0L},
		{"step_x", typNZLFLOAT, &Step, 0L},
		{"file_y", typLAST | typTEXT, &file1, 0L}};

	switch(rw) {
	case SAVE_VARS:
		return SaveVarGO(Desc);
	case INIT_VARS:
		InitVarsGO(Desc);
		isPolygon = true;
		memcpy(&LineDef, defs.GetLine(), sizeof(LineDEF));
		LineDef.pattern = 0L;
		BgColor = defs.Color(COL_BG);
		memcpy(&pgFill, defs.GetFill(), sizeof(FillDEF));
		if(pgFill.hatch) memcpy(&pgFillLine, pgFill.hatch, sizeof(LineDEF));
		pgFill.hatch = &pgFillLine;		dirty = true;	mo = 0L;
		mrc.left = mrc.right = mrc.top = mrc.bottom = 0;