KSG-Framework/Diagramm.cpp

#include "Diagramm.h"

#include <math.h>

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

using namespace Framework;

// Inhalt der SLDiag Klasse aus Diagramm.h
// Konstruktor
SLDiag::SLDiag()
    : ZeichnungHintergrund(),
      gF(0xFF000000),
      lFarbe(new Array<int>()),
      lName(new RCArray<Text>()),
      ph(new RCArray<Array<int>>()),
      pb(new RCArray<Array<int>>()),
      lastValue(new Array<int>()),
      textRd(0),
      gitterGr(0, 0),
      lines(0)
{
    style = 0;
}

// Destruktor
SLDiag::~SLDiag()
{
    lFarbe->release();
    lName->release();
    ph->release();
    pb->release();
    lastValue->release();
    if (textRd) textRd->release();
}

// nicht constant
void SLDiag::setTextRendererZ(TextRenderer* textRd)
{
    if (this->textRd) this->textRd->release();
    this->textRd = textRd;
}

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

void SLDiag::setGSize(Punkt& gr) // setzt die Größe des Gitters
{
    gitterGr = gr;
    rend = 1;
}

void SLDiag::setGFarbe(int f) // setzt die Gitter Farbe
{
    gF = f;
    rend = 1;
}

void SLDiag::addLinie(const char* name) // fügt eine Linie hinzu
{
    addLinie(new Text(name));
    rend = 1;
}

void SLDiag::addLinie(Text* txt)
{
    lFarbe->add(0xFFFFFFFF, lines);
    lName->add(txt, lines);
    ph->add(new Array<int>(), lines);
    pb->add(new Array<int>(), lines);
    int rbr = rahmen && hatStyle(Style::Rahmen) ? rahmen->getRBreite() : 0;
    pb->z(lines)->set(gr.x - rbr * 2, 0);
    ++lines;
    rend = 1;
}

void SLDiag::setLFarbe(int lNum, int f) // setzt die Linienfarbe
{
    lFarbe->set(f, lNum);
    rend = 1;
}

void SLDiag::addPunkt(int lNum, int x, int h) // fügt einen Punkt hinzu
{
    Array<int>* ph_tmp = ph->z(lNum);
    Array<int>* pb_tmp = pb->z(lNum);
    if (ph_tmp && pb_tmp)
    {
        int i = pb_tmp->get(0);
        i -= x;
        if (i >= 0) pb_tmp->set(i, 0);
        while (i < 0)
        {
            ph_tmp->remove(0);
            pb_tmp->remove(0);
            if (!pb_tmp->getEintragAnzahl() || !ph_tmp->getEintragAnzahl())
                break;
            int ii = -i;
            i = pb_tmp->get(0);
            i -= ii;
            pb_tmp->set(i, 0);
        }
        pb_tmp->add(x);
        ph_tmp->add(h);
        lastValue->set(h, lNum);
    }
    rend = 1;
}

void SLDiag::removeLinie(int lNum) // entfernt eine Linie
{
    lFarbe->remove(lNum);
    lName->remove(lNum);
    ph->remove(lNum);
    pb->remove(lNum);
    --lines;
    rend = 1;
}

void SLDiag::render(Bild& zRObj) // zeichnet nach zRObj
{
    if (hatStyle(Style::Sichtbar))
    {
        lockZeichnung();
        removeStyle(Style::VScroll | Style::HScroll);
        ZeichnungHintergrund::render(zRObj);
        if (!zRObj.setDrawOptions(innenPosition, innenSize))
        {
            unlockZeichnung();
            return;
        }
        int hv = getHighestValue();
        hv = hv ? hv : 1;
        double yFaktor = innenSize.y / hv;
        if (hatStyle(Style::Gitter))
        {
            double ghi = gitterGr.y * yFaktor;
            int yo = innenSize.y - 1;
            int bo = innenSize.x, ho = innenSize.y;
            int maxBr = (int)((double)innenSize.x / gitterGr.x + 0.5);
            int maxHi = ghi ? (int)(innenSize.y / ghi + 0.5) : 0;
            if (hatStyle(Style::HAlpha))
            {
                for (int i = 0; i < maxBr; ++i)
                    zRObj.drawLinieVAlpha(gitterGr.x * i, 0, ho, gF);
                for (int i = 0; i < maxHi; ++i)
                    zRObj.drawLinieHAlpha(0, (int)(yo - ghi * i + 0.5), bo, gF);
            }
            else
            {
                for (int i = 0; i < maxBr; ++i)
                    zRObj.drawLinieV(gitterGr.x * i, 0, ho, gF);
                for (int i = 0; i < maxHi; ++i)
                    zRObj.drawLinieH(0, (int)(yo - ghi * i + 0.5), bo, gF);
            }
        }
        for (int i = 0; i < lines; ++i)
        {
            int f_tmp = lFarbe->hat(i) ? lFarbe->get(i) : 0;
            Text* n_tmp = lName->z(i);
            Array<int>* ph_tmp = ph->z(i);
            Array<int>* pb_tmp = pb->z(i);
            if (hatStyle(Style::LinienName) && textRd && n_tmp)
            {
                textRd->setSchriftSize(12);
                Text rtxt = n_tmp->getText();
                rtxt += ": ";
                rtxt += lastValue->get(i);
                textRd->renderText(5, 5 + 15 * i, rtxt, zRObj, f_tmp);
            }
            if (ph_tmp && pb_tmp)
            {
                int lastX = 0;
                int lastY = innenSize.y - 1;
                int ph_anz = ph_tmp->getEintragAnzahl();
                int pb_anz = pb_tmp->getEintragAnzahl();
                for (int ii = 0; ii < ph_anz && ii < pb_anz; ++ii)
                {
                    if (!ph_tmp || !pb_tmp) break;
                    int xpos = lastX + pb_tmp->get(ii);
                    int ypos = innenSize.y
                             - (int)(ph_tmp->get(ii) * yFaktor + 0.5) - 1;
                    if (ypos == -1) ++ypos;
                    if (ypos < 0 || xpos < 0) break;
                    if (hatStyle(Style::HAlpha))
                        zRObj.drawLinieAlpha(
                            Punkt(lastX, lastY), Punkt(xpos, ypos), f_tmp);
                    else
                        zRObj.drawLinie(
                            Punkt(lastX, lastY), Punkt(xpos, ypos), f_tmp);
                    lastX = xpos;
                    lastY = ypos;
                }
            }
        }
        zRObj.releaseDrawOptions();
        unlockZeichnung();
    }
}

// constant
Schrift* SLDiag::getSchrift() const // gibt die Schrift zurück
{
    if (textRd) return textRd->getSchrift();
    return 0;
}

Schrift* SLDiag::zSchrift() const
{
    return textRd ? textRd->zSchrift() : 0;
}

const Punkt& SLDiag::getGSize() const // gibt die Gitter Größe zurück
{
    return gitterGr;
}

int SLDiag::getGFarbe() const // gibt die Gitter Farbe zurück
{
    return gF;
}

int SLDiag::getLinienNummer(
    const char* name) const // gibt die Linien Nummer zurück
{
    for (int i = 0; i < lines; ++i)
    {
        if (lName->z(i)->istGleich(name)) return i;
    }
    return -1;
}

int SLDiag::getLinienNummer(Text* name) const
{
    for (int i = 0; i < lines; ++i)
    {
        if (lName->z(i)->istGleich(name->getText()))
        {
            name->release();
            return i;
        }
    }
    name->release();
    return -1;
}

Text* SLDiag::getLinienName(int lNum) const // gibt den Linien Namen zurück
{
    return lName->get(lNum);
}

Text* SLDiag::zLinienNamen(int lNum) const
{
    return lName->z(lNum);
}

int SLDiag::getHighestValue() const // gibt den Höchsten Wert zurück
{
    int ret = 0;
    for (int i = 0; i < lines; ++i)
    {
        int tmp = getHighestValue(i);
        ret = ret >= tmp ? ret : tmp;
    }
    return ret;
}

int SLDiag::getHighestValue(int lNum) const
{
    int ret = 0;
    Array<int>* tmp = ph->z(lNum);
    int anz = tmp->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
        ret = ret >= tmp->get(i) ? ret : tmp->get(i);
    return ret;
}

int SLDiag::getMedian(int lNum) const // gibt den durchschnittswert zurück
{
    int count;
    int all = 0;
    Array<int>* tmp = ph->z(lNum);
    int anz = tmp->getEintragAnzahl();
    for (count = 1; count <= anz; ++count)
        all += tmp->get(count - 1);
    return (int)((double)all / count + 0.5);
}

int SLDiag::getLAnzahl() const // gibt die Linien Anzahl zurück
{
    return lines;
}

int SLDiag::getLastValue(int lNum) const // gibt den letzten Wert zurück
{
    return lastValue->get(lNum);
}

// Inhalt der DiagWert Struktur aus Diagramm.h
// Konstruktor
DiagWert::DiagWert()
    : ReferenceCounter(),
      style(0),
      farbe(0xFFFFFFFF),
      hintergrund(0),
      name(new Text()),
      punkte(new Array<DiagPunkt*>)
{}

// Destruktor
DiagWert::~DiagWert()
{
    name->release();
    int anz = punkte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (punkte->hat(i)) delete punkte->get(i);
    }
    punkte->release();
}

// Inhalt der DiagDaten Struktur aus Diagramm.h
// Konstruktor
DiagDaten::DiagDaten()
    : ReferenceCounter(),
      style(0),
      rasterDicke(0),
      rasterBreite(0),
      rasterHeight(0),
      rasterFarbe(0),
      hIntervallFarbe(0xFFFFFFFF),
      vIntervallFarbe(0xFFFFFFFF),
      hIntervallName(new Text()),
      vIntervallName(new Text()),
      hIntervallTexte(new RCArray<Text>),
      vIntervallTexte(new RCArray<Text>),
      hIntervallWerte(new Array<double>),
      vIntervallWerte(new Array<double>),
      hIntervallBreite(0),
      vIntervallHeight(0),
      werte(new RCArray<DiagWert>())
{}

// Destruktor
DiagDaten::~DiagDaten()
{
    hIntervallName->release();
    vIntervallName->release();
    hIntervallWerte->release();
    vIntervallWerte->release();
    hIntervallTexte->release();
    vIntervallTexte->release();
    werte->release();
}

// Inhalt der BaseDiag Klasse aus Diagramm.h
// Konstruktor
BaseDiag::BaseDiag(Critical* lock)
    : daten(new DiagDaten()),
      changed(0),
      lock(lock)
{}

// Destruktor
BaseDiag::~BaseDiag()
{
    if (daten) daten->release();
}

// nicht constant
void BaseDiag::setDiagDatenZ(
    DiagDaten* dd) // Setzt einen Zeiger auf die Daten des Diagramms
{
    lock->lock();
    if (daten) daten->release();
    daten = dd;
    lock->unlock();
    changed = 1;
}

void BaseDiag::setDiagDaten(DiagDaten* dd) // Kopiert die Daten eines Diagramms
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    daten->style = dd->style;
    daten->rasterBreite = dd->rasterBreite;
    daten->rasterHeight = dd->rasterHeight;
    daten->rasterFarbe = dd->rasterFarbe;
    daten->hIntervallFarbe = dd->hIntervallFarbe;
    daten->vIntervallFarbe = dd->vIntervallFarbe;
    daten->hIntervallName->setText(*dd->hIntervallName);
    daten->vIntervallName->setText(*dd->vIntervallName);
    int anz = dd->hIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (dd->hIntervallWerte->hat(i))
            daten->hIntervallWerte->set(dd->hIntervallWerte->get(i), i);
    }
    anz = dd->vIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (dd->vIntervallWerte->hat(i))
            daten->vIntervallWerte->set(dd->vIntervallWerte->get(i), i);
    }
    daten->hIntervallBreite = dd->hIntervallBreite;
    daten->vIntervallHeight = dd->vIntervallHeight;
    anz = dd->werte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        DiagWert* tmp = dd->werte->z(i);
        if (tmp)
        {
            DiagWert* w = new DiagWert();
            w->style = tmp->style;
            w->farbe = tmp->farbe;
            w->hintergrund = tmp->hintergrund;
            w->name->setText(tmp->name->getText());
            int anz = tmp->punkte->getEintragAnzahl();
            for (int j = 0; j < anz; ++j)
            {
                if (tmp->punkte->hat(j))
                {
                    DiagPunkt* p = new DiagPunkt();
                    p->hIntervall = tmp->punkte->get(j)->hIntervall;
                    p->vIntervall = tmp->punkte->get(j)->vIntervall;
                    w->punkte->set(p, j);
                }
            }
            daten->werte->set(w, i);
        }
    }
    dd->release();
    lock->unlock();
    changed = 1;
}

void BaseDiag::setRasterDicke(int d) // Rasterdicke setzen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->rasterDicke != d) changed = 1;
    daten->rasterDicke = d;
    lock->unlock();
}

void BaseDiag::setRasterBreite(int br) // Rasterbreite setzen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->rasterBreite != br) changed = 1;
    daten->rasterBreite = br;
    lock->unlock();
}

void BaseDiag::setRasterHeight(int hi) // Rasterhöhe setzen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->rasterHeight != hi) changed = 1;
    daten->rasterHeight = hi;
    lock->unlock();
}

void BaseDiag::setRasterFarbe(int f) // Rasterfarbe setzen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->rasterFarbe != f) changed = 1;
    daten->rasterFarbe = f;
    lock->unlock();
}

void BaseDiag::setHIntervallBreite(double br) // Intervall Breite
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    daten->hIntervallBreite = br;
    lock->unlock();
}

void BaseDiag::setVIntervallHeight(double hi) // Intervall Höhe
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    daten->vIntervallHeight = hi;
    lock->unlock();
}

void BaseDiag::setHIntervallFarbe(int f) // Farbe des Horizontalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->hIntervallFarbe != f) changed = 1;
    daten->hIntervallFarbe = f;
    lock->unlock();
}

void BaseDiag::setVIntervallFarbe(int f) // Farbe des Vertikalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (daten->vIntervallFarbe != f) changed = 1;
    daten->vIntervallFarbe = f;
    lock->unlock();
}

void BaseDiag::setHIntervallName(
    const char* name) // Setzt den Namen des Horizontalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->hIntervallName) daten->hIntervallName = new Text();
    if (!daten->hIntervallName->istGleich(name)) changed = 1;
    daten->hIntervallName->setText(name);
    lock->unlock();
}

void BaseDiag::setHIntervallName(Text* name)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->hIntervallName) daten->hIntervallName = new Text();
    if (!daten->hIntervallName->istGleich(*name)) changed = 1;
    daten->hIntervallName->setText(name);
    lock->unlock();
}

void BaseDiag::setVIntervallName(
    const char* name) // Setzt den Namen des Vertikalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->vIntervallName) daten->vIntervallName = new Text();
    if (!daten->vIntervallName->istGleich(name)) changed = 1;
    daten->vIntervallName->setText(name);
    lock->unlock();
}

void BaseDiag::setVIntervallName(Text* name)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->vIntervallName) daten->vIntervallName = new Text();
    if (!daten->vIntervallName->istGleich(*name)) changed = 1;
    daten->vIntervallName->setText(name);
    lock->unlock();
}

void BaseDiag::addHIntervallText(double hIntervall,
    const char* text) // Text eines Horizontalen Intervalls hinzufügen
{
    setHIntervallText(hIntervall, text);
}

void BaseDiag::addHIntervallText(double hIntervall, Text* text)
{
    setHIntervallText(hIntervall, *text);
    text->release();
}

void BaseDiag::setHIntervallTextZ(double hIntervall,
    Text* text) // Setzt den Text eines Horizontalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->hIntervallWerte->hat(i)
            && daten->hIntervallWerte->get(i) == hIntervall)
        {
            daten->hIntervallTexte->set(text, i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    daten->hIntervallWerte->set(hIntervall, anz);
    daten->hIntervallTexte->set(text, anz);
    lock->unlock();
    changed = 1;
}

void BaseDiag::setHIntervallText(double hIntervall, Text* text)
{
    setHIntervallText(hIntervall, *text);
    text->release();
}

void BaseDiag::setHIntervallText(double hIntervall, const char* text)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->hIntervallWerte->hat(i)
            && daten->hIntervallWerte->get(i) == hIntervall)
        {
            if (!daten->hIntervallTexte->z(i))
                daten->hIntervallTexte->set(new Text(text), i);
            else
                daten->hIntervallTexte->z(i)->setText(text);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    daten->hIntervallWerte->set(hIntervall, anz);
    daten->hIntervallTexte->set(new Text(text), anz);
    lock->unlock();
    changed = 1;
}

void BaseDiag::removeHIntervallText(
    double hIntervall) // Text eines Horizontalen Intervalls entfernen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->hIntervallWerte->hat(i)
            && daten->hIntervallWerte->get(i) == hIntervall)
        {
            daten->hIntervallTexte->remove(i);
            daten->hIntervallWerte->remove(i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    lock->unlock();
}

void BaseDiag::addVIntervallText(double vIntervall,
    const char* text) // Text eines Vertikalen Intervalls hinzufügen
{
    setVIntervallText(vIntervall, text);
}

void BaseDiag::addVIntervallText(double vIntervall, Text* text)
{
    setVIntervallText(vIntervall, *text);
    text->release();
}

void BaseDiag::setVIntervallTextZ(
    double vIntervall, Text* text) // Setzt den Text eines Vertikalen Intervalls
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->vIntervallWerte->hat(i)
            && daten->vIntervallWerte->get(i) == vIntervall)
        {
            daten->vIntervallTexte->set(text, i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    daten->vIntervallWerte->set(vIntervall, anz);
    daten->vIntervallTexte->set(text, anz);
    lock->unlock();
    changed = 1;
}

void BaseDiag::setVIntervallText(double vIntervall, Text* text)
{
    setVIntervallText(vIntervall, *text);
    text->release();
}

void BaseDiag::setVIntervallText(double vIntervall, const char* text)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->vIntervallWerte->hat(i)
            && daten->vIntervallWerte->get(i) == vIntervall)
        {
            if (!daten->vIntervallTexte->z(i))
                daten->vIntervallTexte->set(new Text(text), i);
            else
                daten->vIntervallTexte->z(i)->setText(text);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    daten->vIntervallWerte->set(vIntervall, anz);
    daten->vIntervallTexte->set(new Text(text), anz);
    lock->unlock();
    changed = 1;
}

void BaseDiag::removeVIntervallText(
    double vIntervall) // Text eines Vertikalen Intervalls entfernen
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->vIntervallWerte->hat(i)
            && daten->vIntervallWerte->get(i) == vIntervall)
        {
            daten->vIntervallTexte->remove(i);
            daten->vIntervallWerte->remove(i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    lock->unlock();
}

void BaseDiag::addWertZ(DiagWert* w) // Fügt einen Wert hinzu
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    daten->werte->add(w);
    lock->unlock();
    changed = 1;
}

void BaseDiag::addWert(DiagWert* w)
{
    lock->lock();
    DiagWert* tmp = new DiagWert();
    tmp->style = w->style;
    tmp->farbe = w->farbe;
    tmp->hintergrund = w->hintergrund;
    tmp->name->setText(*w->name);
    int anz = w->punkte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (w->punkte->hat(i))
        {
            DiagPunkt* p = new DiagPunkt();
            p->hIntervall = w->punkte->get(i)->hIntervall;
            p->vIntervall = w->punkte->get(i)->vIntervall;
            tmp->punkte->set(p, i);
        }
    }
    w->release();
    addWertZ(tmp);
    lock->unlock();
    changed = 1;
}

void BaseDiag::addWert(const char* name)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    DiagWert* w = new DiagWert();
    w->name->setText(name);
    daten->werte->add(w);
    lock->unlock();
    changed = 1;
}

void BaseDiag::addWert(Text* txt)
{
    addWert(*txt);
    txt->release();
}

void BaseDiag::setWertFarbe(int wNum, int f) // setzt die Farbe eines Wertes
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    daten->werte->z(wNum)->farbe = f;
    lock->unlock();
    changed = 1;
}

void BaseDiag::addPunktZ(
    int wNum, DiagPunkt* p) // fügt einem Wert einen Punkt hinzu
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    while (!daten->werte->hat(wNum))
        daten->werte->add(new DiagWert());
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    daten->werte->z(wNum)->punkte->add(p);
    lock->unlock();
    changed = 1;
}

void BaseDiag::addPunkt(int wNum, DiagPunkt* p)
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    while (!daten->werte->hat(wNum))
        daten->werte->add(new DiagWert());
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    DiagPunkt* tmp = new DiagPunkt();
    tmp->hIntervall = p->hIntervall;
    tmp->vIntervall = p->vIntervall;
    daten->werte->z(wNum)->punkte->add(tmp);
    lock->unlock();
    changed = 1;
}

void BaseDiag::addPunkt(int wNum, double hI, double vI)
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    DiagPunkt* tmp = new DiagPunkt();
    tmp->hIntervall = hI;
    tmp->vIntervall = vI;
    daten->werte->z(wNum)->punkte->add(tmp);
    lock->unlock();
    changed = 1;
}

// Ändert einen vorhandenen Punkt eines Wertes
void BaseDiag::setPunktZ(int wNum, double hI, DiagPunkt* p)
{
    setPunktZ(wNum, getDiagPunktPos(wNum, hI), p);
}

void BaseDiag::setPunkt(int wNum, double hI, DiagPunkt* p)
{
    setPunkt(wNum, getDiagPunktPos(wNum, hI), p->hIntervall, p->vIntervall);
}

void BaseDiag::setPunkt(int wNum, double hI, double h, double v)
{
    setPunkt(wNum, getDiagPunktPos(wNum, hI), h, v);
}

void BaseDiag::setPunktZ(int wNum, int pNum, DiagPunkt* p)
{
    if (pNum < 0 || wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    if (daten->werte->z(wNum)->punkte->hat(pNum))
        delete daten->werte->z(wNum)->punkte->get(pNum);
    daten->werte->z(wNum)->punkte->set(p, pNum);
    lock->unlock();
    changed = 1;
}

void BaseDiag::setPunkt(int wNum, int pNum, DiagPunkt* p)
{
    if (pNum < 0 || wNum < 0) return;
    setPunkt(wNum, pNum, p->hIntervall, p->vIntervall);
}

void BaseDiag::setPunkt(int wNum, int pNum, double h, double v)
{
    if (pNum < 0 || wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    if (!daten->werte->z(wNum)->punkte->hat(pNum))
        daten->werte->z(wNum)->punkte->set(new DiagPunkt(), pNum);
    daten->werte->z(wNum)->punkte->get(pNum)->hIntervall = h;
    daten->werte->z(wNum)->punkte->get(pNum)->vIntervall = v;
    lock->unlock();
    changed = 1;
}

// Löscht einen vorhandenen Punkt
void BaseDiag::removePunkt(int wNum, double hI)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    int anz = daten->werte->z(wNum)->punkte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->werte->z(wNum)->punkte->hat(i)
            && daten->werte->z(wNum)->punkte->get(i)->hIntervall == hI)
        {
            delete daten->werte->z(wNum)->punkte->get(i);
            daten->werte->z(wNum)->punkte->remove(i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    lock->unlock();
}

void BaseDiag::removePunkt(int wNum, int pNum)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
    if (daten->werte->z(wNum)->punkte->hat(pNum))
    {
        delete daten->werte->z(wNum)->punkte->get(pNum);
        daten->werte->z(wNum)->punkte->remove(pNum);
        changed = 1;
    }
    lock->unlock();
}

void BaseDiag::removeWert(int wNum) // entfernt einen Wert
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    daten->werte->remove(wNum);
    lock->unlock();
    changed = 1;
}

void BaseDiag::removeWert(const char* name)
{
    lock->lock();
    if (!daten) daten = new DiagDaten();
    if (!daten->werte) daten->werte = new RCArray<DiagWert>();
    int anz = daten->werte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        DiagWert* tmp = daten->werte->z(i);
        if (tmp && tmp->name && tmp->name->istGleich(name))
        {
            daten->werte->remove(i);
            lock->unlock();
            changed = 1;
            return;
        }
    }
    lock->unlock();
}

void BaseDiag::removeWert(Text* name)
{
    removeWert(name->getText());
    name->release();
}

void BaseDiag::addDatenStyle(int style) // Setzt den Style der Daten
{
    if (!daten) daten = new DiagDaten();
    if ((daten->style | style) != daten->style) changed = 1;
    daten->style |= style;
}

void BaseDiag::setDatenStyle(int style)
{
    if (!daten) daten = new DiagDaten();
    if (daten->style != style) changed = 1;
    daten->style = style;
}

void BaseDiag::setDatenStyle(int style, bool addRemove)
{
    if (addRemove)
        addDatenStyle(style);
    else
        removeDatenStyle(style);
}

void BaseDiag::removeDatenStyle(int style)
{
    if (!daten) daten = new DiagDaten();
    if ((daten->style & ~style) != daten->style) changed = 1;
    daten->style &= ~style;
}

void BaseDiag::addWertStyle(int wNum, int style) // Setzt den Style eines Wertes
{
    if (wNum < 0) return;
    if (!daten) daten = new DiagDaten();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if ((daten->werte->z(wNum)->style | style) != daten->werte->z(wNum)->style)
        changed = 1;
    daten->werte->z(wNum)->style |= style;
}

void BaseDiag::setWertStyle(int wNum, int style)
{
    if (wNum < 0) return;
    if (!daten) daten = new DiagDaten();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if (daten->werte->z(wNum)->style != style) changed = 1;
    daten->werte->z(wNum)->style = style;
}

void BaseDiag::setWertStyle(int wNum, int style, bool addRemove)
{
    if (wNum < 0) return;
    if (addRemove)
        addWertStyle(wNum, style);
    else
        removeWertStyle(wNum, style);
}

void BaseDiag::removeWertStyle(int wNum, int style)
{
    if (wNum < 0) return;
    if (!daten) daten = new DiagDaten();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
    if ((daten->werte->z(wNum)->style & ~style) != daten->werte->z(wNum)->style)
        changed = 1;
    daten->werte->z(wNum)->style &= ~style;
}

// constant
DiagDaten* BaseDiag::getDiagDaten() const // Gibt die Daten des Diagramms zurück
{
    return daten ? dynamic_cast<DiagDaten*>(daten->getThis()) : 0;
}

DiagDaten* BaseDiag::zDiagDaten() const
{
    return daten;
}

DiagWert* BaseDiag::getDiagWert(
    int wNum) const // Gibt die Daten eines Wertes zurück
{
    return (daten && daten->werte) ? daten->werte->get(wNum) : 0;
}

DiagWert* BaseDiag::zDiagWert(int wNum) const
{
    return (daten && daten->werte) ? daten->werte->z(wNum) : 0;
}

DiagWert* BaseDiag::getDiagWert(const char* name) const
{
    return getDiagWert(getDiagWertPos(name));
}

DiagWert* BaseDiag::zDiagWert(const char* name) const
{
    return zDiagWert(getDiagWertPos(name));
}

int BaseDiag::getDiagWertPos(
    const char* name) const // Gibt die Position eines Wertes zurück
{
    if (!daten || !daten->werte) return -1;
    int anz = daten->werte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->werte->z(i) && daten->werte->z(i)->name
            && daten->werte->z(i)->name->istGleich(name))
            return i;
    }
    return -1;
}

int BaseDiag::getDiagPunktPos(int wNum,
    double hI) const // Gibt die Position eines Punktes von einem Wert zurück
{
    if (!daten || !daten->werte || !daten->werte->z(wNum)
        || !daten->werte->z(wNum)->punkte)
        return -1;
    int anz = daten->werte->z(wNum)->punkte->getEintragAnzahl();
    for (int i = 0; i < anz; ++i)
    {
        if (daten->werte->z(wNum)->punkte->hat(i)
            && daten->werte->z(wNum)->punkte->get(i)->hIntervall == hI)
            return i;
    }
    return -1;
}

int BaseDiag::getDiagPunktPos(char* wName, double hI) const
{
    return getDiagPunktPos(getDiagWertPos(wName), hI);
}

bool BaseDiag::hatDatenStyle(int style) const // Prüft den Style der Daten
{
    if (!daten) return 0;
    return (daten->style | style) == daten->style;
}

bool BaseDiag::hatDatenStyleNicht(int style) const
{
    if (!daten) return 1;
    return (daten->style | style) != daten->style;
}

bool BaseDiag::hatWertStyle(
    int wNum, int style) const // Prüft den Style eines Wertes
{
    if (!daten || !daten->werte || !daten->werte->z(wNum)) return 0;
    return (daten->werte->z(wNum)->style | style)
        == daten->werte->z(wNum)->style;
}

bool BaseDiag::hatWertStyleNicht(int wNum, int style) const
{
    if (!daten || !daten->werte || !daten->werte->z(wNum)) return 1;
    return (daten->werte->z(wNum)->style | style)
        != daten->werte->z(wNum)->style;
}

// Inhalt der LDiag Klasse aus Diagramm.h
// Konstruktor
LDiag::LDiag()
    : ZeichnungHintergrund(),
      BaseDiag(&cs),
      textRd(0),
      dRam(new LRahmen()),
      dBgF(0),
      dBgB(0),
      dAf(new AlphaFeld()),
      vIntervallRB(new Bild()),
      hIntervallRB(new Bild()),
      schriftGr(12)
{
    style = Style::MELockZeichnung;
    vertikalScrollBar = new VScrollBar();
    horizontalScrollBar = new HScrollBar();
}

// Destruktor
LDiag::~LDiag()
{
    if (textRd) textRd->release();
    if (dRam) dRam->release();
    if (dBgB) dBgB->release();
    if (dAf) dAf->release();
    if (vIntervallRB) vIntervallRB->release();
    if (hIntervallRB) hIntervallRB->release();
}

void LDiag::doMausEreignis(MausEreignis& me, bool userRet)
{
    if (hatDatenStyle(DiagDaten::Style::Sichtbar)
        && (hatStyle(Style::HScroll) || hatStyle(Style::VScroll)) && userRet)
    {
        int rbr = 0;
        if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
        bool vs = hatStyle(Style::VScroll) && vertikalScrollBar;
        bool hs = hatStyle(Style::HScroll) && horizontalScrollBar;
        if (vs)
        {
            if (hs)
                horizontalScrollBar->doMausMessage(
                    rbr, gr.y - rbr - 15, gr.x - rbr * 2 - 15, 15, me);
            vertikalScrollBar->doMausMessage(
                gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me);
        }
        else if (hs)
            horizontalScrollBar->doMausMessage(
                rbr, gr.y - rbr - 15, gr.x - rbr * 2, 15, me);
    }
    me.verarbeitet = userRet;
}

// nicht constant
void LDiag::setTextRendererZ(TextRenderer* textRd)
{
    lockZeichnung();
    if (this->textRd) this->textRd->release();
    this->textRd = textRd;
    unlockZeichnung();
}

void LDiag::setSchriftZ(Schrift* schrift) // Setzt die Schrift
{
    lockZeichnung();
    if (!this->textRd)
        textRd = new TextRenderer(schrift);
    else
        textRd->setSchriftZ(schrift);
    rend = 1;
    unlockZeichnung();
}

void LDiag::setSchriftSize(int gr)
{
    lockZeichnung();
    if (schriftGr != gr) rend = 1;
    schriftGr = gr;
    unlockZeichnung();
}

void LDiag::setDatenRahmenZ(
    Rahmen* ram) // Setzt den inneren Rahmen um das eigentliche Diagramm
{
    lockZeichnung();
    if (dRam) dRam->release();
    dRam = ram;
    unlockZeichnung();
    rend = 1;
}

void LDiag::setDatenRahmen(Rahmen* ram)
{
    lockZeichnung();
    if (!dRam) dRam = new LRahmen();
    dRam->setAlpha(ram->hatAlpha());
    dRam->setFarbe(ram->getFarbe());
    dRam->setRamenBreite(ram->getRBreite());
    unlockZeichnung();
    ram->release();
    rend = 1;
}

void LDiag::setDatenRahmenBreite(int br)
{
    lockZeichnung();
    if (!dRam) dRam = new LRahmen();
    if (dRam->getRBreite() != br) rend = 1;
    dRam->setRamenBreite(br);
    unlockZeichnung();
}

void LDiag::setDatenRahmenFarbe(int f)
{
    lockZeichnung();
    if (!dRam) dRam = new LRahmen();
    dRam->setFarbe(f);
    unlockZeichnung();
    rend = 1;
}

void LDiag::setDatenHintergrundFarbe(
    int f) // Setzt den Hintergrund des eigentlichen Diagramms
{
    dBgF = f;
    rend = 1;
}

void LDiag::setDatenHintergrundBildZ(Bild* b)
{
    lockZeichnung();
    if (dBgB) dBgB->release();
    dBgB = b;
    unlockZeichnung();
    rend = 1;
}

void LDiag::setDatenHintergrundBild(Bild* b)
{
    lockZeichnung();
    if (!dBgB) dBgB = new Bild();
    dBgB->neuBild(b->getBreite(), b->getHeight(), 0);
    dBgB->drawBild(0, 0, b->getBreite(), b->getHeight(), *b);
    unlockZeichnung();
    b->release();
    rend = 1;
}

void LDiag::setDatenAlphaFeldZ(
    AlphaFeld* af) // Setzt das AlphaFeld des eigentlichen Diagramms
{
    lockZeichnung();
    if (dAf) dAf->release();
    dAf = af;
    unlockZeichnung();
    rend = 1;
}

void LDiag::setDatenAlphaFeld(AlphaFeld* af)
{
    lockZeichnung();
    if (!dAf) dAf = new AlphaFeld();
    dAf->setFarbe(af->getFarbe());
    dAf->setStrength(af->getStrength());
    unlockZeichnung();
    af->release();
    rend = 1;
}

void LDiag::setDatenAlphaFeldFarbe(int f)
{
    lockZeichnung();
    if (!dAf) dAf = new AlphaFeld();
    dAf->setFarbe(f);
    unlockZeichnung();
    rend = 1;
}

void LDiag::setDatenAlphaFeldStrength(int st)
{
    lockZeichnung();
    if (!dAf) dAf = new AlphaFeld();
    if (dAf->getStrength() != st) rend = 1;
    dAf->setStrength(st);
    unlockZeichnung();
}

void LDiag::render(Bild& zRObj)
{
    if (!hatDatenStyle(DiagDaten::Style::Sichtbar)) return;
    ZeichnungHintergrund::render(zRObj);
    if (!zRObj.setDrawOptions(innenPosition, innenSize)) return;
    lockZeichnung();
    int dgy = 0;
    int dgbr = innenSize.x;
    int dghi = innenSize.y;
    int vIAnz = 0;
    int hIAnz = 0;
    if (daten)
    { // Auto werte berechnen
        vIAnz = daten->vIntervallWerte
                  ? daten->vIntervallWerte->getEintragAnzahl()
                  : 0;
        hIAnz = daten->hIntervallWerte
                  ? daten->hIntervallWerte->getEintragAnzahl()
                  : 0;
        if (daten->vIntervallWerte
            && hatDatenStyle(DiagDaten::Style::AutoIntervallHeight))
        {
            double maxW = 0;
            for (int i = 0; i < vIAnz; ++i)
            {
                if (daten->vIntervallWerte->hat(i)
                    && daten->vIntervallWerte->get(i) > maxW)
                    maxW = daten->vIntervallWerte->get(i);
            }
            if (vertikalScrollBar && hatStyle(Style::VScroll))
                daten->vIntervallHeight
                    = maxW ? (vertikalScrollBar->getScroll() / maxW) : 0;
            else
                daten->vIntervallHeight
                    = maxW ? (vIntervallRB->getBreite() / maxW) : 0;
        }
        if (hatDatenStyle(DiagDaten::Style::AutoRasterHeight))
            daten->rasterHeight = daten->vIntervallHeight;
        if (daten->hIntervallWerte
            && hatDatenStyle(DiagDaten::Style::AutoIntervallBreite))
        {
            double maxW = 0;
            for (int i = 0; i < hIAnz; ++i)
            {
                if (daten->hIntervallWerte->hat(i)
                    && daten->hIntervallWerte->get(i) > maxW)
                    maxW = daten->hIntervallWerte->get(i);
            }
            if (horizontalScrollBar && hatStyle(Style::HScroll))
                daten->hIntervallBreite
                    = maxW ? (horizontalScrollBar->getScroll() / maxW) : 0;
            else
                daten->hIntervallBreite
                    = maxW ? (hIntervallRB->getBreite() / maxW) : 0;
        }
        if (hatDatenStyle(DiagDaten::Style::AutoRasterBreite))
            daten->rasterBreite = daten->hIntervallBreite;
    }
    if (hatDatenStyle(DiagDaten::Style::VIntervall) && textRd && schriftGr
        && daten)
    { // Rendern des vertikalen Intervalls
        int vIRBbr = innenSize.y;
        if (hatDatenStyle(DiagDaten::Style::HIntervall)
            && daten->hIntervallFarbe)
            vIRBbr -= schriftGr + 2;
        if (vIRBbr > 0)
        {
            if (vIntervallRB->getBreite() != vIRBbr
                || vIntervallRB->getHeight() != schriftGr + 2)
                vIntervallRB->neuBild(vIRBbr, schriftGr + 2, 0xFF000000);
            else
                vIntervallRB->fillRegion(
                    0, 0, vIRBbr, schriftGr + 2, 0xFF000000);
            textRd->setSchriftSize(schriftGr);
            if (daten->vIntervallWerte)
            {
                int* rf = new int[vIAnz];
                int anz = 0;
                bool* fertig = new bool[vIAnz];
                ZeroMemory(fertig, vIAnz);
                for (int i = 0; i < vIAnz; ++i)
                {
                    double min = 0;
                    int mI = -1;
                    for (int j = 0; j < vIAnz; ++j)
                    {
                        if (!fertig[j] && daten->vIntervallWerte->hat(j)
                            && (daten->vIntervallWerte->get(j) < min || mI < 0))
                        {
                            mI = j;
                            min = daten->vIntervallWerte->get(j);
                        }
                    }
                    if (mI < 0) break;
                    rf[anz] = mI;
                    ++anz;
                    fertig[mI] = 1;
                }
                delete[] fertig;
                Text txt;
                int xPos = 0;
                if (vertikalScrollBar && hatStyle(Style::VScroll))
                    xPos -= vertikalScrollBar->getScroll();
                int rWeite = xPos - 10;
                for (int i = anz - 1; i >= 0; --i)
                {
                    txt = "";
                    if (hatDatenStyle(DiagDaten::Style::VIntervallTexte)
                        && daten->vIntervallTexte
                        && daten->vIntervallTexte->z(rf[i]))
                        txt = daten->vIntervallTexte->z(rf[i])->getText();
                    else if (hatDatenStyleNicht(
                                 DiagDaten::Style::VIntervallTexte)
                             || !daten->vIntervallWerte)
                        txt = daten->vIntervallWerte->get(rf[i]);
                    xPos = (int)(daten->vIntervallWerte->get(rf[i])
                                 * daten->vIntervallHeight);
                    xPos = (vertikalScrollBar && hatStyle(Style::VScroll)
                                   ? vertikalScrollBar->getScroll()
                                   : vIntervallRB->getBreite())
                         - xPos;
                    if (vertikalScrollBar && hatStyle(Style::VScroll))
                        xPos -= vertikalScrollBar->getScroll();
                    int br = textRd->getTextBreite(txt);
                    if (xPos + br > vIntervallRB->getBreite()
                        && vIntervallRB->getBreite() - br >= rWeite + 10)
                        xPos = vIntervallRB->getBreite() - br;
                    if (xPos >= rWeite + 10)
                    {
                        textRd->renderText(xPos,
                            1,
                            txt,
                            *vIntervallRB,
                            daten->vIntervallFarbe);
                        rWeite = xPos + br + 10;
                    }
                }
                delete[] rf;
            }
            if (daten->vIntervallName)
            {
                int vinbr
                    = textRd->getTextBreite(daten->vIntervallName->getText());
                int vinx = vIntervallRB->getBreite() / 2 - vinbr / 2;
                vIntervallRB->fillRegion(
                    vinx - 5, 1, vinbr + 10, schriftGr, 0xFF000000);
                textRd->renderText(vinx,
                    1,
                    daten->vIntervallName->getText(),
                    *vIntervallRB,
                    daten->vIntervallFarbe);
            }
            if (hatDatenStyle(DiagDaten::Style::HIntervall)
                && daten->hIntervallFarbe)
                zRObj.alphaBild90(innenSize.x - vIntervallRB->getHeight(),
                    schriftGr + 2,
                    vIntervallRB->getBreite(),
                    vIntervallRB->getHeight(),
                    *vIntervallRB);
            else
                zRObj.alphaBild90(innenSize.x - vIntervallRB->getHeight(),
                    0,
                    vIntervallRB->getBreite(),
                    vIntervallRB->getHeight(),
                    *vIntervallRB);
            dgbr -= vIntervallRB->getHeight();
        }
    }
    if (hatDatenStyle(DiagDaten::Style::HIntervall) && textRd && schriftGr
        && daten)
    { // Rendern des horizontalen Intervalls
        int hIRBbr = innenSize.x;
        if (hatDatenStyle(DiagDaten::Style::VIntervall)
            && daten->vIntervallFarbe)
            hIRBbr -= schriftGr + 2;
        if (hIRBbr > 0)
        {
            if (hIntervallRB->getBreite() != hIRBbr
                || hIntervallRB->getHeight() != schriftGr + 2)
                hIntervallRB->neuBild(hIRBbr, schriftGr + 2, 0xFF000000);
            else
                hIntervallRB->fillRegion(
                    0, 0, hIRBbr, schriftGr + 2, 0xFF000000);
            textRd->setSchriftSize(schriftGr);
            if (daten->hIntervallWerte)
            {
                int* rf = new int[hIAnz];
                int anz = 0;
                bool* fertig = new bool[hIAnz];
                ZeroMemory(fertig, hIAnz);
                for (int i = 0; i < hIAnz; ++i)
                {
                    double min = 0;
                    int mI = -1;
                    for (int j = 0; j < hIAnz; ++j)
                    {
                        if (!fertig[j] && daten->hIntervallWerte->hat(j)
                            && (daten->hIntervallWerte->get(j) < min || mI < 0))
                        {
                            mI = j;
                            min = daten->hIntervallWerte->get(j);
                        }
                    }
                    if (mI < 0) break;
                    rf[anz] = mI;
                    ++anz;
                    fertig[mI] = 1;
                }
                delete[] fertig;
                Text txt;
                int xPos = 0;
                if (horizontalScrollBar && hatStyle(Style::HScroll))
                    xPos -= horizontalScrollBar->getScroll();
                int rWeite = xPos - 10;
                for (int i = 0; i < anz; ++i)
                {
                    txt = "";
                    if (hatDatenStyle(DiagDaten::Style::HIntervallTexte)
                        && daten->hIntervallTexte
                        && daten->hIntervallTexte->z(rf[i]))
                        txt = daten->hIntervallTexte->z(rf[i])->getText();
                    else if (hatDatenStyleNicht(
                                 DiagDaten::Style::HIntervallTexte)
                             || !daten->hIntervallWerte)
                        txt = daten->hIntervallWerte->get(rf[i]);
                    xPos = (int)(daten->hIntervallWerte->get(rf[i])
                                 * daten->hIntervallBreite);
                    if (horizontalScrollBar && hatStyle(Style::HScroll))
                        xPos -= horizontalScrollBar->getScroll();
                    int br = textRd->getTextBreite(txt);
                    if (xPos + br > hIntervallRB->getBreite()
                        && hIntervallRB->getBreite() - br >= rWeite + 10)
                        xPos = hIntervallRB->getBreite() - br;
                    if (xPos >= rWeite + 10)
                    {
                        textRd->renderText(xPos,
                            1,
                            txt,
                            *hIntervallRB,
                            daten->hIntervallFarbe);
                        rWeite = xPos + br + 10;
                    }
                }
                delete[] rf;
            }
            if (daten->hIntervallName)
            {
                int hinbr
                    = textRd->getTextBreite(daten->hIntervallName->getText());
                int hinx = hIntervallRB->getBreite() / 2 - hinbr / 2;
                hIntervallRB->fillRegion(
                    hinx - 5, 1, hinbr + 10, schriftGr, 0xFF000000);
                textRd->renderText(hinx,
                    1,
                    daten->hIntervallName->getText(),
                    *hIntervallRB,
                    daten->hIntervallFarbe);
            }
            zRObj.alphaBild(0,
                0,
                hIntervallRB->getBreite(),
                hIntervallRB->getHeight(),
                *hIntervallRB);
            dghi -= hIntervallRB->getHeight();
            dgy += hIntervallRB->getHeight();
        }
    }
    if (!zRObj.setDrawOptions(0, dgy, dgbr, dghi))
    {
        zRObj.releaseDrawOptions();
        unlockZeichnung();
        return;
    }
    dgy = 0;
    int dgrbr = 0;
    if (hatStyle(Style::DatenRahmen) && dRam)
    {
        dRam->setSize(dgbr, dghi);
        dRam->render(zRObj);
        dgrbr = dRam->getRBreite();
    }
    if (!zRObj.setDrawOptions(dgrbr, dgrbr, dgbr - dgrbr * 2, dghi - dgrbr * 2))
    {
        zRObj.releaseDrawOptions();
        zRObj.releaseDrawOptions();
        unlockZeichnung();
        return;
    }
    if (hatStyle(Style::DatenHintergrund))
    {
        if (hatStyle(Style::DatenHAlpha))
            zRObj.alphaRegion(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, dBgF);
        else
            zRObj.fillRegion(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, dBgF);
        if (hatStyle(Style::DatenHBild) && dBgB)
        {
            if (hatStyle(Style::DatenHAlpha))
                zRObj.alphaBild(
                    0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, *dBgB);
            else
                zRObj.drawBild(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, *dBgB);
        }
    }
    if (hatStyle(Style::DatenBuffered) && dAf)
    {
        dAf->setSize(dgbr - dgrbr * 2, dghi - dgrbr * 2);
        dAf->render(zRObj);
    }
    if (hatDatenStyle(DiagDaten::Style::Raster) && daten && daten->rasterDicke
        && daten->rasterBreite && daten->rasterHeight)
    { // Raster
        int maxBr = dgbr;
        if (horizontalScrollBar && hatStyle(Style::HScroll))
            maxBr = horizontalScrollBar->getScroll();
        int maxHi = dghi;
        if (vertikalScrollBar && hatStyle(Style::VScroll))
            maxHi = vertikalScrollBar->getScroll();
        for (double x = horizontalScrollBar && hatStyle(Style::HScroll)
                          ? -horizontalScrollBar->getScroll()
                          : 0;
             x < maxBr;
             x += daten->rasterBreite)
        {
            for (int i = 0; i < daten->rasterDicke; ++i)
            {
                if (hatDatenStyle(DiagDaten::Style::RasterAlpha))
                    zRObj.drawLinieVAlpha((int)(x + i),
                        dgy + dgrbr,
                        dghi - dgrbr * 2,
                        daten->rasterFarbe);
                else
                    zRObj.drawLinieV((int)(x + i),
                        dgy + dgrbr,
                        dghi - dgrbr * 2,
                        daten->rasterFarbe);
            }
        }
        for (double y = maxHi;
             y > (vertikalScrollBar && hatStyle(Style::VScroll)
                      ? -vertikalScrollBar->getScroll()
                      : 0);
             y -= daten->rasterHeight)
        {
            for (int i = 0; i < daten->rasterDicke; ++i)
            {
                if (hatDatenStyle(DiagDaten::Style::RasterAlpha))
                    zRObj.drawLinieHAlpha(
                        0, (int)(y + i), dgbr - dgrbr * 2, daten->rasterFarbe);
                else
                    zRObj.drawLinieH(
                        0, (int)(y + i), dgbr - dgrbr * 2, daten->rasterFarbe);
            }
        }
    }
    if (daten && daten->werte && daten->werte->getEintragAnzahl()
        && daten->hIntervallBreite && daten->vIntervallHeight)
    { // Werte
        int wAnz = daten->werte->getEintragAnzahl();
        for (int i = 0; i < wAnz; ++i)
        {
            DiagWert* wert = daten->werte->z(i);
            if (wert && hatWertStyle(i, DiagWert::Style::Sichtbar)
                && wert->punkte && wert->punkte->getEintragAnzahl())
            {
                int pAnz = wert->punkte->getEintragAnzahl();
                int* rf = new int[pAnz];
                bool* fertig = new bool[pAnz];
                int anz = 0;
                ZeroMemory(fertig, pAnz);
                for (int j = 0; j < pAnz; ++j)
                {
                    double min = -1;
                    int p = -1;
                    for (int pi = 0; pi < pAnz; ++pi)
                    {
                        if (wert->punkte->hat(pi) && !fertig[pi]
                            && (p < 0
                                || wert->punkte->get(pi)->hIntervall < min))
                        {
                            min = wert->punkte->get(pi)->hIntervall;
                            p = pi;
                        }
                    }
                    if (p < 0) break;
                    rf[anz] = p;
                    fertig[p] = 1;
                    ++anz;
                }
                delete[] fertig;
                int rpx = horizontalScrollBar && hatStyle(Style::HScroll)
                            ? -horizontalScrollBar->getScroll()
                            : 0;
                int rpy = vertikalScrollBar && hatStyle(Style::VScroll)
                            ? -vertikalScrollBar->getScroll()
                            : 0;
                rpy += dgy;
                int dgmhi
                    = vertikalScrollBar && hatStyle(Style::VScroll)
                        ? dgy + vertikalScrollBar->getScrollData()->max + dgrbr
                        : dgy + dghi - dgrbr;
                if (hatWertStyle(i, DiagWert::Style::Hintergrund))
                {
                    DiagPunkt* vorher = 0;
                    DiagPunkt* jetzt = 0;
                    for (int j = 0; j < anz; ++j)
                    {
                        jetzt = wert->punkte->get(rf[j]);
                        if (jetzt && vorher)
                        {
                            int ax = (int)(rpx
                                           + vorher->hIntervall
                                                 * daten->hIntervallBreite);
                            int ay = (int)(dgmhi
                                           - vorher->vIntervall
                                                 * daten->vIntervallHeight);
                            int bx = (int)(rpx
                                           + jetzt->hIntervall
                                                 * daten->hIntervallBreite);
                            int by = (int)(dgmhi
                                           - jetzt->vIntervall
                                                 * daten->vIntervallHeight);
                            if (ax >= bx)
                            {
                                vorher = jetzt;
                                continue;
                            }
                            if (!(ax > dgbr - dgrbr || bx < 0
                                    || (ay > dgy + dghi - dgrbr
                                        && by > dgy + dghi - dgrbr)))
                            {
                                double yf = (double)(by - ay) / (bx - ax);
                                double y = (double)ay;
                                ax = ax < 0 ? 0 : ax;
                                bx = bx > dgbr - dgrbr ? dgbr - dgrbr : bx;
                                if (hatWertStyle(i, DiagWert::Style::HAlpha))
                                {
                                    for (int x = ax; x < bx; x++, y += yf)
                                        zRObj.drawLinieVAlpha(x,
                                            (int)(y + 0.5),
                                            dgmhi - (int)(y + 0.5),
                                            wert->hintergrund);
                                }
                                else
                                {
                                    for (int x = ax; x < bx; x++, y += yf)
                                        zRObj.drawLinieV(x,
                                            (int)(y + 0.5),
                                            dgmhi - (int)(y + 0.5),
                                            wert->hintergrund);
                                }
                                if (hatWertStyle(i, DiagWert::Style::Alpha))
                                    zRObj.drawLinieAlpha(Punkt(ax, ay),
                                        Punkt(bx, by),
                                        wert->farbe);
                                else
                                    zRObj.drawLinie(Punkt(ax, ay),
                                        Punkt(bx, by),
                                        wert->farbe);
                            }
                        }
                        vorher = jetzt;
                    }
                }
                else
                {
                    DiagPunkt* vorher = 0;
                    DiagPunkt* jetzt = 0;
                    for (int j = 0; j < anz; ++j)
                    {
                        jetzt = wert->punkte->get(rf[j]);
                        if (jetzt && vorher)
                        {
                            if (hatWertStyle(i, DiagWert::Style::Alpha))
                                zRObj.drawLinieAlpha(
                                    Punkt(
                                        (int)(rpx
                                              + vorher->hIntervall
                                                    * daten->hIntervallBreite),
                                        (int)(dgmhi
                                              - vorher->vIntervall
                                                    * daten->vIntervallHeight)),
                                    Punkt(
                                        (int)(rpx
                                              + jetzt->hIntervall
                                                    * daten->hIntervallBreite),
                                        (int)(dgmhi
                                              - jetzt->vIntervall
                                                    * daten->vIntervallHeight)),
                                    wert->farbe);
                            else
                                zRObj.drawLinie(
                                    Punkt(
                                        (int)(rpx
                                              + vorher->hIntervall
                                                    * daten->hIntervallBreite),
                                        (int)(dgmhi
                                              - vorher->vIntervall
                                                    * daten->vIntervallHeight)),
                                    Punkt(
                                        (int)(rpx
                                              + jetzt->hIntervall
                                                    * daten->hIntervallBreite),
                                        (int)(dgmhi
                                              - jetzt->vIntervall
                                                    * daten->vIntervallHeight)),
                                    wert->farbe);
                        }
                        vorher = jetzt;
                    }
                }
                delete[] rf;
            }
        }
    }
    if (daten && daten->werte && daten->werte->getEintragAnzahl() && textRd
        && schriftGr)
    {
        int wAnz = daten->werte->getEintragAnzahl();
        int rx = 5;
        int ry = 5;
        textRd->setSchriftSize(schriftGr);
        for (int i = 0; i < wAnz; ++i)
        {
            DiagWert* w = daten->werte->z(i);
            if (w && w->name && hatWertStyle(i, DiagWert::Style::Name)
                && hatWertStyle(i, DiagWert::Style::Sichtbar))
            {
                int br = textRd->getTextBreite(w->name->getText());
                zRObj.alphaRegion(rx, ry, br, schriftGr, 0xA0000000);
                textRd->renderText(rx, ry, w->name->getText(), zRObj, w->farbe);
                ry += 15;
            }
        }
    }
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
    unlockZeichnung();
}

// constant
Schrift* LDiag::getSchrift() const // Gibt die Schrift zurück
{
    return textRd ? textRd->getSchrift() : 0;
}

Schrift* LDiag::zSchrift() const
{
    return textRd ? textRd->zSchrift() : 0;
}

Rahmen* LDiag::getDatenRahmen()
    const // Gibt den inneren Rahmen um das eigentliche Diagramm zurück
{
    return dRam ? dynamic_cast<Rahmen*>(dRam->getThis()) : 0;
}

Rahmen* LDiag::zDatenRahmen() const
{
    return dRam;
}

int LDiag::getDatenRahmenFarbe() const
{
    return dRam ? dRam->getFarbe() : 0;
}

int LDiag::getDatenRahmenBreite() const
{
    return dRam ? dRam->getRBreite() : 0;
}

int LDiag::getDatenHintergrundFarbe()
    const // Gibt den Hintergrund des eigentlichen Diagramms zurück
{
    return dBgF;
}

Bild* LDiag::getDatenHintergrundBild() const
{
    return dBgB ? dynamic_cast<Bild*>(dBgB->getThis()) : 0;
}

Bild* LDiag::zDatenHintergrundBild() const
{
    return dBgB;
}

AlphaFeld* LDiag::getDatenAlphaFeld()
    const // Gibt das AlphaFeld des eigentlichen Diagramms zurück
{
    return dAf ? dynamic_cast<AlphaFeld*>(dAf->getThis()) : 0;
}

AlphaFeld* LDiag::zDatenAlphaFeld() const
{
    return dAf;
}

int LDiag::getDatenAlphaFeldFarbe() const
{
    return dAf ? dAf->getFarbe() : 0;
}

int LDiag::getDatenAlphaFeldStrength() const
{
    return dAf ? dAf->getStrength() : 0;
}