KSG-Client/KSGClient/NachLogin/Editor/Karte/Beschreibung/KEBEditor.cpp

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

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

// Inhalt der KEBEditor Klasse aus KEBEditor.h
// Konstruktor
KEBEditor::KEBEditor( Schrift *zSchrift, KEBeschreibung *zKeb )
    : Zeichnung()
{
    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();
    ksgs = Framework::getDLLRegister()->ladeDLL( "KSGScript.dll", "data/bin/KSGScript.dll" );
    if( ksgs )
    {
        KSGSGetEditor getKSGScriptEditor = (KSGSGetEditor)GetProcAddress( ksgs, KSGS_EDITOR_FUNKTION );
        if( getKSGScriptEditor )
        {
            text = getKSGScriptEditor();
            text->setSchriftZ( ( ksgsS ? ksgsS : zSchrift )->getThis() );
            text->setSize( 750, 510 );
            text->setPosition( 120, 10 );
            text->setStyle( ZeichnungHintergrund::Style::HScroll | ZeichnungHintergrund::Style::VScroll | ZeichnungHintergrund::Style::Erlaubt | ZeichnungHintergrund::Style::Rahmen | ZeichnungHintergrund::Style::Hintergrund );
            text->setRahmenBreite( 1 );
            text->setRahmenFarbe( 0xFF00FF00 );
            text->setHorizontalScrollPos( 0 );
            text->setVertikalScrollPos( 0 );
            text->setMausEreignis( _ret1ME );
            text->setTastaturEreignis( _ret1TE );
            text->setText( new Text( "" ) );
        }
        else
        {
            text = 0;
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                new Text( "Der Einstiegspunkt '" KSGS_EDITOR_FUNKTION "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                new Text( "Ok" ), 0 );
        }
    }
    else
    {
        text = 0;
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
            new Text( "Die DLL-Datei 'data/bin/KSGScript.dll' konnte nicht geladen werden." ),
            new Text( "Ok" ), 0 );
    }
    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;
}

// Destruktor
KEBEditor::~KEBEditor()
{
    beschreibung->release();
    titelBild->release();
    mapBild->release();
    ladenBild->release();
    bild->release();
    text->release();
    speichern->release();
    importieren->release();
    vorschau->release();
    if( ksgs )
        Framework::getDLLRegister()->releaseDLL( "KSGScript.dll" );
}

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

void KEBEditor::setText( Text *zText )
{
    text->setText( new Text( zText->getText() ) );
    bild->removeStyle( BildZ::Style::Sichtbar );
    text->addStyle( ZeichnungHintergrund::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( ZeichnungHintergrund::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;
}