#include "AuswahlBox.h"

#include "AlphaFeld.h"
#include "Bild.h"
#include "Knopf.h"
#include "MausEreignis.h"
#include "Rahmen.h"
#include "Schrift.h"
#include "Scroll.h"
#include "TastaturEreignis.h"
#include "Text.h"
#include "TextFeld.h"
#include "ToolTip.h"

using namespace Framework;

// Inhalt der AuswahlBox Klasse aus AuswahlBox.h
// Konstruktor
AuswahlBox::AuswahlBox()
    : ZeichnungHintergrund(),
      textRd(0),
      msStyle(0),
      members(new RCArray<TextFeld>()),
      ausfahren(new Knopf()),
      auswRahmen(new LRahmen()),
      auswBgF(0xFF000000),
      auswBgB(0),
      auswAf(new AlphaFeld()),
      msAuswRahmen(0),
      msAuswBgF(0),
      msAuswBgB(0),
      msAuswAf(0),
      mausRahmen(new LRahmen()),
      mausBgF(0xFF000000),
      mausBgB(0),
      mausAf(new AlphaFeld()),
      msMausRahmen(0),
      msMausBgF(0),
      msMausBgB(0),
      msMausAf(0),
      anzahl(0),
      auswahl(0),
      ausgeklappt(0),
      ausklappHeight(0),
      ausklapMaxHeight(200),
      eintragHeight(15),
      tickval(0),
      mausEintrag(0),
      scrollAnzeigen(0),
      eAkP(0),
      eAk(0)
{
    vertikalScrollBar = new VScrollBar();
    style = Style::Normal;
    rahmen = new LRahmen();
    rahmen->setFarbe(0xFFFFFFFF);
    rahmen->setRamenBreite(1);
    ausfahren->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt
                        | Knopf::Style::KlickBuffer);
    ausfahren->setKBFarbe(0xA0000000);
    ausfahren->setKBStrength(10);
    ausfahren->setSize(18, 18);
    ausfahren->setSchriftFarbe(0xFFFFFFFF);
    ausfahren->setText("\\/");
    auswRahmen->setFarbe(0xFF00FF00);
    auswRahmen->setRamenBreite(1);
    auswAf->setFarbe(0xA000FF00);
    auswAf->setStrength(7);
    mausRahmen->setFarbe(0xFF00FF00);
    mausRahmen->setRamenBreite(1);
    mausAf->setFarbe(0x5000FF00);
    mausAf->setStrength(7);
    gr.x = 20;
    gr.y = 20;
}

// Destruktor
AuswahlBox::~AuswahlBox()
{
    if (textRd) textRd->release();
    if (msStyle) msStyle->release();
    if (members) members->release();
    if (ausfahren) ausfahren->release();
    if (auswRahmen) auswRahmen->release();
    if (auswBgB) auswBgB->release();
    if (auswAf) auswAf->release();
    if (msAuswRahmen) msAuswRahmen->release();
    if (msAuswAf) msAuswAf->release();
    if (msAuswBgB) msAuswBgB->release();
    if (msAuswBgF) msAuswBgF->release();
    if (mausRahmen) mausRahmen->release();
    if (mausAf) mausAf->release();
    if (mausBgB) mausBgB->release();
    if (msMausRahmen) msMausRahmen->release();
    if (msMausAf) msMausAf->release();
    if (msMausBgB) msMausBgB->release();
    if (msMausBgF) msMausBgF->release();
}

void AuswahlBox::doMausEreignis(MausEreignis& me, bool userRet) // Maus
{
    if (hatStyleNicht(Style::Erlaubt) || hatStyleNicht(Style::Fokus)
        || me.verarbeitet)
    {
        ausgeklappt = 0;
        me.verarbeitet = 1;
        return;
    }
    if (!userRet) return;
    mausEintrag = -1;
    bool insideParent = me.insideParent;
    me.insideParent = me.mx >= 0 && me.mx < gr.x && me.my >= 0
                   && me.my < gr.y + ausklappHeight;
    bool vera = me.verarbeitet;
    if (ausfahren)
    {
        int tmpMx = me.mx;
        int tmpMy = me.my;
        if (me.mx >= 0 && me.my >= 0 && me.mx < gr.x && me.my < gr.y)
            me.mx = ausfahren->getX(), me.my = ausfahren->getY() + 1;
        ausfahren->doPublicMausEreignis(me);
        me.mx = tmpMx, me.my = tmpMy;
    }
    if (me.verarbeitet && !vera && me.id == ME_RLinks)
    {
        ausgeklappt = !ausgeklappt;
        if (ausgeklappt) mausEintrag = auswahl;
        if (scrollAnzeigen) scrollZuEintrag(mausEintrag);
    }
    if (hatStyle(Style::VScroll) && vertikalScrollBar && ausgeklappt
        && scrollAnzeigen)
    {
        int rbr = 0;
        if (rahmen && hatStyle(Style::Rahmen)) rbr = rahmen->getRBreite();
        if ((me.mx > gr.x - 15 - rbr && me.my > gr.y) || me.id == ME_UScroll
            || me.id == ME_DScroll)
        {
            vertikalScrollBar->doMausMessage(gr.x - rbr - 15,
                gr.y,
                15,
                vertikalScrollBar->getScrollData()->anzeige,
                me);
            me.verarbeitet = 1;
        }
    }
    if (!me.verarbeitet)
    {
        int eintr = -1;
        int tmp = me.my - gr.y
                + (vertikalScrollBar ? vertikalScrollBar->getScroll() : 0);
        if (hatStyle(Style::MultiStyled))
        {
            for (int i = 0; i < anzahl; ++i)
            {
                if (tmp > 0
                    && tmp < (members->z(i) ? members->z(i)->getHeight() : 0))
                {
                    eintr = i;
                    break;
                }
                tmp -= members->z(i) ? members->z(i)->getHeight() : 0;
            }
        }
        else
        {
            for (int i = 0; i < anzahl; ++i)
            {
                if (tmp > 0 && tmp < eintragHeight)
                {
                    eintr = i;
                    break;
                }
                tmp -= eintragHeight;
            }
        }
        if (ausgeklappt && me.mx > 0 && me.mx < gr.x && me.my > gr.y
            && me.my < gr.y + ausklappHeight)
        {
            if (eintr >= 0)
            {
                if (me.id == ME_RLinks)
                {
                    if (auswahl != eintr) rend = 1;
                    auswahl = eintr;
                    if (eAk) eAk(eAkP, this, 0, auswahl);
                }
                if (mausEintrag != eintr) rend = 1;
                mausEintrag = eintr;
            }
        }
    }
    me.verarbeitet = 1;
    me.insideParent = insideParent;
}

// nicht constant
void AuswahlBox::setEventParam(void* p) // setzt den Event Parameter
{
    eAkP = p;
}

void AuswahlBox::setEventAktion(
    std::function<void(void*, AuswahlBox*, int, int)>
        event) // setzt die Event Funktion
{
    this->eAk = event;
}

void AuswahlBox::setSchriftZ(Schrift* schrift) // setzt die schrift
{
    if (!this->textRd)
        textRd = new TextRenderer(schrift);
    else
        textRd->setSchriftZ(schrift);
    ausfahren->setSchriftZ(dynamic_cast<Schrift*>(schrift->getThis()));
    rend = 1;
}

void AuswahlBox::setTextRendererZ(TextRenderer* textRd)
{
    if (this->textRd) this->textRd->release();
    this->textRd = textRd;
}

void AuswahlBox::addEintrag(const char* txt) // Eintrag hinzufuegen
{
    TextFeld* tf = new TextFeld();
    if (textRd) tf->setSchriftZ(textRd->getSchrift());
    tf->addStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center
                 | TextFeld::Style::Rahmen);
    tf->setText(txt);
    tf->setSchriftFarbe(0xFFFFFFFF);
    tf->setRahmenFarbe(0xFFFFFFFF);
    tf->setSize(0, eintragHeight);
    members->add(tf, anzahl);
    ++anzahl;
    rend = 1;
}

void AuswahlBox::addEintrag(Text* txt)
{
    TextFeld* tf = new TextFeld();
    if (textRd) tf->setSchriftZ(textRd->getSchrift());
    tf->addStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center
                 | TextFeld::Style::Rahmen);
    tf->setText(txt);
    tf->setSchriftFarbe(0xFFFFFFFF);
    tf->setRahmenFarbe(0xFFFFFFFF);
    tf->setSize(0, eintragHeight);
    members->add(tf, anzahl);
    ++anzahl;
    rend = 1;
}

void AuswahlBox::addEintragZ(TextFeld* txt)
{
    members->add(txt, anzahl);
    ++anzahl;
    rend = 1;
}

void AuswahlBox::setEintrag(int i, const char* txt) // Eintrag setzen
{
    if (members->z(i)) members->z(i)->setText(txt);
    rend = 1;
}

void AuswahlBox::setEintrag(int i, Text* txt)
{
    if (members->z(i))
        members->z(i)->setText(txt);
    else
        txt->release();
    rend = 1;
}

void AuswahlBox::setEintragZ(int i, TextFeld* txt)
{
    if (i < anzahl)
        members->set(txt, i);
    else
        txt->release();
    rend = 1;
}

void AuswahlBox::removeEintrag(int i) // Eintrag entfernen
{
    if (i < anzahl)
    {
        members->remove(i);
        if (msStyle) msStyle->remove(i);
        if (msAuswRahmen) msAuswRahmen->remove(i);
        if (msAuswBgF) msAuswBgF->remove(i);
        if (msAuswBgB) msAuswBgB->remove(i);
        if (msAuswAf) msAuswAf->remove(i);
        if (msMausRahmen) msMausRahmen->remove(i);
        if (msMausBgF) msMausBgF->remove(i);
        if (msMausBgB) msMausBgB->remove(i);
        if (msMausAf) msMausAf->remove(i);
        if (auswahl > i) --auswahl;
        if (mausEintrag > i) --mausEintrag;
        --anzahl;
        rend = 1;
    }
}

void AuswahlBox::setAusklappKnopfZ(Knopf* ausK) // Ausklapp Knopf setzen
{
    if (ausfahren) ausfahren->release();
    ausfahren = ausK;
    rend = 1;
}

void AuswahlBox::setEintragRahmenZ(
    int i, Rahmen* rahmen) // Eintrag Rahmen setzen
{
    if (members->z(i))
        members->z(i)->setRahmenZ(rahmen);
    else
        rahmen->release();
    rend = 1;
}

void AuswahlBox::setEintragRahmenFarbe(
    int i, int f) // Eintrag Rahmen Farbe setzen
{
    if (members->z(i)) members->z(i)->setRahmenFarbe(f);
    rend = 1;
}

void AuswahlBox::setEintragRahmenBreite(
    int i, int rbr) // Eintrag Rahmen Breite setzen
{
    if (members->z(i)) members->z(i)->setRahmenBreite(rbr);
    rend = 1;
}

void AuswahlBox::setEintragHintergrundFarbe(
    int i, int f) // Eintrag Hintergrund farbe setzen
{
    if (members->z(i)) members->z(i)->setHintergrundFarbe(f);
    rend = 1;
}

void AuswahlBox::setEintragHintergrundBildZ(
    int i, Bild* bgB) // Eintrag Hintergrund Bild setzen
{
    if (members->z(i))
        members->z(i)->setHintergrundBildZ(bgB);
    else
        bgB->release();
    rend = 1;
}

void AuswahlBox::setEintragHintergrundBild(int i, Bild* bgB)
{
    if (members->z(i))
        members->z(i)->setHintergrundBild(bgB);
    else
        bgB->release();
    rend = 1;
}

void AuswahlBox::setEintragAlphaFeldZ(
    int i, AlphaFeld* af) // Eintrag AlphaFeld setzen
{
    if (members->z(i)) members->z(i)->setAlphaFeldZ(af);
    rend = 1;
}

void AuswahlBox::setEintragAlphaFeldFarbe(
    int i, int afF) // Eintrag AlphaFeld Farbe setzen
{
    if (members->z(i)) members->z(i)->setAlphaFeldFarbe(afF);
    rend = 1;
}

void AuswahlBox::setEintragAlphaFeldStrength(
    int i, int afSt) // Eintrag AlphaFeld Staerke setzen
{
    if (members->z(i)) members->z(i)->setAlphaFeldStrength(afSt);
    rend = 1;
}

void AuswahlBox::setAuswRahmenZ(Rahmen* rahmen) // Auswahl Rahmen setzen
{
    if (auswRahmen) auswRahmen->release();
    auswRahmen = rahmen;
    rend = 1;
}

void AuswahlBox::setAuswRahmenFarbe(int f) // Auswahl Rahmen Farbe setzen
{
    if (!auswRahmen) auswRahmen = new LRahmen();
    auswRahmen->setFarbe(f);
    rend = 1;
}

void AuswahlBox::setAuswRahmenBreite(int rbr) // Auswahl Rahmen Breite setzen
{
    if (!auswRahmen) auswRahmen = new LRahmen();
    auswRahmen->setRamenBreite(rbr);
    rend = 1;
}

void AuswahlBox::setAuswHintergrundFarbe(
    int f) // Auswahl Hintergrund Farbe setzen
{
    auswBgF = f;
    rend = 1;
}

void AuswahlBox::setAuswHintergrundBildZ(
    Bild* bgB) // Auswahl Hintergrund Bild setzen
{
    if (auswBgB) auswBgB->release();
    auswBgB = bgB;
    rend = 1;
}

void AuswahlBox::setAuswHintergrundBild(Bild* bgB)
{
    if (!auswBgB) auswBgB = new Bild();
    auswBgB->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
    auswBgB->drawBild(0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
    bgB->release();
    rend = 1;
}

void AuswahlBox::setAuswAlphaFeldZ(AlphaFeld* af) // Auswahl AlphaFeld setzen
{
    if (auswAf) auswAf->release();
    auswAf = af;
    rend = 1;
}

void AuswahlBox::setAuswAlphaFeldFarbe(
    int afF) // Auswahl AlphaFeld Farbe setzen
{
    if (!auswAf) auswAf = new AlphaFeld();
    auswAf->setFarbe(afF);
    rend = 1;
}

void AuswahlBox::setAuswAlphaFeldStrength(
    int afSt) // Auswahl Alpha Feld staerke setzen
{
    if (!auswAf) auswAf = new AlphaFeld();
    auswAf->setStrength(afSt);
    rend = 1;
}

void AuswahlBox::setMsAuswRahmenZ(
    int i, Rahmen* rahmen) // Multistyle Auswahl Rahmen setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        rahmen->release();
        return;
    }
    if (!msAuswRahmen) msAuswRahmen = new RCArray<Rahmen>();
    msAuswRahmen->set(rahmen, i);
    rend = 1;
}

void AuswahlBox::setMsAuswRahmenFarbe(
    int i, int f) // Multistyle Auswahl Rahmen Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msAuswRahmen) msAuswRahmen = new RCArray<Rahmen>();
    if (!msAuswRahmen->z(i)) msAuswRahmen->set(new LRahmen(), i);
    msAuswRahmen->z(i)->setFarbe(f);
    rend = 1;
}

void AuswahlBox::setMsAuswRahmenBreite(
    int i, int rbr) // Multistyle Auswahl Breite setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msAuswRahmen) msAuswRahmen = new RCArray<Rahmen>();
    if (!msAuswRahmen->z(i)) msAuswRahmen->set(new LRahmen(), i);
    msAuswRahmen->z(i)->setRamenBreite(rbr);
    rend = 1;
}

void AuswahlBox::setMsAuswHintergrundFarbe(
    int i, int f) // Multistyle Auswahl Hintergrund Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msAuswBgF) msAuswBgF = new Array<int>();
    msAuswBgF->set(f, i);
    rend = 1;
}

void AuswahlBox::setMsAuswHintergrundBildZ(
    int i, Bild* bgB) // Multistyle Auswahl Hintergrund Bild setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        bgB->release();
        return;
    }
    if (!msAuswBgB) msAuswBgB = new RCArray<Bild>();
    msAuswBgB->set(bgB, i);
    rend = 1;
}

void AuswahlBox::setMsAuswHintergrundBild(int i, Bild* bgB)
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        bgB->release();
        return;
    }
    if (!msAuswBgB) msAuswBgB = new RCArray<Bild>();
    if (!msAuswBgB->z(i))
    {
        Bild* z = new Bild;
        z->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
        z->drawBild(0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
        msAuswBgB->set(z, i);
    }
    else
    {
        msAuswBgB->z(i)->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
        msAuswBgB->z(i)->drawBild(
            0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
    }
    bgB->release();
    rend = 1;
}

void AuswahlBox::setMsAuswAlphaFeldZ(
    int i, AlphaFeld* af) // Multistyle Auswahl AlphaFeld setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        af->release();
        return;
    }
    if (!msAuswAf) msAuswAf = new RCArray<AlphaFeld>();
    msAuswAf->set(af, i);
    rend = 1;
}

void AuswahlBox::setMsAuswAlphaFeldFarbe(
    int i, int afF) // Multistyle Auswahl AlphaFeld Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msAuswAf) msAuswAf = new RCArray<AlphaFeld>();
    if (!msAuswAf->z(i)) msAuswAf->set(new AlphaFeld(), i);
    msAuswAf->z(i)->setFarbe(afF);
    rend = 1;
}

void AuswahlBox::setMsAuswAlphaFeldStrength(
    int i, int afSt) // Multistyle Auswahl AlphaFeld staerke setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msAuswAf) msAuswAf = new RCArray<AlphaFeld>();
    if (!msAuswAf->z(i)) msAuswAf->set(new AlphaFeld(), i);
    msAuswAf->z(i)->setStrength(afSt);
    rend = 1;
}

void AuswahlBox::setMausRahmenZ(Rahmen* rahmen) // Maus Rahmen setzen
{
    if (mausRahmen) mausRahmen->release();
    mausRahmen = rahmen;
    rend = 1;
}

void AuswahlBox::setMausRahmenFarbe(int f) // Maus Rahmen Farbe setzen
{
    if (!mausRahmen) mausRahmen = new LRahmen();
    mausRahmen->setFarbe(f);
    rend = 1;
}

void AuswahlBox::setMausRahmenBreite(int rbr) // Maus Rahmen breite setzen
{
    if (!mausRahmen) mausRahmen = new LRahmen();
    mausRahmen->setRamenBreite(rbr);
    rend = 1;
}

void AuswahlBox::setMausHintergrundFarbe(int f) // Maus Hintergrund Farbe setzen
{
    mausBgF = f;
    rend = 1;
}

void AuswahlBox::setMausHintergrundBildZ(
    Bild* bgB) // Maus Hintergrund Bild setzen
{
    if (mausBgB) mausBgB->release();
    mausBgB = bgB;
    rend = 1;
}

void AuswahlBox::setMausHintergrundBild(Bild* bgB)
{
    if (!mausBgB) mausBgB = new Bild();
    mausBgB->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
    mausBgB->drawBild(0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
    bgB->release();
    rend = 1;
}

void AuswahlBox::setMausAlphaFeldZ(AlphaFeld* af) // Maus AlphaFeld setzen
{
    if (mausAf) mausAf->release();
    mausAf = af;
    rend = 1;
}

void AuswahlBox::setMausAlphaFeldFarbe(int afF) // Maus AlphaFeld Farbe setzen
{
    if (!mausAf) mausAf = new AlphaFeld();
    mausAf->setFarbe(afF);
    rend = 1;
}

void AuswahlBox::setMausAlphaFeldStrength(
    int afSt) // Maus AlphaFeld staerke setzen
{
    if (!mausAf) mausAf = new AlphaFeld();
    mausAf->setStrength(afSt);
    rend = 1;
}

void AuswahlBox::setMsMausRahmenZ(
    int i, Rahmen* rahmen) // Multistyle Maus Rahmen setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        rahmen->release();
        return;
    }
    if (!msMausRahmen) msMausRahmen = new RCArray<Rahmen>();
    msMausRahmen->set(rahmen, i);
    rend = 1;
}

void AuswahlBox::setMsMausRahmenFarbe(
    int i, int f) // Multistyle Maus Rahmen Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msMausRahmen) msMausRahmen = new RCArray<Rahmen>();
    if (!msMausRahmen->z(i)) msMausRahmen->set(new LRahmen(), i);
    msMausRahmen->z(i)->setFarbe(f);
    rend = 1;
}

void AuswahlBox::setMsMausRahmenBreite(
    int i, int rbr) // Multistyle Maus Rahmen breite setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msMausRahmen) msMausRahmen = new RCArray<Rahmen>();
    if (!msMausRahmen->z(i)) msMausRahmen->set(new LRahmen(), i);
    msMausRahmen->z(i)->setRamenBreite(rbr);
    rend = 1;
}

void AuswahlBox::setMsMausHintergrundFarbe(
    int i, int f) // Multistyle Maus Hintergrund Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msMausBgF) msMausBgF = new Array<int>();
    msMausBgF->set(f, i);
    rend = 1;
}

void AuswahlBox::setMsMausHintergrundBildZ(
    int i, Bild* bgB) // Multistyle Maus Hintergrund Bild setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        bgB->release();
        return;
    }
    if (!msMausBgB) msMausBgB = new RCArray<Bild>();
    msMausBgB->set(bgB, i);
    rend = 1;
}

void AuswahlBox::setMsMausHintergrundBild(int i, Bild* bgB)
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        bgB->release();
        return;
    }
    if (!msMausBgB) msMausBgB = new RCArray<Bild>();
    if (!msMausBgB->z(i))
    {
        Bild* z = new Bild;
        z->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
        z->drawBild(0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
        msMausBgB->set(z, i);
    }
    else
    {
        msMausBgB->z(i)->neuBild(bgB->getBreite(), bgB->getHeight(), 0);
        msMausBgB->z(i)->drawBild(
            0, 0, bgB->getBreite(), bgB->getHeight(), *bgB);
    }
    bgB->release();
    rend = 1;
}

void AuswahlBox::setMsMausAlphaFeldZ(
    int i, AlphaFeld* af) // Multistyle Maus AlphaFeld setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl)
    {
        af->release();
        return;
    }
    if (!msMausAf) msMausAf = new RCArray<AlphaFeld>();
    msMausAf->set(af, i);
    rend = 1;
}

void AuswahlBox::setMsMausAlphaFeldFarbe(
    int i, int afF) // Multistyle Maus AlphaFeld Farbe setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msMausAf) msMausAf = new RCArray<AlphaFeld>();
    if (!msMausAf->z(i)) msMausAf->set(new AlphaFeld(), i);
    msMausAf->z(i)->setFarbe(afF);
    rend = 1;
}

void AuswahlBox::setMsMausAlphaFeldStrength(
    int i, int afSt) // Multistyle Maus AlphaFeld staerke setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msMausAf) msMausAf = new RCArray<AlphaFeld>();
    if (!msMausAf->z(i)) msMausAf->set(new AlphaFeld(), i);
    msMausAf->z(i)->setStrength(afSt);
    rend = 1;
}

void AuswahlBox::setAuswahl(int i) // Eintrag auswaehlen
{
    if (i < anzahl && i != auswahl)
    {
        auswahl = i;
        if (eAk) eAk(eAkP, this, 0, auswahl);
        rend = 1;
    }
}

void AuswahlBox::ausklappen() // liste ausklappen
{
    ausgeklappt = 1;
}

void AuswahlBox::einklappen() // liste einklappen
{
    ausgeklappt = 0;
}

void AuswahlBox::scrollZuEintrag(int i) // liste scrollen
{
    if (hatStyle(Style::VScroll) && vertikalScrollBar && i < anzahl)
    {
        int scrollPos = 0;
        if (hatStyle(Style::MultiStyled))
        {
            for (int j = 0; j < i; ++j)
                scrollPos += members->z(j) ? members->z(j)->getHeight() : 0;
        }
        else
            scrollPos += i * eintragHeight;
        vertikalScrollBar->scroll(scrollPos);
        rend = 1;
    }
}

void AuswahlBox::setMaxAuskappHeight(
    int maxHeight) // hoehe der Liste beim ausklappen
{
    ausklapMaxHeight = maxHeight;
}

void AuswahlBox::setEintragHeight(int height) // setzt die Hoehe der Eintraege
{
    eintragHeight = height;
}

void AuswahlBox::addMsStyle(
    int i, __int64 abStyle) // Multistyle style hinzufuegen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msStyle) msStyle = new Array<__int64>();
    msStyle->set(msStyle->get(i) | abStyle, i);
    rend = 1;
}

void AuswahlBox::setMsStyle(
    int i, __int64 abStyle, bool add) // Multistyle style setzen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msStyle) msStyle = new Array<__int64>();
    if (add)
        msStyle->set(msStyle->get(i) | abStyle, i);
    else
        msStyle->set(msStyle->get(i) & ~abStyle, i);
    rend = 1;
}

void AuswahlBox::setMsStyle(int i, __int64 abStyle)
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msStyle) msStyle = new Array<__int64>();
    msStyle->set(abStyle, i);
    rend = 1;
}

void AuswahlBox::removeMsStyle(
    int i, __int64 abStyle) // Multistyle style entfernen
{
    if (hatStyleNicht(Style::MultiStyled) || i >= anzahl) return;
    if (!msStyle) msStyle = new Array<__int64>();
    msStyle->set(msStyle->get(i) & ~abStyle, i);
    rend = 1;
}

bool AuswahlBox::tick(double tickVal) // tick
{
    if (ausgeklappt && ausfahren && !ausfahren->zText()->istGleich("/\\"))
    {
        ausfahren->setText("/\\");
        rend = 1;
    }
    else if (!ausgeklappt && ausfahren && !ausfahren->zText()->istGleich("\\/"))
    {
        ausfahren->setText("\\/");
        rend = 1;
    }
    if (hatStyleNicht(Style::Sichtbar) || hatStyleNicht(Style::Erlaubt))
        ausgeklappt = 0;
    rend |= ausfahren->tick(tickVal);
    this->tickval += tickVal * 300;
    int val = (int)this->tickval;
    if (val < 1) return ZeichnungHintergrund::tick(tickVal);
    this->tickval -= val;
    int maxHeight = rahmen ? rahmen->getRBreite() : 0;
    if (hatStyleNicht(Style::MultiStyled))
        maxHeight += anzahl * eintragHeight;
    else
        for (int i = 0; i < anzahl; ++i)
            maxHeight += members->z(i) ? members->z(i)->getHeight() : 0;
    if (maxHeight > ausklapMaxHeight)
    {
        if (hatStyle(Style::VScroll) && vertikalScrollBar)
        {
            scrollAnzeigen = 1;
            vertikalScrollBar->update(maxHeight, ausklapMaxHeight);
        }
        maxHeight = ausklapMaxHeight;
    }
    else
        scrollAnzeigen = 0;
    if (ausgeklappt)
    {
        if (ausklappHeight < maxHeight)
        {
            ausklappHeight += val;
            if (ausklappHeight > maxHeight) ausklappHeight = maxHeight;
            rend = 1;
        }
    }
    else
    {
        if (ausklappHeight > 0)
        {
            ausklappHeight -= val;
            if (ausklappHeight < 0) ausklappHeight = 0;
            rend = 1;
        }
    }
    for (int i = 0; i < anzahl; ++i)
    {
        if (i != auswahl)
            rend |= members->z(i)->tick(tickVal);
        else
            members->z(i)->tick(tickVal);
    }
    return ZeichnungHintergrund::tick(tickVal);
}

void AuswahlBox::doTastaturEreignis(TastaturEreignis& te) // Tastatur
{
    if (te.verarbeitet || hatStyleNicht(Style::Fokus)
        || hatStyleNicht(Style::Erlaubt))
        return;
    if (te.id == TE_Release)
    {
        switch (te.virtualKey)
        {
        case T_Oben:
            if (auswahl > 0)
                --auswahl;
            else
                auswahl = anzahl - 1;
            if (eAk) eAk(eAkP, this, 0, auswahl);
            scrollZuEintrag(auswahl);
            rend = 1;
            break;
        case T_Unten:
            if (auswahl < anzahl - 1)
                ++auswahl;
            else
                auswahl = 0;
            if (eAk) eAk(eAkP, this, 0, auswahl);
            scrollZuEintrag(auswahl);
            rend = 1;
            break;
        }
    }
    if (te.verarbeitet && nTak) te.verarbeitet = nTak(ntakParam, this, te);
}

void AuswahlBox::render(Bild& zRObj) // zeichnet nach zRObj
{
    if (hatStyle(Style::Sichtbar))
    {
        lockZeichnung();
        int br = gr.x;
        int hi = gr.y + ausklappHeight;
        if ((ausklappHeight
                && !zRObj.setDrawOptionsErzwingen(pos.x, pos.y, br, hi))
            || (!ausklappHeight && !zRObj.setDrawOptions(pos.x, pos.y, br, hi)))
        {
            unlockZeichnung();
            return;
        }
        int rbr = 0;
        if (hatStyle(Style::Rahmen) && rahmen) // Rahmen zeichnen
        {
            rahmen->setSize(br, hi);
            rahmen->render(zRObj);
            rbr = rahmen->getRBreite();
        }
        if ((ausklappHeight
                && !zRObj.setDrawOptionsErzwingen(
                    rbr, rbr, br - rbr * 2, hi - rbr * 2))
            || (!ausklappHeight
                && !zRObj.setDrawOptions(rbr, rbr, br - rbr * 2, hi - rbr * 2)))
        {
            zRObj.releaseDrawOptions();
            unlockZeichnung();
            return;
        }
        if (hatStyle(Style::Hintergrund))
        {
            if (hatStyle(Style::HAlpha))
                zRObj.alphaRegion(0, 0, br, hi, hintergrundFarbe);
            else
                zRObj.fillRegion(0, 0, br, hi, hintergrundFarbe);
            if (hatStyle(Style::HBild) && hintergrundBild)
            {
                if (hatStyle(Style::HAlpha))
                    zRObj.alphaBild(0, 0, br, hi, *hintergrundBild);
                else
                    zRObj.drawBild(0, 0, br, hi, *hintergrundBild);
            }
        }
        if (hatStyle(Style::Buffered) && hintergrundFeld)
        {
            hintergrundFeld->setSize(br - rbr * 2, hi - rbr * 2);
            hintergrundFeld->render(zRObj);
        }
        if (ausfahren) // Ausklapp Knopf zeichnen
        {
            ausfahren->setSize(gr.y - rbr * 2, gr.y - rbr * 2);
            ausfahren->setPosition(gr.x - rbr - ausfahren->getBreite(), rbr);
            ausfahren->render(zRObj);
        }
        if (members) // Ausgewaehtes TextFeld zeichnen
        {
            if (auswahl < 0)
            {
                auswahl = 0;
                if (eAk) eAk(eAkP, this, 0, auswahl);
            }
            if (auswahl >= anzahl)
            {
                auswahl = anzahl - 1;
                if (eAk) eAk(eAkP, this, 0, auswahl);
            }
            TextFeld* tf = auswahl >= 0 ? members->z(auswahl) : 0;
            if (tf)
            {
                AlphaFeld* tmpBuffer = 0;
                bool tmpB = 0;
                int tmpHFarbe = 0;
                bool tmpH = 0;
                Bild* tmpHBild = 0;
                bool tmpHB = 0;
                bool tmpHAlpha = 0;
                Rahmen* tmpRahmen = 0;
                bool tmpR = 0;
                if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                {
                    if (hatStyle(Style::AuswahlBuffer))
                    {
                        tmpBuffer = tf->getAlphaFeld();
                        tf->setAlphaFeldZ(
                            dynamic_cast<AlphaFeld*>(auswAf->getThis()));
                        tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                        tf->setStyle(TextFeld::Style::Buffered,
                            hatStyle(Style::AuswahlBuffer));
                    }
                    if (hatStyle(Style::AuswahlHintergrund))
                    {
                        tmpH = tf->hatStyle(TextFeld::Style::Hintergrund);
                        tmpHFarbe = tf->getHintergrundFarbe();
                        tf->setHintergrundFarbe(auswBgF);
                        tf->setStyle(TextFeld::Style::Hintergrund,
                            hatStyle(Style::Hintergrund));
                        if (hatStyle(Style::AuswahlHBild))
                        {
                            tmpHBild = tf->getHintergrundBild();
                            tf->setHintergrundBildZ(
                                dynamic_cast<Bild*>(auswBgB->getThis()));
                            tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                            tf->setStyle(
                                TextFeld::Style::HBild, hatStyle(Style::HBild));
                        }
                        if (hatStyle(Style::AuswahlHAlpha))
                        {
                            tmpHAlpha = tf->hatStyle(TextFeld::Style::HAlpha);
                            tf->setStyle(TextFeld::Style::HAlpha,
                                hatStyle(Style::AuswahlHAlpha));
                        }
                    }
                    if (hatStyle(Style::AuswahlRahmen))
                    {
                        tmpRahmen = tf->getRahmen();
                        tf->setRahmenZ(
                            dynamic_cast<Rahmen*>(auswRahmen->getThis()));
                        tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                        tf->setStyle(TextFeld::Style::Rahmen,
                            hatStyle(Style::AuswahlRahmen));
                    }
                }
                else
                {
                    if (hatMsStyle(auswahl, Style::AuswahlBuffer) && msAuswAf)
                    {
                        tmpBuffer = tf->getAlphaFeld();
                        tf->setAlphaFeldZ(msAuswAf->get(auswahl));
                        tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                        tf->setStyle(TextFeld::Style::Buffered,
                            hatMsStyle(auswahl, Style::AuswahlBuffer));
                    }
                    if (hatMsStyle(auswahl, Style::AuswahlHintergrund))
                    {
                        tmpH = tf->hatStyle(Style::Hintergrund);
                        tf->setStyle(TextFeld::Style::Hintergrund,
                            hatMsStyle(auswahl, Style::AuswahlHintergrund));
                        if (msAuswBgF && msAuswBgF->hat(auswahl))
                        {
                            tmpHFarbe = tf->getHintergrundFarbe();
                            tf->setHintergrundFarbe(msAuswBgF->get(auswahl));
                        }
                        if (hatMsStyle(auswahl, Style::AuswahlHBild)
                            && msAuswBgB)
                        {
                            tmpHBild = tf->getHintergrundBild();
                            tf->setHintergrundBildZ(msAuswBgB->get(auswahl));
                            tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                            tf->setStyle(TextFeld::Style::HBild,
                                hatMsStyle(auswahl, Style::HBild));
                        }
                        if (hatMsStyle(auswahl, Style::AuswahlHAlpha))
                        {
                            tmpHAlpha = tf->hatStyle(TextFeld::Style::HAlpha);
                            tf->setStyle(TextFeld::Style::HAlpha,
                                hatMsStyle(auswahl, Style::AuswahlHAlpha));
                        }
                    }
                    if (hatMsStyle(auswahl, Style::AuswahlRahmen)
                        && msAuswRahmen)
                    {
                        tmpRahmen = tf->getRahmen();
                        tf->setRahmenZ(msAuswRahmen->get(auswahl));
                        tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                        tf->setStyle(TextFeld::Style::Rahmen,
                            hatMsStyle(auswahl, Style::AuswahlRahmen));
                    }
                }
                int tmpHi = tf->getHeight();
                tf->setPosition(0, 0);
                tf->setSize(
                    gr.x - rbr * 2 - (ausfahren ? ausfahren->getBreite() : 0),
                    gr.y - rbr * 2);
                tf->render(zRObj);
                tf->setSize(tf->getBreite(), tmpHi);
                if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                {
                    if (hatStyle(Style::AuswahlBuffer))
                    {
                        tf->setAlphaFeldZ(tmpBuffer);
                        tf->setStyle(TextFeld::Style::Buffered, tmpB);
                    }
                    if (hatStyle(Style::AuswahlHintergrund))
                    {
                        tf->setHintergrundFarbe(tmpHFarbe);
                        tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                        if (hatStyle(Style::AuswahlHBild))
                        {
                            tf->setHintergrundBildZ(tmpHBild);
                            tf->setStyle(TextFeld::Style::HBild, tmpHB);
                        }
                        if (hatStyle(Style::AuswahlHAlpha))
                            tf->setStyle(TextFeld::Style::HAlpha, tmpHAlpha);
                    }
                    if (hatStyle(Style::AuswahlRahmen))
                    {
                        tf->setRahmenZ(tmpRahmen);
                        tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                    }
                }
                else
                {
                    if (hatMsStyle(auswahl, Style::AuswahlBuffer) && msAuswAf)
                    {
                        tf->setAlphaFeldZ(tmpBuffer);
                        tf->setStyle(TextFeld::Style::Buffered, tmpB);
                    }
                    if (hatMsStyle(auswahl, Style::AuswahlHintergrund))
                    {
                        tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                        if (msAuswBgF && msAuswBgF->hat(auswahl))
                            tf->setHintergrundFarbe(tmpHFarbe);
                        if (hatMsStyle(auswahl, Style::AuswahlHBild)
                            && msAuswBgB)
                        {
                            tf->setHintergrundBildZ(tmpHBild);
                            tf->setStyle(TextFeld::Style::HBild, tmpHB);
                        }
                        if (hatMsStyle(auswahl, Style::AuswahlHAlpha))
                            tf->setStyle(TextFeld::Style::HAlpha, tmpHAlpha);
                    }
                    if (hatMsStyle(auswahl, Style::AuswahlRahmen)
                        && msAuswRahmen)
                    {
                        tf->setRahmenZ(tmpRahmen);
                        tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                    }
                }
            }
        }
        bool vsb = hatStyle(Style::VScroll)
                && vertikalScrollBar; // Scroll bar zeichnen
        if (auswahl >= anzahl)
        {
            auswahl = 0;
            if (eAk) eAk(eAkP, this, 0, auswahl);
        }
        if (members)
        {
            if (vsb && ausklappHeight)
            {
                br -= 15;
                vertikalScrollBar->getScrollData()->anzeige
                    = ausklappHeight - rbr;
                vertikalScrollBar->render(
                    br - rbr, gr.y, 15, ausklappHeight - rbr, zRObj);
            }
            if ((ausklappHeight
                    && !zRObj.setDrawOptionsErzwingen(
                        0, gr.y, br - rbr, hi - rbr - gr.y))
                || (!ausklappHeight
                    && !zRObj.setDrawOptions(
                        0, gr.y, br - rbr, hi - rbr - gr.y)))
            {
                zRObj.releaseDrawOptions();
                zRObj.releaseDrawOptions();
                unlockZeichnung();
                return;
            }
            int maxHeight = 0;
            int dy = 0;
            if (vsb) dy -= vertikalScrollBar->getScroll();
            int mdy = hi - rbr;
            anzahl = members->getEintragAnzahl();
            for (int i = 0; i < anzahl; ++i)
            {
                TextFeld* tf = members->z(i);
                if (dy >= mdy && !vsb) break;
                tf->setPosition(0, dy);
                tf->setSize(br - rbr * 2, tf->getHeight());
                maxHeight += tf->getHeight();
                bool selected = auswahl == i;
                AlphaFeld* tmpBuffer = 0;
                bool tmpB = 0;
                int tmpHFarbe = 0;
                bool tmpH = 0;
                Bild* tmpHBild = 0;
                bool tmpHB = 0;
                bool tmpHAlpha = 0;
                Rahmen* tmpRahmen = 0;
                bool tmpR = 0;
                if (selected)
                {
                    if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                    {
                        if (hatStyle(Style::AuswahlBuffer))
                        {
                            tmpBuffer = tf->getAlphaFeld();
                            tf->setAlphaFeldZ(
                                dynamic_cast<AlphaFeld*>(auswAf->getThis()));
                            tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                            tf->setStyle(TextFeld::Style::Buffered,
                                hatStyle(Style::AuswahlBuffer));
                        }
                        if (hatStyle(Style::AuswahlHintergrund))
                        {
                            tmpH = tf->hatStyle(TextFeld::Style::Hintergrund);
                            tmpHFarbe = tf->getHintergrundFarbe();
                            tf->setHintergrundFarbe(auswBgF);
                            tf->setStyle(TextFeld::Style::Hintergrund,
                                hatStyle(Style::Hintergrund));
                            if (hatStyle(Style::AuswahlHBild))
                            {
                                tmpHBild = tf->getHintergrundBild();
                                tf->setHintergrundBildZ(
                                    dynamic_cast<Bild*>(auswBgB->getThis()));
                                tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                                tf->setStyle(TextFeld::Style::HBild,
                                    hatStyle(Style::HBild));
                            }
                            if (hatStyle(Style::AuswahlHAlpha))
                            {
                                tmpHAlpha
                                    = tf->hatStyle(TextFeld::Style::HAlpha);
                                tf->setStyle(TextFeld::Style::HAlpha,
                                    hatStyle(Style::AuswahlHAlpha));
                            }
                        }
                        if (hatStyle(Style::AuswahlRahmen))
                        {
                            tmpRahmen = tf->getRahmen();
                            tf->setRahmenZ(
                                dynamic_cast<Rahmen*>(auswRahmen->getThis()));
                            tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                            tf->setStyle(TextFeld::Style::Rahmen,
                                hatStyle(Style::AuswahlRahmen));
                        }
                    }
                    else
                    {
                        if (hatMsStyle(i, Style::AuswahlBuffer) && msAuswAf)
                        {
                            tmpBuffer = tf->getAlphaFeld();
                            tf->setAlphaFeldZ(msAuswAf->get(i));
                            tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                            tf->setStyle(TextFeld::Style::Buffered,
                                hatMsStyle(i, Style::AuswahlBuffer));
                        }
                        if (hatMsStyle(i, Style::AuswahlHintergrund))
                        {
                            tmpH = tf->hatStyle(Style::Hintergrund);
                            tf->setStyle(TextFeld::Style::Hintergrund,
                                hatMsStyle(i, Style::AuswahlHintergrund));
                            if (msAuswBgF && msAuswBgF->hat(i))
                            {
                                tmpHFarbe = tf->getHintergrundFarbe();
                                tf->setHintergrundFarbe(msAuswBgF->get(i));
                            }
                            if (hatMsStyle(i, Style::AuswahlHBild) && msAuswBgB)
                            {
                                tmpHBild = tf->getHintergrundBild();
                                tf->setHintergrundBildZ(msAuswBgB->get(i));
                                tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                                tf->setStyle(TextFeld::Style::HBild,
                                    hatMsStyle(i, Style::HBild));
                            }
                            if (hatMsStyle(i, Style::AuswahlHAlpha))
                            {
                                tmpHAlpha
                                    = tf->hatStyle(TextFeld::Style::HAlpha);
                                tf->setStyle(TextFeld::Style::HAlpha,
                                    hatMsStyle(i, Style::AuswahlHAlpha));
                            }
                        }
                        if (hatMsStyle(i, Style::AuswahlRahmen) && msAuswRahmen)
                        {
                            tmpRahmen = tf->getRahmen();
                            tf->setRahmenZ(msAuswRahmen->get(i));
                            tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                            tf->setStyle(TextFeld::Style::Rahmen,
                                hatMsStyle(i, Style::AuswahlRahmen));
                        }
                    }
                }
                else if (mausEintrag == i)
                {
                    if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                    {
                        if (hatStyle(Style::MausBuffer))
                        {
                            tmpBuffer = tf->getAlphaFeld();
                            tf->setAlphaFeldZ(
                                dynamic_cast<AlphaFeld*>(mausAf->getThis()));
                            tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                            tf->setStyle(TextFeld::Style::Buffered,
                                hatStyle(Style::MausBuffer));
                        }
                        if (hatStyle(Style::MausHintergrund))
                        {
                            tmpH = tf->hatStyle(TextFeld::Style::Hintergrund);
                            tmpHFarbe = tf->getHintergrundFarbe();
                            tf->setHintergrundFarbe(mausBgF);
                            tf->setStyle(TextFeld::Style::Hintergrund,
                                hatStyle(Style::Hintergrund));
                            if (hatStyle(Style::MausHBild))
                            {
                                tmpHBild = tf->getHintergrundBild();
                                tf->setHintergrundBildZ(
                                    dynamic_cast<Bild*>(mausBgB->getThis()));
                                tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                                tf->setStyle(TextFeld::Style::HBild,
                                    hatStyle(Style::HBild));
                            }
                            if (hatStyle(Style::MausHAlpha))
                            {
                                tmpHAlpha
                                    = tf->hatStyle(TextFeld::Style::HAlpha);
                                tf->setStyle(TextFeld::Style::HAlpha,
                                    hatStyle(Style::MausHAlpha));
                            }
                        }
                        if (hatStyle(Style::MausRahmen))
                        {
                            tmpRahmen = tf->getRahmen();
                            tf->setRahmenZ(
                                dynamic_cast<Rahmen*>(mausRahmen->getThis()));
                            tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                            tf->setStyle(TextFeld::Style::Rahmen,
                                hatStyle(Style::MausRahmen));
                        }
                    }
                    else
                    {
                        if (hatMsStyle(i, Style::MausBuffer) && msAuswAf)
                        {
                            tmpBuffer = tf->getAlphaFeld();
                            tf->setAlphaFeldZ(msMausAf->get(i));
                            tmpB = tf->hatStyle(TextFeld::Style::Buffered);
                            tf->setStyle(TextFeld::Style::Buffered,
                                hatMsStyle(i, Style::MausBuffer));
                        }
                        if (hatMsStyle(i, Style::MausHintergrund))
                        {
                            tmpH = tf->hatStyle(Style::Hintergrund);
                            tf->setStyle(TextFeld::Style::Hintergrund,
                                hatMsStyle(i, Style::MausHintergrund));
                            if (msMausBgF && msMausBgF->hat(i))
                            {
                                tmpHFarbe = tf->getHintergrundFarbe();
                                tf->setHintergrundFarbe(msMausBgF->get(i));
                            }
                            if (hatMsStyle(i, Style::MausHBild) && msMausBgB)
                            {
                                tmpHBild = tf->getHintergrundBild();
                                tf->setHintergrundBildZ(msMausBgB->get(i));
                                tmpHB = tf->hatStyle(TextFeld::Style::HBild);
                                tf->setStyle(TextFeld::Style::HBild,
                                    hatMsStyle(i, Style::HBild));
                            }
                            if (hatMsStyle(i, Style::MausHAlpha))
                            {
                                tmpHAlpha
                                    = tf->hatStyle(TextFeld::Style::HAlpha);
                                tf->setStyle(TextFeld::Style::HAlpha,
                                    hatMsStyle(i, Style::MausHAlpha));
                            }
                        }
                        if (hatMsStyle(i, Style::MausRahmen) && msMausRahmen)
                        {
                            tmpRahmen = tf->getRahmen();
                            tf->setRahmenZ(msMausRahmen->get(i));
                            tmpR = tf->hatStyle(TextFeld::Style::Rahmen);
                            tf->setStyle(TextFeld::Style::Rahmen,
                                hatMsStyle(i, Style::MausRahmen));
                        }
                    }
                }
                tf->render(zRObj);
                if (selected)
                {
                    if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                    {
                        if (hatStyle(Style::AuswahlBuffer))
                        {
                            tf->setAlphaFeldZ(tmpBuffer);
                            tf->setStyle(TextFeld::Style::Buffered, tmpB);
                        }
                        if (hatStyle(Style::AuswahlHintergrund))
                        {
                            tf->setHintergrundFarbe(tmpHFarbe);
                            tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                            if (hatStyle(Style::AuswahlHBild))
                            {
                                tf->setHintergrundBildZ(tmpHBild);
                                tf->setStyle(TextFeld::Style::HBild, tmpHB);
                            }
                            if (hatStyle(Style::AuswahlHAlpha))
                                tf->setStyle(
                                    TextFeld::Style::HAlpha, tmpHAlpha);
                        }
                        if (hatStyle(Style::AuswahlRahmen))
                        {
                            tf->setRahmenZ(tmpRahmen);
                            tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                        }
                    }
                    else
                    {
                        if (hatMsStyle(i, Style::AuswahlBuffer) && msAuswAf)
                        {
                            tf->setAlphaFeldZ(tmpBuffer);
                            tf->setStyle(TextFeld::Style::Buffered, tmpB);
                        }
                        if (hatMsStyle(i, Style::AuswahlHintergrund))
                        {
                            tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                            if (msAuswBgF && msAuswBgF->hat(i))
                                tf->setHintergrundFarbe(tmpHFarbe);
                            if (hatMsStyle(i, Style::AuswahlHBild) && msAuswBgB)
                            {
                                tf->setHintergrundBildZ(tmpHBild);
                                tf->setStyle(TextFeld::Style::HBild, tmpHB);
                            }
                            if (hatMsStyle(i, Style::AuswahlHAlpha))
                                tf->setStyle(
                                    TextFeld::Style::HAlpha, tmpHAlpha);
                        }
                        if (hatMsStyle(i, Style::AuswahlRahmen) && msAuswRahmen)
                        {
                            tf->setRahmenZ(tmpRahmen);
                            tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                        }
                    }
                }
                else if (mausEintrag == i)
                {
                    if (hatStyleNicht(Style::MultiStyled) || !msStyle)
                    {
                        if (hatStyle(Style::MausBuffer))
                        {
                            tf->setAlphaFeldZ(tmpBuffer);
                            tf->setStyle(TextFeld::Style::Buffered, tmpB);
                        }
                        if (hatStyle(Style::MausHintergrund))
                        {
                            tf->setHintergrundFarbe(tmpHFarbe);
                            tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                            if (hatStyle(Style::MausHBild))
                            {
                                tf->setHintergrundBildZ(tmpHBild);
                                tf->setStyle(TextFeld::Style::HBild, tmpHB);
                            }
                            if (hatStyle(Style::MausHAlpha))
                                tf->setStyle(
                                    TextFeld::Style::HAlpha, tmpHAlpha);
                        }
                        if (hatStyle(Style::MausRahmen))
                        {
                            tf->setRahmenZ(tmpRahmen);
                            tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                        }
                    }
                    else
                    {
                        if (hatMsStyle(i, Style::MausBuffer) && msAuswAf)
                        {
                            tf->setAlphaFeldZ(tmpBuffer);
                            tf->setStyle(TextFeld::Style::Buffered, tmpB);
                        }
                        if (hatMsStyle(i, Style::MausHintergrund))
                        {
                            tf->setStyle(TextFeld::Style::Hintergrund, tmpH);
                            if (msAuswBgF && msAuswBgF->hat(i))
                                tf->setHintergrundFarbe(tmpHFarbe);
                            if (hatMsStyle(i, Style::MausHBild) && msAuswBgB)
                            {
                                tf->setHintergrundBildZ(tmpHBild);
                                tf->setStyle(TextFeld::Style::HBild, tmpHB);
                            }
                            if (hatMsStyle(i, Style::MausHAlpha))
                                tf->setStyle(
                                    TextFeld::Style::HAlpha, tmpHAlpha);
                        }
                        if (hatMsStyle(i, Style::MausRahmen) && msAuswRahmen)
                        {
                            tf->setRahmenZ(tmpRahmen);
                            tf->setStyle(TextFeld::Style::Rahmen, tmpR);
                        }
                    }
                }
                dy += tf->getHeight();
            }
            if (vertikalScrollBar)
                vertikalScrollBar->getScrollData()->max = maxHeight;
            zRObj.releaseDrawOptions();
        }
        zRObj.releaseDrawOptions();
        zRObj.releaseDrawOptions();
        unlockZeichnung();
    }
}

// constant
int AuswahlBox::getEintragPos(
    const char* txt) const // gibt die Eintrag Position zurueck
{
    for (int i = 0; i < anzahl; ++i)
        if (members->z(i) && members->z(i)->zText()->istGleich(txt)) return i;
    return -1;
}

int AuswahlBox::getEintragPos(Text* txt) const
{
    for (int i = 0; i < anzahl; ++i)
    {
        if (members->z(i) && members->z(i)->zText()->istGleich(txt->getText()))
        {
            txt->release();
            return i;
        }
    }
    txt->release();
    return -1;
}

Text* AuswahlBox::getEintragText(int i) const // gibt den Eintrag Text zurueck
{
    if (i >= anzahl) return 0;
    return members->z(i) ? members->z(i)->getText() : 0;
}

Text* AuswahlBox::zEintragText(int i) const
{
    if (i >= anzahl) return 0;
    return members->z(i) ? members->z(i)->zText() : 0;
}

TextFeld* AuswahlBox::getEintrag(int i) const // gibt den Eintrag zurueck
{
    if (i >= anzahl) return 0;
    return members->get(i);
}

TextFeld* AuswahlBox::zEintrag(int i) const
{
    if (i >= anzahl) return 0;
    return members->z(i);
}

int AuswahlBox::getAuswahl()
    const // gibt die Position des ausgewaehlten Eintrages zurueck
{
    return auswahl;
}

int AuswahlBox::getEintragAnzahl() const // gibt die Anzahl der Eintraege zurueck
{
    return anzahl;
}

bool AuswahlBox::istAusgeklappt() const // prueft, ob die Liste ausgeklappt ist
{
    return ausgeklappt;
}

int AuswahlBox::getMaxHeight() const // gibt die maximale Hoehe der Liste zurueck
{
    if (!hatStyle(Style::MaxHeight)) return 0;
    return ausklapMaxHeight;
}

int AuswahlBox::getEintragHeight() const // gibt die Hoehe der Eintraege zurueck
{
    return eintragHeight;
}

Knopf*
AuswahlBox::getAusklappKnopf() const // gibt den aus-/einklapp Knopf zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return ausfahren ? dynamic_cast<Knopf*>(ausfahren->getThis()) : 0;
}

Knopf* AuswahlBox::zAusklappKnopf() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return ausfahren;
}

Rahmen* AuswahlBox::getEintragRahmen(
    int i) const // gibt den Eintrag Rahmen zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getRahmen();
}

Rahmen* AuswahlBox::zEintragRahmen(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->zRahmen();
}

int AuswahlBox::getEintragRahmenFarbe(
    int i) const // gibt die Eintrag Rahmen Frabe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getRahmenFarbe();
}

int AuswahlBox::getEintragRahmenBreite(
    int i) const // gibt die Eintrag Rahmen Breite zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getRahmenBreite();
}

AlphaFeld* AuswahlBox::getEintragAlphaFeld(
    int i) const // gibt das Eintrag AlphaFeld zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getAlphaFeld();
}

AlphaFeld* AuswahlBox::zEintragAlphaFeld(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->zAlphaFeld();
}

int AuswahlBox::getEintragAlphaFeldFarbe(
    int i) const // gibt die Eintrag AlphaFeld Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getAlphaFeldFarbe();
}

int AuswahlBox::getEintragAlphaFeldStrength(
    int i) const // gibt die Eintrag AlphaFeld staerke zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getAlphaFeldStrength();
}

int AuswahlBox::getEintragHintergrundFarbe(
    int i) const // gibt die Eintrag Hintergrund Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getHintergrundFarbe();
}

Bild* AuswahlBox::getEintragHintergrundBild(
    int i) const // gibt das Eintrag Hintergrund Bild zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->getHintergrundBild();
}

Bild* AuswahlBox::zEintragHintergrundBild(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!members->z(i)) return 0;
    return members->z(i)->zHintergrundBild();
}

Rahmen* AuswahlBox::getAuswRahmen() const // gibt den Auswahl Rahmen zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswRahmen ? dynamic_cast<Rahmen*>(auswRahmen->getThis()) : 0;
}

Rahmen* AuswahlBox::zAuswRahmen() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswRahmen;
}

int AuswahlBox::getAuswRahmenFarbe()
    const // gibt die Auswahl Rahmen Frabe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswRahmen ? auswRahmen->getFarbe() : 0;
}

int AuswahlBox::getAuswRahmenBreite()
    const // gibt die Auswahl Rahmen Breite zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswRahmen ? auswRahmen->getRBreite() : 0;
}

AlphaFeld*
AuswahlBox::getAuswAlphaFeld() const // gibt das Auswahl AlphaFeld zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswAf ? dynamic_cast<AlphaFeld*>(auswAf->getThis()) : 0;
}

AlphaFeld* AuswahlBox::zAuswAlphaFeld() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswAf;
}

int AuswahlBox::getAuswAlphaFeldFarbe()
    const // gibt die Auswahl AlphaFeld Farbe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswAf ? auswAf->getFarbe() : 0;
}

int AuswahlBox::getAuswAlphaFeldStrength()
    const // gibt die Auswahl AlphaFeld staerke zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswAf ? auswAf->getStrength() : 0;
}

int AuswahlBox::getAuswHintergrundFarbe()
    const // gibt die Auswahl Hintergrund Farbe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswBgF;
}

Bild* AuswahlBox::getAuswHintergrundBild()
    const // gibt das Auswahl Hintergrund Bild zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswBgB ? dynamic_cast<Bild*>(auswBgB->getThis()) : 0;
}

Bild* AuswahlBox::zAuswHintergrundBild() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return auswBgB;
}

Rahmen* AuswahlBox::getMsAuswRahmen(
    int i) const // gibt den Multistyle Auswahl Rahmen zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswRahmen) return 0;
    return msAuswRahmen->z(i)
             ? dynamic_cast<Rahmen*>(msAuswRahmen->z(i)->getThis())
             : 0;
}

Rahmen* AuswahlBox::zMsAuswRahmen(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswRahmen) return 0;
    return msAuswRahmen->z(i);
}

int AuswahlBox::getMsAuswRahmenFarbe(
    int i) const // gibt die Multistyle Auswahl Rahmen Frabe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswRahmen) return 0;
    return msAuswRahmen->z(i) ? msAuswRahmen->z(i)->getFarbe() : 0;
}

int AuswahlBox::getMsAuswRahmenBreite(
    int i) const // gibt die Multistyle Auswahl Rahmen Breite zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswRahmen) return 0;
    return msAuswRahmen->z(i) ? msAuswRahmen->z(i)->getRBreite() : 0;
}

AlphaFeld* AuswahlBox::getMsAuswAlphaFeld(
    int i) const // gibt das Multistyle Auswahl AlphaFeld zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswAf) return 0;
    return msAuswAf->z(i) ? dynamic_cast<AlphaFeld*>(msAuswAf->z(i)->getThis())
                          : 0;
}

AlphaFeld* AuswahlBox::zMsAuswAlphaFeld(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswAf) return 0;
    return msAuswAf->z(i);
}

int AuswahlBox::getMsAuswAlphaFeldFarbe(
    int i) const // gibt die Multistyle Auswahl AlphaFeld Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswAf) return 0;
    return msAuswAf->z(i) ? msAuswAf->z(i)->getFarbe() : 0;
}

int AuswahlBox::getMsAuswAlphaFeldStrength(
    int i) const // gibt die Multistyle Auswahl AlphaFeld staerke zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswAf) return 0;
    return msAuswAf->z(i) ? msAuswAf->z(i)->getStrength() : 0;
}

int AuswahlBox::getMsAuswHintergrundFarbe(
    int i) const // gibt die Multistyle Auswahl Hintergrund Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswBgF || !msAuswBgF->hat(i)) return 0;
    return msAuswBgF->get(i);
}

Bild* AuswahlBox::getMsAuswHintergrundBild(
    int i) const // gibt das Multistyle Auswahl Hintergrund Bild zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswBgB) return 0;
    return msAuswBgB->get(i);
}

Bild* AuswahlBox::zMsAuswHintergrundBild(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msAuswBgB) return 0;
    return msAuswBgB->z(i);
}

Rahmen* AuswahlBox::getMausRahmen() const // gibt den Maus Rahmen zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausRahmen ? dynamic_cast<Rahmen*>(mausRahmen->getThis()) : 0;
}

Rahmen* AuswahlBox::zMausRahmen() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausRahmen;
}

int AuswahlBox::getMausRahmenFarbe() const // gibt die Maus Rahmen Frabe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausRahmen ? mausRahmen->getFarbe() : 0;
}

int AuswahlBox::getMausRahmenBreite()
    const // gibt die Maus Rahmen Breite zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausRahmen ? mausRahmen->getRBreite() : 0;
}

AlphaFeld*
AuswahlBox::getMausAlphaFeld() const // gibt das Maus AlphaFeld zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausAf ? dynamic_cast<AlphaFeld*>(mausAf->getThis()) : 0;
}

AlphaFeld* AuswahlBox::zMausAlphaFeld() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausAf;
}

int AuswahlBox::getMausAlphaFeldFarbe()
    const // gibt die Maus AlphaFeld Farbe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausAf ? mausAf->getFarbe() : 0;
}

int AuswahlBox::getMausAlphaFeldStrength()
    const // gibt die Maus AlphaFeld staerke zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausAf ? mausAf->getStrength() : 0;
}

int AuswahlBox::getMausHintergrundFarbe()
    const // gibt die Maus Hintergrund Farbe zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausBgF;
}

Bild* AuswahlBox::getMausHintergrundBild()
    const // gibt das Maus Hintergrund Bild zurueck
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausBgB ? dynamic_cast<Bild*>(mausBgB->getThis()) : 0;
}

Bild* AuswahlBox::zMausHintergrundBild() const
{
    if (hatStyle(Style::MultiStyled)) return 0;
    return mausBgB;
}

Rahmen* AuswahlBox::getMsMausRahmen(
    int i) const // gibt den Multistyle Maus Rahmen zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausRahmen) return 0;
    return msMausRahmen->get(i);
}

Rahmen* AuswahlBox::zMsMausRahmen(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausRahmen) return 0;
    return msMausRahmen->z(i);
}

int AuswahlBox::getMsMausRahmenFarbe(
    int i) const // gibt die Multistyle Maus Rahmen Frabe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausRahmen) return 0;
    return msMausRahmen->z(i) ? msMausRahmen->z(i)->getFarbe() : 0;
}

int AuswahlBox::getMsMausRahmenBreite(
    int i) const // gibt die Multistyle Maus Rahmen Breite zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausRahmen) return 0;
    return msMausRahmen->z(i) ? msMausRahmen->z(i)->getRBreite() : 0;
}

AlphaFeld* AuswahlBox::getMsMausAlphaFeld(
    int i) const // gibt das Multistyle Maus AlphaFeld zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausAf) return 0;
    return msMausAf->get(i);
}

AlphaFeld* AuswahlBox::zMsMausAlphaFeld(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausAf) return 0;
    return msMausAf->z(i);
}

int AuswahlBox::getMsMausAlphaFeldFarbe(
    int i) const // gibt die Multistyle Maus AlphaFeld Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausAf) return 0;
    return msMausAf->z(i) ? msMausAf->z(i)->getFarbe() : 0;
}

int AuswahlBox::getMsMausAlphaFeldStrength(
    int i) const // gibt die Multistyle Maus AlphaFeld staerke zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausAf) return 0;
    return msMausAf->z(i) ? msMausAf->z(i)->getStrength() : 0;
}

int AuswahlBox::getMsMausHintergrundFarbe(
    int i) const // gibt die Multistyle Maus Hintergrund Farbe zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausBgF || !msMausBgF->hat(i)) return 0;
    return msMausBgF->get(i);
}

Bild* AuswahlBox::getMsMausHintergrundBild(
    int i) const // gibt das Multistyle Maus Hintergrund Bild zurueck
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausBgB) return 0;
    return msMausBgB->get(i);
}

Bild* AuswahlBox::zMsMausHintergrundBild(int i) const
{
    if (!hatStyle(Style::MultiStyled)) return 0;
    if (!msMausBgB) return 0;
    return msMausBgB->z(i);
}

// Prueft, ob ein Punkt in diesem Objekt liegt
//  x: die x koordinate des punktes
//  y: die y koordinate des punktes
//  return: 1, wenn der punkt innen ist, 0 sonst
bool AuswahlBox::istPunktInnen(int x, int y) const
{
    return x >= pos.x && x < pos.x + gr.x && y >= pos.y
        && y < pos.y + gr.y + ausklappHeight;
}

bool AuswahlBox::hatMsStyle(
    int i, __int64 abStyle) const // prueft ob Multistyle style vorhanden
{
    if ((style | Style::MultiStyled) != style || !msStyle || !msStyle->hat(i))
        return 0;
    return (msStyle->get(i) | abStyle) == msStyle->get(i);
}

bool AuswahlBox::hatMsStyleNicht(
    int i, __int64 abStyle) const // prueft ob Multistyle style nicht vorhanden
{
    if ((style | Style::MultiStyled) != style || !msStyle || !msStyle->hat(i))
        return 1;
    return (msStyle->get(i) | abStyle) != msStyle->get(i);
}

Zeichnung* AuswahlBox::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
{
    AuswahlBox* obj = new AuswahlBox();
    obj->setPosition(pos);
    obj->setSize(gr);
    obj->setMausEreignisParameter(makParam);
    obj->setTastaturEreignisParameter(takParam);
    obj->setMausEreignis(mak);
    obj->setTastaturEreignis(tak);
    if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
    obj->setStyle(style);
    if (textRd)
        obj->setTextRendererZ(dynamic_cast<TextRenderer*>(textRd->getThis()));
    if (rahmen) obj->setRahmenZ((Rahmen*)rahmen->dublizieren());
    if (ausfahren) obj->setAusklappKnopfZ((Knopf*)ausfahren->dublizieren());
    obj->setHintergrundFarbe(hintergrundFarbe);
    if (hintergrundBild)
        obj->setHintergrundBild(
            dynamic_cast<Bild*>(hintergrundBild->getThis()));
    if (hintergrundFeld)
        obj->setAlphaFeldZ((AlphaFeld*)hintergrundFeld->dublizieren());
    if (auswRahmen) obj->setAuswRahmenZ((Rahmen*)auswRahmen->dublizieren());
    obj->setAuswHintergrundFarbe(auswBgF);
    if (auswBgB)
        obj->setAuswHintergrundBild(dynamic_cast<Bild*>(auswBgB->getThis()));
    if (auswAf) obj->setAuswAlphaFeldZ((AlphaFeld*)auswAf->dublizieren());
    if (mausRahmen) obj->setMausRahmenZ((Rahmen*)mausRahmen->dublizieren());
    obj->setMausHintergrundFarbe(mausBgF);
    if (mausBgB)
        obj->setMausHintergrundBild(dynamic_cast<Bild*>(mausBgB->getThis()));
    if (mausAf) obj->setMausAlphaFeldZ((AlphaFeld*)mausAf->dublizieren());
    obj->setMaxAuskappHeight(ausklapMaxHeight);
    obj->setEintragHeight(eintragHeight);
    for (int i = 0; i < anzahl; ++i)
    {
        if (members->z(i))
        {
            obj->addEintrag("a");
            obj->setEintragZ(i, (TextFeld*)members->z(i)->dublizieren());
            if (msStyle && msStyle->hat(i)) obj->setMsStyle(i, msStyle->get(i));
            if (msAuswRahmen && msAuswRahmen->z(i))
                obj->setMsAuswRahmenZ(
                    i, (Rahmen*)msAuswRahmen->z(i)->dublizieren());
            if (msAuswBgF && msAuswBgF->hat(i))
                obj->setMsAuswHintergrundFarbe(i, msAuswBgF->get(i));
            if (msAuswBgB && msAuswBgB->z(i))
                obj->setMsAuswHintergrundBild(i, msAuswBgB->get(i));
            if (msAuswAf && msAuswAf->z(i))
                obj->setMsAuswAlphaFeldZ(
                    i, (AlphaFeld*)msAuswAf->z(i)->dublizieren());
            if (msMausRahmen && msMausRahmen->z(i))
                obj->setMsMausRahmenZ(
                    i, (Rahmen*)msMausRahmen->z(i)->dublizieren());
            if (msMausBgF && msMausBgF->hat(i))
                obj->setMsMausHintergrundFarbe(i, msMausBgF->get(i));
            if (msMausBgB && msMausBgB->z(i))
                obj->setMsMausHintergrundBild(i, msMausBgB->get(i));
            if (msMausAf && msMausAf->z(i))
                obj->setMsMausAlphaFeldZ(
                    i, (AlphaFeld*)msMausAf->z(i)->dublizieren());
        }
    }
    obj->setAlphaFeldFarbe(auswahl);
    return obj;
}