#include "KEBeschreibung.h"
#include <TextFeld.h>
#include <Text.h>
#include <MausEreignis.h>
#include "../../../../Global/Initialisierung.h"
#include "../../../../Global/Variablen.h"
#include <DateiSystem.h>

bool KEBKnopfPressME( void *p, void *obj, MausEreignis me );

// Inhalt der KEBEditor Klasse aus KEBEditor.h
// Konstruktor
KEBEditor::KEBEditor( Schrift *zSchrift, KEBeschreibung *zKeb )
{
    beschreibung = initKnopf( 10, 10, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beschreibung" );
    initToolTip( beschreibung, "Beschreibung bei der Kartenauswahl", zSchrift->getThis(), hauptScreen );
    beschreibung->setMausEreignisParameter( zKeb );
    beschreibung->setMausEreignis( KEBKnopfPressME );
    titelBild = initKnopf( 10, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Titel Bild" );
    initToolTip( titelBild, "Titelbild während der Kartenauswahl (200x100)", zSchrift->getThis(), hauptScreen );
    titelBild->setMausEreignisParameter( zKeb );
    titelBild->setMausEreignis( KEBKnopfPressME );
    mapBild = initKnopf( 10, 70, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Minimap Bild" );
    initToolTip( mapBild, "Kartenvorschau Bild währed des erstellens einer Gruppe (348x348)", zSchrift->getThis(), hauptScreen );
    mapBild->setMausEreignisParameter( zKeb );
    mapBild->setMausEreignis( KEBKnopfPressME );
    ladenBild = initKnopf( 10, 100, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Laden Bild" );
    initToolTip( ladenBild, "Hintergrundbild beim Laden der Karte", zSchrift->getThis(), hauptScreen );
    ladenBild->setMausEreignisParameter( zKeb );
    ladenBild->setMausEreignis( KEBKnopfPressME );
    bild = initBildZ( 120, 10, 750, 510, ( BildZ::Style::normal | BildZ::Style::Alpha ) & ~BildZ::Style::Sichtbar, 0 );
    LTDSDatei *sd = new LTDSDatei();
    sd->setPfad( new Text( "data/schriften/ksgs.ltds" ) );
    sd->leseDaten();
    Schrift *ksgsS = sd->ladeSchrift();
    sd->release();
    text = initTextFeld( 120, 10, 750, 510, ksgsS ? ksgsS : zSchrift, ( TextFeld::Style::TextGebiet | TextFeld::Style::HScroll ) & ~TextFeld::Style::Sichtbar, "" );
    if( ksgsS )
        ksgsS->release();
    speichern = initKnopf( 10, 500, 100, 20, zSchrift, 0, "Speichern" );
    initToolTip( speichern, "Beschreibung speichern", zSchrift->getThis(), hauptScreen );
    speichern->setMausEreignisParameter( zKeb );
    speichern->setMausEreignis( KEBKnopfPressME );
    importieren = initKnopf( 10, 500, 100, 20, zSchrift, 0, "Importieren" );
    initToolTip( importieren, "Bild von Festplatte hochladen", zSchrift->getThis(), hauptScreen );
    importieren->setMausEreignisParameter( zKeb );
    importieren->setMausEreignis( KEBKnopfPressME );
    vorschau = initKnopf( 10, 470, 100, 20, zSchrift, 0, "Script Testen" );
    initToolTip( vorschau, "Die Beschreibung auf Scriptfehler testen", zSchrift->getThis(), hauptScreen );
    vorschau->setMausEreignisParameter( zKeb );
    vorschau->setMausEreignis( KEBKnopfPressME );
    jetzt = 0;
    sichtbar = 0;
    alpha = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KEBEditor::~KEBEditor()
{
    beschreibung->release();
    titelBild->release();
    mapBild->release();
    ladenBild->release();
    bild->release();
    text->release();
    speichern->release();
    importieren->release();
    vorschau->release();
}

// nicht constant
void KEBEditor::setSichtbar( bool s )
{
    sichtbar = s;
}

void KEBEditor::setText( Text *zText )
{
    text->setText( zText->getText() );
    bild->removeStyle( BildZ::Style::Sichtbar );
    text->addStyle( TextFeld::Style::Sichtbar );
    importieren->removeStyle( Knopf::Style::Sichtbar );
    speichern->addStyle( Knopf::Style::Sichtbar );
    vorschau->addStyle( Knopf::Style::Sichtbar );
}

void KEBEditor::setBild( Bild *zBild )
{
    bild->setBildZ( zBild->getThis() );
    text->removeStyle( TextFeld::Style::Sichtbar );
    bild->addStyle( BildZ::Style::Sichtbar );
    speichern->removeStyle( Knopf::Style::Sichtbar );
    importieren->addStyle( Knopf::Style::Sichtbar );
    vorschau->removeStyle( Knopf::Style::Sichtbar );
}

bool KEBEditor::tick( double tv )
{
    bool ret = beschreibung->tick( tv );
    ret |= titelBild->tick( tv );
    ret |= mapBild->tick( tv );
    ret |= ladenBild->tick( tv );
    ret |= bild->tick( tv );
    ret |= text->tick( tv );
    ret |= speichern->tick( tv );
    ret |= importieren->tick( tv );
    ret |= vorschau->tick( tv );
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KEBEditor::doMausEreignis( MausEreignis &me )
{
    if( !sichtbar )
        return;
    beschreibung->setAlphaFeldFarbe( 0x5500FF00 );
    titelBild->setAlphaFeldFarbe( 0x5500FF00 );
    mapBild->setAlphaFeldFarbe( 0x5500FF00 );
    ladenBild->setAlphaFeldFarbe( 0x5500FF00 );
    bool mv = me.verarbeitet;
    beschreibung->doMausEreignis( me );
    if( !mv && me.verarbeitet && me.id == ME_RLinks )
        jetzt = 1;
    mv = me.verarbeitet;
    titelBild->doMausEreignis( me );
    if( !mv && me.verarbeitet && me.id == ME_RLinks )
        jetzt = 2;
    mv = me.verarbeitet;
    mapBild->doMausEreignis( me );
    if( !mv && me.verarbeitet && me.id == ME_RLinks )
        jetzt = 3;
    mv = me.verarbeitet;
    ladenBild->doMausEreignis( me );
    if( !mv && me.verarbeitet && me.id == ME_RLinks )
        jetzt = 4;
    if( jetzt == 1 )
        beschreibung->setAlphaFeldFarbe( 0x0000FF00 );
    if( jetzt == 2 )
        titelBild->setAlphaFeldFarbe( 0x0000FF00 );
    if( jetzt == 3 )
        mapBild->setAlphaFeldFarbe( 0x0000FF00 );
    if( jetzt == 4 )
        ladenBild->setAlphaFeldFarbe( 0x0000FF00 );
    bild->doMausEreignis( me );
    text->doMausEreignis( me );
    speichern->doMausEreignis( me );
    importieren->doMausEreignis( me );
    vorschau->doMausEreignis( me );
}

void KEBEditor::doTastaturEreignis( TastaturEreignis &te )
{
    if( !sichtbar )
        return;
    text->doTastaturEreignis( te );
}

void KEBEditor::render( Bild &zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    beschreibung->render( zRObj );
    titelBild->render( zRObj );
    mapBild->render( zRObj );
    ladenBild->render( zRObj );
    text->render( zRObj );
    bild->render( zRObj );
    speichern->render( zRObj );
    importieren->render( zRObj );
    vorschau->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
int KEBEditor::getKNum( Knopf *zK ) const
{
    if( zK == beschreibung )
        return 1;
    if( zK == titelBild )
        return 2;
    if( zK == mapBild )
        return 3;
    if( zK == ladenBild )
        return 4;
    if( zK == speichern )
        return -1;
    if( zK == importieren )
        return -2;
    if( zK == vorschau )
        return -3;
    return 0;
}

Text *KEBEditor::zBeschreibung() const
{
    return text->zText();
}

int KEBEditor::getJetzt() const
{
    return jetzt;
}

bool KEBEditor::istSichtbar() const
{
    return sichtbar;
}

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

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