KSG-Script/ksgScript/Befehl/KSGSKlasse.cpp

#include "KSGSKlasse.h"
#include "../Error/Error.h"
#include "../Main/KSGScriptObj.h"
#include "../Klassen/KSGSTyp.h"
#include "../Klassen/KSGSBool.h"
#include "../Klassen/KSGSInt.h"
#include "../Klassen/KSGSDouble.h"
#include "../Klassen/KSGSText.h"
#include "../Klassen/KSGSBild.h"
#include "../Klassen/KSGSMausEreignis.h"
#include "../Klassen/KSGSTastaturEreignis.h"
#include "../Klassen/KSGSTextFeld.h"
#include "../Klassen/KSGSKnopf.h"
#include "../Klassen/KSGSFenster.h"
#include "../Klassen/KSGSBildZ.h"
#include "../Klassen/KSGSAnimation2DData.h"
#include "../Klassen/KSGSAnimation2D.h"
#include "../Klassen/KSGSArray.h"

using namespace KSGScript;

// Inhalt der KSGSKlasseInstanz Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasseInstanz::KSGSKlasseInstanz( int typ, Array< KSGSVariableDef * > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptProcessor *zObj )
    : ReferenceCounter()
{
    lokaleVariablen = new RCArray< KSGSVariable >();
    varPublic = new Array< bool >();
    funktionen = funcs;
    obj = zObj;
    lokaleVariablen->add( dynamic_cast<KSGSKlasseInstanz *>( getThis() ), 0 );
    varPublic->set( 0, 0 );
    int anz = zVars ? zVars->getEintragAnzahl() : 0;
    for( int i = 0; i < anz; i++ )
    {
        lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( zObj, zVars->get( i ) ), zVars->get( i )->id + 1 );
        varPublic->set( zVars->get( i )->sichtbar == 1, zVars->get( i )->id + 1 );
    }
    this->typ = typ;
}

// Destruktor
KSGSKlasseInstanz::~KSGSKlasseInstanz()
{
    lokaleVariablen->release();
    if( funktionen )
        funktionen->release();
    varPublic->release();
}

// nicht constant
KSGSVariable *KSGSKlasseInstanz::startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter )
{
    if( !funktionen || ( !zugriff && ( !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 1 ) ) )
    {
        error( 18, {}, obj );
        parameter->release();
        return 0;
    }
    if( !funktionen->z( id ) )
    {
        parameter->release();
        return 0;
    }
    KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( obj, dynamic_cast<KSGSKlasseInstanz *>( getThis() ), parameter );
    KSGSVariable *ret = inst->startFunktion();
    inst->release();
    return ret;
}

KSGSVariable *KSGSKlasseInstanz::doOperator( int id, KSGSVariable *rechts )
{
    error( 21, {}, obj );
    if( rechts )
        rechts->release();
    return 0;
}

void KSGSKlasseInstanz::setVariable( int id, KSGSVariable *var )
{
    lokaleVariablen->set( var, id );
}

// constant
KSGSVariable *KSGSKlasseInstanz::getVariable( int id, bool zugriff ) const
{
    if( !zugriff && ( !varPublic->hat( id ) || !varPublic->get( id ) ) )
    {
        error( 17, {}, obj );
        return 0;
    }
    return lokaleVariablen->get( id );
}

KSGSVariable *KSGSKlasseInstanz::umwandelnIn( int typ ) const
{
    error( 16, {}, obj );
    return 0;
}

int KSGSKlasseInstanz::getTyp() const
{
    return typ;
}

// verarbeiten
bool KSGSKlasseInstanz::getBool() const
{
    if( typ == KSGS_BOOL )
        return ( (KSGSBoolKlasse *)this )->getVal();
    else
    {
        KSGSBoolKlasse *tmp = (KSGSBoolKlasse *)umwandelnIn( KSGS_BOOL );
        if( tmp )
        {
            bool ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return 0;
    }
}

int KSGSKlasseInstanz::getInt() const
{
    if( typ == KSGS_INT )
        return ( (KSGSIntKlasse *)this )->getVal();
    else
    {
        KSGSIntKlasse *tmp = (KSGSIntKlasse *)umwandelnIn( KSGS_INT );
        if( tmp )
        {
            int ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return 0;
    }
}

double KSGSKlasseInstanz::getDouble() const
{
    if( typ == KSGS_DOUBLE )
        return ( (KSGSDoubleKlasse *)this )->getVal();
    else
    {
        KSGSDoubleKlasse *tmp = (KSGSDoubleKlasse *)umwandelnIn( KSGS_DOUBLE );
        if( tmp )
        {
            double ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return 0;
    }
}

Text *KSGSKlasseInstanz::getText() const
{
    if( typ == KSGS_TEXT )
        return ( (KSGSTextKlasse *)this )->getVal();
    else
    {
        KSGSTextKlasse *tmp = (KSGSTextKlasse *)umwandelnIn( KSGS_TEXT );
        if( tmp )
        {
            Text *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Text( "" );
    }
}

Bild *KSGSKlasseInstanz::getBild() const
{
    if( typ == KSGS_BILD )
        return ( (KSGSBildKlasse *)this )->getVal();
    else
    {
        KSGSBildKlasse *tmp = (KSGSBildKlasse *)umwandelnIn( KSGS_BILD );
        if( tmp )
        {
            Bild *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Bild();
    }
}

MausEreignis KSGSKlasseInstanz::getMausEreignis() const
{
    if( typ == KSGS_MAUSEREIGNIS )
        return ( (KSGSMausEreignisKlasse *)this )->getVal();
    else
    {
        KSGSMausEreignisKlasse *tmp = (KSGSMausEreignisKlasse *)umwandelnIn( KSGS_MAUSEREIGNIS );
        if( tmp )
        {
            MausEreignis ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return MausEreignis{ 0, 0, 0, 0, 1, 0, 0 };
    }
}

TastaturEreignis KSGSKlasseInstanz::getTastaturEreignis() const
{
    if( typ == KSGS_TASTATUREREIGNIS )
        return ( (KSGSTastaturEreignisKlasse *)this )->getVal();
    else
    {
        KSGSTastaturEreignisKlasse *tmp = (KSGSTastaturEreignisKlasse *)umwandelnIn( KSGS_TASTATUREREIGNIS );
        if( tmp )
        {
            TastaturEreignis ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return TastaturEreignis{ 0, 0, 0 };
    }
}

TextFeld *KSGSKlasseInstanz::getTextFeld() const
{
    if( typ == KSGS_TEXTFELD )
        return ( (KSGSTextFeldKlasse *)this )->getVal();
    else
    {
        KSGSTextFeldKlasse *tmp = (KSGSTextFeldKlasse *)umwandelnIn( KSGS_TEXTFELD );
        if( tmp )
        {
            TextFeld *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new TextFeld();
    }
}

Knopf *KSGSKlasseInstanz::getKnopf() const
{
    if( typ == KSGS_KNOPF )
        return ( (KSGSKnopfKlasse *)this )->getVal();
    else
    {
        KSGSKnopfKlasse *tmp = (KSGSKnopfKlasse *)umwandelnIn( KSGS_KNOPF );
        if( tmp )
        {
            Knopf *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Knopf();
    }
}

Fenster *KSGSKlasseInstanz::getFenster() const
{
    if( typ == KSGS_FENSTER )
        return ( (KSGSFensterKlasse *)this )->getVal();
    else
    {
        KSGSFensterKlasse *tmp = (KSGSFensterKlasse *)umwandelnIn( KSGS_FENSTER );
        if( tmp )
        {
            Fenster *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Fenster();
    }
}

BildZ *KSGSKlasseInstanz::getBildZ() const
{
    if( typ == KSGS_BILDO )
        return ( (KSGSBildZKlasse *)this )->getVal();
    else
    {
        KSGSBildZKlasse *tmp = (KSGSBildZKlasse *)umwandelnIn( KSGS_BILDO );
        if( tmp )
        {
            BildZ *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new BildZ();
    }
}

Animation2DData *KSGSKlasseInstanz::getAnimation2DData() const
{
    if( typ == KSGS_ANIMATION2DDATA )
        return ( (KSGSAnimation2DDataKlasse *)this )->getVal();
    else
    {
        KSGSAnimation2DDataKlasse *tmp = (KSGSAnimation2DDataKlasse *)umwandelnIn( KSGS_ANIMATION2DDATA );
        if( tmp )
        {
            Animation2DData *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Animation2DData();
    }
}

Animation2D *KSGSKlasseInstanz::getAnimation2D() const
{
    if( typ == KSGS_ANIMATION2D )
        return ( (KSGSAnimation2DKlasse *)this )->getVal();
    else
    {
        KSGSAnimation2DKlasse *tmp = (KSGSAnimation2DKlasse *)umwandelnIn( KSGS_ANIMATION2D );
        if( tmp )
        {
            Animation2D *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new Animation2D();
    }
}

Zeichnung *KSGSKlasseInstanz::getZeichnung() const
{
    switch( typ )
    {
    case KSGS_TEXTFELD:
        return ( (KSGSTextFeldKlasse *)this )->zVal();
    case KSGS_KNOPF:
        return ( (KSGSKnopfKlasse *)this )->zVal();
    case KSGS_FENSTER:
        return ( (KSGSFensterKlasse *)this )->zVal();
    case KSGS_BILDO:
        return ( (KSGSBildZKlasse *)this )->zVal();
    case KSGS_ANIMATION2D:
        return ( (KSGSAnimation2DKlasse *)this )->zVal();
    }
    return 0;
}

RCArray< KSGSVariable > *KSGSKlasseInstanz::getArray() const
{
    if( typ == KSGS_ARRAY )
        return ( (KSGSArrayKlasse *)this )->getVal();
    else
    {
        KSGSArrayKlasse *tmp = (KSGSArrayKlasse *)umwandelnIn( KSGS_ARRAY );
        if( tmp )
        {
            RCArray< KSGSVariable > *ret = tmp->getVal();
            tmp->release();
            return ret;
        }
        return new RCArray< KSGSVariable >();
    }
}

// static
KSGSVariable *KSGSKlasseInstanz::erstellVariable( KSGScriptProcessor *zObj, KSGSVariableDef *def )
{
    if( !def )
    {
        error( 0, {}, zObj );
        return 0;
    }
    if( def->typId < KSGS_TYP_MIN )
    {
        error( 0, {}, zObj );
        return 0;
    }
    if( def->typId <= KSGS_TYP_MAX )
    { // Vordefinierter Typ
        switch( def->typId )
        {
        case KSGS_BOOL:
            if( def->wert.istGleich( "true" ) )
                return new KSGSBoolKlasse( zObj, 1 );
            if( def->wert.istGleich( "false" ) )
                return new KSGSBoolKlasse( zObj, 0 );
            if( def->wert.getLength() )
                return new KSGSBoolKlasse( zObj, (int)def->wert != 0 );
            return new KSGSBoolKlasse( zObj );
        case KSGS_INT:
            if( def->wert.getLength() )
                return new KSGSIntKlasse( zObj, def->wert );
            return new KSGSIntKlasse( zObj );
        case KSGS_DOUBLE:
            if( def->wert.getLength() )
                return new KSGSDoubleKlasse( zObj, def->wert );
            return new KSGSDoubleKlasse( zObj );
        case KSGS_TEXT:
            if( def->wert.getLength() )
                return new KSGSTextKlasse( zObj, def->wert );
            return new KSGSTextKlasse( zObj );
        case KSGS_BILD:
            return new KSGSBildKlasse( zObj );
        case KSGS_MAUSEREIGNIS:
            return new KSGSMausEreignisKlasse( zObj );
        case KSGS_TASTATUREREIGNIS:
            return new KSGSTastaturEreignisKlasse( zObj );
        case KSGS_TEXTFELD:
            return new KSGSTextFeldKlasse( zObj );
        case KSGS_KNOPF:
            return new KSGSKnopfKlasse( zObj );
        case KSGS_FENSTER:
            return new KSGSFensterKlasse( zObj );
        case KSGS_BILDO:
            return new KSGSBildZKlasse( zObj );
        case KSGS_ANIMATION2DDATA:
            return new KSGSAnimation2DDataKlasse( zObj );
        case KSGS_ANIMATION2D:
            return new KSGSAnimation2DKlasse( zObj );
        default:
            error( 1, {}, zObj );
            break;
        }
        return 0;
    }
    else if( zObj ) // Im Script Definierter Typ
        return zObj->erstellKlassenInstanz( def->typId );
    error( 0, {}, zObj );
    return 0;
}


// Inhalt der KSGSKlasse Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasse::KSGSKlasse( int id )
    : ReferenceCounter()
{
    var = new Array< KSGSVariableDef * >();
    funktionen = new RCArray< KSGSFunktion >();
    this->id = id;
}

// Destruktor
KSGSKlasse::~KSGSKlasse()
{
    int anz = var->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        delete var->get( i );
    var->release();
    funktionen->release();
}

// nicht constant
void KSGSKlasse::addVariable( KSGSVariableDef *var )
{
    this->var->add( var );
}

void KSGSKlasse::addFunktion( KSGSFunktion *func )
{
    funktionen->add( func );
}

KSGSKlasseInstanz *KSGSKlasse::erstellInstanz( KSGScriptProcessor *zObj )
{
    return new KSGSKlasseInstanz( id, var, dynamic_cast<RCArray<KSGSFunktion>*>( funktionen->getThis() ), zObj );
}

// constant
int KSGSKlasse::getId() const
{
    return id;
}