KSG-Framework/M2Datei.cpp

#include "M2Datei.h"

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

using namespace Framework;

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

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

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

// 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.open(Datei::Style::lesen);
    char anz = 0;
    d.lese(&anz, 1);
    modelName->leeren();
    modelPos->leeren();
    for (int i = 0; i < anz; i++)
    {
        char len = 0;
        d.lese(&len, 1);
        char* txt = new char[len + 1];
        d.lese(txt, len);
        txt[(int)len] = 0;
        modelName->set(new Text(txt), i);
        delete[] txt;
        __int64 pos = 0;
        d.lese((char*)&pos, 8);
        modelPos->set(pos, i);
    }
    d.close();
}

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 (!removeModel(name)) return 0;
            break;
        }
    }
    anz = modelName->getEintragAnzahl();
    Datei d;
    d.setDatei(pfad->getText());
    d.open(Datei::Style::lesen);
    Datei neu;
    neu.setDatei(pfad->getText());
    neu.zPfad()->append("0");
    while (neu.existiert())
        neu.zPfad()->append("0");
    if (!neu.open(Datei::Style::schreiben))
    {
        if (d.istOffen()) d.close();
        return 0;
    }
    modelName->add(new Text(name));
    int offs = textLength(name) + 9;
    for (int i = 0; i < anz; i++)
        modelPos->set(modelPos->get(i) + offs, i);
    if (d.getSize() < 0)
        modelPos->add(offs + 1);
    else
        modelPos->add(d.getSize() + offs);
    anz++;
    char tmp = (char)anz;
    neu.schreibe(&tmp, 1);
    for (int i = 0; i < anz; i++)
    {
        char len = (char)modelName->z(i)->getLength();
        neu.schreibe(&len, 1);
        neu.schreibe(modelName->z(i)->getText(), len);
        __int64 pos = modelPos->get(i);
        neu.schreibe((char*)&pos, 8);
    }
    if (d.existiert())
    {
        d.setLPosition(modelPos->get(0) - offs, 0);
        __int64 dl = d.getSize() - 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.close();
    char pAnz = (char)zMdr->polygons->getEintragAnzahl();
    neu.schreibe(&pAnz, 1);
    for (int p = 0; p < pAnz; p++)
    {
        char pNameL = (char)zMdr->polygons->get(p).name->getLength();
        int vAnz = zMdr->polygons->get(p).vertex->getEintragAnzahl();
        char options = 1;
        for (int i = 0; i < vAnz; i++)
            options
                = (char)(options
                         & (char)zMdr->polygons->get(p).tKordinaten->hat(i));
        if (pNameL != 0) options |= 2;
        if (zMdr->polygons->get(p).transparent) options |= 4;
        neu.schreibe(&options, 1);
        if ((options | 2) == options) // name
        {
            neu.schreibe(&pNameL, 1);
            neu.schreibe(zMdr->polygons->get(p).name->getText(), pNameL);
        }
        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 ((options | 1) == options) // textur
            {
                float 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.remove();
    neu.close();
    neu.umbenennen(pfad->getText());
    leseDaten();
    return 1;
}

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

bool M2Datei::removeModel(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.open(Datei::Style::lesen)) return 0;
    Datei neu;
    neu.setDatei(pfad->getText());
    neu.zPfad()->append("0");
    while (neu.existiert())
        neu.zPfad()->append("0");
    if (!neu.open(Datei::Style::schreiben))
    {
        if (d.istOffen()) d.close();
        return 0;
    }
    char nAnz = (char)(anz - 1);
    neu.schreibe(&nAnz, 1);
    int offs = modelName->z(p)->getLength() + 9;
    __int64 startP = 0, endP = 0, start2P = 0;
    for (int i = 0; i < anz; i++)
    {
        char nLen = (char)modelName->z(i)->getLength();
        const 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(&nLen, 1);
            neu.schreibe(n, nLen);
            neu.schreibe((char*)&pos, 8);
        }
    }
    if (d.istOffen())
    {
        d.setLPosition(startP, 0);
        __int64 bLen = endP - startP;
        char bytes[2048];
        while (bLen > 0)
        {
            int l = 2048 > bLen ? (int)bLen : 2048;
            d.lese(bytes, l);
            neu.schreibe(bytes, l);
            bLen -= l;
        }
        if (start2P)
        {
            d.setLPosition(start2P, 0);
            bLen = d.getSize() - start2P;
            while (bLen > 0)
            {
                int l = 2048 > bLen ? (int)bLen : 2048;
                d.lese(bytes, l);
                neu.schreibe(bytes, l);
                bLen -= l;
            }
        }
        d.close();
    }
    d.remove();
    neu.close();
    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.open(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.close();
        return 0;
    }
    char pAnz = 0;
    d.lese(&pAnz, 1);
    Array<Polygon2D>* polygons = new Array<Polygon2D>();
    for (int p = 0; p < pAnz; p++)
    {
        char options = 0;
        d.lese(&options, 1);
        Polygon2D polygon;
        polygon.schwerpunkt = new Vertex(0, 0);
        polygon.transparent = (options | 4) == options;
        polygon.name = new Text();
        if ((options | 2) == options)
        {
            char nameL = 0;
            d.lese(&nameL, 1);
            char* name = new char[nameL + 1];
            name[(int)nameL] = 0;
            d.lese(name, nameL);
            polygon.name->setText(name);
            delete[] name;
        }
        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();
        }
        polygon.vertex = new Array<Vertex>();
        if ((options | 1) == options) // wenn textur
            polygon.tKordinaten = new Array<Vertex>();
        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.schwerpunkt += p * (float)(1.0 / vAnz);
            polygon.vertex->add(p);
            if ((options | 1) == options) // wenn textur
            {
                Vertex tp;
                d.lese((char*)&tp.x, 4);
                d.lese((char*)&tp.y, 4);
                polygon.tKordinaten->add(tp);
            }
        }
        polygons->add(polygon);
    }
    d.close();
    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);
}