KSG-Framework/M2Datei.cpp

#include "M2Datei.h"
#include "Text.h"
#include "Datei.h"
#include "Model2D.h"

using namespace Framework;

// Inhalt der M2Datei Klasse aus M2Datei.h
// Konstruktor
M2Datei::M2Datei()
{
	pfad = new Text();
	modelName = new RCArray< Text >();
	modelPos = new Array< __int64 >();
	ref = 1;
}

M2Datei::M2Datei( const char *pfad )
{
	this->pfad = new Text( pfad );
	modelName = new RCArray< Text >();
	modelPos = new Array< __int64 >();
	ref = 1;
}

M2Datei::M2Datei( Text *pfad )
{
	this->pfad = pfad;
	modelName = new RCArray< Text >();
	modelPos = new Array< __int64 >();
	ref = 1;
}

// Destruktor
M2Datei::~M2Datei()
{
	pfad->release();
	modelName->release();
	modelPos->release();
}

// nicht constant
void M2Datei::setPfad( const char *pfad )
{
	this->pfad->setText( pfad );
}

void M2Datei::setPfadZ( Text *pfad )
{
	if( this->pfad )
		this->pfad->release();
	this->pfad = pfad;
}

void M2Datei::leseDaten()
{
	Datei d;
	d.setDatei( pfad->getText() );
	d.öffnen( Datei::Style::lesen );
	char anz = 0;
	d.lese( &anz, 1 );
	modelName->leeren();
	modelPos->leeren();
	for( int i = 0; i < anz; i++ )
	{
		char län = 0;
		d.lese( &län, 1 );
		char *txt = new char[ län + 1 ];
		d.lese( txt, län );
		txt[ (int)län ] = 0;
		modelName->set( new Text( txt ), i );
		delete[] txt;
		__int64 pos = 0;
		d.lese( (char*)&pos, 8 );
		modelPos->set( pos, i );
	}
	d.schließen();
}

bool M2Datei::saveModel( Model2DData *zMdr, Text *name )
{
	bool ret = saveModel( zMdr, name->getText() );
	name->release();
	return ret;
}

bool M2Datei::saveModel( Model2DData *zMdr, const char *name )
{
	int anz = modelName->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
	{
		if( modelName->z( i )->istGleich( name ) )
		{
			if( !löscheModel( name ) )
				return 0;
			break;
		}
	}
	anz = modelName->getEintragAnzahl();
	Datei d;
	d.setDatei( pfad->getText() );
	d.öffnen( Datei::Style::lesen );
	Datei neu;
	neu.setDatei( pfad->getText() );
	neu.zPfad()->anhängen( "0" );
	while( neu.existiert() )
		neu.zPfad()->anhängen( "0" );
	if( !neu.öffnen( Datei::Style::schreiben ) )
	{
		if( d.istOffen() )
			d.schließen();
		return 0;
	}
	modelName->add( new Text( name ) );
	int offs = textLänge( name ) + 9;
	for( int i = 0; i < anz; i++ )
		modelPos->set( modelPos->get( i ) + offs, i );
	if( d.getGröße() < 0 )
		modelPos->add( offs + 1 );
	else
		modelPos->add( d.getGröße() + offs );
	anz++;
	char tmp = (char)anz;
	neu.schreibe( &tmp, 1 );
	for( int i = 0; i < anz; i++ )
	{
		char län = (char)modelName->z( i )->getLänge();
		neu.schreibe( &län, 1 );
		neu.schreibe( modelName->z( i )->getText(), län );
		__int64 pos = modelPos->get( i );
		neu.schreibe( (char*)&pos, 8 );
	}
	if( d.existiert() )
	{
		d.setLPosition( modelPos->get( 0 ) - offs, 0 );
		__int64 dl = d.getGröße() - d.getLPosition();
		char bytes[ 2048 ];
		while( dl )
		{
			int l = dl > 2048 ? 2048 : (int)dl;
			d.lese( bytes, l );
			neu.schreibe( bytes, l );
			dl -= l;
		}
	}
	d.schließen();
	char pAnz = zMdr->polygons->getEintragAnzahl();
	neu.schreibe( &pAnz, 1 );
	for( int p = 0; p < pAnz; p++ )
	{
		int vAnz = zMdr->polygons->get( p ).vertex->getEintragAnzahl();
		char textur = 1;
		for( int i = 0; i < vAnz; i++ )
			textur &= (char)zMdr->polygons->get( p ).tKordinaten->hat( i );
		neu.schreibe( &textur, 1 );
		neu.schreibe( (char*)&vAnz, 4 );
		for( int i = 0; i < vAnz; i++ )
		{
			float v = zMdr->polygons->get( p ).vertex->get( i ).x;
			neu.schreibe( (char*)&v, 4 );
			v = zMdr->polygons->get( p ).vertex->get( i ).y;
			neu.schreibe( (char*)&v, 4 );
			if( textur )
			{
				int t = zMdr->polygons->get( p ).tKordinaten->get( i ).x;
				neu.schreibe( (char*)&t, 4 );
				t = zMdr->polygons->get( p ).tKordinaten->get( i ).y;
				neu.schreibe( (char*)&t, 4 );
			}
		}
	}
	d.löschen();
	neu.schließen();
	neu.umbenennen( pfad->getText() );
	leseDaten();
	return 1;
}

bool M2Datei::löscheModel( Text *name )
{
	bool ret = löscheModel( name->getText() );
	name->release();
	return ret;
}

bool M2Datei::löscheModel( const char *name )
{
	int anz = modelName->getEintragAnzahl();
	int p = -1;
	for( int i = 0; i < anz; i++ )
	{
		if( modelName->z( i )->istGleich( name ) )
		{
			p = i;
			break;
		}
	}
	if( p < 0 )
		return 0;
	Datei d;
	d.setDatei( pfad->getText() );
	if( !d.öffnen( Datei::Style::lesen ) )
		return 0;
	Datei neu;
	neu.setDatei( pfad->getText() );
	neu.zPfad()->anhängen( "0" );
	while( neu.existiert() )
		neu.zPfad()->anhängen( "0" );
	if( !neu.öffnen( Datei::Style::schreiben ) )
	{
		if( d.istOffen() )
			d.schließen();
		return 0;
	}
	char nAnz = (char)anz - 1;
	neu.schreibe( &nAnz, 1 );
	int offs = modelName->z( p )->getLänge() + 9;
	__int64 startP = 0, endP = 0, start2P = 0;
	for( int i = 0; i < anz; i++ )
	{
		char nLän = (char)modelName->z( i )->getLänge();
		char *n = modelName->z( i )->getText();
		__int64 pos = modelPos->get( i );
		if( !startP )
			startP = pos;
		if( i == p + 1 )
			start2P = pos;
		if( i == p )
		{
			if( !endP )
				endP = pos;
			if( i < anz - 1 )
				offs += (int)( modelPos->get( i + 1 ) - pos );
		}
		if( i != p )
		{
			pos -= offs;
			neu.schreibe( &nLän, 1 );
			neu.schreibe( n, nLän );
			neu.schreibe( (char*)&pos, 8 );
		}
	}
	if( d.istOffen() )
	{
		d.setLPosition( startP, 0 );
		__int64 bLän = endP - startP;
		char bytes[ 2048 ];
		while( bLän > 0 )
		{
			int l = 2048 > bLän ? (int)bLän : 2048;
			d.lese( bytes, l );
			neu.schreibe( bytes, l );
			bLän -= l;
		}
		if( start2P )
		{
			d.setLPosition( start2P, 0 );
			bLän = d.getGröße() - start2P;
			while( bLän > 0 )
			{
				int l = 2048 > bLän ? (int)bLän : 2048;
				d.lese( bytes, l );
				neu.schreibe( bytes, l );
				bLän -= l;
			}
		}
		d.schließen();
	}
	d.löschen();
	neu.schließen();
	neu.umbenennen( pfad->getText() );
	leseDaten();
	return 1;
}

// constant
Model2DData *M2Datei::ladeModel( Text *name ) const
{
	Model2DData *ret = ladeModel( name->getText() );
	name->release();
	return ret;
}

Model2DData *M2Datei::ladeModel( const char *name ) const
{
	Datei d;
	d.setDatei( pfad->getText() );
	if( !d.öffnen( Datei::Style::lesen ) )
		return 0;
	int anz = modelName->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
	{
		if( modelName->z( i )->istGleich( name ) )
		{
			d.setLPosition( modelPos->get( i ), 0 );
			break;
		}
	}
	if( !d.getLPosition() )
	{
		d.schließen();
		return 0;
	}
	char pAnz = 0;
	d.lese( &pAnz, 1 );
	Array< Polygon2D > *polygons = new Array< Polygon2D >();
	for( int p = 0; p < pAnz; p++ )
	{
		char textur = 0;
		d.lese( &textur, 1 );
		int vAnz = 0;
		d.lese( (char*)&vAnz, 4 );
		if( polygons->hat( p ) )
		{
			if( polygons->get( p ).vertex )
				polygons->get( p ).vertex->release();
			if( polygons->get( p ).tKordinaten )
				polygons->get( p ).tKordinaten->release();
		}
		Polygon2D polygon;
		polygon.vertex = new Array< Vertex >();
		if( textur )
			polygon.tKordinaten = new Array< Punkt >();
		else
			polygon.tKordinaten = 0;
		for( int v = 0; v < vAnz; v++ )
		{
			Vertex p;
			d.lese( (char*)&p.x, 4 );
			d.lese( (char*)&p.y, 4 );
			polygon.vertex->add( p );
			if( textur )
			{
				Punkt tp;
				d.lese( (char*)&tp.x, 4 );
				d.lese( (char*)&tp.y, 4 );
				polygon.tKordinaten->add( tp );
			}
		}
		polygons->add( polygon );
	}
	d.schließen();
	Model2DData *ret = new Model2DData();
	ret->erstelleModell( polygons );
	return ret;
}

bool M2Datei::hatModel( const char *name ) const
{
	int anz = modelName->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
	{
		if( modelName->z( i )->istGleich( name ) )
			return 1;
	}
	return 0;
}

int M2Datei::getModelAnzahl() const
{
	return modelName->getEintragAnzahl();
}

Text *M2Datei::zModelName( int i ) const
{
	return modelName->z( i );
}

// Reference Counting
M2Datei *M2Datei::getThis()
{
	++ref;
	return this;
}

M2Datei *M2Datei::release()
{
	if( !--ref )
		delete this;
	return 0;
}