KSG-Framework/Diagram.cpp

#include "Diagram.h"

#include <math.h>

#include "AlphaField.h"
#include "Image.h"
#include "MouseEvent.h"
#include "Border.h"
#include "Font.h"
#include "Scroll.h"
#include "Text.h"
#include "ToolTip.h"

using namespace Framework;

// Contents of the LineDiagram class from Diagram.h
// Constructor
LineDiagram::LineDiagram()
    : DrawableBackground(),
      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;
}

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

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

void LineDiagram::setFontZ(Font* schrift) // sets the font
{
    if (!this->textRd)
        textRd = new TextRenderer(schrift);
    else
        textRd->setFontZ(schrift);
    rend = 1;
}

void LineDiagram::setGSize(Punkt& gr) // sets the grid size
{
    gitterGr = gr;
    rend = 1;
}

void LineDiagram::setGFarbe(int f) // sets the grid color
{
    gF = f;
    rend = 1;
}

void LineDiagram::addLinie(const char* name) // adds a line
{
    addLinie(new Text(name));
    rend = 1;
}

void LineDiagram::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::Border) ? rahmen->getRBreite() : 0;
    pb->z(lines)->set(gr.x - rbr * 2, 0);
    ++lines;
    rend = 1;
}

void LineDiagram::setLFarbe(int lNum, int f) // sets the line color
{
    lFarbe->set(f, lNum);
    rend = 1;
}

void LineDiagram::addPunkt(int lNum, int x, int h) // adds a point
{
    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->getEntryCount() || !ph_tmp->getEntryCount())
                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 LineDiagram::removeLinie(int lNum) // removes a line
{
    lFarbe->remove(lNum);
    lName->remove(lNum);
    ph->remove(lNum);
    pb->remove(lNum);
    --lines;
    rend = 1;
}

void LineDiagram::render(Image& zRObj) // draws to zRObj
{
    if (hatStyle(Style::Sichtbar))
    {
        lockDrawable();
        removeStyle(Style::VScroll | Style::HScroll);
        DrawableBackground::render(zRObj);
        if (!zRObj.setDrawOptions(innenPosition, innenSize))
        {
            unlockDrawable();
            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->getEntryCount();
                int pb_anz = pb_tmp->getEntryCount();
                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();
        unlockDrawable();
    }
}

// constant
Font* LineDiagram::getFont() const // returns the font
{
    if (textRd) return textRd->getFont();
    return 0;
}

Font* LineDiagram::zFont() const
{
    return textRd ? textRd->zFont() : 0;
}

const Punkt& LineDiagram::getGSize() const // returns the grid size
{
    return gitterGr;
}

int LineDiagram::getGFarbe() const // returns the grid color
{
    return gF;
}

int LineDiagram::getLinienNummer(const char* name) const // returns the line number
{
    for (int i = 0; i < lines; ++i)
    {
        if (lName->z(i)->istGleich(name)) return i;
    }
    return -1;
}

int LineDiagram::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* LineDiagram::getLinienName(int lNum) const // returns the line name
{
    return lName->get(lNum);
}

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

int LineDiagram::getHighestValue() const // returns the highest value
{
    int ret = 0;
    for (int i = 0; i < lines; ++i)
    {
        int tmp = getHighestValue(i);
        ret = ret >= tmp ? ret : tmp;
    }
    return ret;
}

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

int LineDiagram::getMedian(int lNum) const // returns the average value
{
    int count;
    int all = 0;
    Array<int>* tmp = ph->z(lNum);
    int anz = tmp->getEntryCount();
    for (count = 1; count <= anz; ++count)
        all += tmp->get(count - 1);
    return (int)((double)all / count + 0.5);
}

int LineDiagram::getLAnzahl() const // returns the number of lines
{
    return lines;
}

int LineDiagram::getLastValue(int lNum) const // returns the last value
{
    return lastValue->get(lNum);
}

// Contents of the DiagramValue struct from Diagram.h
// Constructor
DiagramValue::DiagramValue()
    : ReferenceCounter(),
      style(0),
      farbe(0xFFFFFFFF),
      hintergrund(0),
      name(new Text()),
      punkte(new Array<DiagramPoint*>)
{}

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

// Contents of the DiagramData struct from Diagram.h
// Constructor
DiagramData::DiagramData()
    : 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<DiagramValue>())
{}

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

// Contents of the BaseDiagram class from Diagram.h
// Constructor
BaseDiagram::BaseDiagram(Critical* lock)
    : daten(new DiagramData()),
      changed(0),
      lock(lock)
{}

// Destructor
BaseDiagram::~BaseDiagram()
{
    if (daten) daten->release();
}

// non-constant
void BaseDiagram::setDiagramDataZ(
    DiagramData* dd) // Sets a pointer to the diagram data
{
    lock->lock();
    if (daten) daten->release();
    daten = dd;
    lock->unlock();
    changed = 1;
}

void BaseDiagram::setDiagramData(DiagramData* dd) // copies the diagram data
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    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->getEntryCount();
    for (int i = 0; i < anz; ++i)
    {
        if (dd->hIntervallWerte->hat(i))
            daten->hIntervallWerte->set(dd->hIntervallWerte->get(i), i);
    }
    anz = dd->vIntervallWerte->getEntryCount();
    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->getEntryCount();
    for (int i = 0; i < anz; ++i)
    {
        DiagramValue* tmp = dd->werte->z(i);
        if (tmp)
        {
            DiagramValue* w = new DiagramValue();
            w->style = tmp->style;
            w->farbe = tmp->farbe;
            w->hintergrund = tmp->hintergrund;
            w->name->setText(tmp->name->getText());
            int anz = tmp->punkte->getEntryCount();
            for (int j = 0; j < anz; ++j)
            {
                if (tmp->punkte->hat(j))
                {
                    DiagramPoint* p = new DiagramPoint();
                    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 BaseDiagram::setRasterDicke(int d) // set raster thickness
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->rasterDicke != d) changed = 1;
    daten->rasterDicke = d;
    lock->unlock();
}

void BaseDiagram::setRasterBreite(int br) // set raster width
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->rasterBreite != br) changed = 1;
    daten->rasterBreite = br;
    lock->unlock();
}

void BaseDiagram::setRasterHeight(int hi) // set raster height
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->rasterHeight != hi) changed = 1;
    daten->rasterHeight = hi;
    lock->unlock();
}

void BaseDiagram::setRasterFarbe(int f) // set raster color
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->rasterFarbe != f) changed = 1;
    daten->rasterFarbe = f;
    lock->unlock();
}

void BaseDiagram::setHIntervallBreite(double br) // interval width
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    daten->hIntervallBreite = br;
    lock->unlock();
}

void BaseDiagram::setVIntervallHeight(double hi) // interval height
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    daten->vIntervallHeight = hi;
    lock->unlock();
}

void BaseDiagram::setHIntervallFarbe(int f) // color of the horizontal interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->hIntervallFarbe != f) changed = 1;
    daten->hIntervallFarbe = f;
    lock->unlock();
}

void BaseDiagram::setVIntervallFarbe(int f) // color of the vertical interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (daten->vIntervallFarbe != f) changed = 1;
    daten->vIntervallFarbe = f;
    lock->unlock();
}

void BaseDiagram::setHIntervallName(
    const char* name) // Sets the name of the horizontal interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->hIntervallName) daten->hIntervallName = new Text();
    if (!daten->hIntervallName->istGleich(name)) changed = 1;
    daten->hIntervallName->setText(name);
    lock->unlock();
}

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

void BaseDiagram::setVIntervallName(
    const char* name) // Sets the name of the vertical interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->vIntervallName) daten->vIntervallName = new Text();
    if (!daten->vIntervallName->istGleich(name)) changed = 1;
    daten->vIntervallName->setText(name);
    lock->unlock();
}

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

void BaseDiagram::addHIntervallText(double hIntervall,
    const char* text) // Add text for a horizontal interval
{
    setHIntervallText(hIntervall, text);
}

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

void BaseDiagram::setHIntervallTextZ(double hIntervall,
    Text* text) // Sets the text of a horizontal interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEntryCount();
    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 BaseDiagram::setHIntervallText(double hIntervall, Text* text)
{
    setHIntervallText(hIntervall, *text);
    text->release();
}

void BaseDiagram::setHIntervallText(double hIntervall, const char* text)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEntryCount();
    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 BaseDiagram::removeHIntervallText(
    double hIntervall) // removes the text of a horizontal interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
    if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
    int anz = daten->hIntervallWerte->getEntryCount();
    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 BaseDiagram::addVIntervallText(double vIntervall,
    const char* text) // Add text for a vertical interval
{
    setVIntervallText(vIntervall, text);
}

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

void BaseDiagram::setVIntervallTextZ(
    double vIntervall, Text* text) // Sets the text of a vertical interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEntryCount();
    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 BaseDiagram::setVIntervallText(double vIntervall, Text* text)
{
    setVIntervallText(vIntervall, *text);
    text->release();
}

void BaseDiagram::setVIntervallText(double vIntervall, const char* text)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEntryCount();
    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 BaseDiagram::removeVIntervallText(
    double vIntervall) // removes the text of a vertical interval
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
    if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
    int anz = daten->vIntervallWerte->getEntryCount();
    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 BaseDiagram::addWertZ(DiagramValue* w) // Adds a value
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    daten->werte->add(w);
    lock->unlock();
    changed = 1;
}

void BaseDiagram::addWert(DiagramValue* w)
{
    lock->lock();
    DiagramValue* tmp = new DiagramValue();
    tmp->style = w->style;
    tmp->farbe = w->farbe;
    tmp->hintergrund = w->hintergrund;
    tmp->name->setText(*w->name);
    int anz = w->punkte->getEntryCount();
    for (int i = 0; i < anz; ++i)
    {
        if (w->punkte->hat(i))
        {
            DiagramPoint* p = new DiagramPoint();
            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 BaseDiagram::addWert(const char* name)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    DiagramValue* w = new DiagramValue();
    w->name->setText(name);
    daten->werte->add(w);
    lock->unlock();
    changed = 1;
}

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

void BaseDiagram::setWertFarbe(int wNum, int f) // sets the color of a value
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagramValue(), wNum);
    daten->werte->z(wNum)->farbe = f;
    lock->unlock();
    changed = 1;
}

void BaseDiagram::addPunktZ(int wNum, DiagramPoint* p) // adds a point to a value
{
    if (wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    while (!daten->werte->hat(wNum))
        daten->werte->add(new DiagramValue());
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagramPoint*>();
    daten->werte->z(wNum)->punkte->add(p);
    lock->unlock();
    changed = 1;
}

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

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

// changes an existing point
void BaseDiagram::setPunktZ(int wNum, double hI, DiagramPoint* p)
{
    setPunktZ(wNum, getDiagramPointPos(wNum, hI), p);
}

void BaseDiagram::setPunkt(int wNum, double hI, DiagramPoint* p)
{
    setPunkt(wNum, getDiagramPointPos(wNum, hI), p->hIntervall, p->vIntervall);
}

void BaseDiagram::setPunkt(int wNum, double hI, double h, double v)
{
    setPunkt(wNum, getDiagramPointPos(wNum, hI), h, v);
}

void BaseDiagram::setPunktZ(int wNum, int pNum, DiagramPoint* p)
{
    if (pNum < 0 || wNum < 0) return;
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagramValue(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagramPoint*>();
    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 BaseDiagram::setPunkt(int wNum, int pNum, DiagramPoint* p)
{
    if (pNum < 0 || wNum < 0) return;
    setPunkt(wNum, pNum, p->hIntervall, p->vIntervall);
}

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

// Deletes an existing point
void BaseDiagram::removePunkt(int wNum, double hI)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagramValue(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagramPoint*>();
    int anz = daten->werte->z(wNum)->punkte->getEntryCount();
    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 BaseDiagram::removePunkt(int wNum, int pNum)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagramValue(), wNum);
    if (!daten->werte->z(wNum)->punkte)
        daten->werte->z(wNum)->punkte = new Array<DiagramPoint*>();
    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 BaseDiagram::removeWert(int wNum) // removes a value
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    daten->werte->remove(wNum);
    lock->unlock();
    changed = 1;
}

void BaseDiagram::removeWert(const char* name)
{
    lock->lock();
    if (!daten) daten = new DiagramData();
    if (!daten->werte) daten->werte = new RCArray<DiagramValue>();
    int anz = daten->werte->getEntryCount();
    for (int i = 0; i < anz; ++i)
    {
        DiagramValue* 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 BaseDiagram::removeWert(Text* name)
{
    removeWert(name->getText());
    name->release();
}

void BaseDiagram::addDatenStyle(int style) // Sets the style of the data
{
    if (!daten) daten = new DiagramData();
    if ((daten->style | style) != daten->style) changed = 1;
    daten->style |= style;
}

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

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

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

void BaseDiagram::addWertStyle(int wNum, int style) // Sets the style of a value
{
    if (wNum < 0) return;
    if (!daten) daten = new DiagramData();
    if (!daten->werte->z(wNum)) daten->werte->set(new DiagramValue(), wNum);
    if ((daten->werte->z(wNum)->style | style) != daten->werte->z(wNum)->style)
        changed = 1;
    daten->werte->z(wNum)->style |= style;
}

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

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

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

// constant
DiagramData* BaseDiagram::getDiagramData() const // Returns the diagram data
{
    return daten ? dynamic_cast<DiagramData*>(daten->getThis()) : 0;
}

DiagramData* BaseDiagram::zDiagramData() const
{
    return daten;
}

DiagramValue* BaseDiagram::getDiagramValue(int wNum) const // Returns the data of a value
{
    return (daten && daten->werte) ? daten->werte->get(wNum) : 0;
}

DiagramValue* BaseDiagram::zDiagramValue(int wNum) const
{
    return (daten && daten->werte) ? daten->werte->z(wNum) : 0;
}

DiagramValue* BaseDiagram::getDiagramValue(const char* name) const
{
    return getDiagramValue(getDiagramValuePos(name));
}

DiagramValue* BaseDiagram::zDiagramValue(const char* name) const
{
    return zDiagramValue(getDiagramValuePos(name));
}

int BaseDiagram::getDiagramValuePos(
    const char* name) const // Returns the position of a value
{
    if (!daten || !daten->werte) return -1;
    int anz = daten->werte->getEntryCount();
    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 BaseDiagram::getDiagramPointPos(int wNum,
    double hI) const // Returns the position of a point from a value
{
    if (!daten || !daten->werte || !daten->werte->z(wNum)
        || !daten->werte->z(wNum)->punkte)
        return -1;
    int anz = daten->werte->z(wNum)->punkte->getEntryCount();
    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 BaseDiagram::getDiagramPointPos(char* wName, double hI) const
{
    return getDiagramPointPos(getDiagramValuePos(wName), hI);
}

bool BaseDiagram::hatDatenStyle(int style) const // Checks the style of the data
{
    if (!daten) return 0;
    return (daten->style | style) == daten->style;
}

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

bool BaseDiagram::hatWertStyle(
    int wNum, int style) const // Checks the style of a value
{
    if (!daten || !daten->werte || !daten->werte->z(wNum)) return 0;
    return (daten->werte->z(wNum)->style | style)
        == daten->werte->z(wNum)->style;
}

bool BaseDiagram::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;
}

// Contents of the BarDiagram class from Diagram.h
// Constructor
BarDiagram::BarDiagram()
    : DrawableBackground(),
      BaseDiagram(&cs),
      textRd(0),
      dRam(new LBorder()),
      dBgF(0),
      dBgB(0),
      dAf(new AlphaField()),
      vIntervallRB(new Image()),
      hIntervallRB(new Image()),
      schriftGr(12)
{
    style = Style::MELockDrawable;
    vertikalScrollBar = new VScrollBar();
    horizontalScrollBar = new HScrollBar();
}

// Destructor
BarDiagram::~BarDiagram()
{
    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 BarDiagram::doMouseEvent(MouseEvent& me, bool userRet)
{
    if (hatDatenStyle(DiagramData::Style::Sichtbar)
        && (hatStyle(Style::HScroll) || hatStyle(Style::VScroll)) && userRet)
    {
        int rbr = 0;
        if (hatStyle(Style::Border) && 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;
}

// non-constant
void BarDiagram::setTextRendererZ(TextRenderer* textRd)
{
    lockDrawable();
    if (this->textRd) this->textRd->release();
    this->textRd = textRd;
    unlockDrawable();
}

void BarDiagram::setFontZ(Font* schrift) // Sets the font
{
    lockDrawable();
    if (!this->textRd)
        textRd = new TextRenderer(schrift);
    else
        textRd->setFontZ(schrift);
    rend = 1;
    unlockDrawable();
}

void BarDiagram::setSchriftSize(int gr)
{
    lockDrawable();
    if (schriftGr != gr) rend = 1;
    schriftGr = gr;
    unlockDrawable();
}

void BarDiagram::setDataBorderZ(
    Border* ram) // Sets the inner border around the actual diagram
{
    lockDrawable();
    if (dRam) dRam->release();
    dRam = ram;
    unlockDrawable();
    rend = 1;
}

void BarDiagram::setDataBorder(Border* ram)
{
    lockDrawable();
    if (!dRam) dRam = new LBorder();
    dRam->setAlpha(ram->hatAlpha());
    dRam->setFarbe(ram->getFarbe());
    dRam->setRamenBreite(ram->getRBreite());
    unlockDrawable();
    ram->release();
    rend = 1;
}

void BarDiagram::setDatenRahmenBreite(int br)
{
    lockDrawable();
    if (!dRam) dRam = new LBorder();
    if (dRam->getRBreite() != br) rend = 1;
    dRam->setRamenBreite(br);
    unlockDrawable();
}

void BarDiagram::setDatenRahmenFarbe(int f)
{
    lockDrawable();
    if (!dRam) dRam = new LBorder();
    dRam->setFarbe(f);
    unlockDrawable();
    rend = 1;
}

void BarDiagram::setDatenHintergrundFarbe(
    int f) // Sets the background of the actual diagram
{
    dBgF = f;
    rend = 1;
}

void BarDiagram::setDatenHintergrundImageZ(Image* b)
{
    lockDrawable();
    if (dBgB) dBgB->release();
    dBgB = b;
    unlockDrawable();
    rend = 1;
}

void BarDiagram::setDatenHintergrundImage(Image* b)
{
    lockDrawable();
    if (!dBgB) dBgB = new Image();
    dBgB->neuImage(b->getBreite(), b->getHeight(), 0);
    dBgB->drawImage(0, 0, b->getBreite(), b->getHeight(), *b);
    unlockDrawable();
    b->release();
    rend = 1;
}

void BarDiagram::setDataAlphaFieldZ(
    AlphaField* af) // Sets the AlphaField of the actual diagram
{
    lockDrawable();
    if (dAf) dAf->release();
    dAf = af;
    unlockDrawable();
    rend = 1;
}

void BarDiagram::setDataAlphaField(AlphaField* af)
{
    lockDrawable();
    if (!dAf) dAf = new AlphaField();
    dAf->setFarbe(af->getFarbe());
    dAf->setStrength(af->getStrength());
    unlockDrawable();
    af->release();
    rend = 1;
}

void BarDiagram::setDatenAlphaFeldFarbe(int f)
{
    lockDrawable();
    if (!dAf) dAf = new AlphaField();
    dAf->setFarbe(f);
    unlockDrawable();
    rend = 1;
}

void BarDiagram::setDatenAlphaFeldStrength(int st)
{
    lockDrawable();
    if (!dAf) dAf = new AlphaField();
    if (dAf->getStrength() != st) rend = 1;
    dAf->setStrength(st);
    unlockDrawable();
}

void BarDiagram::render(Image& zRObj)
{
    if (!hatDatenStyle(DiagramData::Style::Sichtbar)) return;
    DrawableBackground::render(zRObj);
    if (!zRObj.setDrawOptions(innenPosition, innenSize)) return;
    lockDrawable();
    int dgy = 0;
    int dgbr = innenSize.x;
    int dghi = innenSize.y;
    int vIAnz = 0;
    int hIAnz = 0;
    if (daten)
    { // calculating auto values
        vIAnz = daten->vIntervallWerte
                  ? daten->vIntervallWerte->getEntryCount()
                  : 0;
        hIAnz = daten->hIntervallWerte
                  ? daten->hIntervallWerte->getEntryCount()
                  : 0;
        if (daten->vIntervallWerte
            && hatDatenStyle(DiagramData::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(DiagramData::Style::AutoRasterHeight))
            daten->rasterHeight = daten->vIntervallHeight;
        if (daten->hIntervallWerte
            && hatDatenStyle(DiagramData::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(DiagramData::Style::AutoRasterBreite))
            daten->rasterBreite = daten->hIntervallBreite;
    }
    if (hatDatenStyle(DiagramData::Style::VIntervall) && textRd && schriftGr
        && daten)
    { // rendering of the vertical interval
        int vIRBbr = innenSize.y;
        if (hatDatenStyle(DiagramData::Style::HIntervall)
            && daten->hIntervallFarbe)
            vIRBbr -= schriftGr + 2;
        if (vIRBbr > 0)
        {
            if (vIntervallRB->getBreite() != vIRBbr
                || vIntervallRB->getHeight() != schriftGr + 2)
                vIntervallRB->neuImage(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(DiagramData::Style::VIntervallTexte)
                        && daten->vIntervallTexte
                        && daten->vIntervallTexte->z(rf[i]))
                        txt = daten->vIntervallTexte->z(rf[i])->getText();
                    else if (hatDatenStyleNicht(
                                 DiagramData::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(DiagramData::Style::HIntervall)
                && daten->hIntervallFarbe)
                zRObj.alphaImage90(innenSize.x - vIntervallRB->getHeight(),
                    schriftGr + 2,
                    vIntervallRB->getBreite(),
                    vIntervallRB->getHeight(),
                    *vIntervallRB);
            else
                zRObj.alphaImage90(innenSize.x - vIntervallRB->getHeight(),
                    0,
                    vIntervallRB->getBreite(),
                    vIntervallRB->getHeight(),
                    *vIntervallRB);
            dgbr -= vIntervallRB->getHeight();
        }
    }
    if (hatDatenStyle(DiagramData::Style::HIntervall) && textRd && schriftGr
        && daten)
    { // rendering of the horizontal interval
        int hIRBbr = innenSize.x;
        if (hatDatenStyle(DiagramData::Style::VIntervall)
            && daten->vIntervallFarbe)
            hIRBbr -= schriftGr + 2;
        if (hIRBbr > 0)
        {
            if (hIntervallRB->getBreite() != hIRBbr
                || hIntervallRB->getHeight() != schriftGr + 2)
                hIntervallRB->neuImage(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(DiagramData::Style::HIntervallTexte)
                        && daten->hIntervallTexte
                        && daten->hIntervallTexte->z(rf[i]))
                        txt = daten->hIntervallTexte->z(rf[i])->getText();
                    else if (hatDatenStyleNicht(
                                 DiagramData::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.alphaImage(0,
                0,
                hIntervallRB->getBreite(),
                hIntervallRB->getHeight(),
                *hIntervallRB);
            dghi -= hIntervallRB->getHeight();
            dgy += hIntervallRB->getHeight();
        }
    }
    if (!zRObj.setDrawOptions(0, dgy, dgbr, dghi))
    {
        zRObj.releaseDrawOptions();
        unlockDrawable();
        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();
        unlockDrawable();
        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::DatenHImage) && dBgB)
        {
            if (hatStyle(Style::DatenHAlpha))
                zRObj.alphaImage(
                    0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, *dBgB);
            else
                zRObj.drawImage(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(DiagramData::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(DiagramData::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(DiagramData::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->getEntryCount()
        && daten->hIntervallBreite && daten->vIntervallHeight)
    { // values
        int wAnz = daten->werte->getEntryCount();
        for (int i = 0; i < wAnz; ++i)
        {
            DiagramValue* wert = daten->werte->z(i);
            if (wert && hatWertStyle(i, DiagramValue::Style::Sichtbar)
                && wert->punkte && wert->punkte->getEntryCount())
            {
                int pAnz = wert->punkte->getEntryCount();
                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, DiagramValue::Style::Hintergrund))
                {
                    DiagramPoint* vorher = 0;
                    DiagramPoint* 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, DiagramValue::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, DiagramValue::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
                {
                    DiagramPoint* vorher = 0;
                    DiagramPoint* jetzt = 0;
                    for (int j = 0; j < anz; ++j)
                    {
                        jetzt = wert->punkte->get(rf[j]);
                        if (jetzt && vorher)
                        {
                            if (hatWertStyle(i, DiagramValue::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->getEntryCount() && textRd
        && schriftGr)
    {
        int wAnz = daten->werte->getEntryCount();
        int rx = 5;
        int ry = 5;
        textRd->setSchriftSize(schriftGr);
        for (int i = 0; i < wAnz; ++i)
        {
            DiagramValue* w = daten->werte->z(i);
            if (w && w->name && hatWertStyle(i, DiagramValue::Style::Name)
                && hatWertStyle(i, DiagramValue::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();
    unlockDrawable();
}

// constant
Font* BarDiagram::getFont() const // Returns the font
{
    return textRd ? textRd->getFont() : 0;
}

Font* BarDiagram::zFont() const
{
    return textRd ? textRd->zFont() : 0;
}

Border* BarDiagram::getDataBorder()
    const // Returns the inner border around the actual diagram
{
    return dRam ? dynamic_cast<Border*>(dRam->getThis()) : 0;
}

Border* BarDiagram::zDataBorder() const
{
    return dRam;
}

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

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

int BarDiagram::getDatenHintergrundFarbe()
    const // Returns the background of the actual diagram
{
    return dBgF;
}

Image* BarDiagram::getDatenHintergrundImage() const
{
    return dBgB ? dynamic_cast<Image*>(dBgB->getThis()) : 0;
}

Image* BarDiagram::zDatenHintergrundImage() const
{
    return dBgB;
}

AlphaField*
BarDiagram::getDataAlphaField() const // Returns the AlphaField of the actual diagram
{
    return dAf ? dynamic_cast<AlphaField*>(dAf->getThis()) : 0;
}

AlphaField* BarDiagram::zDataAlphaField() const
{
    return dAf;
}

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

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